@abide/abide 0.55.0 → 0.56.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # abide
 
+## 0.56.0
+
+### Minor Changes
+
+- lift buried async sub-expressions in state/linked/computed seeds (ADR-0032, script side) ([`6b269f4`](https://github.com/briancray/abide/commit/6b269f45d8ab2e117d62684620542cfd1199631e))
+- a linked seed that reads a pending blocking cell becomes a blocking AsyncState ([`8329365`](https://github.com/briancray/abide/commit/83293652689d6a95c8cf4ffe66722e33be1aa63b))
+- a034b2d: `linked` seed that reads a pending blocking cell becomes a blocking `AsyncState`
+
+    A `linked()` whose seed transitively reads a blocking (`await`-marked) async cell used to throw a `SuspenseSignal` out of its eager reseed effect at construction — the effect is a leaf with no reader to swallow the suspend, so it escaped to the caller. The classification probe now routes a seed that suspends to a writable async cell, and that cell marks itself blocking when its seed synchronously suspends, so its own reads pause too. A blocking read now behaves the same inside a `linked` seed as it does in a `computed` seed or a template binding.
+
+- a034b2d: Lift buried async sub-expressions in `state` / `state.linked` / `state.computed` seeds
+
+    A script seed whose argument buries a promise/stream call — `state.linked(getSession()?.filteredSources ?? [])` — now lifts that call to an injected streaming peek-cell, exactly as a `{#if getSession()?.x}` template position already does. It reads `undefined` while pending (composing with `?.`/`??`) instead of type-erroring on `Promise.filteredSources`, and reseeds when the source resolves. A bare whole-seed call/identifier (`state.computed(getRates())`, `chat.done()`) is unchanged — only a compound seed that buries an async call is lifted. This closes the gap where the script side was less forgiving than the template side.
+
 ## 0.55.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.55.0",
+    "version": "0.56.0",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",

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

@@ -4,7 +4,11 @@ import { attrLiftPosition } from './attrLiftPosition.ts'
 import { hasTopLevelAwait } from './hasTopLevelAwait.ts'
 import { isFunctionScopeBoundary } from './isFunctionScopeBoundary.ts'
 import { isWhitespaceText } from './isWhitespaceText.ts'
-import { type LiftPosition, liftAsyncSubExpressions } from './liftAsyncSubExpressions.ts'
+import {
+    type LiftPosition,
+    type LiftSpan,
+    liftAsyncSubExpressions,
+} from './liftAsyncSubExpressions.ts'
 import { parseTemplate } from './parseTemplate.ts'
 import {
     NESTED_REACTIVE_BINDINGS,
@@ -94,7 +98,7 @@ export function compileShadow(
         importedReactives,
         propsLocalName,
         watchLocalName,
-    } = analyzeScript(scriptBody, scriptStart)
+    } = analyzeScript(scriptBody, scriptStart, classify)
     builder.raw(shadowPreamble(importedReactives))
     /* Every `computed`/`linked` scope line reads through this: it invokes the seed thunk and
        unwraps a promise/stream to the value a BARE cell read peeks (ADR-0019/0032) — so an async
@@ -492,7 +496,11 @@ function collectNestedScriptAwaitDiagnostics(
    module-scope type declarations, the value-typed scope lines, and the `props<Shape>()`
    prop shapes. `scriptStart` is the body's absolute offset in the source, so verbatim
    spans map back exactly. */
-function analyzeScript(scriptBody: string, scriptStart: number): ScriptAnalysis {
+function analyzeScript(
+    scriptBody: string,
+    scriptStart: number,
+    classify?: InterpolationClassifier,
+): ScriptAnalysis {
     const imports: ScopeLine[] = []
     const types: ScopeLine[] = []
     const scope: ScopeLine[] = []
@@ -564,7 +572,7 @@ function analyzeScript(scriptBody: string, scriptStart: number): ScriptAnalysis
             continue
         }
         for (const declaration of reactive) {
-            scope.push(scopeLineFor(declaration, propsShapes, verbatim, span, bindings))
+            scope.push(scopeLineFor(declaration, propsShapes, verbatim, span, bindings, classify))
         }
     }
     return {
@@ -623,12 +631,85 @@ function reactiveDeclarations(
 
 /* Builds one scope line for a reactive declaration, projecting it to its value
    type. A `props()` destructure contributes its whole shape (pushed into `propsShapes`). */
+/* Splits a SEED's source text so each buried async sub-expression is wrapped in its shadow peek
+   helper (`$$peek`/`$$peekStream`) — the script-seed twin of the builder's `emitPeeked` (ADR-0032),
+   but returning a mapped `{ text, segments }` for a scope line rather than driving the builder. So a
+   bare `state.linked(getSession()?.x ?? [])` shadow-types via `$$peek(getSession())?.x ?? []` (the
+   RESOLVED value, `?.`/`??` compose) instead of erroring on `Promise.x` — mirroring exactly what the
+   `desugarSignals` lift builds. Fail-open: no classifier, a thunk seed (the walk stops at function
+   boundaries — matching the build, which also leaves a `() => …` seed unlifted), or an unparseable
+   span → the seed emits verbatim as one span. Every original char keeps its true source offset; the
+   inserted wrapper chars are unmapped, so diagnostics land precisely. */
+function peekWrappedSeed(
+    seedText: string,
+    sourceStart: number,
+    prefixLength: number,
+    classify: InterpolationClassifier | undefined,
+): { text: string; segments: ShadowMapping[] } {
+    const verbatimResult = {
+        text: seedText,
+        segments: [{ shadowStart: prefixLength, sourceStart, length: seedText.length }],
+    }
+    if (classify === undefined) {
+        return verbatimResult
+    }
+    let spans: LiftSpan[]
+    try {
+        let counter = 0
+        spans = liftAsyncSubExpressions(
+            seedText,
+            sourceStart,
+            classify,
+            () => `__v${counter++}`,
+            'content',
+        ).spans.filter((span) => !span.blocking)
+    } catch {
+        return verbatimResult
+    }
+    if (spans.length === 0) {
+        return verbatimResult
+    }
+    /* A single span covering the WHOLE seed is the whole-seed case (`computed(getRates())`): the
+       `$$cellValue`/`$$cellValuePending` wrapper the caller already applies unwraps it, so peek-
+       wrapping it here would double-unwrap (`T` → `T | undefined`). Skip it — only PROPER sub-
+       expressions wrap, matching `liftScriptSeed`'s identical whole-seed skip on the build side. */
+    const only = spans.length === 1 ? spans[0] : undefined
+    if (only !== undefined && seedText.slice(only.start, only.end).trim() === seedText.trim()) {
+        return verbatimResult
+    }
+    let text = ''
+    const segments: ShadowMapping[] = []
+    const pushMapped = (chunk: string, chunkSource: number): void => {
+        segments.push({
+            shadowStart: prefixLength + text.length,
+            sourceStart: chunkSource,
+            length: chunk.length,
+        })
+        text += chunk
+    }
+    let cursor = 0
+    for (const span of spans) {
+        if (span.start > cursor) {
+            pushMapped(seedText.slice(cursor, span.start), sourceStart + cursor)
+        }
+        text += span.kind === 'asyncIterable' ? '$$peekStream(' : '$$peek('
+        pushMapped(seedText.slice(span.start, span.end), sourceStart + span.start)
+        text += ')'
+        cursor = span.end
+    }
+    if (cursor < seedText.length) {
+        pushMapped(seedText.slice(cursor), sourceStart + cursor)
+    }
+    return { text, segments }
+}
+
 function scopeLineFor(
     declaration: ts.VariableDeclaration,
     propsShapes: string[],
     verbatim: (node: ts.Node) => string,
     span: (node: ts.Node, prefixLength: number) => ShadowMapping,
     bindings: ReactiveImportBindings,
+    classify?: InterpolationClassifier,
 ): ScopeLine {
     const name = ts.isIdentifier(declaration.name) ? declaration.name.text : '_'
     const call = declaration.initializer as ts.CallExpression
@@ -689,9 +770,12 @@ function scopeLineFor(
             })
         }
         const prefix = `let ${name}${annotation} = (`
+        /* Peek-wrap a buried async sub-expression in the initial too (the `desugarSignals` lift
+           runs on `state` seeds), so `state(getSession()?.x ?? [])` type-checks. */
+        const seed = seedPeekWrap(init, verbatim, span, prefix.length, classify)
         return withCalleeRef({
-            text: `${prefix}${verbatim(init)});`,
-            segments: [span(declaration.name, 4), span(init, prefix.length)],
+            text: `${prefix}${seed.text});`,
+            segments: [span(declaration.name, 4), ...seed.segments],
         })
     }
     /* computed<T>(compute) / linked<T>(seed) — the only callees left: T is the value
@@ -730,12 +814,33 @@ function scopeLineFor(
        pre-existing type-directed case, unchanged here.) */
     const helper = seedIsAsync(fn) && !seedIsBlocking(fn) ? '$$cellValuePending' : '$$cellValue'
     const prefix = `${keyword} ${name}${annotation} = ${helper}(${wrapPrefix}`
+    /* Peek-wrap any buried async sub-expression in the seed (ADR-0032, script side) so a bare
+       `getSession()?.x ?? []` types as its resolved value — matching the `desugarSignals` lift.
+       A whole-seed async call / a thunk seed yields no wrap (verbatim), exactly as the build. */
+    const seed = seedPeekWrap(fn, verbatim, span, prefix.length, classify)
     return withCalleeRef({
-        text: `${prefix}${verbatim(fn)}${wrapSuffix});`,
-        segments: [span(declaration.name, keywordOffset), span(fn, prefix.length)],
+        text: `${prefix}${seed.text}${wrapSuffix});`,
+        segments: [span(declaration.name, keywordOffset), ...seed.segments],
     })
 }
 
+/* The seed peek-wrap as a scope line contributes it: a bare CALL or IDENTIFIER seed (the whole-seed
+   / probe case — `getRates()`, `chat.done()`) stays verbatim so the `$$cellValue` wrapper unwraps it
+   and no probe receiver is lifted, mirroring `desugarSignals`'s bare-seed skip; every other seed
+   descends into `peekWrappedSeed`. */
+function seedPeekWrap(
+    seed: ts.Expression,
+    verbatim: (node: ts.Node) => string,
+    span: (node: ts.Node, prefixLength: number) => ShadowMapping,
+    prefixLength: number,
+    classify: InterpolationClassifier | undefined,
+): { text: string; segments: ShadowMapping[] } {
+    if (ts.isCallExpression(seed) || ts.isIdentifier(seed)) {
+        return { text: verbatim(seed), segments: [span(seed, prefixLength)] }
+    }
+    return peekWrappedSeed(verbatim(seed), span(seed, 0).sourceStart, prefixLength, classify)
+}
+
 /* True for a `computed`/`linked` seed that `wrapSeed` (desugarSignals) turns into an ASYNC thunk —
    a thunk the author wrote `async`, or a bare seed carrying a top-level `await` (`computed(await
    x)`). The shadow must agree so it unwraps the promise to the resolved value AND so the top-level

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

@@ -1,8 +1,11 @@
 import ts from 'typescript'
 import { assignmentTargetNames } from './assignmentTargetNames.ts'
 import { hasTopLevelAwait } from './hasTopLevelAwait.ts'
+import { liftScriptSeed, type ScriptSeedLift } from './liftScriptSeed.ts'
+import type { InjectedCell } from './lowerAsyncInterpolations.ts'
 import { type ReactiveImportBindings, reactiveImportBindings } from './resolveReactiveExport.ts'
 import { signalCallee } from './signalCallee.ts'
+import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
 import type { InterpolationKind } from './types/InterpolationKind.ts'
 import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
 import { wrapSeed } from './wrapSeed.ts'
@@ -279,6 +282,77 @@ export function desugarSignals(
         }
         return seedKind(argument) === 'promise'
     }
+    /* ADR-0032 (script side): a `state`/`linked`/`computed` seed whose ARGUMENT buries a
+       promise/stream sub-expression (`getSession()?.filteredSources ?? []`) — not the whole seed
+       — gets that sub-expression lifted to an injected streaming peek-cell, exactly as a template
+       interpolation does, so it reads `undefined` while pending and composes with `?.`/`??`. The
+       lift runs on the seed's checker type via the SAME classifier the whole-seed routing uses,
+       bridged to the interpolation shape (its `undefined` failure sentinel folds to `sync`, safe
+       because the walk only branches on `promise`/`asyncIterable`). Cached per declaration so the
+       shared `__vs` mint stays consistent between the name-collection pass and the transform. */
+    const liftClassify: InterpolationClassifier | undefined =
+        seedClassify === undefined ? undefined : (loc, code) => seedClassify(loc, code) ?? 'sync'
+    let scriptSeedCounter = 0
+    const mintScriptSeed = (): string => `__vs${scriptSeedCounter++}`
+    const seedLifts = new Map<ts.VariableDeclaration, ScriptSeedLift | undefined>()
+    const seedLiftFor = (declaration: ts.VariableDeclaration): ScriptSeedLift | undefined => {
+        if (seedLifts.has(declaration)) {
+            return seedLifts.get(declaration)
+        }
+        const lift = computeSeedLift(declaration)
+        seedLifts.set(declaration, lift)
+        return lift
+    }
+    /* Applies the per-callee gate then runs the lift. A seed the WHOLE-seed classification already
+       claims — an author `await` (blocking), a bare promise/stream call — is left untouched so the
+       existing routing (or the runtime probe) owns it and nothing double-wraps; only a buried
+       sub-expression in an otherwise-sync seed lifts. */
+    function computeSeedLift(declaration: ts.VariableDeclaration): ScriptSeedLift | undefined {
+        if (liftClassify === undefined) {
+            return undefined
+        }
+        /* Only a single-declaration statement lifts: the injected peek-cells are emitted before the
+           owning statement, which can't split a `let a = …, b = …` list cleanly — and a
+           `rejectMixedDeclaration`-legal same-kind multi-declaration seed-lift is vanishingly rare.
+           Leaving it unlifted degrades to the pre-lift behavior (no injected orphan cell). */
+        const list = declaration.parent
+        if (!ts.isVariableDeclarationList(list) || list.declarations.length !== 1) {
+            return undefined
+        }
+        const callee = signalCallee(declaration, bindings)
+        if (callee === 'computed') {
+            if (
+                !isComputedSlot(declaration, bindings) ||
+                isAsyncComputed(declaration) ||
+                isEagerStreamComputed(declaration) ||
+                isPromiseComputed(declaration)
+            ) {
+                return undefined
+            }
+        } else if (callee === 'linked' || callee === 'state') {
+            const argument = seedArgument(declaration)
+            if (argument === undefined || isAsyncSeed(wrapSeed(argument))) {
+                return undefined
+            }
+        } else {
+            return undefined
+        }
+        const argument = seedArgument(declaration)
+        if (argument === undefined) {
+            return undefined
+        }
+        /* A bare CALL or IDENTIFIER seed is the whole-seed case (`computed(getRates())`,
+           `linked(chat.done())`, `state.computed(getRates.refreshing({...}))`) — the existing
+           whole-seed routing / runtime probe owns it, and descending into it would lift a probe
+           RECEIVER (`chat` out of `chat.done()`), breaking the call. Only a COMPOUND seed — a
+           member/binary/etc. that BURIES an async call — lifts. Mirrors `isBareCallComputed`. */
+        if (ts.isCallExpression(argument) || ts.isIdentifier(argument)) {
+            return undefined
+        }
+        const start = argument.getStart(source)
+        const seedText = source.text.slice(start, argument.getEnd())
+        return liftScriptSeed(seedText, scriptBase + start, liftClassify, mintScriptSeed)
+    }
     for (const statement of source.statements) {
         if (!ts.isVariableStatement(statement)) {
             continue
@@ -317,6 +391,16 @@ export function desugarSignals(
                 cellReadNames.add(declaration.name.text)
                 continue
             }
+            /* Register any injected `__vsN` peek-cell a buried async seed sub-expression lifts, so
+               the reference-lowering emits `$$readCell(__vsN)` for its reads. The owning
+               declaration keeps its own bucket (a lifted computed's seed is now SYNC — a lazy
+               `derive` — while a lifted `linked`/`state` stays its usual cell). */
+            const seedLift = seedLiftFor(declaration)
+            if (seedLift !== undefined) {
+                for (const cell of seedLift.cells) {
+                    cellReadNames.add(cell.name)
+                }
+            }
             if (isPlainStateSlot(declaration, bindings)) {
                 /* Plain `state(initial)` → a serializable `model` doc slot. */
                 stateNames.add(declaration.name.text)
@@ -394,6 +478,7 @@ export function desugarSignals(
                     writtenNames,
                     isEagerStreamComputed,
                     isPromiseComputed,
+                    seedLiftFor,
                 ),
             )
         }
@@ -422,9 +507,11 @@ function loweredStatement(
     writtenNames: ReadonlySet<string>,
     isEagerStreamComputed: EagerStreamPredicate,
     isPromiseComputed: EagerStreamPredicate,
+    seedLiftFor: (declaration: ts.VariableDeclaration) => ScriptSeedLift | undefined,
 ): ts.Statement[] {
     rejectMixedDeclaration(statement, bindings)
     return (
+        liftedSeedStatements(statement, bindings, seedLiftFor) ??
         injectedComputedStatements(statement, injectedCellNames, blockingCellNames) ??
         stateAssignmentStatements(statement, bindings) ??
         computedStatements(
@@ -439,6 +526,106 @@ function loweredStatement(
     )
 }
 
+/* Parses a lifted seed fragment (`getSession()` / `__vs0?.filteredSources ?? []`) back into an
+   expression node. Wrapped in parens so an object-literal or comma seed parses as an expression;
+   the node is synthetic (mini-parse positions), safe because every downstream pass — reference
+   renaming, doc-access lowering — is position-independent. */
+function parseSeedExpression(code: string): ts.Expression {
+    const file = ts.createSourceFile('__seed.ts', `(${code})`, ts.ScriptTarget.Latest, true)
+    const statement = file.statements[0]
+    if (statement !== undefined && ts.isExpressionStatement(statement)) {
+        const expression = statement.expression
+        return ts.isParenthesizedExpression(expression) ? expression.expression : expression
+    }
+    throw new Error(`abide: could not parse lifted seed expression: ${code}`)
+}
+
+/* `() => (<expr>)` — the bare thunk an injected STREAM peek-cell wraps its source in (byte-mirrors
+   an explicit `state.computed(getStream())`). */
+function bareThunk(expression: ts.Expression): ts.Expression {
+    return factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        factory.createParenthesizedExpression(expression),
+    )
+}
+
+/* The injected `const __vsN = scope().trackedComputed(...)` cell for one lifted sub-expression —
+   the script-side twin of `injectedComputedStatements`: a PROMISE sub-expression becomes an async
+   unwrapping thunk carrying the streaming flag (`!blocking`), a STREAM stays a bare probe thunk. */
+function injectedSeedCell(cell: InjectedCell): ts.Statement {
+    const source = parseSeedExpression(cell.code)
+    const args =
+        cell.kind === 'promise'
+            ? [wrapAwaitSeed(source), cell.blocking ? factory.createFalse() : factory.createTrue()]
+            : [bareThunk(source)]
+    return constDeclaration(cell.name, scopeMethodCall('trackedComputed', args))
+}
+
+/* If any declaration in `statement` carries a script-seed lift (ADR-0032), lowers the whole
+   statement HERE: each lifted declaration emits its injected `__vsN` peek-cells FIRST (declared
+   before the owning statement — the seed runs eagerly at construction, so an appended cell would
+   be a TDZ reference), then the owning declaration lowered over its now-SYNC rewritten seed (a
+   lifted `computed` is a lazy `derive`; a `linked`/`state` keeps its cell). A non-lifted sibling
+   in the same (same-kind) statement re-enters the normal lowering as its own single declaration.
+   Returns undefined when no declaration lifts, so the standard dispatch runs. */
+function liftedSeedStatements(
+    statement: ts.Statement,
+    bindings: ReactiveImportBindings,
+    seedLiftFor: (declaration: ts.VariableDeclaration) => ScriptSeedLift | undefined,
+): ts.Statement[] | undefined {
+    if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1) {
+        return undefined
+    }
+    const declaration = statement.declarationList.declarations[0]!
+    const lift = seedLiftFor(declaration)
+    if (lift === undefined || !ts.isIdentifier(declaration.name)) {
+        return undefined
+    }
+    const output: ts.Statement[] = []
+    {
+        for (const cell of lift.cells) {
+            output.push(injectedSeedCell(cell))
+        }
+        const name = declaration.name.text
+        const seed = parseSeedExpression(lift.rewrittenSeedText)
+        const callee = signalCallee(declaration, bindings)
+        const rest = (declaration.initializer as ts.CallExpression).arguments.slice(1)
+        if (callee === 'computed') {
+            /* The rewritten seed is SYNC (it reads the peek-cells), so the computed is a lazy
+               `derive` doc slot read as `name()` — recomputes when a peek-cell reseeds. */
+            output.push(
+                constDeclaration(
+                    name,
+                    scopeMethodCall('derive', [factory.createStringLiteral(name), wrapSeed(seed)]),
+                ),
+            )
+        } else if (callee === 'linked') {
+            output.push(
+                constDeclaration(name, scopeMethodCall('linked', [wrapSeed(seed), ...rest])),
+            )
+        } else if (isPlainStateSlot(declaration, bindings)) {
+            output.push(
+                factory.createExpressionStatement(
+                    factory.createAssignment(
+                        factory.createPropertyAccessExpression(
+                            factory.createIdentifier('$$model'),
+                            name,
+                        ),
+                        seed,
+                    ),
+                ),
+            )
+        } else {
+            output.push(constDeclaration(name, scopeMethodCall('state', [seed, ...rest])))
+        }
+    }
+    return output
+}
+
 /* Lowers a synthetic `const __vN = computed(<seed>)` (an async (sub)expression peek-cell
    `analyzeComponent` injected, ADR-0032) to a `scope().trackedComputed(...)` cell read via
    `$$readCell`. Two shapes, by the seed:

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

@@ -0,0 +1,47 @@
+import { liftAsyncSubExpressions } from './liftAsyncSubExpressions.ts'
+import type { InjectedCell } from './lowerAsyncInterpolations.ts'
+import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
+
+/* The pieces a script-seed lift yields: the async sub-expressions hoisted out of a
+   `state`/`linked`/`computed` seed argument (each an injected peek-cell) plus the seed
+   rewritten to reference them by bare `__vsN`. `desugarSignals` turns `cells` into
+   `scope().trackedComputed(...)` consts emitted BEFORE the owning declaration and parses
+   `rewrittenSeedText` back into the lowered seed. */
+export type ScriptSeedLift = { cells: InjectedCell[]; rewrittenSeedText: string }
+
+/*
+The script-side twin of the template `lowerAsyncInterpolations` walk (ADR-0032): runs
+`liftAsyncSubExpressions` over a `state`/`state.linked`/`state.computed` seed ARGUMENT so a
+buried promise/stream sub-expression (`getSession()?.filteredSources ?? []`) lifts to an
+injected streaming peek-cell — reading `undefined` while pending so `?.`/`??` compose — exactly
+as it would in a `{#if getSession()?.x}` template position. Only PROPER sub-expressions lift: a
+seed that IS a single async expression (`computed(getSession())`, `linked(getStream())`) is left
+whole for the existing whole-seed classification / runtime probe, so this never double-wraps.
+
+`classify` absent (no warm program) ⇒ no lift — a buried bare-async sub-expression needs the
+checker to know it is a promise, and a seed carrying a top-level `await` is already routed by the
+caller's whole-seed classification, so fail-open here is a plain no-op. `seedLoc` is the seed's
+absolute source offset, so each lifted span resolves against the shadow's source→shadow mappings.
+*/
+export function liftScriptSeed(
+    seedText: string,
+    seedLoc: number,
+    classify: InterpolationClassifier | undefined,
+    mint: () => string,
+): ScriptSeedLift | undefined {
+    if (classify === undefined) {
+        return undefined
+    }
+    const result = liftAsyncSubExpressions(seedText, seedLoc, classify, mint, 'content')
+    if (result.lifts.length === 0) {
+        return undefined
+    }
+    /* A single span covering the whole seed is the whole-seed case (`computed(getSession())`) —
+       leave it to the existing classification (`isPromiseComputed`) / the runtime probe rather
+       than pointlessly wrapping the seed in its own cell. Only proper sub-expressions lift. */
+    const only = result.spans.length === 1 ? result.spans[0] : undefined
+    if (only !== undefined && seedText.slice(only.start, only.end).trim() === seedText.trim()) {
+        return undefined
+    }
+    return { cells: result.lifts, rewrittenSeedText: result.code }
+}

package/src/lib/ui/linked.ts

@@ -5,6 +5,7 @@ import { createAsyncCell } from './runtime/createAsyncCell.ts'
 import { createEffectNode } from './runtime/createEffectNode.ts'
 import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
 import { routeBareSeed } from './runtime/routeBareSeed.ts'
+import { SuspenseSignal } from './runtime/SuspenseSignal.ts'
 import type { State } from './runtime/types/State.ts'
 import { state } from './state.ts'
 
@@ -67,10 +68,26 @@ export function linked<T>(
        non-stream value falls through to the plain synchronous cell. */
     let probe: unknown
     let threw = false
+    let suspended = false
     try {
         probe = seed()
-    } catch {
+    } catch (error) {
         threw = true
+        suspended = error instanceof SuspenseSignal
+    }
+    /* The seed SUSPENDED — it read a pending BLOCKING cell (`await`-marked). A sync `state`
+       here would hold `undefined` while the reseed effect re-threw the suspend, letting it
+       escape at construction. Route to the eager async cell instead: `createAsyncCell` already
+       treats a synchronously-suspending seed as "pending" — it stays in flight, the throwing
+       read subscribed its effect to the blocking dependency, and it re-runs on settle — and it
+       marks the cell BLOCKING so its own reads pause too, matching a lazy `computed(() =>
+       blockingCell)`. This makes a blocking read behave the same in a `linked` seed as in a
+       `computed` seed or a template. A real (non-suspense) throw keeps the sync fall-through. */
+    if (suspended) {
+        return createAsyncCell(seed as () => unknown, {
+            writable: true,
+            transform: coerce,
+        }) as AsyncState<T>
     }
     if (!threw && isAsyncIterable(probe)) {
         return createAsyncCell(seed as () => unknown, {

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

@@ -210,6 +210,16 @@ export function createAsyncCell(
                promise is registered (there is none), so the SSR barrier's fixpoint drain
                picks this cell up on that re-run instead. */
             if (error instanceof SuspenseSignal) {
+                /* This cell's pending reads must PAUSE too — the seed derives from a blocking
+                   source, so a reader peeking `undefined` (the streaming default) would race the
+                   dependency instead of waiting for it. Mark blocking from the SUSPEND itself,
+                   since a synchronously-suspending seed produces no promise for the `isThenable`
+                   branch to read it from; honour a `streaming` opt-out for symmetry with that
+                   branch. Once the seed re-runs and settles a value this flag is moot (a retained
+                   value is returned before `blocking` is ever consulted). */
+                if (options.streaming !== true) {
+                    blockingSource = true
+                }
                 if (myRun === runId) {
                     inFlight = undefined
                     writeNode(errorNode, undefined)