@abide/abide 0.53.0 → 0.55.0

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

@@ -1,7 +1,7 @@
 import { effect } from '../effect.ts'
 import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
 import { claimChild } from '../runtime/claimChild.ts'
-import { claimExpected } from '../runtime/claimExpected.ts'
+import { claimMarker } from '../runtime/claimMarker.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { scope } from '../runtime/scope.ts'
 import { scopeGroup } from '../runtime/scopeGroup.ts'
@@ -82,8 +82,7 @@ export function each<T>(
         const segment = keyed ? keyOf(item) : position
         const hydration = RENDER.hydration
         if (hydration !== undefined) {
-            const start = claimExpected(hydration, parent, 'each row start marker')
-            hydration.next.set(parent, start.nextSibling)
+            const start = claimMarker(hydration, parent, 'each row start marker')
             const dispose = group.track(
                 scope(() =>
                     withPathFrom(basePath, segment, () =>
@@ -91,8 +90,7 @@ export function each<T>(
                     ),
                 ),
             )
-            const end = claimExpected(hydration, parent, 'each row end marker')
-            hydration.next.set(parent, end.nextSibling)
+            const end = claimMarker(hydration, parent, 'each row end marker')
             return { start, end, dispose, cell, indexCell }
         }
         /* Shared detached-range create primitive: a `[ … ]` fragment built under `parent`'s

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

@@ -1,3 +1,4 @@
+import { parkCursor } from '../runtime/parkCursor.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { scope } from '../runtime/scope.ts'
 import type { UiProps } from '../runtime/types/UiProps.ts'
@@ -31,7 +32,7 @@ export function fillBoundary(
     }
     /* Hydrate: adopt the server content between the markers in place. */
     const parent = open.parentNode as Node
-    hydration.next.set(parent, open.nextSibling)
+    parkCursor(hydration, parent, open.nextSibling)
     const scoped = withScope(() => scope(() => build(parent, props)))
     return { dispose: disposeRange(scoped, open, close) }
 }

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

@@ -1,5 +1,4 @@
-import { hydrationWindow } from '../../shared/hydrationWindow.ts'
-import { RENDER } from '../runtime/RENDER.ts'
+import { runHydrationPass } from '../runtime/runHydrationPass.ts'
 import { scope } from '../runtime/scope.ts'
 import { withScope } from './withScope.ts'
 
@@ -24,18 +23,12 @@ export function hydrate(
     build: (host: Element, props: unknown) => void,
     props?: unknown,
 ): () => void {
-    const previous = RENDER.hydration
-    RENDER.hydration = { next: new Map() }
-    hydrationWindow.enter()
-    try {
+    /* The pass lifecycle (claim cursor, withhold window, render pass, restore-on-throw)
+       is owned by `runHydrationPass` — the same bracket the router's hydrating mount runs. */
+    return runHydrationPass(() => {
         /* Same shared mount core as `mount` (see `withScope`) — a hydrated component owns a
            scope too, adopting the model its build adopts — run with the claim cursor active. */
         const { lexical } = withScope(() => scope(() => build(host, props)))
         return () => lexical.dispose()
-    } finally {
-        RENDER.hydration = previous
-        /* Outermost exit clears the window and wakes the peeks this pass withheld; a nested
-           child hydrate raises/lowers the depth without firing it early. */
-        hydrationWindow.exit()
-    }
+    })
 }

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

@@ -1,13 +1,37 @@
+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 { commentData } from './commentData.ts'
+import { discardAndRebuild } from './discardAndRebuild.ts'
 import { mountRange } from './mountRange.ts'
+import { openMarker } from './openMarker.ts'
 
 /*
-Mounts a child component as a marker-bounded range at `before` in `parent` — no
-wrapper element, so the child's root is a true direct child of the parent (see
-`mountRange`). Files the range's dispose with the mounting owner so its scope and DOM
-leave together when the parent (or branch/row) tears down.
+The client mount for a child component — a DUAL-MODE adopter, and the ONLY child mount the
+compiler emits. A child mounts as a marker-bounded range at `before` in `parent` (no wrapper
+element, so the child's root is a true direct child — see `mountRange`), its dispose filed
+with the mounting owner so scope and DOM leave together on teardown.
+
+The server decides per render whether a HOISTABLE child (ADR-0039) inlined (fast/settled) or
+streamed (still-pending), and the client build can't know which — nor whether this child was
+hoistable at all — so hydrate mode probes the cursor:
+
+  - `<!--[-->` (RANGE_OPEN) next → the server INLINED the child (every non-hoistable child,
+    and a hoistable one whose flight settled); adopt its range in place.
+  - `<!--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.
+
+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 mountChild(
@@ -21,6 +45,50 @@ export function mountChild(
        row key the each block already pushed). Absent (a non-compiled caller) → no path segment. */
     ordinal?: number,
 ): void {
-    const handle = withOptionalPath(ordinal, () => mountRange(parent, factory.build, props, before))
+    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 && commentData(cursor) === `abide:await:${childPath}`
+
+    if (!streamed) {
+        /* INLINE — the server inlined the child's `[ … ]` range; adopt it 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 && commentData(inner) === 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 handle = discardAndRebuild(
+        hydration,
+        parent,
+        open,
+        `/abide:await:${childPath}`,
+        (after) => run(() => mountRange(parent, factory.build, props, after)),
+    )
     OWNER.current?.push(handle.dispose)
 }

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

@@ -1,5 +1,6 @@
 import { effect } from '../effect.ts'
 import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
+import { parkCursor } from '../runtime/parkCursor.ts'
 import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { scope } from '../runtime/scope.ts'
@@ -82,7 +83,7 @@ export function mountSwappableRange<Key>(
         const chosen = chosenFor(activeKey)
         const matchedEnd = matchingRangeClose(start)
         clearBetween(start, matchedEnd)
-        hydration.next.set(parent, matchedEnd)
+        parkCursor(hydration, parent, matchedEnd)
         end = openMarker(parent, RANGE_CLOSE)
         if (chosen !== undefined) {
             dispose = group.track(fillBefore(end, chosen))

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

@@ -1,4 +1,4 @@
-import { claimExpected } from '../runtime/claimExpected.ts'
+import { claimMarker } from '../runtime/claimMarker.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 
 /*
@@ -12,9 +12,7 @@ rather than a list of single nodes.
 export function openMarker(parent: Node, data: string, before: Node | null = null): Comment {
     const hydration = RENDER.hydration
     if (hydration !== undefined) {
-        const node = claimExpected(hydration, parent, `control-flow marker "${data}"`) as Comment
-        hydration.next.set(parent, node.nextSibling)
-        return node
+        return claimMarker(hydration, parent, `control-flow marker "${data}"`)
     }
     const node = document.createComment(data)
     /* `before` (a node already in `parent`) places the block among static siblings —

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

@@ -1,6 +1,7 @@
-import { claimExpected } from '../runtime/claimExpected.ts'
+import { claimMarker } from '../runtime/claimMarker.ts'
 import { OUTLET_CLOSE, OUTLET_OPEN } from '../runtime/OUTLET_MARKER.ts'
 import { PENDING_OUTLET } from '../runtime/PENDING_OUTLET.ts'
+import { parkCursor } from '../runtime/parkCursor.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { commentData } from './commentData.ts'
 
@@ -30,7 +31,7 @@ export function outlet(
         PENDING_OUTLET.current = { open, close }
         return { open, close }
     }
-    const open = claimExpected(hydration, parent, 'outlet open marker') as Comment
+    const open = claimMarker(hydration, parent, 'outlet open marker')
     /* Skip to the matching close: depth-count outlet markers (nested child-layer slots
        are balanced), so a layout wrapping another layout skips its WHOLE subtree. */
     let depth = 1
@@ -56,7 +57,7 @@ export function outlet(
         )
     }
     const close = node as Comment
-    hydration.next.set(parent, close.nextSibling)
+    parkCursor(hydration, parent, close.nextSibling)
     PENDING_OUTLET.current = { open, close }
     return { open, close }
 }

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

