@abide/abide 0.58.0 → 0.100.0

package/src/lib/ui/runtime/withPathFrom.ts

@@ -1,20 +0,0 @@
-import { ambientPathBacking } from './ambientPathBacking.ts'
-import { escapeKey } from './escapeKey.ts'
-
-/*
-Runs `build` with the render path set to `base` + one escaped `segment` (ADR-0033 D1). Unlike
-`withPath` (which pushes relative to the LIVE ambient), this composes from an EXPLICIT base — for
-a control-flow block that rebuilds content reactively AFTER mount, when the ambient path is no
-longer on the stack. The block captures `CURRENT_PATH.current` at construction (its render-time
-ancestry) and re-establishes `base/segment` for every branch/row build — initial and every later
-swap — so a component or cell built on a swap still gets its full, stable id, not a bare segment.
-
-Pushes through the backing's `run` (not a set-then-restore slot): the server's AsyncLocalStorage
-backing makes the composed path survive an `await` inside `build`, so a render body resuming after
-a cell barrier or child render reads its own path; the client's synchronous module-var `run` is a
-plain save/restore. `run` returns `build()`'s value (a value on the client, a promise on the server).
-*/
-export function withPathFrom<T>(base: string, segment: string | number, build: () => T): T {
-    const composedPath = base === '' ? escapeKey(segment) : `${base}/${escapeKey(segment)}`
-    return ambientPathBacking.active.run(composedPath, build)
-}

package/src/lib/ui/runtime/withoutHydration.ts

@@ -1,22 +0,0 @@
-import { RENDER } from './RENDER.ts'
-
-/*
-Runs `build` with the hydration claim cursor cleared, restoring it after. The
-control-flow blocks route FRESH builds through here — a pending/resolved await
-branch, a try's catch branch, a fillBefore insert — so their build helpers
-create nodes instead of trying to claim server DOM that isn't there. A rebuild
-that fires while an outer hydrate pass is still active (e.g. a synchronous write
-that flips a `when`/`switch` mid-hydrate) would otherwise make `cloneStatic` /
-text claim discarded or nonexistent nodes and silently render nothing. The
-`finally` restore lets a fresh build sit inside an ongoing hydrate pass without
-ending it early.
-*/
-export function withoutHydration<T>(build: () => T): T {
-    const previous = RENDER.hydration
-    RENDER.hydration = undefined
-    try {
-        return build()
-    } finally {
-        RENDER.hydration = previous
-    }
-}

package/src/lib/ui/runtime/writeNode.ts

@@ -1,16 +0,0 @@
-import { trigger } from './trigger.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Writes a signal node. An `Object.is`-equal write is a no-op — equality at the
-leaf is exactly what stops a no-change patch from waking readers, and (via the
-document's structural sharing) what stops an untouched sibling subtree from
-re-running when its parent changes identity.
-*/
-export function writeNode(node: ReactiveNode, value: unknown): void {
-    if (Object.is(node.value, value)) {
-        return
-    }
-    node.value = value
-    trigger(node)
-}

package/src/lib/ui/scope.ts

@@ -1,20 +0,0 @@
-import { createScope } from './createScope.ts'
-import { CURRENT_SCOPE } from './runtime/CURRENT_SCOPE.ts'
-import type { Scope } from './types/Scope.ts'
-
-/*
-Resolves the current lexical scope — established per lexical level by the compiler,
-so it reads "where you are" with no handle. Outside any scope (boot, a script) it
-mints a detached root once and reuses it. Now the INTERNAL lowering host: the author
-reactive surface is the imported `state`/`state.linked`/`state.computed`/`effect`; the
-compiler lowers each onto this scope (`$$scope().derive`/`.linked`/`.effect`), and
-`state.share`/`.shared` route through it. Still published so generated code and the
-type-checking shadow can import it; not part of the author-facing surface.
-*/
-// @documentation plumbing
-export function scope(): Scope {
-    if (!CURRENT_SCOPE.current) {
-        CURRENT_SCOPE.current = createScope()
-    }
-    return CURRENT_SCOPE.current
-}

package/src/lib/ui/seedBootState.ts

@@ -1,53 +0,0 @@
-import { baseSlot } from '../shared/baseSlot.ts'
-import { createTraceContext } from '../shared/createTraceContext.ts'
-import { healthSeedSlot } from '../shared/healthSeedSlot.ts'
-import { requestScopeSlot } from '../shared/requestScopeSlot.ts'
-import { rpcTimeoutSlot } from '../shared/rpcTimeoutSlot.ts'
-import { setAppName } from '../shared/setAppName.ts'
-import type { SsrBootState } from '../shared/types/SsrBootState.ts'
-
-/* Seeds every `__SSR__` boot-state field into its ambient slot. The map is typed
-   EXHAUSTIVELY over `SsrBootState`, so a boot field can't be added to the payload
-   without a seeder here — the compile error is what guarantees a stamped field is
-   never silently dropped client-side. Base is seeded first (object-key order), as the
-   prior hand-written sequence required: the cache seed that follows keys call urls
-   through the base resolver. */
-const SEED: { [K in keyof Required<SsrBootState>]: (value: SsrBootState[K]) => void } = {
-    base: (value) => {
-        baseSlot.resolver = () => value ?? ''
-    },
-    app: (value) => setAppName(value),
-    health: (value) => {
-        healthSeedSlot.payload = value
-    },
-    clientTimeout: (value) => {
-        rpcTimeoutSlot.ms = value
-    },
-    /* Continue the SSR request's trace (or mint a fresh sampled one if the stamp is
-       missing) and publish the browser's request scope: trace(), log line prefixes, and
-       the RPC traceparent header resolve through it. elapsedMs is navigation-relative —
-       exactly what performance.now() measures — and the path tracks client navigations
-       because the resolver reads location per call. */
-    trace: (value) => {
-        const traceContext = createTraceContext(value)
-        requestScopeSlot.resolver = () => ({
-            trace: traceContext,
-            elapsedMs: performance.now(),
-            method: 'GET',
-            path: typeof location === 'undefined' ? '' : location.pathname,
-        })
-    },
-}
-
-/* Applies one seeder to its own field — generic over the key so the seeder and its
-   value stay correlated (a bare `SEED[key](boot[key])` loses the correlation). */
-function seedField<K extends keyof SsrBootState>(key: K, boot: SsrBootState): void {
-    SEED[key](boot[key])
-}
-
-/* Seeds all boot-state slots from the payload, before mount. */
-export function seedBootState(boot: SsrBootState): void {
-    for (const key of Object.keys(SEED) as Array<keyof SsrBootState>) {
-        seedField(key, boot)
-    }
-}

package/src/lib/ui/seedStreamedResolution.ts

@@ -1,56 +0,0 @@
-import { activeCacheStore } from '../shared/activeCacheStore.ts'
-import { cacheEntryFromSnapshot } from '../shared/cacheEntryFromSnapshot.ts'
-import { decodeRefJson } from '../shared/decodeRefJson.ts'
-import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
-import { CELL_SEED } from './runtime/CELL_SEED.ts'
-import { receiveStreamedCell } from './runtime/STREAMED_CELLS.ts'
-
-/*
-Seeds one streamed cache resolution into the active store — the single sink for the
-streamed (pending {#await}) cache partition. A full CacheSnapshotEntry warms the entry
-so a `cache()` read resolves synchronously (no wire round-trip) and `<template await>`
-adopts without a refetch; a `{ key, miss }` marker — a body the server couldn't snapshot
-(binary / rejected / evicted) — is a no-op, so that read falls back to a live fetch.
-
-Shared by startClient's boot drain and the live `window.__abideResolve`, so no
-resolved-frame consumer can swap DOM while silently dropping the cache channel — the
-asymmetry that made streamed reads cold-miss to the network.
-*/
-// @documentation plumbing
-export function seedStreamedResolution(resolution: StreamedResolution): void {
-    /* ADR-0039: a STREAMED CHILD's blocking async-cell value that resolved after the head snapshot.
-       Seed it into `CELL_SEED` (the same warm partition `__SSR__.cells` fills, storing the raw
-       ref-json string decoded at cell read) so the child's cell constructs RESOLVED when its
-       deferred mount runs — no flash, no re-run. Checked before `cellKey` (a distinct arm). */
-    if ('cellSeed' in resolution) {
-        CELL_SEED[resolution.cellSeed] = resolution.value
-        return
-    }
-    /* ADR-0035: a streaming CELL's server-resolved value, keyed by render-path id. Route it to the
-       mounted cell (or buffer until it registers) — decoded through the same ref-json codec the
-       server encoded it with, so a Set/Map/Date/bigint/cyclic value survives. */
-    if ('cellKey' in resolution) {
-        receiveStreamedCell(resolution.cellKey, decodeRefJson(resolution.value))
-        return
-    }
-    if ('miss' in resolution) {
-        return
-    }
-    /* Only seed when nothing live holds the key — or when the existing entry is itself
-       an unconsumed hydrated seed (`hydrated === true`, cleared by the first cache()
-       read). A live/settled non-hydrated entry is authoritative; clobbering it with a
-       stale snapshot would drop a fresher value (e.g. one a live fetch already wrote). */
-    const store = activeCacheStore()
-    const existing = store.entries.get(resolution.key)
-    if (existing !== undefined && existing.hydrated !== true) {
-        return
-    }
-    store.entries.set(resolution.key, cacheEntryFromSnapshot(resolution))
-    /* Wake any reader subscribed to this key's lifecycle channel. Seeding used to rely on
-       seed-before-mount ordering (valid for the await path, whose subscription reads the
-       resume manifest, not the cache); an auto-streamed BARE read (ADR-0024) has already
-       mounted and its throwing-peek subscribed the key, so without an explicit dispatch the
-       peek that read `undefined` never re-runs on the streamed value. markLifecycle re-derives
-       the peek scope — the same wake materializeRetained relies on for a late-landing value. */
-    store.markLifecycle(resolution.key)
-}

package/src/lib/ui/settleAsyncCells.ts

@@ -1,51 +0,0 @@
-import { activePendingCells } from './activePendingCells.ts'
-
-/*
-The SSR await-barrier the compiler lowers to `$$settleAsyncCells()` between a
-component's cell declarations and its template (ADR-0019 Tier-2). It DRAINS the
-request-scoped pending list (`splice(0)`) so each barrier awaits only the cells
-declared since the last one — `renderChain` renders layout layers sequentially,
-each with its own barrier, and a drain keeps a later layer from re-awaiting an
-earlier settled layer's cells. `Promise.allSettled` never rejects the render: a
-rejected cell settles into its `error()` state, surfaced at the read site (via
-`$$readCell`), not here. On the client the list is always empty (cells register
-server-side only), so the barrier is a no-op await.
-
-It drains to a FIXPOINT — "await until this branch of the graph stops pausing" —
-not a single snapshot. Pending propagates down dependency edges: a blocking cell
-whose seed reads a still-pending blocking dependency stays pending and registers no
-promise (its seed threw a `SuspenseSignal`, caught as pending, not error). When the
-dependency settles inside this await, the reactive flush is synchronous, so the
-dependent's seed re-runs and registers ITS promise before the loop re-checks — the
-whole chain resolves in order. The per-render list isolation (`isolateCellBarrier`)
-keeps the loop draining only this render's cascade, never a concurrent sibling's.
-
-The round cap bounds a pathological feedback edge — a cell whose settle writes a
-signal its own seed reads re-registers a fresh promise every round, and an
-unbounded fixpoint would hang the SSR request forever. Legitimate chains resolve
-one dependency level per round, so the cap is far above any real graph; hitting
-it renders with whatever settled (the old snapshot-drain behavior) and warns.
-*/
-const MAX_SETTLE_ROUNDS = 1000
-
-// @documentation plumbing
-export async function settleAsyncCells(): Promise<void> {
-    const pending = activePendingCells()
-    if (pending === undefined) {
-        return
-    }
-    let rounds = 0
-    while (pending.promises.length > 0) {
-        if (rounds >= MAX_SETTLE_ROUNDS) {
-            console.warn(
-                '[abide] settleAsyncCells did not reach a fixpoint after ' +
-                    `${MAX_SETTLE_ROUNDS} rounds — an async cell is re-registering ` +
-                    'a promise on every settle (a seed that reads state its own ' +
-                    'resolution writes). Rendering with the values settled so far.',
-            )
-            break
-        }
-        rounds += 1
-        await Promise.allSettled(pending.promises.splice(0))
-    }
-}

package/src/lib/ui/socketChannel.ts

@@ -1,156 +0,0 @@
-import { createSocketSubRegistry } from '../shared/createSocketSubRegistry.ts'
-import { decodeRefJson } from '../shared/decodeRefJson.ts'
-import { encodeRefJson } from '../shared/encodeRefJson.ts'
-import { SOCKETS_PATH } from '../shared/SOCKETS_PATH.ts'
-import type { SocketChannel } from '../shared/types/SocketChannel.ts'
-import type { SocketClientFrame } from '../shared/types/SocketClientFrame.ts'
-import type { SocketServerFrame } from '../shared/types/SocketServerFrame.ts'
-import { withBase } from '../shared/withBase.ts'
-
-let singleton: SocketChannel | undefined
-
-/*
-Lazily opens the single multiplexed ws used by every socket proxy on the page.
-The sub registry + inbound `msg`/`replay`/`end`/`err` routing lives in
-`createSocketSubRegistry` (shared with the test harness); this channel owns the
-transport that wraps it — connect, reconnect/backoff, and visibility.
-
-Outbound frames sent before `ws.onopen` fires are queued and flushed
-on open. The channel reconnects on close with bounded backoff;
-in-flight subs are torn down with the typed disconnect signal so
-consumers' `for await` loops can surface it, then the connection
-comes back up and fresh subs can be opened. The channel itself never
-re-subscribes across a reconnect — it can't know consumer semantics;
-a delta consumer must reconcile state on a fresh connection (e.g.
-re-fetch a snapshot before reapplying deltas). tail() opts in
-above this layer because its latest-wins/window semantics make replay a
-correct reconciliation; raw `for await` consumers keep manual control.
-
-While the backoff timer is armed, `connect()` defers to it: a consumer
-re-subscribing in reaction to the disconnect would otherwise trigger an
-immediate reconnect on every failure cycle, defeating the backoff. Its
-frames queue in `pendingSends` and flush when the timer's attempt opens.
-
-Hidden tabs hold no transport: `visibilitychange: hidden` closes the ws
-through the normal drop path above — subs tear down with the typed
-disconnect, and a resyncing consumer's fresh sub frames queue (connect()
-refuses to open while hidden) until the visible transition reconnects and
-flushes them.
-*/
-export function getSocketChannel(): SocketChannel {
-    if (singleton) {
-        return singleton
-    }
-    let ws: WebSocket | undefined
-    let pendingSends: string[] = []
-    let backoffMs = 250
-    let reconnectTimer: ReturnType<typeof setTimeout> | undefined
-
-    function flushPending(): void {
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            return
-        }
-        for (const message of pendingSends) {
-            ws.send(message)
-        }
-        pendingSends = []
-    }
-
-    function send(frame: SocketClientFrame): void {
-        // ref-json frame so a published message graph with cycles/shared refs survives the wire.
-        const message = encodeRefJson(frame)
-        if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(message)
-            return
-        }
-        pendingSends.push(message)
-        connect()
-    }
-
-    /* The local sub registry + inbound frame routing; this channel owns only the
-       transport (connect/reconnect/backoff/visibility) around it. */
-    const registry = createSocketSubRegistry(send)
-
-    function connect(): void {
-        /* Backoff window owns reconnection; queued frames flush when its attempt opens. */
-        if (reconnectTimer !== undefined) {
-            return
-        }
-        /* Hidden tabs hold no transport — frames queue, the visibility listener reconnects. */
-        if (document.hidden) {
-            return
-        }
-        /* A socket reference in ANY non-closed state means one is already in play — bail.
-           CONNECTING/OPEN are healthy; CLOSING means a close event is still pending and the
-           close handler (which alone nulls `ws` and re-arms the backoff) hasn't run yet.
-           Spawning here would orphan that socket: its deferred close fires against the shared
-           `ws`, draining the fresh connection's subs and nulling it. The close handler always
-           clears `ws`, so reconnection is never stranded — it just sequences after the close. */
-        if (ws) {
-            return
-        }
-        const scheme = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
-        // The mount base routes the upgrade through the proxy (/v2/__abide/sockets).
-        ws = new WebSocket(`${scheme}//${window.location.host}${withBase(SOCKETS_PATH)}`)
-        ws.addEventListener('open', () => {
-            backoffMs = 250
-            flushPending()
-        })
-        ws.addEventListener('message', (event) => {
-            let frame: SocketServerFrame
-            try {
-                frame = decodeRefJson(event.data) as SocketServerFrame
-            } catch {
-                return
-            }
-            registry.routeFrame(frame)
-        })
-        ws.addEventListener('close', () => {
-            const active = registry.drainSubs()
-            /*
-            Drop any queued frames too. We've just torn down every local
-            sub, so replaying their `sub`/`unsub`/`pub` frames on
-            reconnect would open ghost subscriptions on the server that
-            no client object tracks (and never gets an `unsub`). This
-            keeps the "channel never re-subscribes" contract above
-            honest — consumers re-open fresh subs. `drainSubs` cleared the
-            registry before these callbacks run so a consumer reacting to
-            the disconnect (its catch resolves in a microtask, after this
-            handler) registers onto a fresh list.
-            */
-            const hadPending = pendingSends.length > 0
-            pendingSends = []
-            ws = undefined
-            for (const callbacks of active) {
-                callbacks.onDisconnect()
-            }
-            if (active.length === 0 && !hadPending) {
-                return
-            }
-            reconnectTimer = setTimeout(() => {
-                reconnectTimer = undefined
-                connect()
-            }, backoffMs)
-            backoffMs = Math.min(backoffMs * 2, 5000)
-        })
-    }
-
-    /*
-    Release the ws when the tab hides rather than hold an idle connection the
-    browser throttles. Closing rides the normal drop path (close handler →
-    typed disconnect → consumers resync), so by the visible transition the
-    resubscribed frames sit in `pendingSends` waiting for the reconnect.
-    */
-    document.addEventListener('visibilitychange', () => {
-        if (document.hidden) {
-            ws?.close()
-            return
-        }
-        if (pendingSends.length > 0) {
-            connect()
-        }
-    })
-
-    singleton = registry.channel
-    return singleton
-}

package/src/lib/ui/socketProxy.ts

@@ -1,47 +0,0 @@
-import { buildSocketOverChannel } from '../shared/buildSocketOverChannel.ts'
-import { decodeRefJson } from '../shared/decodeRefJson.ts'
-import { SOCKET_SEED } from '../shared/SOCKET_SEED.ts'
-import type { Socket } from '../shared/types/Socket.ts'
-import { getSocketChannel } from './socketChannel.ts'
-import { watch } from './watch.ts'
-
-/*
-Client-side substitute for a server-declared Socket. The bundler emits
-one call per socket export under `src/server/sockets/`: server target uses
-defineSocket (real fan-out), browser target uses socketProxy (subscribe
-over the multiplexed ws channel). Both paths produce identical Socket
-shapes so user code reads the same on either side.
-
-The Socket surface — bare iteration as the live stream, `.tail(n)` seeded
-from the retained tail, `.publish` sending a server-validated `pub` frame —
-is built by buildSocketOverChannel over the page's lazily-opened singleton
-channel; this module only binds that builder to the browser channel so the
-test harness can reuse the identical surface over its own channel.
-
-Backpressure is unbounded — a slow consumer with a chatty socket will
-grow the per-iterator buffer; bounded policies belong in a future
-socketProxy API, not the wire layer.
-*/
-// @documentation plumbing
-export function socketProxy<T>(name: string): Socket<T> {
-    /* Warm-seed from the server's retained frame (shipped in `__SSR__.sockets`, drained into
-       SOCKET_SEED by startClient before mount) so `peek(socket)` returns the SAME value the SSR
-       render committed to instead of undefined on this not-yet-connected client — otherwise the two
-       disagree and hydration discards the server markup. A frame that failed to serialize server-side
-       simply isn't present, and the socket falls back to a cold peek. */
-    const seeded = SOCKET_SEED[name]
-    let initialFrame: T | undefined
-    if (seeded !== undefined) {
-        try {
-            initialFrame = decodeRefJson(seeded) as T
-        } catch {
-            initialFrame = undefined
-        }
-    }
-    const socket = buildSocketOverChannel<T>(name, getSocketChannel, initialFrame)
-    /* Overwrite the shared builder's inert `.watch` with the real reaction sugar
-       (`socket.watch(handler)` ≡ `watch(socket, handler)`). Attached here so the ui-only
-       `watch` primitive never rides into a server bundle. */
-    socket.watch = (handler) => watch(socket, handler)
-    return socket
-}

