Deep linking as an input language
Async Digital Ltd Cardiff, UK
Most apps treat a deep link as a front door. A URL opens a screen, and that is the whole contract. Held to a higher bar, the URL becomes an input language: anything that can fire one (a user, a test, a Shortcut, an agent driving the phone) can move the app to any reachable state, deterministically, from wherever it happens to be. Deep Link Kit is the Swift package I built to hold that bar. It collapses racing URLs to a single winner with cooperative cancellation, reads the app’s current state so one short URL means the right thing from anywhere, keeps its footprint to one folder of the consumer’s codebase, and can deliver a primed, mid-edit draft two sheet layers deep in one call. Each of the five case studies below takes one of those claims and shows the evidence, measured against a demo app built to exercise the kit.
One URL, one deterministic outcome, from anywhere in the app, however fast the next URL lands. That is the contract. This page is the map of how Deep Link Kit keeps it, and where the evidence lives.
What a URL should be able to do
Deep linking has a reputation as plumbing. A marketing link opens the app, the app opens a screen, everyone moves on. The contract stays thin because the input is assumed to be rare and polite: one URL, arriving alone, into an app sitting quietly at its home screen.
None of those assumptions survives automation. The moment URLs become the way tests drive the app, the way demo recordings are staged, and the way a Shortcut or an agent reaches a feature, they arrive in bursts, mid-animation, into whatever state the app was left in. A deep-linking layer that only handles the polite case fails quietly everywhere else: stacked sheets, half-applied navigation, a screen that belongs to the previous URL.
Deep Link Kit is the layer I built for the impolite cases. It turns one URL into a deterministic sequence of structural navigation steps and side effects, applied in order, with cooperative cancellation when the next URL lands before the last one has finished. Four properties carry the weight.
- Race-safe. Racing URLs collapse to last-writer-wins. Cancelled runs leave no half-applied state behind, and every cancellation is a recorded trace event that tests assert against.
- State-aware. The same short URL means the right thing from anywhere. Settings arrives as a sheet from the root and as a push from inside a thread, decided by a frozen snapshot of where the app is, not by routing instructions leaked into the URL.
- Contained. The consumer can answer “where does your URL handling live?” with a folder name and a low percentage. The domain layer never learns the kit exists.
- Programmable. Taps, URLs, tests, and automated screen capture all converge on one apply path. The bar is not “open a screen”; one URL can hand the user a primed draft, two sheet layers deep.
Every claim in this series is measured against a demo messaging app built as the kit’s consumer. The recordings are captures of that app running; the numbers come from its codebase. The app exists so the kit has somewhere honest to prove itself.
The panel below replays the kit’s signature scenario: six URLs fired in under a second, each cancelling the one before, the last one winning, nothing stacking. The recorded version, captured from the demo app with no animation tricks, opens the first article in the series.
- 0.00sbotmessages://conversation/aria-7cancelled
- 0.18sbotmessages://profile/aria-7cancelled
- 0.34sbotmessages://settingscancelled
- 0.51sbotmessages://composecancelled
- 0.69sbotmessages://search?q=invoicecancelled
- 0.88sbotmessages://conversation/studio-channelresolved
Five claims, five measurements
Each article takes one property and shows the receipts: scenario tables, measured footprints, recorded races. The last property carries two articles, one for the input surface and one for how deep a single URL can reach. They read best in order, and each stands alone.
-
When URLs arrive faster than the UI
Five cold-launch burst scenarios, all resolving last-writer-wins. No stacked sheets, no half-applied state, and a trace that proves it.
Read note
-
Where URL handling lives
The containment test for any infrastructure library: a folder name and a low percentage. How the demo consumer answers it.
Read note
-
Same URL, right meaning, from anywhere
Keeping URLs short and readable when the right destination depends on where the user already is.
Read note
-
When navigate means more than push
Search, filters, scroll targets, expansion overlays: a closed set of effect cases, and one apply switch every entry point converges on.
Read note
-
A primed draft from a single URL
Cold launch to a user-ready, mid-edit compose state, two sheet layers deep, in one call. The agentic bar for deep linking.
Read note