@abide/abide 0.54.0 → 0.56.0

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

@@ -1,3 +1,4 @@
+import { messageFromError } from '../../shared/messageFromError.ts'
 import { createShadowProgram, type ShadowProgram } from './createShadowProgram.ts'
 
 /*
@@ -26,7 +27,7 @@ export function cachedShadowProgram(
             cache.set(root, build(root))
         } catch (error) {
             cache.set(root, undefined)
-            const detail = error instanceof Error ? error.message : String(error)
+            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' +

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

@@ -29,15 +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',
@@ -46,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/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/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

@@ -1,10 +1,14 @@
 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'
 
 /* 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,28 +18,6 @@ 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
-    return factory.createArrowFunction(
-        modifiers,
-        undefined,
-        [],
-        undefined,
-        factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-        argument,
-    )
-}
-
 /* 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
@@ -231,10 +213,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
@@ -253,10 +231,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
@@ -308,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
@@ -346,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)
@@ -359,27 +414,21 @@ export function desugarSignals(
                     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; a bare
-                       promise (isPromiseComputed) carries no `await` → streaming, so isBlockingSeed
-                       is false and it never joins this set. */
-                    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. */
@@ -429,6 +478,7 @@ export function desugarSignals(
                     writtenNames,
                     isEagerStreamComputed,
                     isPromiseComputed,
+                    seedLiftFor,
                 ),
             )
         }
@@ -441,7 +491,6 @@ export function desugarSignals(
         derivedNames,
         computedNames,
         cellReadNames,
-        blockingCellNames: new Set([...blockingCellNames, ...scriptBlockingNames]),
     }
 }
 
@@ -458,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(
@@ -475,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: