@abide/abide 0.48.0 → 0.50.0

package/src/lib/server/runtime/createUiPageRenderer.ts

@@ -1,9 +1,12 @@
 import { appNameSlot } from '../../shared/appNameSlot.ts'
 import { SSR_CACHE_CONTROL } from '../../shared/CACHE_CONTROL_VALUES.ts'
+import { encodeRefJson } from '../../shared/encodeRefJson.ts'
 import { formatTraceparent } from '../../shared/formatTraceparent.ts'
+import { hasSeedableRequest } from '../../shared/hasSeedableRequest.ts'
 import { layoutChainForRoute } from '../../shared/layoutChainForRoute.ts'
+import { resolvedCellsSlot } from '../../shared/resolvedCellsSlot.ts'
 import { safeJsonForScript } from '../../shared/safeJsonForScript.ts'
-import { snapshotShippable } from '../../shared/snapshotShippable.ts'
+import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
 import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
 import type { SsrPayload } from '../../shared/types/SsrPayload.ts'
 import type { StreamedResolution } from '../../shared/types/StreamedResolution.ts'
@@ -48,16 +51,18 @@ function resolveChunk(resolution: StreamedResolution): string {
 The abide-ui SSR document renderer. A matched route + params in, a finished HTML
 Response out.
 
-A page with no `await` block renders synchronously and ships buffered. A page with
-await blocks STREAMS: the pending shell flushes first, then each resolved fragment
-(`<abide-resolve>` carrying a JSON `<script>`) as its promise settles, swapped into its boundary
-by the inline SSR_SWAP_SCRIPT — which also registers the value into the resume
+A page with no `await` block AND no pending triggered bare read renders synchronously and
+ships buffered. A page with await blocks — or a triggered BARE async read still pending at
+render-return (ADR-0024) — STREAMS: the pending shell flushes first, then each resolved
+fragment (`<abide-resolve>` carrying a JSON `<script>`) as its promise settles, swapped into
+its boundary by the inline SSR_SWAP_SCRIPT — which also registers the value into the resume
 manifest so client hydration adopts it without re-fetching (see abide/ui/awaitBlock).
 Then, once the stream has run every `{#await}` thunk (creating and settling its cache
-entry mid-stream, after the render-return snapshot), each such entry streams an inline
-`__abideResolve(...)` chunk — a warm snapshot, or a `{ key, miss }` marker for an
-unshippable body (→ live refetch) — seeding the client store before the deferred bundle
-so the block's subscription read is warm (no refetch).
+entry mid-stream, after the render-return snapshot), each such entry — plus any bare-read
+entry triggered during the sync render — streams an inline `__abideResolve(...)` chunk: a
+warm snapshot, or a `{ key, miss }` marker for an unshippable body — e.g. a read 504'd by its
+endpoint `timeout` (→ live refetch) — seeding the client store before the deferred bundle
+so the block's / bare read's subscription is warm (no refetch).
 
 `__SSR__` carries the route/params, mount base, trace, app name, client timeout,
 and the render-return cache snapshot (top-level `await` reads; the client seeds its tab
@@ -97,6 +102,29 @@ export function createUiPageRenderer({
         stack?: string,
     ) => Promise<Response | undefined>
 } {
+    /* The `cells` partition of __SSR__: every async cell that RESOLVED during this render (drained
+       from the request-scoped `resolvedCellsSlot` populated by `createAsyncCell.settleValue`),
+       keyed by its render-path id, each value ref-json-encoded so an in-process graph survives.
+       An unserializable value is dropped (a warn) — that one cell falls back to a client re-run
+       rather than blanking the payload. Undefined when no cell resolved (the common static page). */
+    function resolvedCellCells(): Record<string, string> | undefined {
+        const entries = resolvedCellsSlot.get()?.entries ?? []
+        if (entries.length === 0) {
+            return undefined
+        }
+        const cells: Record<string, string> = {}
+        for (const { key, value } of entries) {
+            try {
+                cells[key] = encodeRefJson(value)
+            } catch {
+                console.warn(
+                    `[abide] async cell "${key}" resolved to an unserializable value — it will re-run on the client instead of hydrating warm.`,
+                )
+            }
+        }
+        return Object.keys(cells).length > 0 ? cells : undefined
+    }
+
     /* Build the __SSR__ <script> the client (startClient) reads on boot. The inline
        (settled) cache partition is computed once by the caller and threaded in, so the
        streaming branch can also drain the pending partition over the same render. */
@@ -111,6 +139,7 @@ export function createUiPageRenderer({
             route: routeUrl,
             params,
             cache: inline,
+            cells: resolvedCellCells(),
             base: base || undefined,
             trace: formatTraceparent(store.trace),
             app: appNameSlot.name,
@@ -183,13 +212,26 @@ export function createUiPageRenderer({
         /* Outermost layout → … → page: load every applicable layout chunk plus the
            page, then render the chain as one document (shared block-id pass). */
         const chainKeys = chainKeysForRoute(routeUrl)
-        const views = await Promise.all([
-            ...chainKeys.map((key) => layouts[key]?.().then((module) => module.default)),
-            loadPage().then((module) => module.default),
+        /* Resolve each view PAIRED with its render-path key (layouts then page), then filter the
+           pairs together. Zipping in one pass makes the key↔view alignment structural rather than
+           an asserted "no view is ever dropped" invariant: were a layout to resolve to no default
+           export, dropping it would otherwise shift every later key by one and mis-key the page's
+           cells (a silent warm-seed mismatch — the class this render-path id exists to kill). The
+           keys stay byte-identical to the client router's `chainKeys`/`pageKey`. */
+        const resolved = await Promise.all([
+            ...chainKeys.map((key) =>
+                layouts[key]?.().then((module) => ({ key, view: module.default })),
+            ),
+            loadPage().then((module) => ({ key: routeUrl, view: module.default })),
         ])
+        const kept = resolved.filter(
+            (entry): entry is { key: string; view: UiComponent } =>
+                entry !== undefined && entry.view !== undefined,
+        )
         const ssr = await renderChain(
-            views.filter((view): view is UiComponent => view !== undefined),
+            kept.map((entry) => entry.view),
             params,
+            kept.map((entry) => entry.key),
         )
 
         /* Snapshot the cache settled by render-return — top-level `await` reads and blocking
@@ -199,10 +241,24 @@ export function createUiPageRenderer({
         const inline = await serializeCacheSnapshot(store.cache)
         const inlinedKeys = new Set(inline.map((entry) => entry.key))
 
-        /* No STREAMING await blocks → ship buffered. Blocking `{#await … then}` blocks
-           rendered inline (their markup is already in `ssr.html`); seed their resolved
-           values so hydration adopts them without a refetch. */
-        if (ssr.awaits.length === 0) {
+        /* ADR-0024: a bare async read (`{user}`, no `{#await}`) that TRIGGERED its fetch during
+           the sync render leaves a still-pending replayable entry in the store at render-return
+           — not yet settled, so it missed the inline snapshot above. Detecting one here is what
+           opens the streaming gate for a page with no await block, so its value streams in
+           instead of shipping `undefined` buffered. `hasSeedableRequest` (the request half of
+           shippability — not `snapshotShippable`, which also demands `settled`) is the gate: it
+           excludes producers and stream cells (a `NamedAsyncIterable` cell holds no wire
+           request), which must stay `peek()`-at-flush and buffered. `!inlinedKeys` drops
+           anything already baked into `__SSR__` (a Tier-2 top-level `await`) so a value never
+           double-ships. */
+        const pendingBareReads = Array.from(store.cache.entries.values()).filter(
+            (entry) => hasSeedableRequest(entry) && !inlinedKeys.has(entry.key),
+        )
+
+        /* No STREAMING await blocks AND no triggered bare read pending → ship buffered exactly
+           as before. Blocking `{#await … then}` blocks rendered inline (their markup is already
+           in `ssr.html`); seed their resolved values so hydration adopts them without a refetch. */
+        if (ssr.awaits.length === 0 && pendingBareReads.length === 0) {
             const html = injectRoutePreloads(
                 shell.replace(SSR_MARKER, (_match, key: string) =>
                     key === 'body' ? ssr.html : key === 'state' ? '' : '',
@@ -232,6 +288,11 @@ export function createUiPageRenderer({
         const head =
             `<script>${SSR_SWAP_SCRIPT}${CACHE_RESOLVE_SCRIPT}</script>` +
             `${await stateTag(routeUrl, params, store, inline)}`
+        /* ADR-0039: the async-cell keys already baked into the head `__SSR__.cells` snapshot. A
+           streamed child's render is deferred to the drain, so its BLOCKING cells resolve AFTER this
+           and must ship as post-body `{cellSeed}` chunks instead — the delta below is keys NOT here.
+           Read `store` directly (the stream body runs outside the request ALS). */
+        const seededCellKeys = new Set(store.resolvedCells.entries.map((entry) => entry.key))
         const filled = injectRoutePreloads(
             shell.replace(HEAD_STATE_MARKER, (_match, key: string) => (key === 'head' ? head : '')),
             routeUrl,
@@ -256,22 +317,72 @@ export function createUiPageRenderer({
                             )
                             first = false
                         }
-                        /* The {#await} reads created (and settled) their cache entries DURING the
-                           stream — the await expression is a thunk `renderToStream` ran lazily —
-                           so they missed the render-return snapshot. Drain them now: each lands an
-                           inline `__abideResolve(...)` chunk (a warm snapshot, or a `{ key, miss }`
-                           marker for an unshippable body → live refetch) before the deferred
-                           bundle, so startClient seeds the store and the block's subscription read
-                           is warm. Skip keys already shipped inline in __SSR__. */
-                        const streamedEntries = Array.from(store.cache.entries.values()).filter(
-                            (entry) => snapshotShippable(entry) && !inlinedKeys.has(entry.key),
+                        /* Two kinds of pending entry land here. (1) `{#await}` reads created (and
+                           settled) their cache entries DURING the stream — the await expression is a
+                           thunk `renderToStream` ran lazily — so they missed the render-return
+                           snapshot. (2) A triggered BARE read (ADR-0024) created its entry during the
+                           sync render but was never awaited, so it may still be in flight now. Drain
+                           both: each lands an inline `__abideResolve(...)` chunk (a warm snapshot, or a
+                           `{ key, miss }` marker for an unshippable body — e.g. a read 504'd by its
+                           endpoint timeout → live refetch) before the deferred bundle, so startClient seeds
+                           the store and the read's subscription is warm. Skip keys already shipped inline in
+                           __SSR__. */
+                        const streamedEntries: CacheEntry[] = Array.from(
+                            store.cache.entries.values(),
+                        ).filter(
+                            (entry) => hasSeedableRequest(entry) && !inlinedKeys.has(entry.key),
                         )
+                        /* `hasSeedableRequest`, NOT `snapshotShippable`: a triggered bare read
+                           (ADR-0024) is drained here still-pending (never awaited by an `{#await}`
+                           thunk), so gating on `settled` up front would skip it — streamCacheResolutions
+                           awaits each entry's body itself (see snapshotEntryFromCache). A pending read is
+                           bounded by its OWN endpoint `timeout` (which 504s the in-process handler during
+                           SSR), so there is no separate SSR-stream deadline. A late-settling `{#await}`
+                           entry is already settled by now, so the set is unchanged for the Tier-3 path. */
                         for await (const resolution of streamCacheResolutions(
                             store.cache,
                             streamedEntries,
                         )) {
                             controller.enqueue(encoder.encode(resolveChunk(resolution)))
                         }
+                        /* ADR-0035: stream each STREAMING cell that SETTLED during this render as an
+                           `__abideResolve({ cellKey, value })` chunk (keyed by its render-path id),
+                           so the client adopts it post-hydration instead of only cold-re-running the
+                           seed — the flash the pre-mount `__SSR__.cells` warm-seed can't fix without
+                           diverging from the pending shell. These are already-settled VALUES
+                           (recorded in createAsyncCell.settleValue), never awaited here: a cell that
+                           stays pending through the request (`{#if getFoo()}` holds) is simply not
+                           streamed and the client cold-runs it. An unserializable value emits nothing.
+                           Read from `store` directly since the stream body runs outside the request ALS. */
+                        for (const { key, value } of store.streamedCells.entries) {
+                            let encoded: string
+                            try {
+                                encoded = encodeRefJson(value)
+                            } catch {
+                                continue
+                            }
+                            controller.enqueue(
+                                encoder.encode(resolveChunk({ cellKey: key, value: encoded })),
+                            )
+                        }
+                        /* ADR-0039: a STREAMED CHILD's BLOCKING async cells resolved during this drain,
+                           after the head `__SSR__.cells` snapshot — ship the delta (keys not already
+                           seeded) as `{cellSeed}` chunks so startClient seeds CELL_SEED before the
+                           child's deferred mount and its cell constructs resolved (no flash/re-run). */
+                        for (const { key, value } of store.resolvedCells.entries) {
+                            if (seededCellKeys.has(key)) {
+                                continue
+                            }
+                            let encoded: string
+                            try {
+                                encoded = encodeRefJson(value)
+                            } catch {
+                                continue
+                            }
+                            controller.enqueue(
+                                encoder.encode(resolveChunk({ cellSeed: key, value: encoded })),
+                            )
+                        }
                         controller.enqueue(encoder.encode(after ?? ''))
                         controller.close()
                     } catch (streamError) {

package/src/lib/server/runtime/devClientFingerprint.ts

@@ -1,7 +1,5 @@
 import { relative } from 'node:path'
-import { fileName } from '../../shared/fileName.ts'
 import { isLayoutFile } from '../../shared/isLayoutFile.ts'
-import { analyzeComponent } from '../../ui/compile/analyzeComponent.ts'
 import { compileComponent } from '../../ui/compile/compileComponent.ts'
 import { nearestProjectRoot } from '../../ui/compile/nearestProjectRoot.ts'
 import { globToPathSet } from './globToPathSet.ts'
@@ -12,36 +10,29 @@ const CSS_HREF = /href=(["'])([^"']*\/_app\/[^"']*\.css)\1/
 // Every `/_app/<hashed-asset>` ref in the shell (the JS entry, the stylesheet) —
 // content-hashed names that move on any rebuild. Normalised out of `structure` so
 // a component/CSS edit (which re-hashes the bundle) doesn't read as a reload; the
-// source-based signals (components, non-component hashes, cssHref) catch real changes.
+// source-based signals (component bodies, non-component hashes, cssHref) catch real changes.
 const APP_ASSET = /\/_app\/[^"'\s)]*/g
 // src/.abide is the build's own generated output (route d.ts) — rewritten every
 // rebuild, so it must stay out of the hash or the page would always reload.
 const GENERATED = /(^|\/)\.abide\//
 
-// page.abide / layout.abide are router-mounted, not `mountChild`-tracked, so they
-// can't hot-swap — they fold into `structure` (a reload) instead.
-function isPageOrLayout(moduleId: string): boolean {
-    return fileName(moduleId) === 'page.abide' || isLayoutFile(moduleId)
-}
-
 /*
 The dev live-reload stamp, computed once at worker boot from SOURCE (the dev
 watcher only watches src/, so source is what a rebuild can reflect). Splits the
 edit space so the browser keeps its page where it can:
 
-  - Each `.abide` is hashed by its client BUILD (`compileComponent`, which carries
-    no CSS), so a style-only edit doesn't change it. A leaf component with no
-    imports that isn't a page/layout is hot-swappable: its hash goes in
-    `components`, keyed by the same module id the loader stamps (so it matches the
-    registry). Every other component (page, layout, import-bearing) folds its hash
-    into `structure` — editing it reloads.
-  - `structure` also covers non-`.abide` source, public stamps, the shell (with
-    the stylesheet href normalised out), and the sorted component-id set (so
-    adding/removing a component reloads).
-  - `cssHref` is the entry stylesheet's current URL, read from the shell.
+  - `structure` fingerprints every source signal a reload must react to: each
+    `.abide`'s client BUILD hash (`compileComponent`, which carries NO CSS — so a
+    style-only edit leaves it unchanged), the component-id set (adding/removing a
+    component reloads), non-`.abide` source, public assets, and the shell (with the
+    content-hashed `/_app/*` asset names normalised out, so a rebuild's re-hash isn't
+    itself a change). Any change here reloads.
+  - `cssHref` is the entry stylesheet's content-hashed URL; a change here ALONE swaps
+    the `<link>` in place — a CSS edit restyles the live page with no reload and no
+    state loss.
 
-A compile failure (mid-edit syntax error) falls back to a raw-source hash marked
-non-hot, so the worst case is a reload, never a throw at boot.
+A compile failure (mid-edit syntax error) falls back to a raw-source hash, so the
+worst case is a reload, never a throw at boot.
 */
 export async function devClientFingerprint({
     srcDir,
@@ -58,8 +49,7 @@ export async function devClientFingerprint({
         .filter((file) => !GENERATED.test(file))
         .sort()
 
-    const components: Record<string, string> = {}
-    const nonHotComponents: string[] = []
+    const componentBodies: string[] = []
     const componentIds: string[] = []
     const otherSource: string[] = []
 
@@ -79,19 +69,14 @@ export async function devClientFingerprint({
             const moduleId = relative(nearestProjectRoot(full, projectRoot), full)
             componentIds.push(moduleId)
             let bodyHash: string
-            let hot = false
             try {
-                const isLayout = isLayoutFile(moduleId)
-                bodyHash = Bun.hash(compileComponent(source, isLayout, moduleId)).toString(36)
-                hot = analyzeComponent(source).imports === '' && !isPageOrLayout(moduleId)
+                bodyHash = Bun.hash(
+                    compileComponent(source, isLayoutFile(moduleId), moduleId),
+                ).toString(36)
             } catch {
                 bodyHash = Bun.hash(source).toString(36)
             }
-            if (hot) {
-                components[moduleId] = bodyHash
-            } else {
-                nonHotComponents.push(`${moduleId}:${bodyHash}`)
-            }
+            componentBodies.push(`${moduleId}:${bodyHash}`)
         }),
     )
 
@@ -111,8 +96,8 @@ export async function devClientFingerprint({
             publicStamps.join('\n'),
             structureShell,
             componentIds.sort().join(','),
-            nonHotComponents.sort().join('\n'),
+            componentBodies.sort().join('\n'),
         ].join('\0'),
     ).toString(36)
-    return { structure, cssHref, components }
+    return { structure, cssHref }
 }

package/src/lib/server/runtime/finalizeResponse.ts

@@ -1,5 +1,6 @@
 import { responseBodyKind } from '../../shared/responseBodyKind.ts'
 import { gzipResponse } from './gzipResponse.ts'
+import { STREAMED_HTML_HEADER } from './STREAMED_HTML_HEADER.ts'
 import type { RequestStore } from './types/RequestStore.ts'
 
 /*
@@ -24,7 +25,16 @@ export function finalizeResponse(
     exemptIdleTimeout: () => void,
 ): Response {
     const kind = responseBodyKind(response)
-    store.responseStreaming = kind === 'streaming'
+    /* Close-monitoring (defer the closing record + cache-stats snapshot until the body
+       actually drains) must also cover progressively-streamed SSR HTML — a live
+       ReadableStream marked by STREAMED_HTML_HEADER that classifies as 'compressible' (it
+       still gzips), NOT as 'streaming'. Read the marker before gzipResponse strips it.
+       Without this, a page with a slow `{#await}` logs ~1ms elapsed and near-empty cache
+       stats at header time instead of the true drain-time values. */
+    const streamedHtml = response.headers.has(STREAMED_HTML_HEADER)
+    store.responseStreaming = kind === 'streaming' || streamedHtml
+    /* Only true frame protocols (SSE/JSONL, socket tail) opt out of the idle-timeout cap;
+       streamed HTML pages deliberately rely on it (see STREAMED_HTML_HEADER). */
     if (kind === 'streaming') {
         exemptIdleTimeout()
     }

package/src/lib/server/runtime/installAmbientScopeStore.ts

@@ -1,19 +1,27 @@
+import { ambientPathBacking } from '../../ui/runtime/ambientPathBacking.ts'
 import { ambientScopeBacking } from '../../ui/runtime/ambientScopeBacking.ts'
+import { cellBarrierBacking } from '../../ui/runtime/cellBarrierBacking.ts'
 import type { Scope } from '../../ui/types/Scope.ts'
+import { pathStore } from './pathStore.ts'
+import { renderCellBarrierStore } from './renderCellBarrierStore.ts'
 import { requestContext } from './requestContext.ts'
 
-/* Ambient scope when no request is in flight (server boot, a standalone render). */
+/* Ambient scope when no request is in flight (server boot, a standalone render). The path needs
+   no such fallback: `pathStore.run` establishes its value with or without a request in flight,
+   and `getStore()` fails open to `''` outside any push. */
 let outsideRequest: Scope | undefined
 
 /*
-Swaps the ambient-scope backing to one keyed off the per-request AsyncLocalStorage
-store, so `CURRENT_SCOPE.current` isolates per request instead of living in one
-module global (see CURRENT_SCOPE). SSR is partly async — a render `await`s inline
-between its `enterScope`/`exitScope` bracket — and the async context propagates the
-right store across those awaits, so a resumed render reads ITS OWN scope even while
-another request renders concurrently. Called once at server boot (createServer),
-alongside the request-scope resolver install. Reads/writes outside any request fall
-back to a module variable (unchanged behaviour for standalone renders).
+Swaps the ambient-scope backing to one keyed off the per-request AsyncLocalStorage store and the
+ambient-PATH backing to the dedicated `pathStore.run` (ADR-0033 D1), so `CURRENT_SCOPE.current` and
+`CURRENT_PATH.current` isolate per request instead of living in one module global (see CURRENT_SCOPE
+/ CURRENT_PATH). SSR is partly async — a render `await`s inline between its `enterScope`/`exitScope`
+bracket — and the async context propagates the right value across those awaits, so a resumed render
+reads ITS OWN scope/path even while another request renders concurrently. For the path, `run`'s value
+is ALSO inherited by the render's own post-await continuation (a mutable slot restored in `finally`
+was not), which is the fix ADR-0033 buys. Called once at server boot (createServer), alongside the
+request-scope resolver install. The scope backing still falls back to a module variable outside any
+request (unchanged behaviour for standalone renders); the path backing needs no such fallback.
 */
 export function installAmbientScopeStore(): void {
     ambientScopeBacking.active = {
@@ -30,4 +38,17 @@ export function installAmbientScopeStore(): void {
             }
         },
     }
+    ambientPathBacking.active = {
+        run: (composedPath, build) => pathStore.run(composedPath, build),
+        get: () => pathStore.getStore() ?? '',
+    }
+    /* Per-render async-cell barrier isolation (ADR-0037 Phase 2): a hoisted concurrent child render
+       runs under its own pending-cells list via `renderCellBarrierStore.run`, and the barrier
+       consumers read it through `cellBarrierBacking.current`. ALS so the fresh list survives the
+       child render's own awaits; `undefined` outside any isolated render leaves the page/request
+       drain untouched. */
+    cellBarrierBacking.active = {
+        current: () => renderCellBarrierStore.getStore(),
+        run: (list, render) => renderCellBarrierStore.run(list, render),
+    }
 }

package/src/lib/server/runtime/logExposedSurfaces.ts

@@ -15,9 +15,10 @@ const redden = (text: string): string =>
     hasColor ? `${Bun.color('red', 'ansi-256')}${text}\x1b[39m` : text
 
 /*
-A declared inputSchema is what makes mcp/cli safe to advertise (see defineRpc /
-defineSocket), so a missing schema gets a red `·` to flag the declaration whose
-machine surfaces are gated behind it.
+A declared inputSchema — OR a build-projected input-type schema (ADR-0030 input
+side), which advertises the same shape — is what makes mcp/cli safe to advertise
+(see defineRpc / defineSocket), so a declaration with neither gets a red `·` to
+flag that its machine surfaces are gated behind a missing contract.
 */
 const schemaCell = (hasSchema: boolean): string => (hasSchema ? PRESENT : redden(ABSENT))
 const flag = (on: boolean): string => (on ? PRESENT : ABSENT)
@@ -133,10 +134,10 @@ export async function logExposedSurfaces(routing: { pages: Pages }): Promise<voi
 
     const rpcRows = Array.from(rpcRegistry.values(), (entry) => [
         withMethod(entry.remote.method, entry.remote.url),
-        schemaCell(Boolean(entry.inputSchema)),
-        flag(entry.clients.browser),
-        flag(entry.clients.mcp),
-        flag(entry.clients.cli),
+        schemaCell(entry.inputSchema !== undefined || entry.inputJsonSchema !== undefined),
+        flag(entry.remote.clients.browser),
+        flag(entry.remote.clients.mcp),
+        flag(entry.remote.clients.cli),
     ]).sort()
 
     logTables([

package/src/lib/server/runtime/pathStore.ts

@@ -0,0 +1,15 @@
+// AsyncLocalStorage is canonical via node:async_hooks — Bun has no separate API
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+/*
+The server's dedicated render-path store (ADR-0033 D1). Backs `CURRENT_PATH.current` during an
+SSR pass with the COMPOSED path as the store value, pushed by `.run(compose(base, segment), build)`
+at each nesting site (route → layout → row → branch → child ordinal). Unlike a mutable slot restored
+in `finally`, `run`'s value is inherited by every async continuation spawned inside it — so a render
+body resuming after an `await` still reads ITS OWN path, and sibling rows/children (continuations of
+the enclosing render body) read the enclosing render's path. Per-request isolation falls out for free
+(each route render is its own `run` tree), which is why this subsumes the path half of the request
+store. Reads outside any `run` fail open to `''` (a detached scope then takes the counter fallback).
+Server-only, kept out of `lib/ui` so the browser bundle never drags in `node:async_hooks`.
+*/
+export const pathStore = new AsyncLocalStorage<string>()

package/src/lib/server/runtime/registryManifests.ts

@@ -52,7 +52,7 @@ export function ensureRegistriesLoaded(): Promise<void> {
             .then(() => undefined)
             /*
             Clear the memo on failure so a transient import error (a
-            module that throws at load, fixed by the next HMR pass)
+            module that throws at load, fixed by the next rebuild)
             doesn't poison every later enumeration request for the
             process lifetime. The rejection still propagates to this
             caller; the reset only affects subsequent calls.

package/src/lib/server/runtime/renderCellBarrierStore.ts

@@ -0,0 +1,15 @@
+// AsyncLocalStorage is canonical via node:async_hooks — Bun has no separate API
+import { AsyncLocalStorage } from 'node:async_hooks'
+import type { PendingAsyncCells } from '../../shared/types/PendingAsyncCells.ts'
+
+/*
+The server's per-RENDER async-cell barrier store (ADR-0037 Phase 2). Backs `cellBarrierBacking` with
+a fresh pending-cells list pushed by `isolateCellBarrier` around a hoisted concurrent child render.
+Unlike the per-request `pendingAsyncCells` (one list a whole request shares), `run`'s value is
+inherited by the child render's own async continuations — so a child that suspends on its script
+await or its `$$settleAsyncCells` barrier keeps reading ITS list, and two sibling renders in flight
+at once never splice each other's cells. `getStore()` is `undefined` outside any isolated render, so
+the page's own cells fall through to the request list. Server-only, kept out of `lib/ui` so the
+browser bundle never drags in `node:async_hooks`. Mirrors `pathStore` (ADR-0033 D1).
+*/
+export const renderCellBarrierStore = new AsyncLocalStorage<PendingAsyncCells>()

package/src/lib/server/runtime/runWithRequestScope.ts

@@ -31,6 +31,9 @@ export function runWithRequestScope(
         url,
         req,
         cache: createCacheStore(),
+        pendingAsyncCells: { promises: [] },
+        resolvedCells: { entries: [] },
+        streamedCells: { entries: [] },
         trace: createTraceContext(req.headers.get('traceparent')),
         start: Bun.nanoseconds(),
     }

package/src/lib/server/runtime/serializeCacheSnapshot.ts

@@ -4,10 +4,12 @@ import type { CacheStore } from '../../shared/types/CacheStore.ts'
 import { snapshotEntryFromCache } from './snapshotEntryFromCache.ts'
 
 /*
-Snapshots the request-scoped cache for SSR at a single instant: every replayable
-(GET-only) entry settled by now, serialized to a wire-safe CacheSnapshotEntry the
-client seeds its store from. Unsettled and non-replayable entries are skipped; a body
-that can't ship (binary / streaming / rejected) drops out via snapshotEntryFromCache.
+Snapshots the request-scoped cache for SSR at a single instant: every entry
+(any method) called inline and settled by now, serialized to a wire-safe
+CacheSnapshotEntry the client seeds its store from — so an inline POST hydrates
+warm rather than re-firing after render. Unsettled entries and producers/stream
+cells (no wire request) are skipped; a body that can't ship (binary / streaming /
+rejected) drops out via snapshotEntryFromCache.
 
 Snapshots concurrently — the awaits are immediate (entries are already settled), but
 their body reads run in parallel. Never blocks on an unsettled entry.

package/src/lib/server/runtime/snapshotEntryFromCache.ts

@@ -1,20 +1,22 @@
 import { contentBodyKind } from '../../shared/contentBodyKind.ts'
 import { contentTypeOf } from '../../shared/contentTypeOf.ts'
-import { hasReplayableRequest } from '../../shared/hasReplayableRequest.ts'
+import { hasSeedableRequest } from '../../shared/hasSeedableRequest.ts'
 import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
 import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
 import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
 import type { CacheStore } from '../../shared/types/CacheStore.ts'
-import type { ReplayableMethod } from '../../shared/types/ReplayableMethod.ts'
+import type { HttpMethod } from '../../shared/types/HttpMethod.ts'
 
 /*
 Awaits one cache entry and turns it into a wire-safe snapshot, or undefined
 when it can't ship. Shared by the inline snapshot path (settled entries,
 resolves immediately) and the streaming drain (pending {#await} entries,
-resolves whenever the underlying fetch lands). Only replayable methods (see
-REPLAYABLE_METHODS) with a textual Content-Type survive — writes must not
-re-fire from a snapshot, body-carrying methods can't be replayed without the
-original request body, and binary bodies don't round-trip through JSON.
+resolves whenever the underlying fetch lands). Any entry carrying a wire request
+(any method — an inline POST seeds too, so it hydrates warm rather than re-firing
+after render) with a textual Content-Type survives; producers/stream cells (no
+request) and binary bodies (don't round-trip through JSON) drop out. Seeding is
+not replay: the seeded value is read warm once, never auto-re-fired (that stays
+GET-only — see REPLAYABLE_METHODS).
 
 Reads the body once and replaces the entry's promise with a string-bodied
 Response so later `shareable()` clones operate on a buffered body instead of
@@ -27,16 +29,14 @@ export async function snapshotEntryFromCache(
     store: CacheStore,
     entry: CacheEntry,
 ): Promise<CacheSnapshotEntry | undefined> {
-    /* The request half of the shared shippability gate: a replayable wire request.
-       Producer entries (no request) and non-replayable methods never snapshot — the
-       streaming-drain caller hands still-pending entries here, so `settled` is NOT gated
-       (the caller's snapshotShippable filter already required it for the entries it picks). */
-    if (!hasReplayableRequest(entry) || !entry.request) {
+    /* The request half of the shared shippability gate: a seedable wire request (any method).
+       Producer entries and stream cells (no request) never snapshot — the streaming-drain
+       caller hands still-pending entries here, so `settled` is NOT gated (the caller's
+       snapshotShippable filter already required it for the entries it picks). */
+    if (!hasSeedableRequest(entry) || !entry.request) {
         return undefined
     }
-    /* `hasReplayableRequest` already verified the uppercased method is replayable; assert it
-       for the snapshot's typed `method` field rather than re-running the same Set check. */
-    const method = entry.request.method.toUpperCase() as ReplayableMethod
+    const method = entry.request.method.toUpperCase() as HttpMethod
     const response = await readSettled(entry.promise as Promise<Response>)
     if (!response) {
         return undefined
@@ -63,8 +63,16 @@ export async function snapshotEntryFromCache(
     }
     /* Read a CLONE, not the original: a reader that captured this same `entry.promise`
        before the replacement below still holds `response` and may `.clone()` it — reading
-       the original here would lock its body and throw "Body already used" for that reader. */
-    const body = await response.clone().text()
+       the original here would lock its body and throw "Body already used" for that reader.
+       The body stream can still error mid-read (reset/truncated upstream) after headers
+       resolved — degrade that to undefined (matching the fetch-rejection path) so one flaky
+       entry doesn't reject the whole snapshot batch and 500 / abort the page stream. */
+    let body: string
+    try {
+        body = await response.clone().text()
+    } catch {
+        return undefined
+    }
     entry.promise = Promise.resolve(
         new Response(body, {
             status: response.status,