@abide/abide 0.54.0 → 0.56.0

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

@@ -0,0 +1,38 @@
+import { SEED_MARKS } from './SEED_MARKS.ts'
+
+/*
+Reads a warm-seed entry (`CELL_SEED` / `DOC_SEED`) under the one-shot contract: a seed
+hydrates exactly one pass, so a LATER fresh mount at the same render-path can't
+warm-adopt a stale boot-time snapshot (an SPA navigation recomputes the identical key).
+
+Two-phase (ADR-0048): during a hydration pass the read MARKS the entry instead of deleting
+it — a clean pass exit deletes the marked keys, and a THROWING pass leaves every value in
+place, so the discard→cold-rebuild recovery re-adopts the SSR-resolved values instead of
+refetching (a cold refetch would leave blocking `await` cells pending and escape as an
+uncaught SuspenseSignal at mount). WITHIN a pass the read is idempotent — a repeat read
+re-adopts the still-present value, because the repeat is a block-level cold rebuild
+reconstructing the same render-path inside the live pass (its first construction marked
+the key, then the adopt desynced); the one-shot half is enforced at pass exit, not per
+read. Outside a pass — the recovery rebuild itself, a manual client-only mount — the
+read deletes immediately, the plain one-shot.
+*/
+export function consumeSeed(store: Record<string, string>, key: string): string | undefined {
+    const marks = SEED_MARKS.current
+    if (marks === undefined) {
+        const value = store[key]
+        if (value !== undefined) {
+            delete store[key]
+        }
+        return value
+    }
+    const value = store[key]
+    if (value !== undefined) {
+        let keys = marks.get(store)
+        if (keys === undefined) {
+            keys = new Set()
+            marks.set(store, keys)
+        }
+        keys.add(key)
+    }
+    return value
+}

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

@@ -12,10 +12,12 @@ import { activePendingCells } from '../activePendingCells.ts'
 import type { Scope } from '../types/Scope.ts'
 import { CELL_SEED } from './CELL_SEED.ts'
 import { CURRENT_SCOPE } from './CURRENT_SCOPE.ts'
+import { consumeSeed } from './consumeSeed.ts'
 import { createEffectNode } from './createEffectNode.ts'
 import { createSignalNode } from './createSignalNode.ts'
 import { readNode } from './readNode.ts'
 import { registerStreamedCell } from './STREAMED_CELLS.ts'
+import { SuspenseSignal } from './SuspenseSignal.ts'
 import { writeNode } from './writeNode.ts'
 
 /* The seed's transform gate (mirrors `state`/`linked`): coerces every value entering
@@ -83,6 +85,14 @@ export function createAsyncCell(
     let inFlight: Promise<unknown> | undefined
     /* Cancels the active stream subscription (a reseed, refresh, or dispose supersedes it). */
     let cancelStream: (() => void) | undefined
+    /* Whether a pending read of this cell PAUSES its reader (ADR-0046). True only for a
+       BLOCKING source — a settling PROMISE the cell would join the SSR barrier for (author
+       `await`, or a fail-open bare-call that registers): `streaming !== true` AND the seed
+       produced a thenable. A STREAM (`isAsyncIterable`) never settles and always peeks, so it
+       is NOT blocking even though it carries the same default `streaming` flag; `run` clears
+       this when it sees a stream. Resolved from the produced source, not the flag alone, so
+       `streaming: false` cannot conflate "author `await`" with "stream". */
+    let blockingSource = false
 
     /* Store a produced value, honouring the write latch and the transform gate. */
     const acceptValue = (value: unknown): void => {
@@ -126,6 +136,16 @@ export function createAsyncCell(
             return
         }
         inFlight = undefined
+        /* A `SuspenseSignal` is a PAUSE, not a failure — the same as the synchronous case in
+           `run`, but arriving through a REJECTION: an async seed (`computed(await f(dep))`) reads a
+           pending blocking `dep` in its synchronous prefix, and the throw becomes the thunk's
+           rejection rather than a sync throw. Stay pending (leave `inFlightNode` true, hold no
+           error); the throwing read subscribed this seed's effect to `dep` during that prefix, so
+           it re-runs and produces the real source once `dep` settles. */
+        if (error instanceof SuspenseSignal) {
+            writeNode(errorNode, undefined)
+            return
+        }
         writeNode(errorNode, error)
         writeNode(inFlightNode, false)
     }