package/src/lib/ui/startClient.ts

@@ -1,156 +0,0 @@
-import { amendBroadcastSlot } from '../shared/amendBroadcastSlot.ts'
-import { applyAmendLocally } from '../shared/applyAmendLocally.ts'
-import { applyCacheStalenessLocally } from '../shared/applyCacheStalenessLocally.ts'
-import { cacheReaderSocketSlot } from '../shared/cacheReaderSocketSlot.ts'
-import { cacheStalenessSlot } from '../shared/cacheStalenessSlot.ts'
-import { cacheStoreSlot } from '../shared/cacheStoreSlot.ts'
-import { createCacheStore } from '../shared/createCacheStore.ts'
-import { pageSlot } from '../shared/pageSlot.ts'
-import { SOCKET_SEED } from '../shared/SOCKET_SEED.ts'
-import { SSR_SCRIPT_ID } from '../shared/SSR_SCRIPT_ID.ts'
-import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
-import type { SsrPayload } from '../shared/types/SsrPayload.ts'
-import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
-import { createAmendReaderHook } from './amendReaderHook.ts'
-import { probeNavigation } from './probeNavigation.ts'
-import { router } from './router.ts'
-import { CELL_SEED } from './runtime/CELL_SEED.ts'
-import { clientPage } from './runtime/clientPage.ts'
-import { DOC_SEED } from './runtime/DOC_SEED.ts'
-import type { RouteLoader } from './runtime/types/RouteLoader.ts'
-import { seedBootState } from './seedBootState.ts'
-import { seedStreamedResolution } from './seedStreamedResolution.ts'
-import { subscribeCacheStaleness } from './subscribeCacheStaleness.ts'
-
-/*
-The official abide-ui client entry. Reads the server's `window.__SSR__` payload,
-seeds a tab-scoped cache store from the inline snapshot (so a warm `cache()` read
-resolves synchronously and the matching `{#await}` adopts the SSR DOM with
-no re-fetch), installs the mount base, seeds the per-page __SSR__ stamps (app
-name, health, RPC timeout), and starts the router — which imports the
-current route's chunk, adopts the server-rendered `#app`, then drives SPA
-navigation — importing each further page's chunk on first visit and probing the
-destination through the server's app.handle so auth/redirect gating still applies.
-Returns a disposer. `target` defaults to `#app`; pass one explicitly in tests.
-*/
-/*
-Reads the server's SSR payload. Production ships it as an inert `<script
-type="application/json">` (ADR-0051) parsed once here in the deferred bundle — off the
-critical path, and through the fast JSON grammar rather than a compiled multi-MB JS object
-literal. A pre-set `globalThis.__SSR__` wins first: the uiStartClient tests stamp it
-directly, and it preserves any pre-bundle inline stamp. The parsed payload is republished
-onto `globalThis.__SSR__` for devtools / inspector visibility.
-*/
-function readSsrPayload(): Partial<SsrPayload> {
-    const globalScope = globalThis as { __SSR__?: Partial<SsrPayload> }
-    const preset = globalScope.__SSR__
-    if (preset !== undefined) {
-        return preset
-    }
-    const element = typeof document !== 'undefined' ? document.getElementById(SSR_SCRIPT_ID) : null
-    const text = element?.textContent
-    if (!text) {
-        return {}
-    }
-    /* Degrade a mangled payload to a cold boot rather than throwing out of startClient (a
-       proxy/extension could corrupt the script text). The old inline `window.__SSR__ = {…}`
-       statement failed the same way — its throw left the global undefined and the `?? {}`
-       fallback booted cold — so keep that resilience instead of failing the whole mount. */
-    let parsed: Partial<SsrPayload>
-    try {
-        parsed = JSON.parse(text) as Partial<SsrPayload>
-    } catch {
-        return {}
-    }
-    globalScope.__SSR__ = parsed
-    return parsed
-}
-
-// @documentation plumbing
-export function startClient(
-    routes: Record<string, RouteLoader>,
-    layoutRoutes: Record<string, RouteLoader> = {},
-    target: Element | null = typeof document !== 'undefined'
-        ? document.getElementById('app')
-        : null,
-): () => void {
-    if (target === null) {
-        throw new Error('[abide] startClient: missing #app target')
-    }
-    const ssr = readSsrPayload()
-    /* Seed the per-page __SSR__ stamps into their shared slots before mount: the mount
-       base, app name (default log channel), health payload (so health()'s first probe is
-       warm), and the env-configured RPC timeout (ABIDE_CLIENT_TIMEOUT, shipped per
-       request). Driven by the exhaustive `seedBootState` map so a new boot field can't be
-       stamped server-side and silently dropped here. Without seeding: no mount base,
-       channel 'app', a cold first health probe, and unbounded RPC fetches. */
-    seedBootState(ssr)
-    /* The `page` proxy reads route/params/url off the router-updated snapshot. */
-    pageSlot.resolver = () => clientPage.value
-
-    const store = createCacheStore()
-    cacheStoreSlot.resolver = () => store
-    /* One tab store: cache(fn, { shared: true }) shares it, so shared is a no-op here. */
-    sharedCacheStoreSlot.resolver = () => store
-    /* invalidate()/refresh() apply to THIS tab's cache (the server entry installs a
-       broadcaster instead — the ADR-0041 side-swap). Same function as the slot fallback so
-       the local-apply path can't diverge. */
-    cacheStalenessSlot.resolver = () => applyCacheStalenessLocally
-    /* amend(args, value) applies to THIS tab's cache too — the server entry broadcasts instead
-       (the ADR-0043 side-swap). Same function as the slot fallback for the same reason. */
-    amendBroadcastSlot.resolver = () => applyAmendLocally
-    /* Open/close a per-call amend value subscription as reactive readers of a key come and go
-       (ADR-0043), so a server amend(args, value) push lands on keys this tab is reading. */
-    const amendReader = createAmendReaderHook()
-    cacheReaderSocketSlot.resolver = () => amendReader.hook
-    /* Seed both SSR cache partitions through the one streamed-resolution sink: `ssr.cache`
-       (inline — reads settled at render-return, in __SSR__) and `__abideResumeCache` (pending
-       {#await} reads whose `__abideResolve(...)` chunks the stream pushed during parse, before
-       this deferred bundle ran). A warm entry lets a `cache()` read resolve synchronously so
-       `{#await}` adopts without a refetch; a miss marker re-fetches live. */
-    const streamed =
-        (globalThis as { __abideResumeCache?: StreamedResolution[] }).__abideResumeCache ?? []
-    for (const resolution of [...(ssr.cache ?? []), ...streamed]) {
-        seedStreamedResolution(resolution)
-    }
-    /* Seed the async-cell warm partition into `CELL_SEED` before mount: a hydrating
-       `createAsyncCell` reads its render-path key here to adopt the SSR-resolved value warm
-       instead of re-running its seed cold (Object.assign so an inline pre-bundle script that
-       already populated `__abideCells` isn't clobbered). */
-    if (ssr.cells !== undefined) {
-        Object.assign(CELL_SEED, ssr.cells)
-    }
-    /* Seed the doc-state warm partition into DOC_SEED before mount: a hydrating `createScope` reads
-       its render-path key to adopt the SSR doc snapshot, so a plain `state(initial)` keeps the server
-       value (the consume-once swap in `scope.replace`) instead of re-running a divergent init. */
-    if (ssr.docs !== undefined) {
-        Object.assign(DOC_SEED, ssr.docs)
-    }
-    /* Seed the socket warm partition into SOCKET_SEED before mount: a hydrating `socketProxy` reads
-       its name key to seed `lastFrame`, so `peek(socket)` returns the server's retained frame instead
-       of undefined on the not-yet-connected client — congruent with the SSR HTML. */
-    if (ssr.sockets !== undefined) {
-        Object.assign(SOCKET_SEED, ssr.sockets)
-    }
-    /* Keep the cache channel live past boot: replace the head's buffering collector with
-       the store-connected sink so a post-boot resolution — the inline doc-stream cache
-       script — seeds the store through `seedStreamedResolution` directly instead of pushing
-       to a buffer nothing drains again. The inline doc-stream script only ever hands this a
-       cache `StreamedResolution`. */
-    ;(globalThis as { __abideResolve?: (resolution: StreamedResolution) => void }).__abideResolve =
-        seedStreamedResolution
-
-    /* Subscribe to the reserved cache-staleness pipe (ADR-0041) AFTER seeding, so a server
-       broadcast drops/refetches this tab's freshly-hydrated cache — live-only, never replay. */
-    const disposeStaleness = subscribeCacheStaleness()
-    const disposeRouter = router(target, routes, layoutRoutes, probeNavigation)
-    return () => {
-        disposeStaleness()
-        amendReader.dispose()
-        /* Clear the reader hook so a post-teardown cache read doesn't re-open amend subscriptions
-           — unlike the staleness/store slots (whose leaked resolver stays benign), a live hook on
-           the read path must not outlive the client it belongs to. */
-        cacheReaderSocketSlot.resolver = undefined
-        disposeRouter()
-    }
-}