@@ -1,35 +1,50 @@
 import { isAsyncCell } from '../../shared/isAsyncCell.ts'
 import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
 import { AsyncCellError } from '../runtime/AsyncCellError.ts'
+import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
 
 /*
-Unified read for a `computed`/`linked` reference the compiler lowers to `$$readCell(NAME)`:
-an async cell (`AsyncComputed`/`AsyncState`) yields its latest retained value, a `derive`
-reader (a function) is called, and a sync `Computed`/`State` yields its `.value`. One read
-shape lets a `linked`/`computed` binding auto-track whichever source it resolved to — a
-settling promise, a stream, or a plain value — with no read-site branching in codegen.
+The one read for a `computed`/`linked` reference the compiler lowers to `$$readCell(NAME)`,
+everywhere — script and template, both sides. An async cell (`AsyncComputed`/`AsyncState`)
+yields its latest retained value, a `derive` reader (a function) is called, and a sync
+`Computed`/`State` yields its `.value`. One read shape lets a `linked`/`computed` binding
+auto-track whichever source it resolved to — a settling promise, a stream, or a plain value —
+with no read-site branching in codegen.
 
-For an async cell this is a **throwing peek** (ADR-0019 D3.2), the value-aware rule that
-routes a "nothing to render" error to the nearest `{#try}`:
+Whether a read PAUSES is a property of the NODE, not the read site (ADR-0042). A pending
+blocking cell (`cell.blocking` — author `await`, the one that joins the SSR barrier) throws
+a `SuspenseSignal`: the reader's branch of the graph pauses until the value resolves, and
+the throwing read subscribed the reader to the cell so it re-runs on settle. A pending
+STREAMING cell peeks `undefined` (composes with `?.`/`??`). So a rendering region withholds,
+a derive over it pauses too, and the SSR barrier awaits it — all off the same node bit,
+with no per-site knowledge threaded through the compiler.
+
+For a settled async cell this stays the value-aware **throwing peek** (ADR-0019 D3.2):
   - error AND no retained value → throw `AsyncCellError` (carries the cell for keep-the-watch);
   - error WITH a retained value → the value (a failed background refresh stays visible — SWR);
-  - pending (no value) → `undefined`;
   - resolved → the value.
-The throw is a codegen behaviour only — `cell.peek()`/`cell.error()` in JS never throw; the
+The throws are codegen behaviour only — `cell.peek()`/`cell.error()` in JS never throw; the
 author handles an error locally via the probes, or lets it reach a `{#try}`.
 */
 // @documentation plumbing
 export function readCell(cell: unknown): unknown {
     if (isAsyncCell(cell)) {
-        const asyncCell = cell as AsyncComputed<unknown>
+        const asyncCell = cell as AsyncComputed<unknown> & { blocking?: boolean }
         const value = asyncCell.peek()
         /* A retained value wins over an error (SWR) and over pending — return it. Only when
-           nothing is retained does an error become "nothing to render" and throw. */
+           nothing is retained does the cell's state decide: an error is "nothing to render"
+           (throw to `{#try}`); a pending blocking cell PAUSES (throw suspense); a pending
+           streaming cell — or a blocking cell that legitimately resolved to `undefined` — is
+           the bare `undefined`. `pending()` (in flight, no value) gates the suspend so a
+           resolved-`undefined` blocking cell never suspends forever. */
         if (value === undefined) {
             const error = asyncCell.error()
             if (error !== undefined) {
                 throw new AsyncCellError(asyncCell, error)
             }
+            if (asyncCell.blocking === true && asyncCell.pending()) {
+                throw new SuspenseSignal(asyncCell)
+            }
         }
         return value
     }

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

@@ -1,6 +1,6 @@
 import { walkAnchorOrder } from '../compile/walkAnchorOrder.ts'
 import { walkElementOrder } from '../compile/walkElementOrder.ts'
-import { claimChild } from '../runtime/claimChild.ts'
+import { claimRun } from '../runtime/claimRun.ts'
 import { HOLE_ATTRIBUTE } from '../runtime/HOLE_ATTRIBUTE.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { commentData } from './commentData.ts'
@@ -121,12 +121,7 @@ export function skeleton(parent: Node, html: string): SkeletonHoles {
     const hydration = RENDER.hydration
     const topLevel: Node[] = []
     if (hydration !== undefined) {
-        let node = claimChild(hydration, parent)
-        for (let count = 0; count < topLevelCount && node !== null; count += 1) {
-            topLevel.push(node)
-            node = node.nextSibling
-        }
-        hydration.next.set(parent, node)
+        claimRun(hydration, parent, topLevelCount, topLevel)
     } else {
         const children = source.childNodes
         /* Stage clones in a fragment ONLY for a live (connected) parent, where one

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

@@ -11,7 +11,8 @@ to the default (`match` undefined); the chosen case's content lives in a RANGE
 bounded by two comment markers, so a case holds any content. Staying on the same
 case across a subject change leaves it mounted; switching clears the range and
 builds the new case fresh. See `mountSwappableRange` for the shared
-hydrate/swap/teardown semantics — the case index is the swap key.
+hydrate/swap/teardown semantics — the case index is the swap key, which doubles as
+the case's render-path segment (`caseSegment` — the alphabet SSR also emits).
 */
 // @documentation plumbing
 export function switchBlock(

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

@@ -1,17 +1,16 @@
 import { effect } from '../effect.ts'
 import { AsyncCellError } from '../runtime/AsyncCellError.ts'
 import { CURRENT_BOUNDARY } from '../runtime/CURRENT_BOUNDARY.ts'
-import { claimExpected } from '../runtime/claimExpected.ts'
+import { claimMarker } from '../runtime/claimMarker.ts'
 import { OWNER } from '../runtime/OWNER.ts'
 import { RENDER } from '../runtime/RENDER.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
 import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
+import { scopeGroup } from '../runtime/scopeGroup.ts'
 import type { Boundary } from '../runtime/types/Boundary.ts'
 import type { State } from '../runtime/types/State.ts'
-import { withoutHydration } from '../runtime/withoutHydration.ts'
 import { state } from '../state.ts'
 import { anchoredBranch } from './anchoredBranch.ts'
-import { discardBoundary } from './discardBoundary.ts'
+import { discardAndRebuild } from './discardAndRebuild.ts'
 
 /*
 Reactive error boundary — the runtime for `<template try>` (ADR-0019 D3). Unlike the old
@@ -191,9 +190,7 @@ export function tryBlock(
         firstHydrate()
         return
     }
-    const anchorNode = document.createTextNode('')
-    branch.anchor = anchorNode
-    parent.insertBefore(anchorNode, before)
+    branch.parkAnchor(before)
     showTry()
 
     /* The first run when hydrating: claim the boundary's open marker, adopt the guarded
@@ -202,26 +199,25 @@ export function tryBlock(
        throws too) discards the boundary and builds the catch fresh. */
     function firstHydrate(): void {
         const cursor = hydration as NonNullable<typeof hydration>
-        const open = claimExpected(cursor, parent, `abide:try:${id} open marker`)
+        const open = claimMarker(cursor, parent, `abide:try:${id} open marker`)
         try {
-            adopt(open)
+            adopt()
         } catch (error) {
             rebuildCold(open, error)
         }
     }
 
-    /* Adopt the guarded branch in place: claim the server's `[` range-open marker, build the
-       guarded content (which claims its nodes) under the boundary, then claim the `]`
-       range-close and the boundary close, parking an anchor so a later swap detaches this
-       range like any other. A build throw disposes the partial scope and rethrows so
-       `firstHydrate` rebuilds cold. */
-    function adopt(open: Node): void {
+    /* Adopt the guarded branch in place — the cursor already sits past the boundary open
+       (claiming it advanced): claim the server's `[` range-open marker, build the guarded
+       content (which claims its nodes) under the boundary, then claim the `]` range-close
+       and the boundary close, parking an anchor so a later swap detaches this range like
+       any other. A build throw disposes the partial scope and rethrows so `firstHydrate`
+       rebuilds cold. */
+    function adopt(): void {
         const cursor = hydration as NonNullable<typeof hydration>
-        cursor.next.set(parent, open.nextSibling ?? null)
         /* The server emits the `[ … ]` range inside the boundary — claim `[` as the live
-           range start, then advance the cursor to the first content node. */
-        const start = claimExpected(cursor, parent, `abide:try:${id} range-open marker`) as Comment
-        cursor.next.set(parent, start.nextSibling ?? null)
+           range start, advancing the cursor to the first content node. */
+        const start = claimMarker(cursor, parent, `abide:try:${id} range-open marker`)
         /* Install the boundary around the whole adopt (build + marker claims); the shared
            strand-dispose guard in `adoptStrand` disposes the partial scope and rethrows on any
            failure, and this `finally` restores the boundary before the rethrow reaches
@@ -234,17 +230,9 @@ export function tryBlock(
             branch.adoptStrand(
                 (host) => renderTry(host),
                 () => {
-                    const end = claimExpected(
-                        cursor,
-                        parent,
-                        `abide:try:${id} range-close marker`,
-                    ) as Comment
-                    cursor.next.set(parent, end.nextSibling ?? null)
-                    const close = claimExpected(cursor, parent, `/abide:try:${id} close marker`)
-                    cursor.next.set(parent, close.nextSibling ?? null)
-                    const anchorNode = document.createTextNode('')
-                    parent.insertBefore(anchorNode, close)
-                    branch.anchor = anchorNode
+                    const end = claimMarker(cursor, parent, `abide:try:${id} range-close marker`)
+                    const close = claimMarker(cursor, parent, `/abide:try:${id} close marker`)
+                    branch.parkAnchor(close)
                     return { start, end }
                 },
             )
@@ -258,18 +246,18 @@ export function tryBlock(
        No catch → rethrow (the throw surfaces past the boundary, as the sync version did). */
     function rebuildCold(open: Node, error: unknown): void {
         branch.detach()
-        const after = discardBoundary(
+        discardAndRebuild(
+            hydration as NonNullable<typeof hydration>,
             parent,
             open,
             `/abide:try:${id}`,
-            hydration as NonNullable<typeof hydration>,
+            (after) => {
+                if (!hasCatch) {
+                    throw error
+                }
+                branch.parkAnchor(after)
+                showCatch(error)
+            },
         )
-        if (!hasCatch) {
-            throw error
-        }
-        const anchorNode = document.createTextNode('')
-        branch.anchor = anchorNode
-        parent.insertBefore(anchorNode, after)
-        withoutHydration(() => showCatch(error))
     }
 }

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

@@ -1,3 +1,4 @@
+import { ELSE_SEGMENT, THEN_SEGMENT } from '../runtime/BRANCH_SEGMENT.ts'
 import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
 import { mountSwappableRange } from './mountSwappableRange.ts'
 
@@ -37,7 +38,9 @@ export function when(
                block (render neither branch) until it settles, exactly as a bare async subject holds;
                the read tracked its cell, so the swap effect re-runs on resolve. */
             try {
-                return condition() ? 'then' : 'else'
+                /* The branch key doubles as the branch's render-path segment (see
+                   BRANCH_SEGMENT), so it is sourced from the shared alphabet SSR also emits. */
+                return condition() ? THEN_SEGMENT : ELSE_SEGMENT
             } catch (signal) {
                 if (!(signal instanceof SuspenseSignal)) {
                     throw signal
@@ -45,7 +48,8 @@ export function when(
                 return 'pending'
             }
         },
-        (branch) => (branch === 'then' ? render : branch === 'else' ? renderElse : undefined),
+        (branch) =>
+            branch === THEN_SEGMENT ? render : branch === ELSE_SEGMENT ? renderElse : undefined,
         before,
         /* An async subject (compiler supplies `isPending`) can render a different branch on the
            server than the pending client, so hydration must not adopt the SSR range in place. */

package/src/lib/ui/linked.ts

@@ -4,6 +4,7 @@ import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
 import { createAsyncCell } from './runtime/createAsyncCell.ts'
 import { createEffectNode } from './runtime/createEffectNode.ts'
 import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
+import { routeBareSeed } from './runtime/routeBareSeed.ts'
 import type { State } from './runtime/types/State.ts'
 import { state } from './state.ts'
 
@@ -41,6 +42,19 @@ export function linked<T>(
     transform?: (next: T, previous: T) => T,
 ): State<T> | AsyncState<T> {
     const coerce = transform as ((next: unknown, previous: unknown) => unknown) | undefined
+    /* A BARE seed that reached the runtime literally (a branch-nested `<script>`, a direct
+       JS caller) — the compile-time `wrapSeed` normalization only covers the leading script,
+       so honor the authored contract (ADR-0045) by VALUE via the shared `routeBareSeed`,
+       exactly as `computed` does; a non-async value becomes a constant seed thunk (reseeds
+       never fire — nothing tracked — matching the wrapped `() => value` form). */
+    if (typeof seed !== 'function') {
+        const value: unknown = seed
+        const cell = routeBareSeed(value, true, coerce)
+        if (cell !== undefined) {
+            return cell as AsyncState<T>
+        }
+        seed = () => value as T
+    }
     /* `await` marker: an async-function seed unwraps its promise into a writable async cell. */
     if (isAsyncFunction(seed)) {
         return createAsyncCell(seed as () => unknown, {

package/src/lib/ui/resumeSeedScript.ts

@@ -23,5 +23,5 @@ export function resumeSeedScript(resume: Record<string, ResumeEntry>): string {
     if (encoded.length === 0) {
         return ''
     }
-    return `<script>Object.assign(window.__abideResume=window.__abideResume||{},${safeJsonForScript(Object.fromEntries(encoded))})</script>`
+    return `<script>Object.assign((window.__abideSeeds=window.__abideSeeds||{}).resume=window.__abideSeeds.resume||{},${safeJsonForScript(Object.fromEntries(encoded))})</script>`
 }

package/src/lib/ui/router.ts

@@ -1,4 +1,3 @@
-import { hydrationWindow } from '../shared/hydrationWindow.ts'
 import { layoutChainForRoute } from '../shared/layoutChainForRoute.ts'
 import { matchRoute } from '../shared/matchRoute.ts'
 import { fillBoundary } from './dom/fillBoundary.ts'
@@ -7,11 +6,10 @@ import { effect } from './effect.ts'
 import { navigatePath } from './navigate.ts'
 import { CHILD_PRESENT } from './runtime/CHILD_PRESENT.ts'
 import { clientPage } from './runtime/clientPage.ts'
-import { enterRenderPass } from './runtime/enterRenderPass.ts'
-import { exitRenderPass } from './runtime/exitRenderPass.ts'
 import { historyEntries } from './runtime/historyEntries.ts'
 import { PENDING_OUTLET } from './runtime/PENDING_OUTLET.ts'
 import { RENDER } from './runtime/RENDER.ts'
+import { runHydrationPass } from './runtime/runHydrationPass.ts'
 import { runtimePath } from './runtime/runtimePath.ts'
 import type { AbideHistoryState } from './runtime/types/AbideHistoryState.ts'
 import type { NavVerdict } from './runtime/types/NavVerdict.ts'
@@ -257,19 +255,10 @@ export function router(
             mountedPageKey = pageKey
         }
         if (hydrating) {
-            const previous = RENDER.hydration
-            RENDER.hydration = { next: new Map() }
-            hydrationWindow.enter()
-            enterRenderPass()
-            try {
-                run()
-            } 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()
-            }
+            /* The pass lifecycle (claim cursor, withhold window, render pass, and the
+               warm-seed restore a throwing pass owes its cold rebuild) is owned by
+               `runHydrationPass` — the same bracket `hydrate` runs. */
+            runHydrationPass(run)
             return
         }
         run()
@@ -566,6 +555,13 @@ export function router(
                             disposeFrom(0)
                             rootBoundary = undefined
                             mountedPageKey = undefined
+                            /* The cell/doc warm seeds the failed pass adopted are still in place —
+                               a pass only MARKS them, deleting on a clean exit (`consumeSeed`,
+                               ADR-0048) — so this cold rebuild re-adopts the SSR-resolved values
+                               instead of refetching (a cold refetch would leave blocking `await`
+                               cells pending, and a top-level `$$readCell` of one sits in no suspense
+                               region — its SuspenseSignal would escape this rebuild and kill the
+                               mount). */
                             buildFrom(0, chainKeys, layoutViews, pageView, key, params, false)
                         }
                         /* Reapply the destination entry's scroll once its DOM exists — a

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

@@ -1,3 +1,4 @@
+import { messageFromError } from '../../shared/messageFromError.ts'
 import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
 
 /*
@@ -13,7 +14,7 @@ export class AsyncCellError extends Error {
     readonly cell: AsyncComputed<unknown>
 
     constructor(cell: AsyncComputed<unknown>, cause: unknown) {
-        super(cause instanceof Error ? cause.message : String(cause), { cause })
+        super(messageFromError(cause), { cause })
         this.name = 'AsyncCellError'
         this.cell = cell
     }

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

@@ -0,0 +1,24 @@
+/*
+The render-path segment alphabet for control-flow branches — the one place the segment a
+branch's content composes under is decided, read by BOTH sides (the same pattern
+`RANGE_MARKER` uses for the wire markers, so a literal can never drift):
+
+  - the client runtimes (`when` returns THEN/ELSE as its swap key, `switchBlock` its case
+    index) hand the key to `mountSwappableRange`, which pushes `String(key)` as the branch's
+    path segment;
+  - the SSR back-end (`generateSSR`) emits the same segment around a branch's content
+    (`withPathBranch`), so a component/cell inside composes a byte-identical
+    serialization-stable id — the warm-seed key (ADR-0033).
+
+A `when` keys its branches by name; a `switchBlock` (a `{#switch}`, or an `{#if}` chain with
+any `{:elseif}`) keys each case by its index in the `[then, ...branches]` source order —
+the default at its own position.
+*/
+export const THEN_SEGMENT = 'then'
+export const ELSE_SEGMENT = 'else'
+
+/* A switchBlock case's segment: its source-order index, stringified exactly as
+   `mountSwappableRange` stringifies the numeric swap key. */
+export function caseSegment(index: number): string {
+    return String(index)
+}

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

@@ -1,3 +1,5 @@
+import { SEEDS } from '../../shared/SEEDS.ts'
+
 /* The async-cell warm-seed manifest: an SSR-resolved cell value, keyed by the cell's
    serialization-stable render-path id (`${scope.id}:${index}`), as a ref-json-encoded STRING
    (decoded lazily at the read site in `createAsyncCell`, so an in-process graph with cycles /
@@ -5,10 +7,6 @@
    `startClient` drains `__SSR__.cells` into here before mount; a hydrating cell reads its key to
    seed its value warm instead of re-running the seed (no refetch, no pending flash).
 
-   Backed by `globalThis.__abideCells` so an inline pre-bundle script and the framework share one
-   store — whoever runs first creates it, the other adopts the same reference (mirrors RESUME). */
-const globalScope = globalThis as { __abideCells?: Record<string, string> }
-globalScope.__abideCells ??= {}
-
+   The `cells` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS). */
 // @documentation plumbing
-export const CELL_SEED: Record<string, string> = globalScope.__abideCells
+export const CELL_SEED: Record<string, string> = SEEDS.cells