@abide/abide 0.48.0 → 0.50.0

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

@@ -0,0 +1,300 @@
+import { ASYNC_CELL } from '../../shared/ASYNC_CELL.ts'
+import { decodeRefJson } from '../../shared/decodeRefJson.ts'
+import { isAsyncIterable } from '../../shared/isAsyncIterable.ts'
+import { isThenable } from '../../shared/isThenable.ts'
+import { resolvedCellsSlot } from '../../shared/resolvedCellsSlot.ts'
+import { streamedCellsSlot } from '../../shared/streamedCellsSlot.ts'
+import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
+import type { AsyncState } from '../../shared/types/AsyncState.ts'
+import type { NamedAsyncIterable } from '../../shared/types/NamedAsyncIterable.ts'
+import { warmSeedKey } from '../../shared/warmSeedKey.ts'
+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 { createEffectNode } from './createEffectNode.ts'
+import { createSignalNode } from './createSignalNode.ts'
+import { readNode } from './readNode.ts'
+import { registerStreamedCell } from './STREAMED_CELLS.ts'
+import { writeNode } from './writeNode.ts'
+
+/* The seed's transform gate (mirrors `state`/`linked`): coerces every value entering
+   the store, whether from a settling promise, a frame, or a `set()`. */
+type Transform = (next: unknown, previous: unknown) => unknown
+
+type AsyncCellOptions = {
+    writable: boolean
+    transform?: Transform
+    /* ADR-0032: a STREAMING cell must NOT join the SSR blocking barrier. A no-`await` async
+       value/content position lowers to a cell that ships pending-`undefined` in the shell and
+       resolves on the client, rather than blocking the first flush inline (that is the `await`
+       tier). Absent/false → today's blocking registration (`await` tier / a keyed bare read).
+       A stream (`isAsyncIterable`) never registers regardless — this only gates a promise seed. */
+    streaming?: boolean
+}
+
+/*
+The source-agnostic async cell — the runtime behind `computed`/`linked` when the seed
+tracks a promise or a NamedAsyncIterable (ADR-0019 D1). It is **eager**: a reactive
+effect runs the seed once at construction (capturing its synchronous dependencies) and
+re-runs — a *reseed* — whenever they change, so independent cells load in parallel and a
+dependent cell re-loads when its dependency settles. The seed's result drives the cell:
+
+  - a **promise** (an `async () => await …` thunk) → unwrap; resolve → value, reject → error;
+  - a **NamedAsyncIterable** (socket / streaming rpc) → `for await` its frames, each frame
+    updating the value; the terminal error/close land on `error()` / clear in-flight;
+  - a **synchronous value** (a seed that produced one directly) → settle immediately.
+
+Read through the probe family only — there is no `.value`. `pending()` is "no value yet",
+`refreshing()` is "a held value while a fresher source is in flight" (a reseed or a
+`refresh()`), `peek()` is the retained value/latest frame (stale-while-revalidate),
+`error()` the last rejection. Every out-of-order settle is guarded by a run id, so a slow
+prior flight never overwrites a newer one. `refresh()` re-invokes the seed keeping the
+value visible; a writable cell adds `set()`, which latches until the next reseed.
+*/
+export function createAsyncCell(
+    seed: () => unknown,
+    options: AsyncCellOptions,
+): AsyncComputed<unknown> | AsyncState<unknown> {
+    const transform = options.transform
+    /* Reactive state, each its own signal so a reader subscribes only to the facets it
+       touches (peeking the value does not re-run on a pending flip, and vice versa). */
+    const valueNode = createSignalNode(undefined)
+    const errorNode = createSignalNode(undefined)
+    const inFlightNode = createSignalNode(true)
+    const hasValueNode = createSignalNode(false)
+
+    /* This cell's serialization-stable warm-seed key: its scope's render-path id + a per-scope
+       index, drawn at construction (in declaration order) so SSR and client agree on it. Minted
+       through the shared `warmSeedKey` so BOTH sides of the handoff (this same isomorphic call,
+       server-side keying `resolvedCells`/`streamedCells` and client-side reading `CELL_SEED`) form
+       the identical string from one definition. Undefined for a detached cell (no scope) — such a
+       cell never crosses SSR→client, so never warm-seeds. */
+    const scope = CURRENT_SCOPE.current as (Scope & { nextCellIndex: () => number }) | undefined
+    const warmKey = scope !== undefined ? warmSeedKey(scope.id, scope.nextCellIndex()) : undefined
+
+    /* `linked` write latch: a local `set()` holds the cell until the next reseed, so an
+       arriving frame / settling promise never clobbers an in-progress edit. Cleared on reseed. */
+    let written = false
+    /* Supersedes out-of-order settles: only the latest run's promise/stream may write. */
+    let runId = 0
+    /* The current run's in-flight promise (undefined once settled, or for a stream/sync seed).
+       Surfaced through `settled()` for the SSR barrier's structural read; a stream never sets it. */
+    let inFlight: Promise<unknown> | undefined
+    /* Cancels the active stream subscription (a reseed, refresh, or dispose supersedes it). */
+    let cancelStream: (() => void) | undefined
+
+    /* Store a produced value, honouring the write latch and the transform gate. */
+    const acceptValue = (value: unknown): void => {
+        if (written) {
+            return
+        }
+        writeNode(valueNode, transform === undefined ? value : transform(value, valueNode.value))
+        writeNode(hasValueNode, true)
+    }
+
+    const settleValue = (myRun: number, value: unknown): void => {
+        if (myRun !== runId) {
+            return
+        }
+        inFlight = undefined
+        acceptValue(value)
+        writeNode(errorNode, undefined)
+        writeNode(inFlightNode, false)
+        /* Server-only: record the resolved value keyed by this cell's render-path id (the `window`
+           guard keeps client settles from ever recording). BLOCKING cells → `resolvedCells`: the
+           barrier awaits them before the template peeks, so the value bakes into the SSR HTML and
+           the page renderer stamps it into the PRE-mount `__SSR__.cells` warm-seed — a warm client
+           value MATCHES it (no flash, no duplication). STREAMING cells → `streamedCells` (ADR-0035):
+           they ship pending in the shell, so their value can't ride the pre-mount seed (it would
+           diverge from the pending markup); it's streamed AFTER the shell as an `__abideResolve`
+           chunk the client adopts POST-hydration. Recording a VALUE (not awaiting a promise) means a
+           cell that never settles this request is simply never recorded — no hang. */
+        if (warmKey !== undefined && typeof window === 'undefined') {
+            if (options.streaming === true) {
+                streamedCellsSlot.get()?.entries.push({ key: warmKey, value })
+            } else {
+                resolvedCellsSlot.get()?.entries.push({ key: warmKey, value })
+            }
+        }
+    }
+
+    /* An error retains the value (SWR): a failed background refresh keeps the stale value
+       visible and surfaces the rejection through `error()` — the read decides what to do. */
+    const settleError = (myRun: number, error: unknown): void => {
+        if (myRun !== runId) {
+            return
+        }
+        inFlight = undefined
+        writeNode(errorNode, error)
+        writeNode(inFlightNode, false)
+    }
+
+    /* Drive a NamedAsyncIterable: first frame clears pending, each later frame updates the
+       value (unless written), a throw lands in `error()`, and completion clears in-flight. */
+    const consumeStream = (myRun: number, source: NamedAsyncIterable<unknown>): void => {
+        const iterator = source[Symbol.asyncIterator]()
+        let live = true
+        cancelStream = (): void => {
+            live = false
+            void iterator.return?.(undefined)
+        }
+        const pump = async (): Promise<void> => {
+            try {
+                while (live && myRun === runId) {
+                    const step = await iterator.next()
+                    if (!live || myRun !== runId) {
+                        return
+                    }
+                    if (step.done === true) {
+                        writeNode(inFlightNode, false)
+                        return
+                    }
+                    acceptValue(step.value)
+                    writeNode(errorNode, undefined)
+                    writeNode(inFlightNode, false)
+                }
+            } catch (error) {
+                settleError(myRun, error)
+            }
+        }
+        /* The pump never rejects (its body is fully try/caught), so the kickoff is contained
+           — no unhandled rejection, never Bun-fatal. */
+        void pump()
+    }
+
+    /* Run (or re-run) the seed. `reseed` marks a dependency-driven new source, which clears
+       the write latch; a `refresh()` passes false so a held write and value survive. */
+    const run = (reseed: boolean): void => {
+        runId += 1
+        const myRun = runId
+        if (cancelStream !== undefined) {
+            cancelStream()
+            cancelStream = undefined
+        }
+        if (reseed) {
+            written = false
+        }
+        writeNode(inFlightNode, true)
+
+        let produced: unknown
+        try {
+            produced = seed()
+        } catch (error) {
+            settleError(myRun, error)
+            return
+        }
+
+        if (isAsyncIterable(produced)) {
+            consumeStream(myRun, produced as NamedAsyncIterable<unknown>)
+            return
+        }
+        if (isThenable(produced)) {
+            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
+               cell — baking the resolved value into the first-pass HTML (ADR-0019 Tier-2). A
+               stream (the `isAsyncIterable` branch above) never registers: it never settles. The
+               `window` guard keeps client construction from ever registering. A `streaming`
+               cell (ADR-0032, a no-`await` position) opts OUT: it ships pending and resolves on
+               the client instead of blocking the flush. */
+            if (typeof window === 'undefined' && options.streaming !== true) {
+                activePendingCells()?.promises.push(inFlight)
+            }
+            /* `.then(onValue, onError)` handles the rejection inline — contained in `error()`,
+               never an unhandled rejection. A STREAMING cell's resolved value is recorded in
+               `settleValue` (ADR-0035), not here — awaiting the promise could hang if it never
+               settles this request. */
+            ;(produced as PromiseLike<unknown>).then(
+                (value) => settleValue(myRun, value),
+                (error) => settleError(myRun, error),
+            )
+            return
+        }
+        settleValue(myRun, produced)
+    }
+
+    /* Warm hydrate: if the server shipped this cell's resolved value (keyed by its render-path
+       id), adopt it NOW — before the eager run — so `hasValue` is already true. The cell then reads
+       as REFRESHING (not pending) through the eager run below, so the value shows instantly with no
+       flash and matches the SSR-rendered branch. The run still fires (revalidate + subscribe the
+       seed's deps for reactivity, SWR), and its settle supersedes via the `runId` guard. Client-
+       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]
+        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 {
+                /* Unserializable/corrupt seed → cold run renders it. */
+            }
+        }
+    }
+
+    /* The eager first-run + reactive reseed: the effect tracks the seed's synchronous reads,
+       so a dependency change re-runs it. Its cleanup cancels any live stream on reseed/dispose. */
+    createEffectNode(() => {
+        run(true)
+        return (): void => {
+            if (cancelStream !== undefined) {
+                cancelStream()
+                cancelStream = undefined
+            }
+        }
+    })
+
+    /* Client-only, STREAMING cells (ADR-0035): a streaming cell ships pending and its value streams
+       in AFTER the shell. Register — AFTER the eager run above, so its `inFlight = true` is already
+       set — to receive that value by render-path id; when it lands, adopt it as a reactive update:
+       the value shows immediately (no `loading…` flash) and the in-flight cold seed run re-settles
+       the same value, superseded by the write latch. The streamed value only ever seeds the initial
+       render; a later dep-driven reseed is authoritative and runs the seed as usual. */
+    if (warmKey !== undefined && options.streaming === true && typeof window !== 'undefined') {
+        registerStreamedCell(warmKey, (value) => {
+            acceptValue(value)
+            writeNode(errorNode, undefined)
+            writeNode(inFlightNode, false)
+        })
+    }
+
+    /* The shared read surface, identical for read-only and writable cells. */
+    const readOnly: AsyncComputed<unknown> = {
+        [ASYNC_CELL]: true,
+        peek: () => readNode(valueNode),
+        /* No value yet: in flight and nothing retained. */
+        pending: () => readNode(inFlightNode) === true && readNode(hasValueNode) !== true,
+        /* A held value being superseded: in flight but a value is retained. */
+        refreshing: () => readNode(inFlightNode) === true && readNode(hasValueNode) === true,
+        error: () => readNode(errorNode),
+        /* Re-invoke the seed keeping the value visible (SWR); not a reseed, so a write holds. */
+        refresh: () => run(false),
+        /* 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,
+    } as AsyncComputed<unknown>
+    if (!options.writable) {
+        return readOnly
+    }
+    /* A writable cell adds `set()`: latches until the next reseed. `settled` rides along from
+       the `readOnly` spread (a runtime affordance not on the public type). */
+    const writable: AsyncState<unknown> = {
+        ...readOnly,
+        set: (value: unknown): void => {
+            written = true
+            writeNode(
+                valueNode,
+                transform === undefined ? value : transform(value, valueNode.value),
+            )
+            writeNode(hasValueNode, true)
+        },
+    }
+    return writable
+}

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

@@ -2,7 +2,6 @@ import { applyPatchToTree } from './applyPatchToTree.ts'
 import { batch } from './batch.ts'
 import { createComputedNode } from './createComputedNode.ts'
 import { createSignalNode } from './createSignalNode.ts'
-import { PATCH_BUS } from './PATCH_BUS.ts'
 import { pathSegments } from './pathSegments.ts'
 import { readNode } from './readNode.ts'
 import { trigger } from './trigger.ts'
@@ -59,12 +58,9 @@ export function createDoc(initial: unknown): Doc {
        truth. Held apart from `nodes` so the structural wake/eviction never touches
        them; their dirtiness is driven entirely by the deps they read (the signal
        graph), not by tree mutations. They are not in `tree`, so `snapshot` omits
-       them, and they never pass through `apply`, so they never hit the patch bus —
-       a recompute is a downstream reaction, not a change to journal/persist/sync. */
+       them, and they never pass through `apply` — a recompute is a downstream reaction
+       of the signal graph, not a tree change. */
     const computed = new Map<string, ReactiveNode>()
-    /* Set to the returned document before any apply runs, so a PATCH_BUS event can
-       name the document it came from (reference identity, the undo/persistence key). */
-    let self: Doc
 
     /* Links `path` into the trie under its parent and continues up the ancestor chain.
        Stops at the first ancestor whose parent set already lists it — that link, and
@@ -227,10 +223,6 @@ export function createDoc(initial: unknown): Doc {
         /* Segments index the tree, so they carry the REAL keys (unescaped); the path
            strings (parentPath, node-map keys) stay escaped, re-walked through walkPath. */
         const segments = patch.path === '' ? [] : pathSegments(patch.path)
-        /* Capture the pre-image only when a consumer is listening (the inverse's only
-           cost): a replace/remove inverts to the value it overwrote, an add to a
-           remove (computed post-apply, below, to resolve an array append's index). */
-        const before = PATCH_BUS.active ? walkPath(tree, patch.path) : undefined
         tree = applyPatchToTree(tree, patch, segments)
         const parentPath = parentPathOf(patch.path)
         const parentValue = walkPath(tree, parentPath).value
@@ -270,40 +262,9 @@ export function createDoc(initial: unknown): Doc {
             } else {
                 wakeSubtree(parentPath, true, true)
             }
-            /* Announce the change before effects flush, so a patch an effect emits in
-               reaction lands AFTER this one on the bus — the journal stays chronological.
-               Emitting inside the batch keeps it ahead of the depth-0 flush on batch exit. */
-            if (PATCH_BUS.active) {
-                PATCH_BUS.emit({ doc: self, patch, inverse: inverseOf(patch, before) })
-            }
         })
     }
 