@@ -181,15 +201,45 @@ export function createAsyncCell(
         try {
             produced = seed()
         } catch (error) {
+            /* A `SuspenseSignal` is a PAUSE, not a failure: this seed read a blocking
+               dependency that has no value yet, so this cell's branch pauses too. Stay
+               pending — leave `inFlightNode` true, hold no value, carry no error — rather
+               than latching the pause into `error()`. The throwing read already subscribed
+               this seed's effect to the pending dependency, so when it settles the effect
+               re-runs the seed, which now reads a value and produces the real source. No
+               promise is registered (there is none), so the SSR barrier's fixpoint drain
+               picks this cell up on that re-run instead. */
+            if (error instanceof SuspenseSignal) {
+                /* This cell's pending reads must PAUSE too — the seed derives from a blocking
+                   source, so a reader peeking `undefined` (the streaming default) would race the
+                   dependency instead of waiting for it. Mark blocking from the SUSPEND itself,
+                   since a synchronously-suspending seed produces no promise for the `isThenable`
+                   branch to read it from; honour a `streaming` opt-out for symmetry with that
+                   branch. Once the seed re-runs and settles a value this flag is moot (a retained
+                   value is returned before `blocking` is ever consulted). */
+                if (options.streaming !== true) {
+                    blockingSource = true
+                }
+                if (myRun === runId) {
+                    inFlight = undefined
+                    writeNode(errorNode, undefined)
+                }
+                return
+            }
             settleError(myRun, error)
             return
         }
 
         if (isAsyncIterable(produced)) {
+            /* A stream never settles — it PEEKS `undefined` until its first frame, never pauses. */
+            blockingSource = false
             consumeStream(myRun, produced as NamedAsyncIterable<unknown>)
             return
         }
         if (isThenable(produced)) {
+            /* A settling promise the cell would join the SSR barrier for (author `await`, or a
+               fail-open bare-call) PAUSES a pending read; a `streaming` promise peeks. */
+            blockingSource = options.streaming !== true
             inFlight = produced as Promise<unknown>
             /* Server-only: register the in-flight promise on the request-scoped pending list so
                the SSR barrier (`$$settleAsyncCells`) awaits it before the template peeks the
@@ -222,15 +272,15 @@ export function createAsyncCell(
        only in effect (the store is only ever populated by `startClient`, so it's empty on the
        server — no `window` sniff needed); a decode failure falls through to a cold run. */
     if (warmKey !== undefined) {
-        const seeded = CELL_SEED[warmKey]
+        /* One-shot via `consumeSeed` (two-phase, ADR-0048): a LATER fresh mount at the same
+           render-path can't warm-adopt this boot-time snapshot. `scope.id` is the route PATTERN
+           (params-independent), so an SPA navigation `/products/42`→`/products/99` — or a
+           back-nav that rebuilds the SSR page — recomputes the identical warmKey; unconsumed,
+           the new cell would render `/products/42`'s stale value until revalidation. During a
+           hydration pass the consume only MARKS, so a desync throw hands the seed to the cold
+           rebuild instead of losing it. */
+        const seeded = consumeSeed(CELL_SEED, warmKey)
         if (seeded !== undefined) {
-            /* One-shot: consume the seed so a LATER fresh mount at the same render-path can't
-               warm-adopt this boot-time snapshot. `scope.id` is the route PATTERN (params-
-               independent), so an SPA navigation `/products/42`→`/products/99` — or a back-nav
-               that rebuilds the SSR page — recomputes the identical warmKey; without deleting,
-               the new cell would render `/products/42`'s stale value until revalidation. The seed
-               only ever hydrates the initial SSR render, where each cell is constructed once. */
-            delete CELL_SEED[warmKey]
             try {
                 acceptValue(decodeRefJson(seeded))
             } catch {
@@ -279,6 +329,14 @@ export function createAsyncCell(
         /* The current in-flight promise (undefined once settled / not-a-promise) — an internal
            runtime affordance the SSR barrier reads structurally; not on the public cell types. */
         settled: () => inFlight,
+        /* Whether a pending read of this cell PAUSES its reader (ADR-0046) — true only for a
+           blocking source (a barrier-joining settling promise), resolved from what the seed
+           produced (`blockingSource`) so a stream (which shares the default `streaming` flag)
+           is correctly NON-blocking. A getter, since the seed's eager run sets it. `readCell`
+           consults it; an internal affordance, not on the public cell type. */
+        get blocking(): boolean {
+            return blockingSource
+        },
     } as AsyncComputed<unknown>
     if (!options.writable) {
         return readOnly

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

@@ -13,6 +13,7 @@ export function createComputedNode(compute: () => unknown): ReactiveNode {
         subsHead: undefined,
         subsTail: undefined,
         status: NODE_STATE.DIRTY,
+        thrown: undefined,
         isEffect: false,
     }
 }

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

@@ -52,6 +52,7 @@ export function createEffectNode(fn: () => EffectResult): () => void {
         subsTail: undefined,
         /* Born DIRTY; the immediate `runNode` below captures deps and settles it CLEAN. */
         status: NODE_STATE.DIRTY,
+        thrown: undefined,
         isEffect: true,
     }
     runNode(node)

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

@@ -13,6 +13,7 @@ export function createSignalNode(value: unknown): ReactiveNode {
         subsHead: undefined,
         subsTail: undefined,
         status: NODE_STATE.CLEAN,
+        thrown: undefined,
         isEffect: false,
     }
 }

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

@@ -0,0 +1,10 @@
+import type { HydrationCursor } from './types/HydrationCursor.ts'
+
+/* Repositions the parent's claim cursor at `reference` (null = past the last child). The
+   ONE write site of the cursor invariant: every claim must leave the cursor on the next
+   unclaimed sibling, or the following claim grabs the wrong node — a silent desync. The
+   claim verbs advance through here; a block parks explicitly when it skips or discards a
+   region (an anchor's content, a boundary it re-claims later, a discarded range). */
+export function parkCursor(hydration: HydrationCursor, parent: Node, reference: Node | null): void {
+    hydration.next.set(parent, reference)
+}

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

@@ -8,10 +8,30 @@ settles first (the lazy pull — `updateIfNecessary` refreshes only the deps tha
 changed, recomputing if any did); a signal has no compute and returns its stored
 value directly. Tracking happens after the settle so the reader links to the
 computed itself, not its transitive deps.
+
+The settle runs in a `try` whose `finally` still links the reader: an edge to a
+node is an edge even when that node is currently PAUSED. A computed whose compute
+throws — the common case being a `SuspenseSignal` from a pending blocking cell it
+reads — must still leave its reader subscribed to it, or the reader would never
+re-run when the paused branch resolves (the compute re-runs on settle via its own
+retained deps, then this reader wakes off its edge to the computed). The signal
+fast-path stays a plain track — it has no compute to throw and is the hot read.
 */
 export function readNode(node: ReactiveNode): unknown {
     if (node.compute !== undefined) {
-        updateIfNecessary(node)
+        try {
+            updateIfNecessary(node)
+            /* Throw memoisation: a paused/erroring compute settled CLEAN with its throw
+               retained (`runNode`'s catch) — rethrow it so EVERY reader observes the
+               pause/error, not just the one whose read ran the compute. Cleared by the
+               next successful run once a dep change re-dirties the node. */
+            if (node.thrown !== undefined) {
+                throw node.thrown
+            }
+        } finally {
+            track(node)
+        }
+        return node.value
     }
     track(node)
     return node.value

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

@@ -3,8 +3,8 @@ 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`
+Composes the child's ordinal segment onto the ambient path exactly as the client's dual-mode
+`mountChild` 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

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

@@ -0,0 +1,28 @@
+import { isAsyncIterable } from '../../shared/isAsyncIterable.ts'
+import { isThenable } from '../../shared/isThenable.ts'
+import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
+import type { AsyncState } from '../../shared/types/AsyncState.ts'
+import { createAsyncCell } from './createAsyncCell.ts'
+
+/*
+The ONE statement of the ADR-0045 bare-seed contract for `computed`/`linked`: a bare
+seed that reached the runtime literally (a branch-nested `<script>` keeps its
+`state.computed(...)` calls literal, and a direct JS caller never compiles) routes BY
+VALUE exactly as its thunk form would — a promise → a streaming unwrapped value cell, a
+stream → a frame cell. Anything else returns `undefined`: not async, the caller wraps it
+as a constant seed thunk. The classification order (thenable before async-iterable) and
+the streaming flag are load-bearing and shared here so the two primitives cannot drift.
+*/
+export function routeBareSeed(
+    value: unknown,
+    writable: boolean,
+    transform?: (next: unknown, previous: unknown) => unknown,
+): AsyncComputed<unknown> | AsyncState<unknown> | undefined {
+    if (isThenable(value)) {
+        return createAsyncCell(() => value, { writable, transform, streaming: true })
+    }
+    if (isAsyncIterable(value)) {
+        return createAsyncCell(() => value, { writable, transform })
+    }
+    return undefined
+}

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

@@ -0,0 +1,69 @@
+import { hydrationWindow } from '../../shared/hydrationWindow.ts'
+import { enterRenderPass } from './enterRenderPass.ts'
+import { exitRenderPass } from './exitRenderPass.ts'
+import { RENDER } from './RENDER.ts'
+import { SEED_MARKS } from './SEED_MARKS.ts'
+
+/*
+The one owner of a hydration pass's lifecycle. A pass is four lifetimes that must open
+and close together — the claim cursor (`RENDER.hydration`), the cache-withhold window
+(`hydrationWindow`, which `cache.peek` reads), the block-id render pass
+(`enterRenderPass`), and the two-phase seed consume (`SEED_MARKS`/`consumeSeed`,
+ADR-0048): the seeds a pass adopts are only MARKED while it runs, deleted on the
+OUTERMOST clean exit, and left in place on a throw — so the caller's
+discard→cold-rebuild recovery re-adopts the SSR-resolved values instead of refetching
+(a cold refetch would leave blocking `await` cells pending and escape as an uncaught
+SuspenseSignal at mount).
+
+Both entry points (`hydrate`, the router's hydrating first mount) run through here, so
+the bracket order and the throw semantics can't drift between them. Nesting is safe:
+the cursor saves/restores, the window/render-pass are depth-counted, and a nested
+clean exit hands its marks to the enclosing pass rather than committing — if the outer
+pass later throws, the nested pass's seeds are still in place for the recovery rebuild.
+*/
+export function runHydrationPass<T>(run: () => T): T {
+    const previous = RENDER.hydration
+    const previousMarks = SEED_MARKS.current
+    RENDER.hydration = { next: new Map() }
+    SEED_MARKS.current = new Map()
+    try {
+        hydrationWindow.enter()
+        enterRenderPass()
+        try {
+            const result = run()
+            const marks = SEED_MARKS.current
+            if (previousMarks === undefined) {
+                /* Outermost clean pass: spend the adopted seeds, preserving the one-shot
+                   contract (a later mount at the same render-path re-inits fresh, never a
+                   stale snapshot). */
+                for (const [store, keys] of marks) {
+                    for (const key of keys) {
+                        delete store[key]
+                    }
+                }
+            } else {
+                /* Nested clean pass: merge the marks upward — only the outermost owner
+                   commits, so an outer throw still leaves every value in place. */
+                for (const [store, keys] of marks) {
+                    let outerKeys = previousMarks.get(store)
+                    if (outerKeys === undefined) {
+                        outerKeys = new Set()
+                        previousMarks.set(store, outerKeys)
+                    }
+                    for (const key of keys) {
+                        outerKeys.add(key)
+                    }
+                }
+            }
+            return result
+        } finally {
+            exitRenderPass()
+            RENDER.hydration = previous
+            /* Outermost exit clears the window and wakes the peeks this pass withheld for
+               SSR congruence, now that the warm value is congruent to show. */
+            hydrationWindow.exit()
+        }
+    } finally {
+        SEED_MARKS.current = previousMarks
+    }
+}

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

@@ -52,7 +52,21 @@ export function runNode(node: ReactiveNode): unknown {
             }
         }
         node.status = NODE_STATE.CLEAN
+        node.thrown = undefined
         return node.value
+    } catch (error) {
+        /* The compute threw — commonly a `SuspenseSignal` from a pending blocking cell it read,
+           propagating the pause down this edge. Settle the node CLEAN anyway (its value is left
+           stale) so a later change to the deps it DID track before throwing re-marks it DIRTY and
+           re-propagates to its subscribers; left DIRTY, `mark`'s status gate would take the
+           settle's CLEAN→DIRTY edge as already-dirty and leave the node permanently inert — the
+           same reset `flushEffects` applies to a thrown effect. The throw is also RETAINED on the
+           node: a CLEAN settle memoises, so without it only this first reader would observe the
+           pause/error and every later reader would silently get the stale value — `readNode`
+           rethrows the retained throw until the next successful run clears it. */
+        node.status = NODE_STATE.CLEAN
+        node.thrown = error
+        throw error
     } finally {
         REACTIVE_CONTEXT.observer = previous
         /* Drop the edges `track` didn't reuse — last run's now-stale dependencies. */

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

@@ -0,0 +1,8 @@
+/* The active hydration pass's claim cursor: per parent, the next server-rendered child
+   to claim — a node pointer (not an index) so it survives nodes a block inserts (anchors,
+   range brackets) mid-hydration. Read through `claimChild` (probe) / the claim verbs
+   (claim + advance); repositioned through `parkCursor`. The live instance hangs off
+   `RENDER.hydration` (undefined outside a pass). */
+export type HydrationCursor = {
+    next: Map<Node, Node | null>
+}

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

@@ -24,5 +24,10 @@ export type ReactiveNode = {
        NODE_STATE). A signal is always CLEAN (no compute); a computed is born DIRTY and
        cycles CLEAN→CHECK/DIRTY→CLEAN as deps change and reads settle it. */
     status: number
+    /* Throw memoisation: what the last compute threw (commonly a `SuspenseSignal`
+       pause), retained while the node sits CLEAN so EVERY reader observes the pause or
+       error — not just the one whose read ran the compute. Cleared by the next
+       successful run; undefined on a signal (no compute to throw). */
+    thrown: unknown
     isEffect: boolean
 }

package/src/lib/ui/settleAsyncCells.ts

@@ -10,15 +10,42 @@ 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
     }
-    const promises = pending.promises.splice(0)
-    if (promises.length > 0) {
-        await Promise.allSettled(promises)
+    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/startClient.ts

@@ -17,7 +17,6 @@ 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 { warmSeedBackup } from './runtime/warmSeedBackup.ts'
 import { seedBootState } from './seedBootState.ts'
 import { seedStreamedResolution } from './seedStreamedResolution.ts'
 import { subscribeCacheStaleness } from './subscribeCacheStaleness.ts'
@@ -99,12 +98,6 @@ export function startClient(
     if (ssr.sockets !== undefined) {
         Object.assign(SOCKET_SEED, ssr.sockets)
     }
-    /* Stash the pristine cell/doc manifests for the router's hydration-desync recovery: the hydration
-       pass consumes CELL_SEED/DOC_SEED (each adopted key is deleted), so a discard→cold-rebuild would
-       otherwise refetch every blocking cell — leaving it pending and throwing an uncaught
-       SuspenseSignal at mount. `restoreWarmSeeds` re-seeds from these before the cold rebuild. */
-    warmSeedBackup.cells = ssr.cells
-    warmSeedBackup.docs = ssr.docs
     /* 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

package/src/lib/ui/tryEncodeResume.ts

@@ -1,20 +1,11 @@
-import { encodeRefJson } from '../shared/encodeRefJson.ts'
+import { encodeSeedValue } from '../shared/encodeSeedValue.ts'
 import type { ResumeEntry } from './runtime/RESUME.ts'
 
-/* ref-json-encode an await-resume entry, or `undefined` if it can't be serialized.
-   encodeRefJson is total (cycles become back-references, functions fold to undefined),
-   but a pathological throw must not blank the surrounding seed/stream — drop just this
-   entry and warn, so the client re-runs that one branch's promise while every other
+/* ref-json-encode an await-resume entry, or `undefined` if it can't be serialized — the
+   await-resume arm of the shared serialize-or-degrade policy (`encodeSeedValue`): drop
+   just this entry, so the client re-runs that one branch's promise while every other
    branch stays seeded. Shared by the streaming (`renderToStream`) and buffered/seed
-   (`resumeSeedScript`) paths so the serialize-or-refetch policy lives in one place. */
+   (`resumeSeedScript`) paths. */
 export function tryEncodeResume(entry: ResumeEntry, id: number | string): string | undefined {
-    try {
-        return encodeRefJson(entry)
-    } catch (cause) {
-        console.warn(
-            `[abide] resume for await ${id} is not serializable; client will refetch it`,
-            cause,
-        )
-        return undefined
-    }
+    return encodeSeedValue(entry, `resume for await ${id}`, 'the client will refetch it')
 }

package/src/lib/ui/watch.ts

@@ -1,4 +1,5 @@
 import { cache } from '../shared/cache.ts'
+import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
 import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
 import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
 import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
@@ -86,7 +87,7 @@ export function watch(
     const handler = argsOrHandler as (value: unknown, context?: CacheOnContext) => void
     /* A subscribable (socket / stream): per-frame delivery with reconnect-replay — the
        existing cache.on loop is the single implementation this branch delegates to. */
-    if (isSubscribable(source)) {
+    if (isAsyncIterable(source)) {
         return cache.on(
             source as NamedAsyncIterable<unknown>,
             handler as (frame: unknown, context: CacheOnContext) => void | Promise<void>,
@@ -94,7 +95,7 @@ export function watch(
     }
     /* An rpc without args → run the smart read reactively, pipe its value to the handler. A
        RemoteFunction is a callable, so accept `function` too — a state cell is a branded-free
-       object and never matches, and a streaming rpc was already caught by isSubscribable above. */
+       object and never matches, and a streaming rpc was already caught by isAsyncIterable above. */
     if (
         source !== null &&
         (typeof source === 'object' || typeof source === 'function') &&
@@ -121,15 +122,6 @@ export function watch(
     })
 }
 
-/* True for a socket / rpc stream — anything async-iterable. */
-function isSubscribable(source: unknown): boolean {
-    return (
-        source !== null &&
-        (typeof source === 'object' || typeof source === 'function') &&
-        typeof (source as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function'
-    )
-}
-
 /*
 Reacts to an rpc's cached value: an effect that runs the smart read (subscribing
 its key synchronously, so the effect re-runs when the value changes — a refresh,

package/src/lib/ui/dom/mountStreamedChild.ts

@@ -1,84 +0,0 @@
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { claimChild } from '../runtime/claimChild.ts'
-import { OWNER } from '../runtime/OWNER.ts'
-import { RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import type { UiComponent } from '../runtime/types/UiComponent.ts'
-import { withOptionalPath } from '../runtime/withOptionalPath.ts'
-import { withoutHydration } from '../runtime/withoutHydration.ts'
-import { discardBoundary } from './discardBoundary.ts'
-import { mountRange } from './mountRange.ts'
-import { openMarker } from './openMarker.ts'
-
-/*
-The client mount for a HOISTABLE child (ADR-0039) — a DUAL-MODE adopter. The server decides per
-render whether a hoistable child inlined (fast/settled) or streamed (still-pending), and the client
-build can't know which, so this probes the hydration cursor:
-
-  - `<!--[-->` (RANGE_OPEN) next → the server INLINED the child; adopt its range exactly as
-    `mountChild` does (byte-identical to the pre-ADR-0039 path).
-  - `<!--abide:await:CHILDPATH-->` next → the server STREAMED it; `__abideSwap` has already spliced
-    the child's `<!--[-->…<!--]-->` between the boundary markers before the bundle ran, so claim the
-    boundary open, adopt the inner range in place, claim the boundary close.
-  - no hydration (a client-side navigation) → a plain create-mode mount, like `mountChild`.
-
-CHILDPATH is the child's render-path — `withPath(ordinal, () => CURRENT_PATH.current)` — computed the
-same way the server's `renderPath(ordinal)` wrote the boundary id, so the two agree with no counter.
-A streamed child re-mounts (no RESUME value of its own — the boundary is html-only); nested `{#await}`
-blocks and async cells inside it adopt through their own existing channels.
-*/
-// @documentation plumbing
-export function mountStreamedChild(
-    parent: Node,
-    factory: UiComponent,
-    props: Parameters<UiComponent>[1],
-    before: Node | null = null,
-    ordinal?: number,
-): void {
-    const run = <T>(build: () => T): T => withOptionalPath(ordinal, build)
-    const mount = (): { dispose: () => void } =>
-        run(() => mountRange(parent, factory.build, props, before))
-
-    const hydration = RENDER.hydration
-    if (hydration === undefined) {
-        /* Call mount() first, THEN register its dispose — `OWNER.current?.push(mount())` would
-           short-circuit the whole expression (never mounting) when there is no owner. */
-        const handle = mount()
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-
-    /* Probe the cursor without consuming it. Streamed iff the next node is this child's boundary. */
-    const childPath = run(() => CURRENT_PATH.current)
-    const cursor = claimChild(hydration, parent)
-    const streamed =
-        cursor !== null &&
-        cursor.nodeType === 8 &&
-        (cursor as Comment).data === `abide:await:${childPath}`
-
-    if (!streamed) {
-        /* INLINE — the server inlined a settled child; adopt its `[ … ]` range in place. */
-        const handle = mount()
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-
-    /* STREAMED — claim the boundary open (advances the cursor to the swapped-in `[`). */
-    const open = openMarker(parent, `abide:await:${childPath}`)
-    const inner = claimChild(hydration, parent)
-    const warm = inner !== null && inner.nodeType === 8 && (inner as Comment).data === RANGE_OPEN
-    if (warm) {
-        const handle = mount()
-        openMarker(parent, `/abide:await:${childPath}`)
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-    /* COLD (defensive — renderToStream drains every await before closing, so a warm boundary is the
-       deterministic path). The fragment never arrived: discard the empty boundary and create-mount
-       the child fresh at that position; its streamed cells resolve post-mount via receiveStreamedCell. */
-    const after = discardBoundary(parent, open, `/abide:await:${childPath}`, hydration)
-    const handle = withoutHydration(() =>
-        run(() => mountRange(parent, factory.build, props, after)),
-    )
-    OWNER.current?.push(handle.dispose)
-}

package/src/lib/ui/dom/readCellBlocking.ts

@@ -1,29 +0,0 @@
-import { isAsyncCell } from '../../shared/isAsyncCell.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { readCell } from './readCell.ts'
-
-/*
-The blocking-cell read the compiler lowers to `$$readCellBlocking(NAME)` for an `await`-marked
-cell (ADR-0042 D5.3). Exactly `readCell`, with one added rule ahead of it: a cell with no value
-*yet* throws a `SuspenseSignal` so the enclosing region SUSPENDS until the value resolves rather
-than rendering against `undefined`. This is what makes an `await` binding read as a resolved `T`
-(never `undefined`-while-pending) on both sides — the client mirrors the server flush barrier.
-
-The suspend is keyed on `cell.pending()` (in-flight AND no value), NOT `peek() === undefined`:
-  - a blocking cell that legitimately resolves to `undefined` is not pending, so it does not
-    suspend forever;
-  - a warm-seeded cell on hydrate is `refreshing()` (has value, in flight), not `pending()`, so it
-    reads its held value and adopts the SSR markup with no suspend and no flash (ADR-0042 D4).
-Everything past the pending gate — the throwing peek (error-with-no-retained-value → `AsyncCellError`
-to `{#try}`, a retained value winning over pending/error via SWR), a function call, or a `.value`
-read — is `readCell` verbatim, so the two reads can never drift.
-*/
-// @documentation plumbing
-export function readCellBlocking(cell: unknown): unknown {
-    /* No value yet → suspend the reading region (distinct from an error, which `readCell` routes). */
-    if (isAsyncCell(cell) && (cell as AsyncComputed<unknown>).pending()) {
-        throw new SuspenseSignal(cell as AsyncComputed<unknown>)
-    }
-    return readCell(cell)
-}