@abide/abide 0.53.0 → 0.55.0

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

@@ -71,7 +71,7 @@ export type RemoteFunction<
        reloads lazily, while `refresh(args?)` REFETCHES now keeping the stale value visible — both
        apply locally on the client and broadcast to every connected client from the server.
        `peek(args?)` reads the retained value synchronously (a streaming rpc peeks its latest
-       frame). `patch` is fetch-only, so it is omitted for a streaming rpc (a stream isn't a
+       frame). `amend` is fetch-only, so it is omitted for a streaming rpc (a stream isn't a
        memoized value) via the intersection below. */
     pending(args?: Args): boolean
     refreshing(args?: Args): boolean
@@ -84,22 +84,33 @@ export type RemoteFunction<
        shadow the server `error()` thrower). Reads the rpc error registry captured at the call
        boundary; the cache is untouched. */
     error(args?: Args): RpcError<Errors> | undefined
-    /* Client-only reaction sugar: `fn.watch(handler)` / `fn.watch(args, handler)` ≡
-       `watch(fn, …)` — runs the smart read reactively and pipes each resolved value to the
-       handler, returning a scope-tied disposer. Reaction is a client concern (`watch` is a ui
-       primitive), so this is an inert no-op server-side; an author `fn.watch(…)` surviving the
-       SSR effect-strip (which leaves member calls intact) is a safe no-op there. The real method
-       is attached client-side by remoteProxy. */
-    watch(handler: (value: Return) => void): () => void
-    watch(args: Args, handler: (value: Return) => void): () => void
-} /* `patch` is fetch-only: a streaming rpc has no single memoized value to mutate, so the
-     method is present only when `Return` is not an AsyncIterable. Two signatures: with args
-     (`patch(args, updater)`) and without (`patch(updater)` — every args-variant). Tuple-wrapped
-     so the conditional doesn't distribute over a `never` Return (an error-only rpc). */ & ([
-        Return,
-    ] extends [AsyncIterable<unknown>]
-        ? Record<never, never>
+} /* Client-only reaction sugar: `fn.watch(handler)` / `fn.watch(args, handler)` ≡ `watch(fn, …)`
+     — runs the smart read reactively and pipes each resolved value to the handler, returning a
+     scope-tied disposer. Inert no-op server-side (reaction is a ui concern; the real method is
+     attached client-side by remoteProxy). The keyed overload collapses away for a no-input rpc
+     (`undefined extends Args`) — there is no key to scope to (ADR-0043 §5, type-only). */ & (undefined extends Args
+        ? {
+              watch(handler: (value: Return) => void): () => void
+          }
         : {
-              patch(args: Args | undefined, updater: (current: Return) => Return): void
-              patch(updater: (current: Return) => Return): void
-          })
+              watch(handler: (value: Return) => void): () => void
+              watch(args: Args, handler: (value: Return) => void): () => void
+          }) /* `amend` is fetch-only: a streaming rpc has no single memoized value to mutate, so the
+     method is present only when `Return` is not an AsyncIterable. The last argument is a
+     replacement `Return` value (broadcastable — ADR-0043) or an updater `(current) => Return`
+     (a local closure). For a keyed rpc the value/updater takes the args key first; the bare
+     `amend(updater)` covers every args-variant (local-only). For a no-input rpc the key
+     collapses away (`amend(value)` / `amend(updater)`). Tuple-wrapped so the conditional
+     doesn't distribute over a `never` Return (an error-only rpc). */ &
+    ([Return] extends [AsyncIterable<unknown>]
+        ? Record<never, never>
+        : undefined extends Args
+          ? {
+                amend(value: Return): void
+                amend(updater: (current: Return) => Return): void
+            }
+          : {
+                amend(args: Args, value: Return): void
+                amend(args: Args, updater: (current: Return) => Return): void
+                amend(updater: (current: Return) => Return): void
+            })

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

@@ -0,0 +1,13 @@
+/*
+The per-request list of retained socket frames read via `peek(socket)` during an SSR render, each
+keyed by the socket's name. `defineSocket`'s server `peek()` pushes an entry when a retained frame is
+read server-side; the page renderer stamps them into `__SSR__.sockets` (ref-json-encoded, last write
+per name winning) so the client seeds the socket's latest frame WARM — a not-yet-connected client's
+`peek(socket)` then returns the same retained value the SSR render committed to instead of `undefined`,
+which would otherwise diverge from the server HTML and trip a hydration desync. Sibling of
+`ResolvedCells` — sockets carry a server value forward like cells, not withhold on the client like
+cache (whose server peek is uniformly undefined).
+*/
+export type SocketTails = {
+    entries: { name: string; value: unknown }[]
+}

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

@@ -27,4 +27,10 @@ export type SsrPayload = SsrBootState & {
        write to each slot adopts the server value, so a plain `state(uuid())`/`state(Date.now())`
        keeps the SSR value instead of recomputing a divergent one. */
     docs?: Record<string, string>
+    /* Retained socket frames read via `peek(socket)` during SSR, keyed by socket name → ref-json
+       string. `startClient` seeds these into `SOCKET_SEED`; a hydrating `socketProxy` adopts the frame
+       as its `lastFrame` so `peek(socket)` returns the SAME retained value the server rendered instead
+       of `undefined` on the not-yet-connected client — otherwise the two disagree and hydration
+       discards the server markup. */
+    sockets?: Record<string, string>
 }

package/src/lib/test/createTestApp.ts

@@ -47,6 +47,7 @@ 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 { socketTailsSlot } from '../shared/socketTailsSlot.ts'
 import { streamedCellsSlot } from '../shared/streamedCellsSlot.ts'
 import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
 import type { Socket } from '../shared/types/Socket.ts'
@@ -111,6 +112,7 @@ export async function createTestApp(): Promise<TestApp> {
         pendingAsyncCellsResolver: pendingAsyncCellsSlot.resolver,
         resolvedCellsResolver: resolvedCellsSlot.resolver,
         streamedCellsResolver: streamedCellsSlot.resolver,
+        socketTailsResolver: socketTailsSlot.resolver,
         docSnapshotsResolver: docSnapshotsSlot.resolver,
         activeServer: serverSlot.active,
         pageRender: pageRenderSlot.render,
@@ -129,6 +131,9 @@ export async function createTestApp(): Promise<TestApp> {
     const sharedStreamedCells = { entries: [] }
     streamedCellsSlot.resolver = () =>
         requestContext.getStore()?.streamedCells ?? sharedStreamedCells
+    /* No shared fallback — mirrors serverEntry: `defineSocket.peek` records off-request too, so a
+       fallback would leak. Off-request this resolves undefined and the record is skipped. */
+    socketTailsSlot.resolver = () => requestContext.getStore()?.socketTails
     const sharedDocSnapshots = { entries: [] }
     docSnapshotsSlot.resolver = () => requestContext.getStore()?.docSnapshots ?? sharedDocSnapshots
     pageSlot.resolver = resolvePageSnapshot
@@ -218,6 +223,7 @@ export async function createTestApp(): Promise<TestApp> {
         pendingAsyncCellsSlot.resolver = previous.pendingAsyncCellsResolver
         resolvedCellsSlot.resolver = previous.resolvedCellsResolver
         streamedCellsSlot.resolver = previous.streamedCellsResolver
+        socketTailsSlot.resolver = previous.socketTailsResolver
         docSnapshotsSlot.resolver = previous.docSnapshotsResolver
         serverSlot.active = previous.activeServer
         pageRenderSlot.render = previous.pageRender

package/src/lib/ui/amendReaderHook.ts

@@ -0,0 +1,125 @@
+import { AMEND_TOPIC_PREFIX } from '../shared/AMEND_TOPIC_PREFIX.ts'
+import { abideLog } from '../shared/abideLog.ts'
+import { cache } from '../shared/cache.ts'
+import { SocketDisconnectedError } from '../shared/SocketDisconnectedError.ts'
+import type { CacheReaderHook } from '../shared/types/CacheReaderHook.ts'
+import type { Socket } from '../shared/types/Socket.ts'
+import { socketProxy } from './socketProxy.ts'
+
+/* A cache key is a broadcastable amend target only when it carries cross-client wire
+   identity — a remote call key (`METHOD /url…`, per keyForRemoteCall). Producer keys
+   (per-process reference ids) and anything else can't be pushed across clients, so we
+   never open a subscription for them. */
+const REMOTE_KEY = /^(?:GET|POST|PUT|PATCH|DELETE|HEAD) \//
+
+/*
+The client-only reactive-reader lifecycle hook (ADR-0043) installed into
+cacheReaderSocketSlot by startClient. When a remote key gains its first live reader it
+opens a subscription to that call's reserved amend topic and folds each pushed value
+into the cache; when the key loses its last reader it closes the subscription — so the
+set of subscribed topics stays congruent with the set of keys this tab is reading (and
+therefore already authorized for). Refcounted per key so co-readers (or the active/shared
+store both reporting a reader) share one subscription.
+
+The channel is live-only (no tail): a value pushed while this tab was disconnected is
+missed, so on a transport loss the hook re-opens a fresh live iterator AND refreshes the
+key — the ADR-0043 convergence rule, reconciling against authoritative server state
+rather than leaving a silently-stale value. `openSocket` is injectable so a test can drive
+frames over its own channel without a live ws.
+*/
+export function createAmendReaderHook(
+    openSocket: (name: string) => Socket<unknown> = socketProxy,
+): { hook: CacheReaderHook; dispose: () => void } {
+    const open = new Map<string, { readers: number; dispose: () => void }>()
+
+    function subscribe(key: string): () => void {
+        const socket = openSocket(AMEND_TOPIC_PREFIX + key)
+        const controller = new AbortController()
+        /* Opening the shared ws channel must never propagate into the cache read that engaged
+           this key — a read can't fail because an optional real-time subscription couldn't open
+           (e.g. no ws transport). Log and give up on this key's push channel; SWR still holds. */
+        let iterator: AsyncIterator<unknown>
+        try {
+            iterator = socket[Symbol.asyncIterator]()
+        } catch (error) {
+            abideLog.error(error)
+            return () => undefined
+        }
+        ;(async () => {
+            while (!controller.signal.aborted) {
+                let next: IteratorResult<unknown>
+                try {
+                    next = await iterator.next()
+                } catch (error) {
+                    if (controller.signal.aborted) {
+                        return
+                    }
+                    /* Transport loss: reconcile the possibly-missed value against server truth,
+                       then re-open a fresh LIVE subscription (no replay) and keep going. */
+                    if (error instanceof SocketDisconnectedError) {
+                        cache.refreshMatching((entry) => entry.key === key, key, undefined, key)
+                        try {
+                            iterator = socket[Symbol.asyncIterator]()
+                        } catch (reopenError) {
+                            abideLog.error(reopenError)
+                            return
+                        }
+                        continue
+                    }
+                    abideLog.error(error)
+                    return
+                }
+                if (controller.signal.aborted || next.done === true) {
+                    return
+                }
+                /* One malformed frame must not tear down the live pipe. Frames come only from the
+                   trusted server (clientPublish is false), so this is defense in depth. */
+                try {
+                    cache.amendByKey(key, next.value)
+                } catch (error) {
+                    abideLog.error(error)
+                }
+            }
+        })()
+        return () => {
+            controller.abort()
+            iterator.return?.(undefined)?.catch(() => undefined)
+        }
+    }
+
+    const hook: CacheReaderHook = {
+        engage(key) {
+            if (!REMOTE_KEY.test(key)) {
+                return
+            }
+            const existing = open.get(key)
+            if (existing) {
+                existing.readers += 1
+                return
+            }
+            open.set(key, { readers: 1, dispose: subscribe(key) })
+        },
+        disengage(key) {
+            const existing = open.get(key)
+            if (existing === undefined) {
+                return
+            }
+            existing.readers -= 1
+            if (existing.readers <= 0) {
+                existing.dispose()
+                open.delete(key)
+            }
+        },
+    }
+
+    /* Tear down every open subscription — for the startClient disposer, in case reads are
+       still mounted when the whole client is torn down (e.g. a test harness). */
+    function dispose(): void {
+        for (const entry of open.values()) {
+            entry.dispose()
+        }
+        open.clear()
+    }
+
+    return { hook, dispose }
+}

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

@@ -38,16 +38,12 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: stri
     { name: 'eachAsync', specifier: 'ui/dom/eachAsync', alias: '$$eachAsync' },
     { name: 'when', specifier: 'ui/dom/when', alias: '$$when' },
     { name: 'awaitBlock', specifier: 'ui/dom/awaitBlock', alias: '$$awaitBlock' },
+    { name: 'awaitSubject', specifier: 'ui/dom/awaitSubject', alias: '$$awaitSubject' },
     { name: 'tryBlock', specifier: 'ui/dom/tryBlock', alias: '$$tryBlock' },
     { name: 'switchBlock', specifier: 'ui/dom/switchBlock', alias: '$$switchBlock' },
     { 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' },
@@ -56,7 +52,6 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: stri
     { name: 'spreadAttrs', specifier: 'ui/dom/spreadAttrs', alias: '$$spreadAttrs' },
     { name: 'readCall', specifier: 'ui/dom/readCall', alias: '$$readCall' },
     { name: 'readCell', specifier: 'ui/dom/readCell', alias: '$$readCell' },
-    { name: 'readCellBlocking', specifier: 'ui/dom/readCellBlocking', alias: '$$readCellBlocking' },
     { name: 'writeCell', specifier: 'ui/dom/writeCell', alias: '$$writeCell' },
     { name: 'cellPending', specifier: 'ui/dom/cellPending', alias: '$$cellPending' },
     { name: 'withPath', specifier: 'ui/runtime/withPath', alias: '$$withPath' },

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

@@ -120,7 +120,6 @@ export function analyzeComponent(
         derivedNames,
         computedNames,
         cellReadNames,
-        blockingCellNames: allBlockingCellNames,
         droppedReactiveImports,
     } = lowerScript(
         fullScriptBody,
@@ -143,7 +142,6 @@ export function analyzeComponent(
         derivedNames,
         computedNames,
         cellReadNames,
-        blockingCellNames: allBlockingCellNames,
         nodes,
         styles,
         /* Hydration adopts every block in place — including `await`, which resumes

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

@@ -0,0 +1,23 @@
+/*
+The lowered `{#await X}` subject, normalised so a cell subject AWAITS its resolution
+(ADR-0047): a BARE async-cell reference is passed RAW (not peeked to `$$readCell(cell)`)
+and wrapped in `$$awaitSubject(...)`, which resolves a cell to a promise-of-its-value —
+so `{#await rates}` (a cell) shows pending then the value; any other subject lowers
+unchanged, so `{#await getFoo()}` (a plain promise) is byte-identical. A name currently
+SHADOWED by a block binding (`{#for rates of …}` / `{:then rates}` over a component cell
+`rates`) is the binder's local, not the cell — it lowers through `lowerExpression` like any
+other subject, matching how every other reference site honours the shadow stack. ONE
+decision site shared by both back-ends (the client `awaitBlock` emit and SSR's blocking /
+streaming / flight-hoist emits), so the bare-cell classification can't drift between them.
+*/
+export function awaitSubjectExpr(
+    promiseCode: string,
+    cellReadNames: ReadonlySet<string>,
+    isShadowed: (name: string) => boolean,
+    lowerExpression: (code: string) => string,
+): string {
+    const bare = promiseCode.trim()
+    return cellReadNames.has(bare) && !isShadowed(bare)
+        ? `$$awaitSubject(${bare})`
+        : lowerExpression(promiseCode)
+}

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

@@ -0,0 +1,39 @@
+import { messageFromError } from '../../shared/messageFromError.ts'
+import { createShadowProgram, type ShadowProgram } from './createShadowProgram.ts'
+
+/*
+Get-or-build the warm shadow program for a project root, cached once per root and shared by
+the interpolation and seed classifiers (whichever is requested first for a root warms it; the
+other reuses it). The shadow program is what makes type-directed async detection possible —
+resolving whether `{getFoo()}` is a promise/stream and lifting it to a streaming/blocking cell.
+
+On a build FAILURE the program is cached as `undefined` and the classifiers degrade to today's
+plain-value / syntactic behavior — the build never breaks. But the failure is WARNED once per
+root: a silent `undefined` disables type-directed async detection for EVERY component in the
+root, so a broken tsconfig would otherwise ship a bare `{getFoo()}` as the literal
+`[object Promise]` text with no signal at all. The warn fires once (guarded by `cache.has`), so
+the two classifiers sharing a cache never double-report.
+
+`build` is injectable so the warn-once path is testable without a broken project on disk;
+callers pass nothing and get `createShadowProgram`.
+*/
+export function cachedShadowProgram(
+    cache: Map<string, ShadowProgram | undefined>,
+    root: string,
+    build: (root: string) => ShadowProgram = createShadowProgram,
+): ShadowProgram | undefined {
+    if (!cache.has(root)) {
+        try {
+            cache.set(root, build(root))
+        } catch (error) {
+            cache.set(root, undefined)
+            const detail = messageFromError(error)
+            console.warn(
+                `[abide] couldn't build the type program for ${root}: ${detail}\n` +
+                    '  type-directed async detection is disabled for this project — a bare promise/stream\n' +
+                    '  read like {getFoo()} renders as text instead of streaming. Check the tsconfig.',
+            )
+        }
+    }
+    return cache.get(root)
+}

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

@@ -29,8 +29,7 @@ export function compileComponent(
        a direct caller (tests) omits it and the front-end runs here — threading `classify` and
        `seedClassify` so type-directed interpolation + cell lowering happen on this path too. */
     const resolved = analyzed ?? analyzeComponent(source, scopeSeed, classify, seedClassify)
-    const { script, stateNames, derivedNames, computedNames, cellReadNames, blockingCellNames, nodes } =
-        resolved
+    const { script, stateNames, derivedNames, computedNames, cellReadNames, nodes } = resolved
     const build = generateBuild(
         nodes,
         'host',
@@ -39,7 +38,6 @@ export function compileComponent(
         computedNames,
         isLayout,
         cellReadNames,
-        blockingCellNames,
     )
     /* The scoped CSS is bundled into the entry stylesheet (see `abideUiPlugin`), not
        injected at runtime; the build only needs the `data-a-…` scope attributes on

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

@@ -0,0 +1,39 @@
+import type { TemplateNode } from './types/TemplateNode.ts'
+
+/*
+Document-order (pre-order) numbering of every `<Child/>` mount site in a template — the
+ordinal a child's render-path roots under (`mountChild` on the client, `$$withPath(ordinal)`
+/ `$$renderPath(ordinal)` on the server). ONE walk both back-ends read (the `skeletonContext`
+pattern), replacing the per-back-end `childOrdinal++` counters that numbered components in
+each generator's own EMISSION order — an order that could silently diverge (build emits a
+component's slot content before taking its own ordinal; SSR emits a switch's default case
+after later cases). Numbering from the tree, not the emission, makes SSR↔client ordinal
+congruence hold by construction.
+
+Returns the lookup, not the map, so the missing-entry policy lives here too: a miss means a
+back-end reached a mount site the shared walk didn't number — a structural divergence,
+surfaced loudly at compile time rather than as a runtime warm-seed/boundary desync.
+*/
+export function componentOrdinals(nodes: TemplateNode[]): (node: TemplateNode) => number {
+    const ordinals = new WeakMap<TemplateNode, number>()
+    let next = 0
+    const walk = (children: TemplateNode[]): void => {
+        for (const child of children) {
+            if (child.kind === 'component') {
+                ordinals.set(child, next)
+                next += 1
+            }
+            if ('children' in child) {
+                walk(child.children)
+            }
+        }
+    }
+    walk(nodes)
+    return (node: TemplateNode): number => {
+        const ordinal = ordinals.get(node)
+        if (ordinal === undefined) {
+            throw new Error('[abide] component mount site not numbered by the shared ordinal walk')
+        }
+        return ordinal
+    }
+}

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

@@ -5,6 +5,7 @@ import { type ReactiveImportBindings, reactiveImportBindings } from './resolveRe
 import { signalCallee } from './signalCallee.ts'
 import type { InterpolationKind } from './types/InterpolationKind.ts'
 import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
+import { wrapSeed } from './wrapSeed.ts'
 
 /* The routing decision for a no-marker `computed(seed)`: `true` routes to the eager
    `trackedComputed` stream cell (read via `$$readCell`, the `cellReadNames` bucket), `false`
@@ -14,25 +15,21 @@ type EagerStreamPredicate = (declaration: ts.VariableDeclaration) => boolean
 
 const factory = ts.factory
 
-/* Normalises a `computed`/`linked` argument into a seed THUNK: a literal `() => …` /
-   `function` argument passes through unchanged (the author already wrote the thunk), any
-   other expression is wrapped as `() => arg`. The wrapper arrow is made ASYNC when the
-   expression contains a top-level `await` (`computed(await load())` → `async () => await
-   load()`), which is exactly the marker the runtime primitive uses to route to an async cell. */
-function wrapSeed(argument: ts.Expression): ts.Expression {
-    if (ts.isArrowFunction(argument) || ts.isFunctionExpression(argument)) {
-        return argument
-    }
-    const modifiers = hasTopLevelAwait(argument)
-        ? [factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-        : undefined
+/* Wraps a seed expression as an async unwrapping thunk `async () => await (arg)` — for a
+   type-directed PROMISE seed (ADR-0023/0043) the author wrote WITHOUT `await`
+   (`state.computed(getFoo())`). The `async`+`await` makes createAsyncCell unwrap the resolved
+   value; a plain `() => getFoo()` thunk would fall to trackedComputed's lazy opaque path (its
+   probe self-identifies only a stream, never a promise). The parens keep a comma/ternary seed
+   a single await operand. Distinct from `wrapSeed`, which only makes the arrow async when the
+   arg already carries a top-level `await`. */
+function wrapAwaitSeed(argument: ts.Expression): ts.Expression {
     return factory.createArrowFunction(
-        modifiers,
+        [factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
         undefined,
         [],
         undefined,
         factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-        argument,
+        factory.createAwaitExpression(factory.createParenthesizedExpression(argument)),
     )
 }
 
@@ -213,10 +210,6 @@ export function desugarSignals(
     derivedNames: Set<string>
     computedNames: Set<string>
     cellReadNames: Set<string>
-    /* The full BLOCKING cell set (ADR-0042): the template-injected `await` cells passed in, unioned
-       with the script-level `await` computeds/linked collected here. The client template lowering
-       reads these via `$$readCellBlocking` (suspend-on-pending). */
-    blockingCellNames: Set<string>
 } {
     assertNoRemovedReaders(source)
     /* The full set of names written anywhere (this script + the template). A prop in this set
@@ -235,10 +228,6 @@ export function desugarSignals(
        One read shape covers both — `$$readCell` peeks an async cell and reads `.value` off a
        sync one — so `linked(getStream())` auto-tracks with no read-site branching. */
     const cellReadNames = new Set<string>()
-    /* Script-level BLOCKING cell names (ADR-0042 D6): a `computed`/`linked` whose seed carries a
-       top-level `await`. Unioned with the template-injected `blockingCellNames` and returned so the
-       CLIENT template lowering reads them via `$$readCellBlocking` (suspend-on-pending). */
-    const scriptBlockingNames = new Set<string>()
     /* A `props()` destructure must be lowered even when it declares no reactive binding
        (a rest-only `const { ...rest } = props()`), so track its presence on its own. */
     let hasPropsDestructure = false
@@ -275,6 +264,21 @@ export function desugarSignals(
         }
         return isBareCallComputed(declaration)
     }
+    /* A type-directed PROMISE seed (ADR-0023/0043): a no-`await` `state.computed(getFoo())` whose
+       seed's checker type resolves to a promise. Routed to an eager STREAMING async cell that
+       unwraps the resolved value and reactively re-resolves when its tracked deps change — the
+       script-level twin of a bare async interpolation (ADR-0032). Only fires with a warm classifier
+       ('promise'); fail-open (no program) leaves it to `isEagerStreamComputed`'s bare-call probe,
+       and the `await`-marker seed is excluded (its wrapped thunk is already async). Kept separate
+       from `isEagerStreamComputed` so `computedStatements` can wrap it as `async () => await (seed)`
+       (a stream seed stays a bare probe thunk). */
+    const isPromiseComputed: EagerStreamPredicate = (declaration) => {
+        const argument = seedArgument(declaration)
+        if (argument === undefined || isAsyncSeed(wrapSeed(argument))) {
+            return false
+        }
+        return seedKind(argument) === 'promise'
+    }
     for (const statement of source.statements) {
         if (!ts.isVariableStatement(statement)) {
             continue
@@ -321,26 +325,26 @@ export function desugarSignals(
                    `name()` (a sync/promise seed), or an eager cell read via `$$readCell(name)`
                    when the wrapped seed is async (an `await`-lowered / passthrough-`async` thunk)
                    or its seed type resolves to a stream (`isEagerStreamComputed`, ADR-0023). */
-                if (isAsyncComputed(declaration) || isEagerStreamComputed(declaration)) {
+                if (
+                    isAsyncComputed(declaration) ||
+                    isEagerStreamComputed(declaration) ||
+                    isPromiseComputed(declaration)
+                ) {
+                    /* Async `computed` (author `await`), an eager stream, or a promise seed — all
+                       read via `$$readCell(name)`. Whether a pending read PAUSES (author `await`,
+                       a blocking cell) or peeks `undefined` (streaming) is carried by the cell
+                       itself at construction (the `trackedComputed(thunk, streaming)` flag), so the
+                       read form is uniform and nothing blocking-specific is collected here. */
                     cellReadNames.add(declaration.name.text)
-                    /* A blocking async computed (author `await`) reads suspend-on-pending. */
-                    const argument = seedArgument(declaration)
-                    if (argument !== undefined && isBlockingSeed(argument)) {
-                        scriptBlockingNames.add(declaration.name.text)
-                    }
                 } else {
                     computedNames.add(declaration.name.text)
                 }
             } else if (callee === 'linked') {
                 /* `linked` → a cell read via `$$readCell(name)`: a plain `State` when the seed
                    is synchronous, an `AsyncState` when it tracks a promise/stream — one read
-                   shape auto-tracks whichever source the runtime primitive resolved to. */
+                   shape auto-tracks whichever source the runtime primitive resolved to. Its
+                   blocking-ness (author `await`) likewise rides on the constructed cell. */
                 cellReadNames.add(declaration.name.text)
-                /* A blocking async linked (author `await`) reads suspend-on-pending, like computed. */
-                const argument = seedArgument(declaration)
-                if (argument !== undefined && isBlockingSeed(argument)) {
-                    scriptBlockingNames.add(declaration.name.text)
-                }
             } else if (callee === 'state') {
                 /* `state(initial, transform)` → a `.value` cell (its write-coercion transform
                    forces a local store); referenced as `name.value`, unchanged. */
@@ -389,6 +393,7 @@ export function desugarSignals(
                     blockingCellNames,
                     writtenNames,
                     isEagerStreamComputed,
+                    isPromiseComputed,
                 ),
             )
         }
@@ -401,7 +406,6 @@ export function desugarSignals(
         derivedNames,
         computedNames,
         cellReadNames,
-        blockingCellNames: new Set([...blockingCellNames, ...scriptBlockingNames]),
     }
 }
 
@@ -417,12 +421,19 @@ function loweredStatement(
     blockingCellNames: ReadonlySet<string>,
     writtenNames: ReadonlySet<string>,
     isEagerStreamComputed: EagerStreamPredicate,
+    isPromiseComputed: EagerStreamPredicate,
 ): ts.Statement[] {
     rejectMixedDeclaration(statement, bindings)
     return (
         injectedComputedStatements(statement, injectedCellNames, blockingCellNames) ??
         stateAssignmentStatements(statement, bindings) ??
-        computedStatements(statement, bindings, signalNames, isEagerStreamComputed) ??
+        computedStatements(
+            statement,
+            bindings,
+            signalNames,
+            isEagerStreamComputed,
+            isPromiseComputed,
+        ) ??
         propsStatements(statement, bindings, writtenNames) ??
         cellStatements(statement, bindings, signalNames) ?? [statement]
     )
@@ -613,6 +624,7 @@ function computedStatements(
     bindings: ReactiveImportBindings,
     signalNames: ReadonlySet<string>,
     isEagerStreamComputed: EagerStreamPredicate,
+    isPromiseComputed: EagerStreamPredicate,
 ): ts.Statement[] | undefined {
     if (!ts.isVariableStatement(statement)) {
         return undefined
@@ -659,6 +671,23 @@ function computedStatements(
                     ]),
                 ),
             )
+        } else if (argument !== undefined && isPromiseComputed(declaration)) {
+            /* Type-directed PROMISE seed (ADR-0023/0043): a bare `state.computed(getFoo())` whose
+               seed resolves to a promise. Wrap it as `async () => await (seed)` so createAsyncCell
+               unwraps the resolved value — a plain `() => getFoo()` thunk would fall to
+               trackedComputed's lazy opaque path (its probe self-identifies only a stream). Passed
+               `streaming: true` (the `true` arg): no author `await` → it does NOT join the SSR
+               blocking barrier — the shell ships pending and the client resolves + reactively
+               re-resolves, the ADR-0032 no-await tier. `await getFoo()` stays the BLOCKING form. */
+            statements.push(
+                constDeclaration(
+                    name,
+                    scopeMethodCall('trackedComputed', [
+                        wrapAwaitSeed(argument),
+                        factory.createTrue(),
+                    ]),
+                ),
+            )
         } else if (isEagerStreamComputed(declaration)) {
             /* Stream seed → the eager `trackedComputed`, which probes the seed and auto-tracks a
                stream (`AsyncComputed`) or falls back to a lazy computed; read via `$$readCell`.