@abide/abide 0.48.0 → 0.50.0

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

@@ -1,8 +1,10 @@
 /* The per-request SSR render context, threaded through a layout chain and every
-   child component a page inlines. `next` is the block-id counter: each `await`/`try`
-   block draws from it in depth-first document order — the SAME order the client
-   allocates ids during its synchronous hydration walk, so the streamed fragments and
-   the `RESUME` manifest line up. Request-local (not a module global) because SSR
-   render is async — a blocking `await` yields, and a shared global counter would
-   interleave across concurrent requests. */
-export type RenderContext = { next: number }
+   child component a page inlines. It is the block-id counter MAP (ADR-0037): each
+   `await`/`try` block draws a path-namespaced id via `blockId(ctx)` — keyed by the
+   ambient render-path, counting 0,1,2… in document order WITHIN each path. Both sides
+   compose the same ids (the client mounts each child under the same path), so the
+   streamed fragments and the `RESUME` manifest line up. Request-local (not a module
+   global) because SSR render is async and concurrent — but sibling child renders write
+   different path keys, so the shared map needs no locking and survives parallel renders
+   (which a single flat counter could not). */
+export type RenderContext = Map<string, number>

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

@@ -9,10 +9,17 @@ import type { ResumeEntry } from '../RESUME.ts'
    on the tag — never land here: they render inline during the async render pass and
    seed `SsrRender.resume`.) */
 export type SsrAwait = {
-    id: number
+    id: string
     promise: () => unknown
     then: (value: unknown) => Promise<string>
     catch?: (error: unknown) => Promise<string>
+    /* ADR-0039 (spike): a STANDALONE-UNIT boundary — a streamed child COMPONENT — carries no
+       resume value of its own (its `then` returns the child's rendered html and merges the child's
+       own awaits/resume for nested composition; the child re-mounts client-side rather than
+       adopting a RESUME[id] value). Marks `settle` to emit an html-only fragment with no resume seed
+       script, so the client never tries to decode a whole SsrRender as an await value. Absent for a
+       normal await block (which seeds its resolved value). */
+    htmlOnly?: boolean
 }
 
 /* The result of a component's server `render()`: the pending-shell HTML, the
@@ -23,5 +30,5 @@ export type SsrRender = {
     html: string
     state: unknown
     awaits: SsrAwait[]
-    resume: Record<number, ResumeEntry>
+    resume: Record<string, ResumeEntry>
 }

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

@@ -18,11 +18,7 @@ export type UiComponent = ((host: Element, props?: UiProps) => () => void) & {
     hydrate?: (host: Element, props?: UiProps) => () => void
     /* The bare client build (`(host, props) => void`) — appends the component's nodes
        to `host`. A nested child mounts it into a marker range (`mountRange`/`mountChild`)
-       instead of the wrapped `mount`, and `hotReplace` re-fills a range with the new
-       module's `build` on edit. */
+       instead of the wrapped `mount`. */
     build: (host: Node, props?: UiProps) => void
     hydratable?: boolean
-    /* Stable module id (project-relative source path) stamped by `compileModule`,
-       keying the component in the hot-reload registry — see `mountChild`. */
-    __abideId?: string
 }

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

@@ -2,10 +2,11 @@
 What a component is invoked with. A top-level page/layout is called by the router
 (client) and `renderChain` (SSR) with its route params as reactive thunks, shaped
 identically to the thunk map `mountChild` passes a nested child — so `props()` reads
