@abide/abide 0.49.0 → 0.50.1

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

@@ -2,7 +2,6 @@ import { applyPatchToTree } from './applyPatchToTree.ts'
 import { batch } from './batch.ts'
 import { createComputedNode } from './createComputedNode.ts'
 import { createSignalNode } from './createSignalNode.ts'
-import { PATCH_BUS } from './PATCH_BUS.ts'
 import { pathSegments } from './pathSegments.ts'
 import { readNode } from './readNode.ts'
 import { trigger } from './trigger.ts'
@@ -59,12 +58,9 @@ export function createDoc(initial: unknown): Doc {
        truth. Held apart from `nodes` so the structural wake/eviction never touches
        them; their dirtiness is driven entirely by the deps they read (the signal
        graph), not by tree mutations. They are not in `tree`, so `snapshot` omits
-       them, and they never pass through `apply`, so they never hit the patch bus —
-       a recompute is a downstream reaction, not a change to journal/persist/sync. */
+       them, and they never pass through `apply` — a recompute is a downstream reaction
+       of the signal graph, not a tree change. */
     const computed = new Map<string, ReactiveNode>()
-    /* Set to the returned document before any apply runs, so a PATCH_BUS event can
-       name the document it came from (reference identity, the undo/persistence key). */
-    let self: Doc
 
     /* Links `path` into the trie under its parent and continues up the ancestor chain.
        Stops at the first ancestor whose parent set already lists it — that link, and
@@ -227,10 +223,6 @@ export function createDoc(initial: unknown): Doc {
         /* Segments index the tree, so they carry the REAL keys (unescaped); the path
            strings (parentPath, node-map keys) stay escaped, re-walked through walkPath. */
         const segments = patch.path === '' ? [] : pathSegments(patch.path)
-        /* Capture the pre-image only when a consumer is listening (the inverse's only
-           cost): a replace/remove inverts to the value it overwrote, an add to a
-           remove (computed post-apply, below, to resolve an array append's index). */
-        const before = PATCH_BUS.active ? walkPath(tree, patch.path) : undefined
         tree = applyPatchToTree(tree, patch, segments)
         const parentPath = parentPathOf(patch.path)
         const parentValue = walkPath(tree, parentPath).value
@@ -270,40 +262,9 @@ export function createDoc(initial: unknown): Doc {
             } else {
                 wakeSubtree(parentPath, true, true)
             }
-            /* Announce the change before effects flush, so a patch an effect emits in
-               reaction lands AFTER this one on the bus — the journal stays chronological.
-               Emitting inside the batch keeps it ahead of the depth-0 flush on batch exit. */
-            if (PATCH_BUS.active) {
-                PATCH_BUS.emit({ doc: self, patch, inverse: inverseOf(patch, before) })
-            }
         })
     }
 
-    /* The patch that undoes `patch`, from the pre-image `before` (a value the change
-       overwrote/removed) and the now-mutated tree. An add inverts to removing the slot
-       it created — resolving an array append (`-`) to the concrete last index it took.
-       A replace/remove of a path that held nothing inverts to remove/nothing. */
-    function inverseOf(
-        patch: Patch,
-        before: ReturnType<typeof walkPath> | undefined,
-    ): Patch | undefined {
-        if (patch.op === 'add') {
-            const parentPath = parentPathOf(patch.path)
-            const parent = walkPath(tree, parentPath).value
-            const resolved =
-                Array.isArray(parent) && patch.path.endsWith('/-')
-                    ? `${parentPath}/${parent.length - 1}`
-                    : patch.path
-            return { op: 'remove', path: resolved }
-        }
-        if (patch.op === 'replace') {
-            return before?.exists
-                ? { op: 'replace', path: patch.path, value: before.value }
-                : { op: 'remove', path: patch.path }
-        }
-        return before?.exists ? { op: 'add', path: patch.path, value: before.value } : undefined
-    }
-
     /*
     A stable accessor bound to one scalar leaf — what the compiler emits so a hot
     loop has zero string work: the node, the parent container, and the leaf key
@@ -355,7 +316,7 @@ export function createDoc(initial: unknown): Doc {
         }
     }
 
-    self = {
+    const self: Doc = {
         read,
         cell,
         derive,

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

@@ -1,3 +1,5 @@
+import { boundaryFor } from './boundaryFor.ts'
+import { CURRENT_BOUNDARY } from './CURRENT_BOUNDARY.ts'
 import { CURRENT_SCOPE } from './CURRENT_SCOPE.ts'
 import { inScope } from './inScope.ts'
 import { NODE_STATE } from './NODE_STATE.ts'
@@ -67,5 +69,12 @@ export function createEffectNode(fn: () => EffectResult): () => void {
     if (OWNER.current !== undefined) {
         OWNER.current.push(dispose)
     }
+    /* Effects built inside a reactive `{#try}` associate with its boundary so a LATER re-run
+       throw (an async cell that rejects post-mount, read via a throwing peek) routes there
+       rather than the collect-and-rethrow fallback. Populated only under a boundary — the
+       node shape stays untouched, the lookup is cold (only on the throw path). */
+    if (CURRENT_BOUNDARY.current !== undefined) {
+        boundaryFor.set(node, CURRENT_BOUNDARY.current)
+    }
     return dispose
 }

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

