@abide/abide 0.49.0 → 0.50.1

package/src/lib/shared/types/RpcBuildStamps.ts

@@ -0,0 +1,23 @@
+import type { ErrorJsonSchemas } from './ErrorJsonSchemas.ts'
+import type { InputCoercion } from './InputCoercion.ts'
+import type { OutputWirePlan } from './OutputWirePlan.ts'
+
+/*
+The build-time facts the warm rpc server program resolves for one `$rpc/**` handler, gathered into
+a single named payload that `prepareRpcModule` destructures (each rewrite direction picks the fields
+it needs). Replaces a positional argument list where ordering was load-bearing — a new build stamp
+is now one field on this shape rather than a new positional slot every caller must thread. Every
+field is optional: an absent field means the warm program resolved no verdict (no program built, an
+unresolvable node), and the rewrite falls open to its char-scan / today's behaviour exactly as
+before. `streaming` overrides the char-scan streaming verdict; the rest are stamped as server opts
+(`coercion`→`coerce`, `inputSchema`→`inputJsonSchema`, `outputSchema`→`outputJsonSchema`,
+`errorSchemas`→`errorJsonSchemas`) or the client opt (`outputWirePlan`).
+*/
+export type RpcBuildStamps = {
+    streaming?: boolean
+    coercion?: InputCoercion
+    inputSchema?: Record<string, unknown>
+    outputSchema?: Record<string, unknown>
+    errorSchemas?: ErrorJsonSchemas
+    outputWirePlan?: OutputWirePlan
+}

package/src/lib/shared/types/RpcErrorGuard.ts

@@ -1,6 +1,5 @@
 import type { HttpError } from '../HttpError.ts'
 import type { ErrorSpec } from './ErrorSpec.ts'
-import type { OutboxEntry } from './OutboxEntry.ts'
 import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
 import type { ValidationErrorData } from './ValidationErrorData.ts'
 
@@ -16,9 +15,9 @@ type DeclaredErrorData<
 /*
 A rpc's `isError` guard — branch a caught error on a kind THIS rpc knows, with the
 data type narrowed from the rpc's own `errors` spec. `rpc.isError(err, 'outOfStock')`
-narrows `.data` to that error's payload; the framework-reserved `'validation'` /
-`'queued'` to their fixed shapes; any other string narrows `.kind` only (`.data`
-stays `unknown` — it belongs to a different rpc, whose type isn't in scope here).
+narrows `.data` to that error's payload; the framework-reserved `'validation'` to its
+fixed shape; any other string narrows `.kind` only (`.data` stays `unknown` — it
+belongs to a different rpc, whose type isn't in scope here).
 
 The declared-name overload comes first so an app error shadows the reserved ones on a
 name collision, and so the kind argument autocompletes to the rpc's declared names.
@@ -32,9 +31,5 @@ export interface RpcErrorGuard<Errors extends ErrorSpec> {
         error: unknown,
         kind: 'validation',
     ): error is HttpError & { kind: 'validation'; data: ValidationErrorData }
-    (
-        error: unknown,
-        kind: 'queued',
-    ): error is HttpError & { kind: 'queued'; data: OutboxEntry<unknown> }
     <Kind extends string>(error: unknown, kind: Kind): error is HttpError & { kind: Kind }
 }

package/src/lib/shared/types/Socket.ts

@@ -9,8 +9,8 @@ fan-out and a client-side ws proxy by build target. Iterating the socket
 is the live stream — no replay. `.tail(count)` opens a subscription seeded
 with the last `count` frames of the retained tail (declared via
 `{ tail: n }`; no-arg = the whole retained tail) before going live — the
-optional Subscribable retention capability a reactive `watch(socket, …)`
-seeds from. `broadcast` is isomorphic: server code broadcasts in-process
+optional NamedAsyncIterable retention capability a reactive `watch(socket, …)`
+seeds from. `publish` is isomorphic: server code publishes in-process
 and fans out to remote subscribers; client code sends a `pub` frame the
 dispatcher validates against the topic's `clientPublish` flag. `clients`
 exposes which adapter surfaces (browser / mcp / cli) advertise this
@@ -21,8 +21,8 @@ export interface Socket<T> extends AsyncIterable<T> {
     readonly clients: ClientFlags
     /* Send a frame to every subscriber (server always; client only when `clientPublish` is
        set). Isomorphic: server code fans out in-process + to remote subscribers; client code
-       sends a validated `pub` frame. */
-    broadcast(message: T): void
+       sends a validated `pub` frame. Mirrors Bun's `server.publish()`. */
+    publish(message: T): void
     tail(count?: number, hooks?: TailHooks): AsyncIterable<T>
     /* The latest retained frame, synchronously — `T | undefined` when none. The value
        member of the probe family for a stream; `peek(socket)` routes here. */

package/src/lib/shared/types/SsrPayload.ts

@@ -10,7 +10,8 @@ write-set and read-set can't drift apart on a matching-string-key handshake.
 
 Three partitions:
   - `SsrBootState` fields seed ambient slots via the exhaustive `seedBootState` map;
-  - `cache` is the inline warm-seed partition, drained through `seedResolved`;
+  - `cache` / `cells` are the warm-seed partitions (settled `cache()` values / resolved async-cell
+    values), drained into their client stores before mount;
   - `route`/`params` are stamped for inspectability and are NOT read by the client
     (the router re-resolves the route from the URL).
 */
@@ -18,4 +19,7 @@ export type SsrPayload = SsrBootState & {
     route: string
     params: Record<string, string>
     cache?: CacheSnapshotEntry[]
+    /* Async-cell values that resolved during SSR, keyed by render-path id → ref-json string.
+       `startClient` seeds these into `CELL_SEED`; a hydrating cell reads its key to warm-hydrate. */
+    cells?: Record<string, string>
 }

package/src/lib/shared/types/StreamPolicy.ts

@@ -0,0 +1,11 @@
+/*
+Endpoint stream policy, declared once on a streaming rpc definition (ADR-0020).
+`n` is the replay depth — how many retained frames a fresh reader gets before
+going live, pairing with the server-side `tail` retention. Endpoint-fixed: a
+late joiner can't request deeper replay than a fresh view. No runtime consumer
+today (subscribableFromResponse ignores it); threaded onto the definition for
+completeness and future use.
+*/
+export type StreamPolicy = {
+    n?: number
+}

package/src/lib/shared/types/StreamedCells.ts

@@ -0,0 +1,19 @@
+/*
+The per-request list of STREAMING async-cell values that SETTLED during this SSR pass, each keyed by
+the cell's serialization-stable render-path id (`${scope.id}:${index}`) (ADR-0035). A streaming cell
+ships pending in the shell (excluded from the pre-mount `__SSR__.cells` warm-seed, which would
+diverge from that pending markup), so instead `createAsyncCell.settleValue` records its resolved
+VALUE here when it settles server-side. The page renderer reads this AFTER the shell — streaming an
+`__abideResolve({ cellKey, value })` chunk per entry — so the client adopts the server-resolved
+value post-hydration (no `loading…` flash) instead of only cold-re-running the seed.
+
+Values (not promises) so the drain never AWAITS — a streaming cell may legitimately stay pending
+through the whole request (the `{#if getFoo()}`-holds case), and awaiting it would hang the
+response. Only cells that settled before the drain point are streamed; one still pending is simply
+not (the client cold-runs it, unchanged). The streaming sibling of `ResolvedCells` (the BLOCKING
+warm-seed, read at render-return and stamped into `__SSR__.cells`); this one is read later in the
+stream and shipped out-of-order as chunks.
+*/
+export type StreamedCells = {
+    entries: { key: string; value: unknown }[]
+}

package/src/lib/shared/types/StreamedResolution.ts

@@ -1,10 +1,28 @@
 import type { CacheSnapshotEntry } from './CacheSnapshotEntry.ts'
 
 /*
-Payload of one streamed `window.__abideResolve(...)` call. A full
-`CacheSnapshotEntry` settles the placeholder with warm data; a `{ key, miss }`
-marker means the server couldn't snapshot that body (binary, rejected, evicted)
-so the client settles the placeholder with a live re-fetch instead. Discriminate
-on the `miss` field.
+Payload of one streamed `window.__abideResolve(...)` call. Three arms:
+
+  - a full `CacheSnapshotEntry` (has `key` + body) settles a cache placeholder with warm data;
+  - a `{ key, miss }` marker means the server couldn't snapshot that cache body (binary, rejected,
+    evicted) so the client settles the placeholder with a live re-fetch instead;
+  - a `{ cellKey, value }` (ADR-0035) carries a STREAMING CELL's server-resolved value, keyed by its
+    render-path warm-key and `encodeRefJson`-encoded, applied post-hydration as a reactive update so
+    a non-cache peek stops flashing `loading…` on hydrate.
+  - a `{ cellSeed, value }` (ADR-0039) carries a STREAMED CHILD's blocking async-cell value that
+    resolved AFTER the head `__SSR__.cells` snapshot (its render was deferred to the drain), seeded
+    PRE-mount into `CELL_SEED` — the same warm partition as `__SSR__.cells` — so the child's cell
+    constructs resolved on hydrate rather than re-running.
+
+Discriminate on `cellSeed` then `cellKey` (cell) then `miss` (cache miss) then default (cache entry).
 */
-export type StreamedResolution = CacheSnapshotEntry | { key: string; miss: true }
+
+/* The cache arms — a warm snapshot entry or a `{ key, miss }` marker. `streamCacheResolutions`
+   yields exactly these (never the cell arm), so its element type is `CacheResolution`, keeping a
+   `.key` access on its results well-typed. */
+export type CacheResolution = CacheSnapshotEntry | { key: string; miss: true }
+
+export type StreamedResolution =
+    | CacheResolution
+    | { cellKey: string; value: string }
+    | { cellSeed: string; value: string }

package/src/lib/shared/types/TailHooks.ts

@@ -1,5 +1,5 @@
 /*
-Hooks a `tail(count, hooks)` caller passes to a Subscribable's retention
+Hooks a `tail(count, hooks)` caller passes to a NamedAsyncIterable's retention
 capability.
 `replayed` must be signalled in-band exactly once per iteration — after the
 last replayed frame, before any live frame, and even when nothing was

package/src/lib/shared/types/WireKind.ts

@@ -0,0 +1,11 @@
+/*
+The wire codec kind for a single top-level Args field (ADR-0029). Generalizes ADR-0028's scalar
+`number`/`boolean` query coercion to the structured value kinds the warm server program can name
+through the type graph — a `Date` / `Set` / `Map` by symbol identity, a `bigint` by type flag.
+parseArgs revives a field's plain-JSON wire form into the runtime value the handler's declared
+type expects: an ISO string → `Date`, a numeric string → `bigint`, a JSON array → `Set`, a JSON
+entries array (or object) → `Map`. Top-level fields only in this increment — a structured value
+NESTED inside another value is not descended into. Reviving is fail-open: an unrevivable value is
+left as its JSON form, never thrown, so the plain-JSON / OpenAPI contract still works.
+*/
+export type WireKind = 'number' | 'boolean' | 'date' | 'bigint' | 'set' | 'map'

package/src/lib/shared/validationHttpError.ts

@@ -0,0 +1,33 @@
+import { fieldErrorsFromIssues } from './fieldErrorsFromIssues.ts'
+import { HttpError } from './HttpError.ts'
+import type { StandardSchemaV1 } from './types/StandardSchemaV1.ts'
+import type { ValidationErrorData } from './types/ValidationErrorData.ts'
+
+/*
+Builds the HttpError a client-side pre-flight validation failure throws (ADR-0026 D2),
+shaped IDENTICALLY to the one a caller gets when the server rejects the same input with a
+422: `kind: 'validation'`, `status: 422`, `data: ValidationErrorData` (`{ issues, fields }`),
+so an `error instanceof HttpError && error.kind === 'validation'` branch — and the
+`error.data.fields` form-error map — read the same whether the rejection came from the
+client pre-flight or the server.
+
+This is a UX optimization ONLY, never a trust boundary: the server's unconditional
+`inputSchema['~standard'].validate` → `validationError` 422 (defineRpc.ts) stays
+authoritative. A client that skips or fakes this check is still fully validated on the
+server.
+
+The `data` mapping (`fieldErrorsFromIssues`) is the same isomorphic helper the server 422
+uses; the response envelope (`{ $abideError, data }`, status 422, reason phrase) mirrors
+`typedErrorResponse('validation', 422, …)` — reconstructed here with a plain web-standard
+`Response` so the browser bundle never imports the server's Response builder. The status
+text mirrors `STATUS_TEXT[422]`.
+*/
+export function validationHttpError(issues: readonly StandardSchemaV1.Issue[]): HttpError {
+    const data: ValidationErrorData = { issues, fields: fieldErrorsFromIssues(issues) }
+    const response = new Response(JSON.stringify({ $abideError: 'validation', data }), {
+        status: 422,
+        statusText: 'Unprocessable Content',
+        headers: { 'content-type': 'application/json' },
+    })
+    return new HttpError(response, 'validation', data)
+}

package/src/lib/shared/warmSeedKey.ts

@@ -0,0 +1,16 @@
+/*
+The single source of the async-cell warm-seed key format: the `${scopeId}:${cellIndex}` string that
+pairs a cell's serialization-stable render-path scope id with its per-scope declaration ordinal.
+
+Both sides of the SSR→client handoff mint the key through THIS callable — the isomorphic
+`createAsyncCell` runs it server-side to key its `resolvedCells`/`streamedCells` entries (which the
+page renderer stamps into `__SSR__.cells` / streams as `{ cellKey }` / `{ cellSeed }` chunks), and
+client-side to look the value up in `CELL_SEED`. Because the two sides now invoke one function, the
+byte-for-byte agreement the warm-seed depends on is a shared definition rather than a template
+literal re-typed at each call site: changing the delimiter here changes it for both sides at once,
+so the SSR-text-≡-first-client-render mismatch class (ADR-0033) cannot silently reopen from a
+one-sided edit. Pure so it stays trivially testable and inlinable.
+*/
+export function warmSeedKey(scopeId: string, cellIndex: number): string {
+    return `${scopeId}:${cellIndex}`
+}

package/src/lib/shared/wireJsonReplacer.ts

@@ -0,0 +1,30 @@
+/*
+The value-directed wire ENCODE step for a rpc response body (ADR-0029 output path). A
+`JSON.stringify` replacer that rewrites the structured runtime values plain JSON can't carry into
+their honest-JSON wire form, so `json()` never drops a `Set`/`Map` to `{}` or throws on a `bigint`:
+
+  - `bigint`  → its digit string (plain JSON.stringify throws on a bigint)
+  - `Set<T>`  → a JSON array of its values (plain JSON.stringify emits `{}`)
+  - `Map<K,V>`→ a JSON array of `[K,V]` entries (uniform, carries non-string keys)
+
+A `Date` needs no branch — its native `toJSON` already rewrote it to an ISO string before the
+replacer runs. Value-directed (not type-directed), so it runs for EVERY client — a non-abide caller
+(curl / an OpenAPI SDK) receives the same honest JSON the projected schema (`jsonSchemaForType`)
+describes. It is naturally recursive: a returned array/object member surfaces through the same
+replacer, so a `Set` nested inside an object still encodes. Never throws — an ordinary value falls
+through untouched.
+*/
+export function wireJsonReplacer(_key: string, value: unknown): unknown {
+    if (typeof value === 'bigint') {
+        return value.toString()
+    }
+    if (value instanceof Set) {
+        return [...value]
+    }
+    if (value instanceof Map) {
+        /* A Map iterates as `[key, value]` pairs, so the spread yields the entries array the
+           client output plan (and the projected schema) expects. */
+        return [...value]
+    }
+    return value
+}

package/src/lib/shared/writeRpcDts.ts

@@ -1,9 +1,11 @@
+import { resolve } from 'node:path'
 import { augmentModule } from './augmentModule.ts'
 import { carriesBodyArgs } from './carriesBodyArgs.ts'
 import { detectRpcMethod } from './detectRpcMethod.ts'
 import { fileStem } from './fileStem.ts'
 import { RPC_ARGS_TYPE } from './RPC_ARGS_TYPE.ts'
 import { rpcUrlForFile } from './rpcUrlForFile.ts'
+import type { HttpMethod } from './types/HttpMethod.ts'
 import { writeDts } from './writeDts.ts'
 
 /*
@@ -22,15 +24,23 @@ export async function writeRpcDts({
     rpcDir,
     rpcFiles,
     importName,
+    methodForModule,
 }: {
     cwd: string
     rpcDir: string
     rpcFiles: string[]
     importName: string
+    /* Warm server-program method resolver (ADR-0025 D2): reads the method off the export's
+       helper symbol so an aliased/re-exported helper resolves where `detectRpcMethod`'s
+       `RPC_EXPORT` regex misses it. Absent (no warm program) or undefined-per-file falls open to
+       the regex, byte-identical to before. */
+    methodForModule?: (modulePath: string) => HttpMethod | undefined
 }): Promise<void> {
     const pairs = await Promise.all(
         rpcFiles.map(async (file): Promise<[string, string] | undefined> => {
-            const method = detectRpcMethod(await Bun.file(`${rpcDir}/${file}`).text())
+            const method =
+                methodForModule?.(resolve(rpcDir, file)) ??
+                detectRpcMethod(await Bun.file(`${rpcDir}/${file}`).text())
             // A body rpc's args can't ride a URL — leave it out of the url() rpc map.
             if (!method || carriesBodyArgs(method)) {
                 return undefined

package/src/lib/shared/writeTestSocketsDts.ts

@@ -8,7 +8,7 @@ Emits a `.d.ts` that augments createTestApp's `SocketClient` interface with one
 entry per $socket, keyed by socket name (the same key `app.sockets.<name>`
 resolves at runtime). The `socket(...)` helper statically returns `Socket<T>`,
 so each entry is the export's own type directly — `app.sockets.chat` types as
-`Socket<ChatMessage>`, iterable for the live stream with `.tail`/`.broadcast`.
+`Socket<ChatMessage>`, iterable for the live stream with `.tail`/`.publish`.
 Written to `src/.abide/testSockets.d.ts` like its rpc sibling.
 */
 export async function writeTestSocketsDts({

package/src/lib/test/createTestApp.ts

@@ -39,8 +39,11 @@ import { commandNameForUrl } from '../shared/commandNameForUrl.ts'
 import { createCacheStore } from '../shared/createCacheStore.ts'
 import { HEALTH_PATH } from '../shared/HEALTH_PATH.ts'
 import { pageSlot } from '../shared/pageSlot.ts'
+import { pendingAsyncCellsSlot } from '../shared/pendingAsyncCellsSlot.ts'
+import { resolvedCellsSlot } from '../shared/resolvedCellsSlot.ts'
 import { SOCKETS_PATH } from '../shared/SOCKETS_PATH.ts'
 import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
+import { streamedCellsSlot } from '../shared/streamedCellsSlot.ts'
 import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
 import type { Socket } from '../shared/types/Socket.ts'
 import { createTestSocketChannel } from './createTestSocketChannel.ts'
@@ -72,7 +75,7 @@ export type TestApp = {
     /* Rpc calls over HTTP, keyed by command name: `app.rpc.getProduct({ id })`. */
     rpc: RpcClient
     /* Sockets keyed by name: `app.sockets.ticker` is the Socket — iterate it for
-       the live stream, `.tail(n)` to seed, `.broadcast(m)` to send. */
+       the live stream, `.tail(n)` to seed, `.publish(m)` to send. */
     sockets: SocketClient
     /* The /__abide/health payload, decoded. */
     health: () => Promise<unknown>
@@ -101,12 +104,24 @@ export async function createTestApp(): Promise<TestApp> {
         sharedResolver: sharedCacheStoreSlot.resolver,
         pageResolver: pageSlot.resolver,
         baseResolver: baseSlot.resolver,
+        pendingAsyncCellsResolver: pendingAsyncCellsSlot.resolver,
+        resolvedCellsResolver: resolvedCellsSlot.resolver,
+        streamedCellsResolver: streamedCellsSlot.resolver,
         activeServer: serverSlot.active,
     }
 
     const sharedStore = createCacheStore()
     sharedCacheStoreSlot.resolver = () => sharedStore
     cacheStoreSlot.resolver = () => requestContext.getStore()?.cache ?? sharedStore
+    const sharedPendingAsyncCells = { promises: [] }
+    pendingAsyncCellsSlot.resolver = () =>
+        requestContext.getStore()?.pendingAsyncCells ?? sharedPendingAsyncCells
+    const sharedResolvedCells = { entries: [] }
+    resolvedCellsSlot.resolver = () =>
+        requestContext.getStore()?.resolvedCells ?? sharedResolvedCells
+    const sharedStreamedCells = { entries: [] }
+    streamedCellsSlot.resolver = () =>
+        requestContext.getStore()?.streamedCells ?? sharedStreamedCells
     pageSlot.resolver = resolvePageSnapshot
 
     /* Eager env validation, exactly as serverEntry: a top-level env(schema) in
@@ -188,6 +203,9 @@ export async function createTestApp(): Promise<TestApp> {
         sharedCacheStoreSlot.resolver = previous.sharedResolver
         pageSlot.resolver = previous.pageResolver
         baseSlot.resolver = previous.baseResolver
+        pendingAsyncCellsSlot.resolver = previous.pendingAsyncCellsResolver
+        resolvedCellsSlot.resolver = previous.resolvedCellsResolver
+        streamedCellsSlot.resolver = previous.streamedCellsResolver
         serverSlot.active = previous.activeServer
     }
 

package/src/lib/ui/README.md

@@ -61,7 +61,7 @@ write-path microbench this runs ~20× faster than a deep-proxy signal baseline.
 
 - `compileSSR` renders to an HTML string (byte-identical to the client DOM).
 - `renderToStream` streams: pending shell first, then resolved `<template await>`
-  fragments out of order as their promises settle; `applyResolved` swaps them in.
+  fragments out of order as their promises settle; the inline swap script swaps them in.
 - `hydrate` adopts the server DOM in place (no re-render) for static-structure
   components — claims existing nodes, splits merged text, wires effects/listeners.
 

package/src/lib/ui/activePendingCells.ts

@@ -0,0 +1,14 @@
+import { pendingAsyncCellsSlot } from '../shared/pendingAsyncCellsSlot.ts'
+import type { PendingAsyncCells } from '../shared/types/PendingAsyncCells.ts'
+import { cellBarrierBacking } from './runtime/cellBarrierBacking.ts'
+
+/*
+The async-cell barrier list a registration (`createAsyncCell`) or a drain (`settleAsyncCells`) should
+use RIGHT NOW: a per-render isolated list if one is active (a hoisted concurrent child render — see
+`isolateCellBarrier`), else the per-request list from `pendingAsyncCellsSlot`. The single seam both
+barrier consumers read, so an isolated render can't leak its in-flight cells into a sibling's or the
+page's drain. Undefined only when neither a render override nor a request/fallback list is installed.
+*/
+export function activePendingCells(): PendingAsyncCells | undefined {
+    return cellBarrierBacking.active.current() ?? pendingAsyncCellsSlot.get()
+}

package/src/lib/ui/compile/BLOCK_KEYWORDS.ts

@@ -0,0 +1,21 @@
+/*
+The control-block vocabulary — the ONE source of truth shared by the parser
+(`parseTemplate`'s dispatch/error) and the LSP highlighter (`structuralHeadTokens`, driven
+by the parse walk), so the keywords the highlighter colors can't drift from the blocks the
+parser accepts (the `{#snippet}` head once went uncolored because a hand-copy omitted it).
+
+`BLOCK_OPENERS` follow `{#`, `BLOCK_CONNECTORS` follow `{:`. `for await` is the async-each
+opener form the highlighter colors as one phrase (the parser reads the `await` inside a
+`for` head); it is not a distinct opener.
+*/
+export const BLOCK_OPENERS = ['if', 'for', 'await', 'switch', 'try', 'snippet'] as const
+
+export const BLOCK_CONNECTORS = [
+    'else if',
+    'else',
+    'then',
+    'catch',
+    'finally',
+    'case',
+    'default',
+] as const

package/src/lib/ui/compile/SSR_ESCAPE.ts

@@ -17,7 +17,10 @@ across bundles. Emitted inline (not imported) so the generated render module is
 self-contained.
 */
 export const SSR_ESCAPE =
-    'const $esc = (v) => String(v).replace(/[&<>"\']/g, (c) => ' +
+    // Nullish escapes to empty text, never the literal `"undefined"` — a pending async
+    // read (ADR-0032 D3) renders nothing. `$attr` guards nullish before it calls `$esc`,
+    // so its whole-value undefined still drops the attribute.
+    'const $esc = (v) => (v == null ? "" : String(v)).replace(/[&<>"\']/g, (c) => ' +
     "({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '\"': '&quot;', \"'\": '&#39;' })[c]);\n" +
     'const $attr = (n, v) => (v === false || v === null || v === undefined) ? "" ' +
     ': v === true ? (" " + n) : (" " + n + \'="\' + $esc(v) + \'"\');\n' +

package/src/lib/ui/compile/UI_RUNTIME_IMPORTS.ts

@@ -1,15 +1,14 @@
 /*
 The abide-ui runtime names every compiled component module depends on, each
-paired with its package subpath (after the package name). One source of truth so
-three things can't drift: the normal module's import block (`compileModule`), the
-hot module's `window.__abide` destructure (dev component HMR), and the dev bridge
-that populates `window.__abide`. Order is the emit order.
+paired with its package subpath (after the package name). One source of truth for
+the import block `compileModule` emits at the head of every component module, so the
+emitted imports can't drift from the real package exports (a test checks each
+resolves). Order is the emit order.
 
 `alias` (when set) is the LOCAL name codegen emits — a `$$`-prefixed form reserved
 for the compiler so a user variable of the helper's bare name can never collide
-(`each as $$each`). It defaults to `name`; the dev bridge keys stay bare (the import
-source), so a hot module destructures `{ name: alias }`. As each helper's emit sites
-flip to its `$$` alias, set `alias` here in lockstep.
+(`each as $$each`). It defaults to `name`. As each helper's emit sites flip to its
+`$$` alias, set `alias` here in lockstep.
 */
 export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: string }[] = [
     { name: 'snippet', specifier: 'shared/snippet', alias: '$$snippet' },
@@ -44,15 +43,43 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: stri
     { name: 'mountSlot', specifier: 'ui/dom/mountSlot', alias: '$$mountSlot' },
     { name: 'outlet', specifier: 'ui/dom/outlet', alias: '$$outlet' },
     { name: 'mountChild', specifier: 'ui/dom/mountChild', alias: '$$mountChild' },
+    {
+        name: 'mountStreamedChild',
+        specifier: 'ui/dom/mountStreamedChild',
+        alias: '$$mountStreamedChild',
+    },
     { name: 'mergeProps', specifier: 'ui/dom/mergeProps', alias: '$$mergeProps' },
     { name: 'spreadProps', specifier: 'ui/dom/spreadProps', alias: '$$spreadProps' },
     { name: 'restProps', specifier: 'ui/dom/restProps', alias: '$$restProps' },
+    { name: 'bindProp', specifier: 'ui/dom/bindProp', alias: '$$bindProp' },
+    { name: 'bindableProp', specifier: 'ui/dom/bindableProp', alias: '$$bindableProp' },
     { name: 'spreadAttrs', specifier: 'ui/dom/spreadAttrs', alias: '$$spreadAttrs' },
     { name: 'readCall', specifier: 'ui/dom/readCall', alias: '$$readCall' },
-    { name: 'mutateDocArray', specifier: 'ui/dom/mutateDocArray', alias: '$$mutateDocArray' },
+    { name: 'readCell', specifier: 'ui/dom/readCell', alias: '$$readCell' },
+    { name: 'cellPending', specifier: 'ui/dom/cellPending', alias: '$$cellPending' },
+    { name: 'withPath', specifier: 'ui/runtime/withPath', alias: '$$withPath' },
+    { name: 'settleAsyncCells', specifier: 'ui/settleAsyncCells', alias: '$$settleAsyncCells' },
+    { name: 'flight', specifier: 'ui/flight', alias: '$$flight' },
+    {
+        name: 'isolateCellBarrier',
+        specifier: 'ui/isolateCellBarrier',
+        alias: '$$isolateCellBarrier',
+    },
+    { name: 'renderPath', specifier: 'ui/runtime/renderPath', alias: '$$renderPath' },
+    {
+        name: 'finalizeStreamedChildren',
+        specifier: 'ui/finalizeStreamedChildren',
+        alias: '$$finalizeStreamedChildren',
+    },
+    {
+        name: 'mutateDocContainer',
+        specifier: 'ui/dom/mutateDocContainer',
+        alias: '$$mutateDocContainer',
+    },
     { name: 'hydrate', specifier: 'ui/dom/hydrate', alias: '$$hydrate' },
     { name: 'escapeKey', specifier: 'ui/runtime/escapeKey', alias: '$$escapeKey' },
     { name: 'nextBlockId', specifier: 'ui/runtime/nextBlockId', alias: '$$nextBlockId' },
+    { name: 'blockId', specifier: 'ui/runtime/blockId', alias: '$$blockId' },
     {
         name: 'enterRenderPass',
         specifier: 'ui/runtime/enterRenderPass',

package/src/lib/ui/compile/abideUiPlugin.ts

@@ -4,8 +4,11 @@ import { isLayoutFile } from '../../shared/isLayoutFile.ts'
 import { messageFromError } from '../../shared/messageFromError.ts'
 import { AbideCompileError } from './AbideCompileError.ts'
 import { compileModule } from './compileModule.ts'
+import type { ShadowProgram } from './createShadowProgram.ts'
+import { interpolationClassifierForRoot } from './interpolationClassifierForRoot.ts'
 import { nearestProjectRoot } from './nearestProjectRoot.ts'
 import { offsetToLineColumn } from './offsetToLineColumn.ts'
+import { seedTypeClassifierForRoot } from './seedTypeClassifierForRoot.ts'
 
 /*
 Bun plugin that loads `.abide` single-file components: compiles each to the ES
@@ -38,11 +41,25 @@ export const abideUiPlugin: BunPlugin = {
         /* Scoped CSS keyed by its virtual specifier, filled as each `.abide` loads and
            read back when Bun resolves the matching `abide-style:` import (browser only). */
         const cssByVirtual = new Map<string, string>()
+        /* One WARM shadow program per project root (ADR-0019, Stage B): the checker +
+           per-file mappings type-directed lowering needs, built lazily on first `.abide`
+           in a root and reused for every component there — not rebuilt per module. */
+        const shadowByRoot = new Map<string, ShadowProgram | undefined>()
 
         build.onLoad({ filter: /\.abide$/ }, async (args) => {
             const source = await Bun.file(args.path).text()
-            const moduleId = relative(nearestProjectRoot(args.path, process.cwd()), args.path)
+            const root = nearestProjectRoot(args.path, process.cwd())
+            const moduleId = relative(root, args.path)
             const isLayout = isLayoutFile(args.path)
+            /* The classifier for this file over its root's warm shadow program. Fail-open:
+               a program that can't build (or a file with no shadow) yields `undefined`, so
+               the module compiles exactly as before. */
+            const classify = interpolationClassifierForRoot(shadowByRoot, root, args.path)
+            /* The seed classifier for this file over the SAME warm shadow program (ADR-0023):
+               reuses the `shadowByRoot` cache `classify` just warmed, so no second program is
+               built. Fail-open identically — a no-marker `computed(seed)` routes by type when
+               it resolves, else by the `isBareCallComputed` syntax heuristic. */
+            const seedClassify = seedTypeClassifierForRoot(shadowByRoot, root, args.path)
             /* Bun frames a plugin throw at `<file>:0` regardless of the real spot, so
                carry the component path + resolved line:col in the message — otherwise a
                control-flow / compile error reads as `:0` and (in deep imports) can look
@@ -66,7 +83,7 @@ export const abideUiPlugin: BunPlugin = {
                the styles come from the analysis `compileModule` already ran, so the loader no
                longer re-analyzes the source just to recover them. */
             const { code, styles } = compileAbide(() =>
-                compileModule(source, { isLayout, moduleId }),
+                compileModule(source, { isLayout, moduleId, classify, seedClassify }),
             )
             /* Browser build with `<style>`(s): concatenate every scoped block's CSS and
                pull it into the bundle via one virtual import, keyed by `moduleId` so the