-    /* The patch that undoes `patch`, from the pre-image `before` (a value the change
-       overwrote/removed) and the now-mutated tree. An add inverts to removing the slot
-       it created — resolving an array append (`-`) to the concrete last index it took.
-       A replace/remove of a path that held nothing inverts to remove/nothing. */
-    function inverseOf(
-        patch: Patch,
-        before: ReturnType<typeof walkPath> | undefined,
-    ): Patch | undefined {
-        if (patch.op === 'add') {
-            const parentPath = parentPathOf(patch.path)
-            const parent = walkPath(tree, parentPath).value
-            const resolved =
-                Array.isArray(parent) && patch.path.endsWith('/-')
-                    ? `${parentPath}/${parent.length - 1}`
-                    : patch.path
-            return { op: 'remove', path: resolved }
-        }
-        if (patch.op === 'replace') {
-            return before?.exists
-                ? { op: 'replace', path: patch.path, value: before.value }
-                : { op: 'remove', path: patch.path }
-        }
-        return before?.exists ? { op: 'add', path: patch.path, value: before.value } : undefined
-    }
-
     /*
     A stable accessor bound to one scalar leaf — what the compiler emits so a hot
     loop has zero string work: the node, the parent container, and the leaf key
@@ -316,30 +277,46 @@ export function createDoc(initial: unknown): Doc {
         const node = nodeFor(path)
         const segments = pathSegments(path)
         const leafKey = segments[segments.length - 1] as string
-        /* Auto-vivify missing ancestor objects so binding a nested path on a doc
-           booted shallow (e.g. `state({})`) doesn't crash, and a later `set` writes
-           into the LIVE tree (so snapshot/persist see it). Mirrors the container
-           assumption applyPatchToTree makes — except the patch path is authored, this
-           walk is compiler-emitted, so the intermediates may not exist yet. */
-        let parent = tree as Record<string, unknown>
-        for (const segment of segments.slice(0, -1)) {
-            let next = parent[segment]
-            if (next === null || typeof next !== 'object') {
-                next = {}
-                parent[segment] = next
+        const ancestors = segments.slice(0, -1)
+        /* The resolved parent container, cached after the first write. `get` never needs
+           it (it reads through `node`), so it is not computed at cell creation. */
+        let parent: Record<string, unknown> | undefined
+        /* Auto-vivify missing ancestor objects so a `set` on a nested path bound over a
+           doc booted shallow (e.g. `state({})`) writes into the LIVE tree (snapshot/persist
+           see it) rather than crashing. Done LAZILY on the first write, NOT at cell
+           creation: `hoistCells` lifts a cell to component-mount scope, so vivifying eagerly
+           would fabricate container structure for a path only ever written behind a branch /
+           in a handler that never runs. Mirrors applyPatchToTree's container assumption,
+           but the intermediates may not exist yet since this walk is compiler-emitted. */
+        const resolveParent = (): Record<string, unknown> => {
+            let current = tree as Record<string, unknown>
+            for (let index = 0; index < ancestors.length; index += 1) {
+                const segment = ancestors[index] as string
+                let next = current[segment]
+                if (next === null || typeof next !== 'object') {
+                    /* Create an array when the NEXT segment addresses an array element (a
+                       numeric index or the `-` push slot), else a plain object — otherwise a
+                       bound path like `items/0/name` on a shallow doc fabricates `items` as an
+                       object keyed by "0", which a later `add("items/-", …)` can't push into. */
+                    const childKey = (ancestors[index + 1] ?? leafKey) as string
+                    next = childKey === '-' || /^\d+$/.test(childKey) ? [] : {}
+                    current[segment] = next
+                }
+                current = next as Record<string, unknown>
             }
-            parent = next as Record<string, unknown>
+            return current
         }
         return {
             get: () => readNode(node) as T,
             set: (value: T) => {
+                parent ??= resolveParent()
                 parent[leafKey] = value
                 writeNode(node, value)
             },
         }
     }
 
-    self = {
+    const self: Doc = {
         read,
         cell,
         derive,

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

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

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

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

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

@@ -1,3 +1,5 @@
+import { boundaryFor } from './boundaryFor.ts'
+import { NODE_STATE } from './NODE_STATE.ts'
 import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
 import type { ReactiveNode } from './types/ReactiveNode.ts'
 import { updateIfNecessary } from './updateIfNecessary.ts'
@@ -39,13 +41,43 @@ export function flushEffects(): void {
 
 function drain(): void {
     let spare: ReactiveNode[] = []
+    let errors: unknown[] | undefined
     do {
         const batch = REACTIVE_CONTEXT.pendingEffects
         REACTIVE_CONTEXT.pendingEffects = spare
         for (let index = 0; index < batch.length; index += 1) {
-            updateIfNecessary(batch[index] as ReactiveNode)
+            const node = batch[index] as ReactiveNode
+            try {
+                updateIfNecessary(node)
+            } catch (error) {
+                /* A node built inside a reactive `{#try}` routes its throw to that boundary
+                   (swap the guarded content to the catch branch) instead of the rethrow
+                   fallback — this is the "later re-run throw" the sync boundary could not
+                   catch. Reset it CLEAN either way so a later write to its deps can re-queue
+                   it (otherwise `mark`'s CLEAN→dirty gate leaves it permanently inert). */
+                const boundary = boundaryFor.get(node)
+                if (boundary !== undefined) {
+                    boundary.handle(error)
+                    node.status = NODE_STATE.CLEAN
+                    continue
+                }
+                /* No boundary — one effect throwing must not strand the effects queued behind
+                   it (they live in this same `batch`, unreachable once we swap
+                   `pendingEffects`); keep draining and surface the error(s) once the graph has
+                   settled rather than swallowing them. */
+                node.status = NODE_STATE.CLEAN
+                if (errors === undefined) {
+                    errors = []
+                }
+                errors.push(error)
+            }
         }
         batch.length = 0
         spare = batch
     } while (REACTIVE_CONTEXT.pendingEffects.length > 0)
+    if (errors !== undefined) {
+        throw errors.length === 1
+            ? errors[0]
+            : new AggregateError(errors, 'abide: effects threw during flush')
+    }
 }

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

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

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

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

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

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

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

@@ -23,6 +23,17 @@ export function scope(build: () => void): () => void {
     OWNER.current = disposers
     try {
         untrack(build)
+    } catch (error) {
+        /* A build that throws partway (e.g. a hydration desync deep in a subtree) has
+           already created and subscribed some effects/listeners. The caller never
+           receives this scope's disposer on the throw path, so tear down what was built —
+           in reverse, children before parents — before rethrowing; otherwise those effects
+           stay subscribed forever with no owner able to dispose them. */
+        for (let index = disposers.length - 1; index >= 0; index -= 1) {
+            disposers[index]?.()
+        }
+        disposers.length = 0
+        throw error
     } finally {
         OWNER.current = previous
     }

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

@@ -1,3 +1,4 @@
+import { abideLog } from '../../shared/abideLog.ts'
 import type { EffectResult } from './types/EffectResult.ts'
 import type { Teardown } from './types/Teardown.ts'
 
@@ -15,15 +16,21 @@ export function toTeardown(result: EffectResult): Teardown | undefined {
     }
     if (result instanceof Promise) {
         return () => {
-            /* Swallow a rejection: an async body that rejected (e.g. an aborted RPC) must
-               not surface as an unhandled rejection when the teardown runs at dispose. */
             result.then(
                 (teardown) => {
                     if (typeof teardown === 'function') {
                         teardown()
                     }
                 },
-                () => undefined,
+                (error) => {
+                    /* A superseded reactive read aborts its in-flight RPC — expected, stays
+                       quiet. Any OTHER rejection is a real bug in the async effect body;
+                       surface it (the visibility goal) instead of silently discarding it. */
+                    const aborted = (error as { name?: string } | undefined)?.name === 'AbortError'
+                    if (!aborted) {
+                        abideLog.error(error)
+                    }
+                },
             )
         }
     }

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

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