@abide/abide 0.54.0 → 0.56.0

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 { 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,8 @@ 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 { SuspenseSignal } from './runtime/SuspenseSignal.ts'
 import type { State } from './runtime/types/State.ts'
 import { state } from './state.ts'
 
@@ -41,6 +43,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, {
@@ -53,10 +68,26 @@ export function linked<T>(
        non-stream value falls through to the plain synchronous cell. */
     let probe: unknown
     let threw = false
+    let suspended = false
     try {
         probe = seed()
-    } catch {
+    } catch (error) {
         threw = true
+        suspended = error instanceof SuspenseSignal
+    }
+    /* The seed SUSPENDED — it read a pending BLOCKING cell (`await`-marked). A sync `state`
+       here would hold `undefined` while the reseed effect re-threw the suspend, letting it
+       escape at construction. Route to the eager async cell instead: `createAsyncCell` already
+       treats a synchronously-suspending seed as "pending" — it stays in flight, the throwing
+       read subscribed its effect to the blocking dependency, and it re-runs on settle — and it
+       marks the cell BLOCKING so its own reads pause too, matching a lazy `computed(() =>
+       blockingCell)`. This makes a blocking read behave the same in a `linked` seed as in a
+       `computed` seed or a template. A real (non-suspense) throw keeps the sync fall-through. */
+    if (suspended) {
+        return createAsyncCell(seed as () => unknown, {
+            writable: true,
+            transform: coerce,
+        }) as AsyncState<T>
     }
     if (!threw && isAsyncIterable(probe)) {
         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,12 +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 { restoreWarmSeeds } from './runtime/restoreWarmSeeds.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'
@@ -258,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()
@@ -567,13 +555,13 @@ export function router(
                             disposeFrom(0)
                             rootBoundary = undefined
                             mountedPageKey = undefined
-                            /* Re-seed the cell/doc warm partitions the failed hydration pass consumed,
-                               so the cold rebuild re-adopts the SSR-resolved values instead of
-                               refetching — a cold refetch leaves blocking `await` cells pending, and a
-                               top-level `$$readCellBlocking` sits in no suspense region, so its
-                               SuspenseSignal would escape this rebuild (it runs inside the catch, past
-                               the try) and kill the mount. Restored, the rebuild reads settled. */
-                            restoreWarmSeeds()
+                            /* 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

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

@@ -1,11 +1,10 @@
+import { SEEDS } from '../../shared/SEEDS.ts'
+
 /* The doc-state warm-seed manifest: an SSR-captured reactive-document snapshot, keyed by its
    scope's serialization-stable render-path id, as a ref-json-encoded STRING (decoded at the read
    site in `createScope`). `startClient` drains `__SSR__.docs` into here before mount; a hydrating
    scope reads its key to seed a plain `state(initial)` to the SERVER value instead of the fresh
-   init — a uuid/timestamp/random otherwise diverges from the SSR HTML. Backed by
-   `globalThis.__abideDocs` so an inline pre-bundle script and the framework share one store —
-   whoever runs first creates it, the other adopts the same reference (mirrors CELL_SEED). */
-const globalScope = globalThis as { __abideDocs?: Record<string, string> }
-globalScope.__abideDocs ??= {}
+   init — a uuid/timestamp/random otherwise diverges from the SSR HTML.
 
-export const DOC_SEED: Record<string, string> = globalScope.__abideDocs
+   The `docs` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS). */
+export const DOC_SEED: Record<string, string> = SEEDS.docs

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

@@ -1,9 +1,11 @@
+import type { HydrationCursor } from './types/HydrationCursor.ts'
+
 /*
 Render mode shared by the dom helpers. In the default (create) mode `hydration`
-is undefined and helpers build fresh nodes. During `hydrate` it holds, per parent,
-the next server-rendered child node to claim — a node pointer (not an index) so it
-survives nodes a block inserts (anchors) mid-hydration. Helpers claim in build
-order, which matches the SSR order, advancing the pointer to the next sibling.
+is undefined and helpers build fresh nodes. During `hydrate` it holds the pass's
+claim cursor (see `HydrationCursor`): helpers claim in build order, which matches
+the SSR order, advancing through the claim verbs (`claimMarker`/`claimRun`/
+`claimText`) or parking explicitly (`parkCursor`).
 
 `blockCounters`/`depth` drive the render-pass block-id counters: every `await`/`try`
 block draws a path-namespaced id via `nextBlockId` (ADR-0037) — `blockCounters` maps
@@ -21,7 +23,7 @@ elements built there get the right namespace — the fragment itself carries non
 undefined outside foreign content. See `enterNamespace`/`effectiveChildNamespace`.
 */
 export const RENDER: {
-    hydration: { next: Map<Node, Node | null> } | undefined
+    hydration: HydrationCursor | undefined
     blockCounters: Map<string, number>
     depth: number
     namespace: string | undefined

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

@@ -1,3 +1,5 @@
+import { SEEDS } from '../../shared/SEEDS.ts'
+
 /* The await-resume manifest: the resolved value (or error) of each streamed
    `await` block, keyed by its boundary id. The SSR stream serializes each entry
    alongside its fragment; the client registers it (via the inline swap script),
@@ -11,13 +13,9 @@
    stream-swap script — vanilla, running before the bundle and the codec load — able
    to register an entry without the decoder.
 
-   Backed by `globalThis.__abideResume` so the inline stream-swap script and the
-   framework share one store: whoever runs first creates it, the other adopts the
-   same reference. */
+   The `resume` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS) —
+   the inline scripts and the framework share the same reference. */
 export type ResumeEntry = { ok: true; value: unknown } | { ok: false; error: unknown }
 
-const globalScope = globalThis as { __abideResume?: Record<string, string> }
-globalScope.__abideResume ??= {}
-
 // @documentation plumbing
-export const RESUME: Record<string, string> = globalScope.__abideResume
+export const RESUME: Record<string, string> = SEEDS.resume

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

@@ -0,0 +1,14 @@
+/* The active hydration pass's consumed-seed marks (ADR-0048 two-phase consume): each seed a
+   pass adopts is MARKED here rather than deleted, so a THROWING pass leaves every value in
+   place for the cold rebuild to re-adopt (no shadow backup), while the OUTERMOST clean pass
+   exit deletes the marked keys — preserving the one-shot contract (an SPA re-nav to the same
+   render-path re-inits fresh). Keyed per store so a mark is an O(1) Set add on the hydrate
+   hot path. Owned by `runHydrationPass`: save/restore for nesting, and a nested clean exit
+   hands its marks to the enclosing pass instead of committing — only the outermost owner
+   spends seeds, so an outer-pass throw can still hand every value to the recovery rebuild.
+   undefined outside a pass, where `consumeSeed` falls back to delete-on-read. Deliberately
+   NOT cleared by `withoutHydration` — a fresh build inside a live pass (a block's cold
+   rebuild) still marks and re-adopts. */
+export const SEED_MARKS: {
+    current: Map<Record<string, string>, Set<string>> | undefined
+} = { current: undefined }

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

@@ -1,8 +1,8 @@
 import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
 
 /*
-The sentinel a compiled blocking read (`$$readCellBlocking`, an `await`-marked cell) raises
-when the cell has no value *yet* — "not resolved," not an error (ADR-0042 D3). It is a sibling
+The sentinel `readCell` raises when a BLOCKING cell (`cell.blocking` — an `await`-marked cell)
+has no value *yet* — "not resolved," not an error (ADR-0042 D3). It is a sibling
 of `AsyncCellError` but a DISTINCT class so the two are told apart by `instanceof`: a suspend is
 caught LOCALLY by the reading region — each DOM primitive (`appendText`, `attr`, `each`,
 `spreadAttrs`, `watch`, and the `when`/`switchBlock` condition) swallows it and withholds to an

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

@@ -1,10 +1,8 @@
-import type { RENDER } from './RENDER.ts'
+import type { HydrationCursor } from './types/HydrationCursor.ts'
 
-/* The next server-rendered node to claim under `parent` during hydration,
-   defaulting to its first child when the pointer hasn't been set yet. */
-export function claimChild(
-    hydration: NonNullable<(typeof RENDER)['hydration']>,
-    parent: Node,
-): Node | null {
+/* The next server-rendered node to claim under `parent` during hydration — a PROBE
+   (the cursor doesn't move), defaulting to the first child when the pointer hasn't
+   been set yet. The claim verbs read through this and advance via `parkCursor`. */
+export function claimChild(hydration: HydrationCursor, parent: Node): Node | null {
     return hydration.next.has(parent) ? (hydration.next.get(parent) ?? null) : parent.firstChild
 }

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

@@ -1,7 +1,7 @@
 import { CURRENT_PATH } from './CURRENT_PATH.ts'
 import { claimChild } from './claimChild.ts'
-import type { RENDER } from './RENDER.ts'
 import { reportHydrationDivergence } from './reportHydrationDivergence.ts'
+import type { HydrationCursor } from './types/HydrationCursor.ts'
 
 /*
 A hydration claim that MUST succeed. Like `claimChild`, but throws a structural error
@@ -13,11 +13,7 @@ invariant from a compile-time-only parity test into a runtime guard. Use only wh
 compiled skeleton GUARANTEES a node — control-flow range markers, keyed-row boundaries —
 never where an end-of-list null is legitimate (e.g. a trailing reactive text binding).
 */
-export function claimExpected(
-    hydration: NonNullable<(typeof RENDER)['hydration']>,
-    parent: Node,
-    expected: string,
-): Node {
+export function claimExpected(hydration: HydrationCursor, parent: Node, expected: string): Node {
     const node = claimChild(hydration, parent)
     if (node === null) {
         /* Name where first on the `hydrate` channel (return ignored — a missing structural node

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

@@ -0,0 +1,13 @@
+import { claimExpected } from './claimExpected.ts'
+import { parkCursor } from './parkCursor.ts'
+import type { HydrationCursor } from './types/HydrationCursor.ts'
+
+/* Claims a compiler-guaranteed marker node (a range bracket, a block/boundary comment,
+   a keyed-row bracket) at the parent's cursor and advances past it. Throws a legible
+   structural desync when no node is there (`claimExpected`) — a missing marker means
+   SSR markup and the client build disagree on structure at this position. */
+export function claimMarker(hydration: HydrationCursor, parent: Node, expected: string): Comment {
+    const node = claimExpected(hydration, parent, expected)
+    parkCursor(hydration, parent, node.nextSibling)
+    return node as Comment
+}

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

@@ -0,0 +1,22 @@
+import { claimChild } from './claimChild.ts'
+import { parkCursor } from './parkCursor.ts'
+import type { HydrationCursor } from './types/HydrationCursor.ts'
+
+/* Claims a run of `count` top-level server-rendered siblings at the parent's cursor and
+   parks it past them (a short run — the server DOM ending early — parks on null). The
+   static-clone paths advance through this: the markup is byte-identical to the server's,
+   so nothing inside needs claiming individually. `into` collects the claimed nodes when
+   the caller resolves holes against them (`skeleton`); omitted, the run is only skipped. */
+export function claimRun(
+    hydration: HydrationCursor,
+    parent: Node,
+    count: number,
+    into?: Node[],
+): void {
+    let node = claimChild(hydration, parent)
+    for (let index = 0; index < count && node !== null; index += 1) {
+        into?.push(node)
+        node = node.nextSibling
+    }
+    parkCursor(hydration, parent, node)
+}