@@ -1,12 +1,13 @@
 import { RENDER } from './RENDER.ts'
 
-/* Marks entry into a render/mount. The OUTERMOST one (depth 0) resets the block-id
-   counter so every render pass starts at 0; a child component's render/mount runs
-   at depth > 0 and continues the parent's counter. Pair with `exitRenderPass`. */
+/* Marks entry into a render/mount. The OUTERMOST one (depth 0) clears the per-path
+   block-id counters so every render pass starts each path at 0 (a re-navigation to the
+   same route must not continue a prior pass's counter); a child component's render/mount
+   runs at depth > 0 and continues the same map. Pair with `exitRenderPass`. */
 // @documentation plumbing
 export function enterRenderPass(): void {
     if (RENDER.depth === 0) {
-        RENDER.blockId = 0
+        RENDER.blockCounters.clear()
     }
     RENDER.depth += 1
 }

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

@@ -1,3 +1,4 @@
+import { boundaryFor } from './boundaryFor.ts'
 import { NODE_STATE } from './NODE_STATE.ts'
 import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
 import type { ReactiveNode } from './types/ReactiveNode.ts'
@@ -49,12 +50,21 @@ function drain(): void {
             try {
                 updateIfNecessary(node)
             } catch (error) {
-                /* One effect throwing must not strand the effects queued behind it — they
-                   live in this same `batch`, which becomes unreachable the moment we swap
-                   `pendingEffects`. Reset the culprit to CLEAN so a later write to its
-                   dependencies can re-queue it (otherwise `mark`'s CLEAN→dirty gate leaves
-                   it permanently inert), then keep draining and surface the error(s) once
-                   the graph has settled rather than swallowing them. */
+                /* A node built inside a reactive `{#try}` routes its throw to that boundary
+                   (swap the guarded content to the catch branch) instead of the rethrow
+                   fallback — this is the "later re-run throw" the sync boundary could not
+                   catch. Reset it CLEAN either way so a later write to its deps can re-queue
+                   it (otherwise `mark`'s CLEAN→dirty gate leaves it permanently inert). */
+                const boundary = boundaryFor.get(node)
+                if (boundary !== undefined) {
+                    boundary.handle(error)
+                    node.status = NODE_STATE.CLEAN
+                    continue
+                }
+                /* No boundary — one effect throwing must not strand the effects queued behind
+                   it (they live in this same `batch`, unreachable once we swap
+                   `pendingEffects`); keep draining and surface the error(s) once the graph has
+                   settled rather than swallowing them. */
                 node.status = NODE_STATE.CLEAN
                 if (errors === undefined) {
                     errors = []

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

@@ -0,0 +1,14 @@
+/*
+True for an `async () => …` / `async function () {}`. This is the async cell's
+`await` marker at runtime: the `computed`/`linked` transform lowers `computed(await p)`
+to `computed(async () => await p)`, so an async-function seed means "unwrap the
+promise and track it" — as opposed to a plain thunk returning a promise, which is held
+opaque (`Computed<Promise<T>>`). The tag is the reliable signal (`.constructor.name`
+survives minification less reliably; `Symbol.toStringTag` is spec-stable).
+*/
+export function isAsyncFunction(value: unknown): boolean {
+    return (
+        typeof value === 'function' &&
+        (value as { [Symbol.toStringTag]?: unknown })[Symbol.toStringTag] === 'AsyncFunction'
+    )
+}

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

@@ -1,11 +1,12 @@
+import { blockId } from './blockId.ts'
 import { RENDER } from './RENDER.ts'
 
-/* The next block id in the current render pass. `await`/`try` blocks draw from it
-   in document order — shared across a component and the children it inlines — so a
-   page id and a child component's id never collide in the global `RESUME` manifest. */
+/* The next block id in the current render pass, namespaced by the ambient render-path
+   (ADR-0037). `await`/`try` blocks draw it in document order WITHIN their path; a page
+   id and a child component's id can never collide because they carry different paths, so
+   ids stay congruent SSR↔client even when the server renders sibling children concurrently.
+   Delegates to the shared `blockId` over the client's per-pass `RENDER.blockCounters` map. */
 // @documentation plumbing
-export function nextBlockId(): number {
-    const id = RENDER.blockId
-    RENDER.blockId += 1
-    return id
+export function nextBlockId(): string {
+    return blockId(RENDER.blockCounters)
 }

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

@@ -0,0 +1,16 @@
+import { CURRENT_PATH } from './CURRENT_PATH.ts'
+import { withPath } from './withPath.ts'
+
+/*
+The render-path a `<Child/>` mounts under — the boundary id of a STREAMED child component (ADR-0039).
+Composes the child's ordinal segment onto the ambient path exactly as the client's `mountChild` /
+`mountStreamedChild` does (`withPath(ordinal, …)`), so the server-written `abide:await:CHILDPATH`
+boundary and the client adopter compute the SAME id with no counter to drift. It carries `/`
+separators and never a `:`, so a child path (`products/0`) can't collide with an await-block id
+(`products:0`). Server-emit-only (the streaming boundary is server codegen), so it tree-shakes out of
+the client bundle like `$$flight`.
+*/
+// @documentation plumbing
+export function renderPath(segment: string | number): string {
+    return withPath(segment, () => CURRENT_PATH.current)
+}

package/src/lib/ui/runtime/types/Boundary.ts

@@ -0,0 +1,9 @@
+/*
+A reactive error boundary — the runtime handle a `{#try}` installs so a LATER re-run
+throw from a guarded effect (an async cell that rejects after mount, read via a throwing
+peek) routes back to it. `handle(error)` swaps the guarded content to the catch branch;
+the scheduler (`flushEffects.drain`) calls it when a node associated with this boundary
+(`boundaryFor`) throws during a flush. Kept minimal so the boundary can install itself as
+the ambient `CURRENT_BOUNDARY` around a guarded build without dragging DOM types here.
+*/
+export type Boundary = { handle(error: unknown): void }

package/src/lib/ui/runtime/types/RenderContext.ts

@@ -1,8 +1,10 @@
 /* The per-request SSR render context, threaded through a layout chain and every
-   child component a page inlines. `next` is the block-id counter: each `await`/`try`
-   block draws from it in depth-first document order — the SAME order the client
-   allocates ids during its synchronous hydration walk, so the streamed fragments and
-   the `RESUME` manifest line up. Request-local (not a module global) because SSR
-   render is async — a blocking `await` yields, and a shared global counter would
-   interleave across concurrent requests. */
-export type RenderContext = { next: number }
+   child component a page inlines. It is the block-id counter MAP (ADR-0037): each
+   `await`/`try` block draws a path-namespaced id via `blockId(ctx)` — keyed by the
+   ambient render-path, counting 0,1,2… in document order WITHIN each path. Both sides
+   compose the same ids (the client mounts each child under the same path), so the
+   streamed fragments and the `RESUME` manifest line up. Request-local (not a module
+   global) because SSR render is async and concurrent — but sibling child renders write
+   different path keys, so the shared map needs no locking and survives parallel renders
+   (which a single flat counter could not). */
+export type RenderContext = Map<string, number>

package/src/lib/ui/runtime/types/SsrRender.ts

@@ -9,10 +9,17 @@ import type { ResumeEntry } from '../RESUME.ts'
    on the tag — never land here: they render inline during the async render pass and
    seed `SsrRender.resume`.) */
 export type SsrAwait = {
-    id: number
+    id: string
     promise: () => unknown
     then: (value: unknown) => Promise<string>
     catch?: (error: unknown) => Promise<string>
+    /* ADR-0039 (spike): a STANDALONE-UNIT boundary — a streamed child COMPONENT — carries no
+       resume value of its own (its `then` returns the child's rendered html and merges the child's
+       own awaits/resume for nested composition; the child re-mounts client-side rather than
+       adopting a RESUME[id] value). Marks `settle` to emit an html-only fragment with no resume seed
+       script, so the client never tries to decode a whole SsrRender as an await value. Absent for a
+       normal await block (which seeds its resolved value). */
+    htmlOnly?: boolean
 }
 
 /* The result of a component's server `render()`: the pending-shell HTML, the
@@ -23,5 +30,5 @@ export type SsrRender = {
     html: string
     state: unknown
     awaits: SsrAwait[]
-    resume: Record<number, ResumeEntry>
+    resume: Record<string, ResumeEntry>
 }

package/src/lib/ui/runtime/types/UiComponent.ts

@@ -18,11 +18,7 @@ export type UiComponent = ((host: Element, props?: UiProps) => () => void) & {
     hydrate?: (host: Element, props?: UiProps) => () => void
     /* The bare client build (`(host, props) => void`) — appends the component's nodes
        to `host`. A nested child mounts it into a marker range (`mountRange`/`mountChild`)
-       instead of the wrapped `mount`, and `hotReplace` re-fills a range with the new
-       module's `build` on edit. */
+       instead of the wrapped `mount`. */
     build: (host: Node, props?: UiProps) => void
     hydratable?: boolean
-    /* Stable module id (project-relative source path) stamped by `compileModule`,
-       keying the component in the hot-reload registry — see `mountChild`. */
-    __abideId?: string
 }

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

@@ -0,0 +1,8 @@
+import { withPath } from './withPath.ts'
+
+/* Runs `build` under the render-path segment for a compiler `ordinal`, or plainly when `ordinal`
+   is undefined (a non-compiled caller that supplied no site id). Shared by the child-mount paths so
+   the "push a path segment iff an ordinal is present" convention lives in one place. */
+export function withOptionalPath<T>(ordinal: number | undefined, build: () => T): T {
+    return ordinal === undefined ? build() : withPath(ordinal, build)
+}

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

@@ -0,0 +1,16 @@
+import { CURRENT_PATH } from './CURRENT_PATH.ts'
+import { withPathFrom } from './withPathFrom.ts'
+
+/*
+Pushes one render-path segment for the duration of `build`, RELATIVE to the live ambient path,
+restoring after (synchronous build, so the save/restore is exact and nesting is a strict stack —
+the same shape `withScope`/`enterRenderPass` use). The segment is `escapeKey`-escaped and joined
+with `/`, so a segment carrying a `/` (a URL-shaped `{#each}` key) survives as one element. Used
+at sites that run DURING the initial render walk (a layout layer, a `<Child/>` mount) where the
+ambient path is the correct base. A control-flow block that rebuilds reactively after mount uses
+`withPathFrom` with a captured base instead.
+*/
+// @documentation plumbing
+export function withPath<T>(segment: string | number, build: () => T): T {
+    return withPathFrom(CURRENT_PATH.current, segment, build)
+}

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

@@ -0,0 +1,20 @@
+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/seedStreamedResolution.ts

@@ -1,6 +1,9 @@
 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
@@ -9,12 +12,27 @@ so a `cache()` read resolves synchronously (no wire round-trip) and `<template a
 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, the live `window.__abideResolve`, and applyResolved,
-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.
+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
     }
@@ -22,10 +40,17 @@ export function seedStreamedResolution(resolution: StreamedResolution): void {
        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 { entries } = activeCacheStore()
-    const existing = entries.get(resolution.key)
+    const store = activeCacheStore()
+    const existing = store.entries.get(resolution.key)
     if (existing !== undefined && existing.hydrated !== true) {
         return
     }
-    entries.set(resolution.key, cacheEntryFromSnapshot(resolution))
+    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

@@ -0,0 +1,24 @@
+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.
+*/
+// @documentation plumbing
+export async function settleAsyncCells(): Promise<void> {
+    const pending = activePendingCells()
+    if (pending === undefined) {
+        return
+    }
+    const promises = pending.promises.splice(0)
+    if (promises.length > 0) {
+        await Promise.allSettled(promises)
+    }
+}

package/src/lib/ui/socketProxy.ts

@@ -11,7 +11,7 @@ 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, `.broadcast` sending a server-validated `pub` frame —
+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.

package/src/lib/ui/startClient.ts

@@ -5,18 +5,12 @@ import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
 import type { SsrPayload } from '../shared/types/SsrPayload.ts'
 import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
 import { probeNavigation } from './probeNavigation.ts'
-import { seedBootState } from './seedBootState.ts'
-
-/* Build-time flag the production client defines false (see build.ts `define`) so the dev-only
-   hot bridge — and the entire DOM runtime it statically pulls in for re-builds — is dead-code-
-   eliminated, not even emitted as a chunk. Dev defines it true; the test preload sets it on
-   globalThis so the bare reference resolves there. */
-declare const __ABIDE_DEV__: boolean
-
 import { router } from './router.ts'
+import { CELL_SEED } from './runtime/CELL_SEED.ts'
 import { clientPage } from './runtime/clientPage.ts'
 import type { RouteLoader } from './runtime/types/RouteLoader.ts'
-import { seedResolved } from './seedResolved.ts'
+import { seedBootState } from './seedBootState.ts'
+import { seedStreamedResolution } from './seedStreamedResolution.ts'
 
 /*
 The official abide-ui client entry. Reads the server's `window.__SSR__` payload,
@@ -40,21 +34,6 @@ export function startClient(
     if (target === null) {
         throw new Error('[abide] startClient: missing #app target')
     }
-    /* Dev only: the live-reload script sets `__abideDev` before this module runs, so the
-       runtime bridge is in place before any component mounts and records its instances
-       (mountChild) for hot replacement. Lazy-imported and `__ABIDE_DEV__`-gated so the
-       bridge (and the DOM runtime it drags in) is fully dead-code-eliminated in production
-       rather than shipped behind a runtime flag the minifier can't prove false. */
-    if (__ABIDE_DEV__ && (globalThis as { __abideDev?: boolean }).__abideDev) {
-        import('./installHotBridge.ts').then((module) => module.installHotBridge())
-    }
-    /* Inspector only: the server injects `__abideInspect` when ABIDE_ENABLE_INSPECTOR is on,
-       so the scope/router bridge arms before the router builds any scope. Inspector can be
-       enabled in production, so this stays a lazy chunk (not `__ABIDE_DEV__`-gated) — emitted
-       but fetched only when the flag is set, never weighing down the default client load. */
-    if ((globalThis as { __abideInspect?: boolean }).__abideInspect) {
-        import('./installInspectorBridge.ts').then((module) => module.installInspectorBridge())
-    }
     const ssr = (globalThis as { __SSR__?: Partial<SsrPayload> }).__SSR__ ?? {}
     /* 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
@@ -78,16 +57,22 @@ export function startClient(
     const streamed =
         (globalThis as { __abideResumeCache?: StreamedResolution[] }).__abideResumeCache ?? []
     for (const resolution of [...(ssr.cache ?? []), ...streamed]) {
-        seedResolved({ kind: 'cache', resolution })
+        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)
     }
     /* Keep the cache channel live past boot: replace the head's buffering collector with
-       the store-connected sink so a post-load resolution — streaming SPA navigation or a
-       socket-delivered SSR frame, both routed through applyResolved — seeds the store
-       directly instead of pushing to a buffer nothing drains again. The inline doc-stream
-       script only ever hands this a cache `StreamedResolution`, so wrap it as a cache frame
-       through the one intake seam. */
+       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 =
-        (resolution) => seedResolved({ kind: 'cache', resolution })
+        seedStreamedResolution
 
     return router(target, routes, layoutRoutes, probeNavigation)
 }

package/src/lib/ui/trackedComputed.ts

@@ -0,0 +1,68 @@
+import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
+import type { AsyncComputed } from '../shared/types/AsyncComputed.ts'
+import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
+import { createAsyncCell } from './runtime/createAsyncCell.ts'
+import { createComputedNode } from './runtime/createComputedNode.ts'
+import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
+import { OWNER } from './runtime/OWNER.ts'
+import { readNode } from './runtime/readNode.ts'
+import type { Computed } from './runtime/types/Computed.ts'
+import { unlinkDeps } from './runtime/unlinkDeps.ts'
+import { untrack } from './runtime/untrack.ts'
+
+/*
+The eager, stream-classifying read-only computed the compiler routes a bare-call /
+identifier seed to — `computed(getStream())` / `computed(ref)` (ADR-0019 D1). Unlike the
+lazy `computed` primitive it PROBES its seed once to self-identify the source: a
+`NamedAsyncIterable` (socket / streaming rpc) auto-tracks its frames as an `AsyncComputed`,
+an `async () => await …` seed unwraps its promise, and anything else — a sync value, a bare
+opaque promise — falls back to the lazy `Computed`, so laziness is preserved on the miss and
+only a real stream/promise producer becomes a cell. It lives apart from the `computed`
+primitive so a DIRECT `computed(() => …)` call stays lazy (the primitive never probes); the
+eager probe is reached only through this compiler-emitted entry, matching how `linked`
+already classifies its seed. The probe runs untracked — a throwaway read must not subscribe
+the enclosing build.
+*/
+export function trackedComputed<T>(
+    compute: () => T | Promise<T> | NamedAsyncIterable<T>,
+    /* ADR-0032: when the compiler lifts a no-`await` async (sub)expression to a cell, it passes
+       `streaming: true` so the resolved promise does not join the SSR blocking barrier (the shell
+       ships pending, the client resolves). Default false = today's blocking registration; a stream
+       seed never registers regardless, so it only matters for a promise-unwrapping seed. */
+    streaming = false,
+): Computed<T> | AsyncComputed<T> {
+    /* `await` marker: an async-function seed unwraps its promise into a read-only async cell. */
+    if (isAsyncFunction(compute)) {
+        return createAsyncCell(compute as () => unknown, {
+            writable: false,
+            streaming,
+        }) as AsyncComputed<T>
+    }
+    /* Probe the seed once (untracked) to detect a self-identifying stream. A discarded stream
+       iterable costs nothing — a streaming rpc defers its fetch to the first pull, which never
+       happens here; a throw means a plain reactive compute, so fall through to the lazy path
+       (it throws at read, unchanged). */
+    let probe: unknown
+    let threw = false
+    try {
+        probe = untrack(compute)
+    } catch {
+        threw = true
+    }
+    if (!threw && isAsyncIterable(probe)) {
+        return createAsyncCell(compute as () => unknown, {
+            writable: false,
+            streaming,
+        }) as AsyncComputed<T>
+    }
+    /* Sync value or a bare (opaque) promise: the lazy computed, identical to the primitive. */
+    const node = createComputedNode(compute as () => unknown)
+    if (OWNER.current !== undefined) {
+        OWNER.current.push(() => unlinkDeps(node))
+    }
+    return {
+        get value(): T {
+            return readNode(node) as T
+        },
+    }
+}