-(`$props[name]?.()`) work uniformly on both. `$children` is the slot builder a parent
-component passes (carrying the component's `{children()}` content), or `CHILD_PRESENT`
-the router/SSR set on a layout that has a child layer below it.
+(`$props[name]?.()`) work uniformly on both. `children` is an ordinary prop thunk like
+any other: on a component it returns the parent's `Snippet`; on a layout with a child
+layer below it, the router/SSR set it to `() => CHILD_PRESENT` (a presence sentinel, not
+a slot builder) so `{#if children}` reads truthy.
 */
-export type UiProps = Record<string, (() => unknown) | ((host: Element) => void)> & {
-    $children?: (host: Element) => void
+export type UiProps = Record<string, () => unknown> & {
+    children?: () => unknown
 }

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

@@ -0,0 +1,8 @@
+import { withPath } from './withPath.ts'
+
+/* Runs `build` under the render-path segment for a compiler `ordinal`, or plainly when `ordinal`
+   is undefined (a non-compiled caller that supplied no site id). Shared by the child-mount paths so
+   the "push a path segment iff an ordinal is present" convention lives in one place. */
+export function withOptionalPath<T>(ordinal: number | undefined, build: () => T): T {
+    return ordinal === undefined ? build() : withPath(ordinal, build)
+}

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

@@ -0,0 +1,16 @@
+import { CURRENT_PATH } from './CURRENT_PATH.ts'
+import { withPathFrom } from './withPathFrom.ts'
+
+/*
+Pushes one render-path segment for the duration of `build`, RELATIVE to the live ambient path,
+restoring after (synchronous build, so the save/restore is exact and nesting is a strict stack —
+the same shape `withScope`/`enterRenderPass` use). The segment is `escapeKey`-escaped and joined
+with `/`, so a segment carrying a `/` (a URL-shaped `{#each}` key) survives as one element. Used
+at sites that run DURING the initial render walk (a layout layer, a `<Child/>` mount) where the
+ambient path is the correct base. A control-flow block that rebuilds reactively after mount uses
+`withPathFrom` with a captured base instead.
+*/
+// @documentation plumbing
+export function withPath<T>(segment: string | number, build: () => T): T {
+    return withPathFrom(CURRENT_PATH.current, segment, build)
+}

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

@@ -0,0 +1,20 @@
+import { ambientPathBacking } from './ambientPathBacking.ts'
+import { escapeKey } from './escapeKey.ts'
+
+/*
+Runs `build` with the render path set to `base` + one escaped `segment` (ADR-0033 D1). Unlike
+`withPath` (which pushes relative to the LIVE ambient), this composes from an EXPLICIT base — for
+a control-flow block that rebuilds content reactively AFTER mount, when the ambient path is no
+longer on the stack. The block captures `CURRENT_PATH.current` at construction (its render-time
+ancestry) and re-establishes `base/segment` for every branch/row build — initial and every later
+swap — so a component or cell built on a swap still gets its full, stable id, not a bare segment.
+
+Pushes through the backing's `run` (not a set-then-restore slot): the server's AsyncLocalStorage
+backing makes the composed path survive an `await` inside `build`, so a render body resuming after
+a cell barrier or child render reads its own path; the client's synchronous module-var `run` is a
+plain save/restore. `run` returns `build()`'s value (a value on the client, a promise on the server).
+*/
+export function withPathFrom<T>(base: string, segment: string | number, build: () => T): T {
+    const composedPath = base === '' ? escapeKey(segment) : `${base}/${escapeKey(segment)}`
+    return ambientPathBacking.active.run(composedPath, build)
+}

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

@@ -0,0 +1,22 @@
+import { RENDER } from './RENDER.ts'
+
+/*
+Runs `build` with the hydration claim cursor cleared, restoring it after. The
+control-flow blocks route FRESH builds through here — a pending/resolved await
+branch, a try's catch branch, a fillBefore insert — so their build helpers
+create nodes instead of trying to claim server DOM that isn't there. A rebuild
+that fires while an outer hydrate pass is still active (e.g. a synchronous write
+that flips a `when`/`switch` mid-hydrate) would otherwise make `cloneStatic` /
+text claim discarded or nonexistent nodes and silently render nothing. The
+`finally` restore lets a fresh build sit inside an ongoing hydrate pass without
+ending it early.
+*/
+export function withoutHydration<T>(build: () => T): T {
+    const previous = RENDER.hydration
+    RENDER.hydration = undefined
+    try {
+        return build()
+    } finally {
+        RENDER.hydration = previous
+    }
+}

package/src/lib/ui/seedStreamedResolution.ts

@@ -1,6 +1,9 @@
 import { activeCacheStore } from '../shared/activeCacheStore.ts'
 import { cacheEntryFromSnapshot } from '../shared/cacheEntryFromSnapshot.ts'
+import { decodeRefJson } from '../shared/decodeRefJson.ts'
 import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
+import { CELL_SEED } from './runtime/CELL_SEED.ts'
+import { receiveStreamedCell } from './runtime/STREAMED_CELLS.ts'
 
 /*
 Seeds one streamed cache resolution into the active store — the single sink for the
@@ -9,12 +12,27 @@ so a `cache()` read resolves synchronously (no wire round-trip) and `<template a
 adopts without a refetch; a `{ key, miss }` marker — a body the server couldn't snapshot
 (binary / rejected / evicted) — is a no-op, so that read falls back to a live fetch.
 
-Shared by startClient's boot drain, the live `window.__abideResolve`, and applyResolved,
-so no resolved-frame consumer can swap DOM while silently dropping the cache channel —
-the asymmetry that made streamed reads cold-miss to the network.
+Shared by startClient's boot drain and the live `window.__abideResolve`, so no
+resolved-frame consumer can swap DOM while silently dropping the cache channel — the
+asymmetry that made streamed reads cold-miss to the network.
 */
 // @documentation plumbing
 export function seedStreamedResolution(resolution: StreamedResolution): void {
+    /* ADR-0039: a STREAMED CHILD's blocking async-cell value that resolved after the head snapshot.
+       Seed it into `CELL_SEED` (the same warm partition `__SSR__.cells` fills, storing the raw
+       ref-json string decoded at cell read) so the child's cell constructs RESOLVED when its
+       deferred mount runs — no flash, no re-run. Checked before `cellKey` (a distinct arm). */
+    if ('cellSeed' in resolution) {
+        CELL_SEED[resolution.cellSeed] = resolution.value
+        return
+    }
+    /* ADR-0035: a streaming CELL's server-resolved value, keyed by render-path id. Route it to the
+       mounted cell (or buffer until it registers) — decoded through the same ref-json codec the
+       server encoded it with, so a Set/Map/Date/bigint/cyclic value survives. */
+    if ('cellKey' in resolution) {
+        receiveStreamedCell(resolution.cellKey, decodeRefJson(resolution.value))
+        return
+    }
     if ('miss' in resolution) {
         return
     }
@@ -22,10 +40,17 @@ export function seedStreamedResolution(resolution: StreamedResolution): void {
        an unconsumed hydrated seed (`hydrated === true`, cleared by the first cache()
        read). A live/settled non-hydrated entry is authoritative; clobbering it with a
        stale snapshot would drop a fresher value (e.g. one a live fetch already wrote). */
-    const { entries } = activeCacheStore()
-    const existing = entries.get(resolution.key)
+    const store = activeCacheStore()
+    const existing = store.entries.get(resolution.key)
     if (existing !== undefined && existing.hydrated !== true) {
         return
     }
-    entries.set(resolution.key, cacheEntryFromSnapshot(resolution))
+    store.entries.set(resolution.key, cacheEntryFromSnapshot(resolution))
+    /* Wake any reader subscribed to this key's lifecycle channel. Seeding used to rely on
+       seed-before-mount ordering (valid for the await path, whose subscription reads the
+       resume manifest, not the cache); an auto-streamed BARE read (ADR-0024) has already
+       mounted and its throwing-peek subscribed the key, so without an explicit dispatch the
+       peek that read `undefined` never re-runs on the streamed value. markLifecycle re-derives
+       the peek scope — the same wake materializeRetained relies on for a late-landing value. */
+    store.markLifecycle(resolution.key)
 }

package/src/lib/ui/settleAsyncCells.ts

@@ -0,0 +1,24 @@
+import { activePendingCells } from './activePendingCells.ts'
+
+/*
+The SSR await-barrier the compiler lowers to `$$settleAsyncCells()` between a
+component's cell declarations and its template (ADR-0019 Tier-2). It DRAINS the
+request-scoped pending list (`splice(0)`) so each barrier awaits only the cells
+declared since the last one — `renderChain` renders layout layers sequentially,
+each with its own barrier, and a drain keeps a later layer from re-awaiting an
+earlier settled layer's cells. `Promise.allSettled` never rejects the render: a
+rejected cell settles into its `error()` state, surfaced at the read site (via
+`$$readCell`), not here. On the client the list is always empty (cells register
+server-side only), so the barrier is a no-op await.
+*/
+// @documentation plumbing
+export async function settleAsyncCells(): Promise<void> {
+    const pending = activePendingCells()
+    if (pending === undefined) {
+        return
+    }
+    const promises = pending.promises.splice(0)
+    if (promises.length > 0) {
+        await Promise.allSettled(promises)
+    }
+}

package/src/lib/ui/socketProxy.ts

@@ -11,7 +11,7 @@ over the multiplexed ws channel). Both paths produce identical Socket
 shapes so user code reads the same on either side.
 
 The Socket surface — bare iteration as the live stream, `.tail(n)` seeded
-from the retained tail, `.broadcast` sending a server-validated `pub` frame —
+from the retained tail, `.publish` sending a server-validated `pub` frame —
 is built by buildSocketOverChannel over the page's lazily-opened singleton
 channel; this module only binds that builder to the browser channel so the
 test harness can reuse the identical surface over its own channel.

package/src/lib/ui/startClient.ts

@@ -5,18 +5,12 @@ import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
 import type { SsrPayload } from '../shared/types/SsrPayload.ts'
 import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
 import { probeNavigation } from './probeNavigation.ts'
-import { seedBootState } from './seedBootState.ts'
-
-/* Build-time flag the production client defines false (see build.ts `define`) so the dev-only
-   hot bridge — and the entire DOM runtime it statically pulls in for re-builds — is dead-code-
-   eliminated, not even emitted as a chunk. Dev defines it true; the test preload sets it on
-   globalThis so the bare reference resolves there. */
-declare const __ABIDE_DEV__: boolean
-
 import { router } from './router.ts'
+import { CELL_SEED } from './runtime/CELL_SEED.ts'
 import { clientPage } from './runtime/clientPage.ts'
 import type { RouteLoader } from './runtime/types/RouteLoader.ts'
-import { seedResolved } from './seedResolved.ts'
+import { seedBootState } from './seedBootState.ts'
+import { seedStreamedResolution } from './seedStreamedResolution.ts'
 
 /*
 The official abide-ui client entry. Reads the server's `window.__SSR__` payload,
@@ -40,21 +34,6 @@ export function startClient(
     if (target === null) {
         throw new Error('[abide] startClient: missing #app target')
     }
-    /* Dev only: the live-reload script sets `__abideDev` before this module runs, so the
-       runtime bridge is in place before any component mounts and records its instances
-       (mountChild) for hot replacement. Lazy-imported and `__ABIDE_DEV__`-gated so the
-       bridge (and the DOM runtime it drags in) is fully dead-code-eliminated in production
-       rather than shipped behind a runtime flag the minifier can't prove false. */
-    if (__ABIDE_DEV__ && (globalThis as { __abideDev?: boolean }).__abideDev) {
-        import('./installHotBridge.ts').then((module) => module.installHotBridge())
-    }
-    /* Inspector only: the server injects `__abideInspect` when ABIDE_ENABLE_INSPECTOR is on,
-       so the scope/router bridge arms before the router builds any scope. Inspector can be
-       enabled in production, so this stays a lazy chunk (not `__ABIDE_DEV__`-gated) — emitted
-       but fetched only when the flag is set, never weighing down the default client load. */
-    if ((globalThis as { __abideInspect?: boolean }).__abideInspect) {
-        import('./installInspectorBridge.ts').then((module) => module.installInspectorBridge())
-    }
     const ssr = (globalThis as { __SSR__?: Partial<SsrPayload> }).__SSR__ ?? {}
     /* Seed the per-page __SSR__ stamps into their shared slots before mount: the mount
        base, app name (default log channel), health payload (so health()'s first probe is
@@ -78,16 +57,22 @@ export function startClient(
     const streamed =
         (globalThis as { __abideResumeCache?: StreamedResolution[] }).__abideResumeCache ?? []
     for (const resolution of [...(ssr.cache ?? []), ...streamed]) {
-        seedResolved({ kind: 'cache', resolution })
+        seedStreamedResolution(resolution)
+    }
+    /* Seed the async-cell warm partition into `CELL_SEED` before mount: a hydrating
+       `createAsyncCell` reads its render-path key here to adopt the SSR-resolved value warm
+       instead of re-running its seed cold (Object.assign so an inline pre-bundle script that
+       already populated `__abideCells` isn't clobbered). */
+    if (ssr.cells !== undefined) {
+        Object.assign(CELL_SEED, ssr.cells)
     }
     /* Keep the cache channel live past boot: replace the head's buffering collector with
-       the store-connected sink so a post-load resolution — streaming SPA navigation or a
-       socket-delivered SSR frame, both routed through applyResolved — seeds the store
-       directly instead of pushing to a buffer nothing drains again. The inline doc-stream
-       script only ever hands this a cache `StreamedResolution`, so wrap it as a cache frame
-       through the one intake seam. */
+       the store-connected sink so a post-boot resolution — the inline doc-stream cache
+       script — seeds the store through `seedStreamedResolution` directly instead of pushing
+       to a buffer nothing drains again. The inline doc-stream script only ever hands this a
+       cache `StreamedResolution`. */
     ;(globalThis as { __abideResolve?: (resolution: StreamedResolution) => void }).__abideResolve =
-        (resolution) => seedResolved({ kind: 'cache', resolution })
+        seedStreamedResolution
 
     return router(target, routes, layoutRoutes, probeNavigation)
 }

package/src/lib/ui/state.ts

@@ -14,11 +14,17 @@ import { scope } from './scope.ts'
    reached ambiently so a component can pass a named value down its subtree. */
 type StateFn = {
     /* No-arg form for an undefined initial with a declared type: `state<Foo>()` is
-       `State<Foo | undefined>`. Without it `state<Foo>(undefined)` is an arity/assign
-       error and `state(undefined)` infers `T = undefined` (every `.value` access then
-       narrows to `never`). */
+       `State<Foo | undefined>`. Without it `state(undefined)` infers `T = undefined`
+       (every `.value` access then narrows to `never`). */
     <T>(): State<T | undefined>
     <T>(initial: T, transform?: (next: T, previous: T) => T): State<T>
+    /* The no-arg form spelled out: `state<Foo>(undefined)` is `State<Foo | undefined>`
+       too. Kept a distinct overload (not `initial?: T`) BELOW the general form — a real
+       initial still binds `T` from the value; only an explicit `undefined` (which the
+       general form rejects as "not assignable to T") falls through to here. A bare
+       `state(undefined)` still resolves against the general form (`T = undefined`), so
+       this overload changes nothing for it. */
+    <T>(initial: undefined): State<T | undefined>
     /* A writable cell reseeded from a reactive thunk (`state.linked(() => src())`). */
     linked: typeof linked
     /* A read-only cell computed from other cells (`state.computed(() => a() + b())`). */

package/src/lib/ui/trackedComputed.ts

@@ -0,0 +1,68 @@
+import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
+import type { AsyncComputed } from '../shared/types/AsyncComputed.ts'
+import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
+import { createAsyncCell } from './runtime/createAsyncCell.ts'
+import { createComputedNode } from './runtime/createComputedNode.ts'
+import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
+import { OWNER } from './runtime/OWNER.ts'
+import { readNode } from './runtime/readNode.ts'
+import type { Computed } from './runtime/types/Computed.ts'
+import { unlinkDeps } from './runtime/unlinkDeps.ts'
+import { untrack } from './runtime/untrack.ts'
+
+/*
+The eager, stream-classifying read-only computed the compiler routes a bare-call /
+identifier seed to — `computed(getStream())` / `computed(ref)` (ADR-0019 D1). Unlike the
+lazy `computed` primitive it PROBES its seed once to self-identify the source: a
+`NamedAsyncIterable` (socket / streaming rpc) auto-tracks its frames as an `AsyncComputed`,
+an `async () => await …` seed unwraps its promise, and anything else — a sync value, a bare
+opaque promise — falls back to the lazy `Computed`, so laziness is preserved on the miss and
+only a real stream/promise producer becomes a cell. It lives apart from the `computed`
+primitive so a DIRECT `computed(() => …)` call stays lazy (the primitive never probes); the
+eager probe is reached only through this compiler-emitted entry, matching how `linked`
+already classifies its seed. The probe runs untracked — a throwaway read must not subscribe
+the enclosing build.
+*/
+export function trackedComputed<T>(
+    compute: () => T | Promise<T> | NamedAsyncIterable<T>,
+    /* ADR-0032: when the compiler lifts a no-`await` async (sub)expression to a cell, it passes
+       `streaming: true` so the resolved promise does not join the SSR blocking barrier (the shell
+       ships pending, the client resolves). Default false = today's blocking registration; a stream
+       seed never registers regardless, so it only matters for a promise-unwrapping seed. */
+    streaming = false,
+): Computed<T> | AsyncComputed<T> {
+    /* `await` marker: an async-function seed unwraps its promise into a read-only async cell. */
+    if (isAsyncFunction(compute)) {
+        return createAsyncCell(compute as () => unknown, {
+            writable: false,
+            streaming,
+        }) as AsyncComputed<T>
+    }
+    /* Probe the seed once (untracked) to detect a self-identifying stream. A discarded stream
+       iterable costs nothing — a streaming rpc defers its fetch to the first pull, which never
+       happens here; a throw means a plain reactive compute, so fall through to the lazy path
+       (it throws at read, unchanged). */
+    let probe: unknown
+    let threw = false
+    try {
+        probe = untrack(compute)
+    } catch {
+        threw = true
+    }
+    if (!threw && isAsyncIterable(probe)) {
+        return createAsyncCell(compute as () => unknown, {
+            writable: false,
+            streaming,
+        }) as AsyncComputed<T>
+    }
+    /* Sync value or a bare (opaque) promise: the lazy computed, identical to the primitive. */
+    const node = createComputedNode(compute as () => unknown)
+    if (OWNER.current !== undefined) {
+        OWNER.current.push(() => unlinkDeps(node))
+    }
+    return {
+        get value(): T {
+            return readNode(node) as T
+        },
+    }
+}

package/src/lib/ui/types/Scope.ts

@@ -3,7 +3,7 @@ import type { effect } from '../effect.ts'
 import type { linked } from '../linked.ts'
 import type { Patch } from '../runtime/types/Patch.ts'
 import type { state } from '../state.ts'
-import type { SyncTransport } from './SyncTransport.ts'
+import type { trackedComputed } from '../trackedComputed.ts'
 
 /*
 A lexical scope: the unit that owns a region's reactive data, its lifetime, and
@@ -14,21 +14,14 @@ surface is the imported `state`/`state.linked`/`state.computed`/`effect` (see
 scope (`$$scope().derive`/`.linked`/`.effect`, `state.share`/`.shared` → `share`/
 `shared`). The data surface MIRRORS `Doc` (read/replace/add/remove/derive/apply/
 snapshot) so the compiler can target a scope as a component's data binding directly;
-it nests (`child`/`root`) and passes values down the tree as context (`share`/`shared`).
+it passes values down the tree as context (`share`/`shared`).
 
-The reactive primitives and capabilities remain on this internal shape because the
-lowered runtime calls them (`$$scope().linked(...)`, generated undo/persist) — they are
-withdrawn from the AUTHOR-facing public surface (docs/examples), not the runtime object.
-Capabilities route where the scope's changes go: `record()` to an undo journal,
-`persist()` to durable storage, `broadcast()` to peers — declared once, then `undo`/
-`redo` act on a recorded scope. The `history`/`persist`/`sync` helpers it composes are
-internal.
+The reactive primitives remain on this internal shape because the lowered runtime calls
+them (`$$scope().linked(...)`) — they are withdrawn from the AUTHOR-facing public surface
+(docs/examples), not the runtime object.
 */
 export type Scope = {
     readonly id: string
-    /* Dev-only display name (the host component/element it mounted into) for the
-       inspector's Reactive tab; undefined for SSR/detached/child scopes. */
-    readonly label?: string
     readonly parent: Scope | undefined
     /* data — mirrors Doc */
     read: <T>(path: string) => T
@@ -54,15 +47,15 @@ export type Scope = {
     state: typeof state
     linked: typeof linked
     computed: typeof computed
+    /* The eager stream-classifying read-only computed a bare-call `computed(getStream())`
+       lowers to — auto-tracks a stream/promise producer, falls back to a lazy computed. */
+    trackedComputed: typeof trackedComputed
     effect: typeof effect
     /* Adopts a teardown into this scope's lifetime — the build's reactivity stopper
        (effects/listeners), run first on `dispose` (before children, before capabilities).
        Internal: the mount core registers the build's disposer here so a component has ONE
        teardown (`dispose`) rather than a separate stop + dispose composed at every site. */
     own: (dispose: () => void) => void
-    /* tree */
-    child: (initial?: unknown) => Scope
-    root: () => Scope
     /* context — values shared DOWN the tree (not in the reactive doc, which doesn't
        inherit): `share` puts a named value on this scope; `shared` reads the closest
        ancestor (self included) that has the key, undefined if none. The value is held
@@ -70,15 +63,6 @@ export type Scope = {
        plain object snapshot. */
     share: (key: string, value: unknown) => void
     shared: <T>(key: string) => T | undefined
-    /* capabilities — enable where the scope's changes go */
-    record: (options?: { limit?: number }) => void
-    persist: (key?: string) => void
-    broadcast: (transport: SyncTransport) => void
-    /* undo/redo — act on a recorded scope */
-    undo: () => void
-    redo: () => void
-    canUndo: () => boolean
-    canRedo: () => boolean
     /* lifetime */
     dispose: () => void
 }

package/src/lib/ui/watch.ts

@@ -1,8 +1,8 @@
 import { cache } from '../shared/cache.ts'
 import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
 import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
+import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
 import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
-import type { Subscribable } from '../shared/types/Subscribable.ts'
 import { effect } from './effect.ts'
 import { generationGuard } from './runtime/generationGuard.ts'
 import type { EffectResult } from './runtime/types/EffectResult.ts'
@@ -40,7 +40,7 @@ export function watch(
     handler: (values: unknown[]) => void,
 ): () => void
 export function watch<Frame>(
-    source: Subscribable<Frame>,
+    source: NamedAsyncIterable<Frame>,
     handler: (frame: Frame, context: CacheOnContext) => void | Promise<void>,
 ): () => void
 export function watch<Args, Return>(
@@ -74,7 +74,7 @@ export function watch(
        existing cache.on loop is the single implementation this branch delegates to. */
     if (isSubscribable(source)) {
         return cache.on(
-            source as Subscribable<unknown>,
+            source as NamedAsyncIterable<unknown>,
             handler as (frame: unknown, context: CacheOnContext) => void | Promise<void>,
         )
     }

package/src/serverEntry.ts

@@ -33,8 +33,11 @@ import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
 import { createCacheStore } from './lib/shared/createCacheStore.ts'
 import { loadEnvFromDataDir } from './lib/shared/loadEnvFromDataDir.ts'
 import { pageSlot } from './lib/shared/pageSlot.ts'
+import { pendingAsyncCellsSlot } from './lib/shared/pendingAsyncCellsSlot.ts'
+import { resolvedCellsSlot } from './lib/shared/resolvedCellsSlot.ts'
 import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
 import { sharedCacheStoreSlot } from './lib/shared/sharedCacheStoreSlot.ts'
+import { streamedCellsSlot } from './lib/shared/streamedCellsSlot.ts'
 
 /*
 Resolve config into process.env before anything reads it (createServer reads
@@ -76,6 +79,17 @@ sharedCacheStoreSlot.resolver = () => sharedCacheStore
 
 cacheStoreSlot.resolver = () => requestContext.getStore()?.cache ?? sharedCacheStore
 
+/* One process-wide fallback list for reads with no request in flight (boot/cron/socket) —
+   real requests each carry their own `pendingAsyncCells`, so the SSR barrier drains a
+   per-request list and concurrent renders never cross-contaminate. */
+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
 
 await createServer({

package/template/src/server/rpc/getHello.ts

@@ -6,17 +6,18 @@ the HTTP method. The bundler swaps the runtime per build target: direct call on
 the server, fetch over the network on the client.
 
 Args (what the caller passes in) come from the handler's parameter type —
-either an inline annotation or an explicit `GET<{ id: string }>(...)`
-generic. Return (what the caller receives after Content-Type-driven
-decoding) is inferred from the handler's return type via the
-`TypedResponse<T>` brand on `json`/`error`/`redirect`/`jsonl`/`sse`, so
-plain `GET(() => json({...}))` already types end-to-end.
+annotate the parameter and the body infers; a typed generic on the helper is a
+compile error. Return (what the caller receives after Content-Type-driven
+decoding) is inferred from the handler's return type via the `TypedResponse<T>`
+brand on `json`/`error`/`redirect`/`jsonl`/`sse`, so plain
+`GET(() => json({...}))` already types end-to-end.
 
-For inbound validation pass a Standard Schema as `inputSchema` in the
-second argument: `GET(fn, { inputSchema })`. Args then infers from the
-schema's output type and the server replies with 422 on validation
-failure. An optional `outputSchema` describes the success body for the
-OpenAPI 200 response and the MCP tool output.
+For inbound validation pass a Standard Schema under `schemas.input` in the
+second argument: `GET(fn, { schemas: { input } })`. Args then infers from the
+schema's output type and the server replies with 422 on validation failure. An
+optional `schemas.output` describes the success body for the OpenAPI 200
+response and the MCP tool output; without one the handler's return type is
+projected to JSON Schema.
 
 `json(...)` from `abide/server/json` is a thin wrapper over `Response.json`
 that defaults `Cache-Control: no-store`, since intermediary caches shouldn't
@@ -24,10 +25,11 @@ memoise rpc replies (the framework's per-request cache handles in-process
 dedupe). Other helpers are siblings, one per file: `abide/server/error`,
 `abide/server/redirect`, `abide/server/sse`, `abide/server/jsonl`.
 
-Every rpc value also exposes `.raw(args?)` (returns the underlying
+Every rpc value also exposes `.raw(args?, init?)` (returns the underlying
 `Response`) for callers that need headers or status. A streaming rpc — a
-jsonl/sse handler — returns a `Subscribable` over the frames from its bare
-call (`fn(args)`); iterate it with `for await` or react to it with `watch(fn(args), frame => …)`.
+jsonl/sse handler — returns a `NamedAsyncIterable` over the frames from its bare
+call (`fn(args)`); iterate it with `for await` or react to it with
+`watch(fn(args), frame => …)`.
 */
 
 import { GET } from '@abide/abide/server/GET'

package/template/test/app.test.ts

@@ -5,7 +5,7 @@ same wiring as `abide start`, no fixtures) and hands back the whole surface:
   app.fetch(path)        — pages and raw HTTP, origin + mount base resolved
   app.rpc.<name>(args)   — RPCs over the real pipeline (CSRF, cookies, base),
                            typed and decoded; .raw(args) for the Response
-  app.sockets.<name>     — a live Socket: iterate it (for await), .peek(), .broadcast(m)
+  app.sockets.<name>     — a live Socket: iterate it (for await), .peek(), .publish(m)
   app.health()           — the /__abide/health payload
 
 `app.rpc` / `app.sockets` are typed from your own RPCs and sockets — generated