@abide/abide 0.53.0 → 0.55.0

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

@@ -1,6 +1,7 @@
 import ts from 'typescript'
 import { escapeKey } from '../runtime/escapeKey.ts'
-import { COMPOUND_ASSIGNMENT_OPERATORS } from './COMPOUND_ASSIGNMENT_OPERATORS.ts'
+import { lowerCompoundAssignment } from './lowerCompoundAssignment.ts'
+import { lowerUpdateExpression } from './lowerUpdateExpression.ts'
 
 /*
 The linchpin compiler pass. Rewrites idiomatic data access on a reactive document
@@ -91,33 +92,24 @@ export function docAccessTransformer(docName: string): ts.TransformerFactory<ts.
         }
 
         function visit(node: ts.Node): ts.Node {
-            /* Assignment (plain or compound) to a doc path → replace patch. */
+            /* Assignment (plain, compound, or logical) to a doc path → replace patch. */
             if (ts.isBinaryExpression(node)) {
                 const segments = pathSegments(node.left as ts.Expression)
                 if (segments) {
-                    const operator = node.operatorToken.kind
-                    if (operator === ts.SyntaxKind.EqualsToken) {
-                        return docCall(docName, 'replace', [
-                            buildPath(segments),
-                            ts.visitNode(node.right, visit) as ts.Expression,
-                        ])
-                    }
-                    const binary = COMPOUND_ASSIGNMENT_OPERATORS.get(operator)
-                    if (binary) {
-                        const next = ts.factory.createBinaryExpression(
-                            docCall(docName, 'read', [buildPath(segments)]),
-                            binary,
-                            ts.visitNode(node.right, visit) as ts.Expression,
-                        )
-                        return docCall(docName, 'replace', [buildPath(segments), next])
+                    const lowered = lowerCompoundAssignment(
+                        node.operatorToken.kind,
+                        () => docCall(docName, 'read', [buildPath(segments)]),
+                        ts.visitNode(node.right, visit) as ts.Expression,
+                        (value) => docCall(docName, 'replace', [buildPath(segments), value]),
+                    )
+                    if (lowered !== undefined) {
+                        return lowered
                     }
                 }
             }
-            /* `path++` / `++path` / `path--` on a doc path → a replace patch (the same
-               shape as `+= 1`). A bare `++` would otherwise survive onto the lowered read
-               (`model.read("n")++` / `cell.get()++`) — invalid, since a call result is not
-               an lvalue. abide handlers are statements, so the postfix/prefix value is
-               discarded and both lower identically. Only `++`/`--` are handled here; other
+            /* `path++` / `++path` / `path--` on a doc path → a replace patch. A bare `++`
+               would otherwise survive onto the lowered read (`model.read("n")++`) — invalid,
+               since a call result is not an lvalue. Only `++`/`--` are handled here; other
                unary operators (`!path`, `-path`) fall through so their operand lowers as a
                normal read. */
             if (
@@ -127,16 +119,12 @@ export function docAccessTransformer(docName: string): ts.TransformerFactory<ts.
             ) {
                 const segments = pathSegments(node.operand)
                 if (segments) {
-                    const step =
-                        node.operator === ts.SyntaxKind.PlusPlusToken
-                            ? ts.SyntaxKind.PlusToken
-                            : ts.SyntaxKind.MinusToken
-                    const next = ts.factory.createBinaryExpression(
-                        docCall(docName, 'read', [buildPath(segments)]),
-                        step,
-                        ts.factory.createNumericLiteral(1),
+                    return lowerUpdateExpression(
+                        ts.isPostfixUnaryExpression(node),
+                        node.operator === ts.SyntaxKind.PlusPlusToken,
+                        () => docCall(docName, 'read', [buildPath(segments)]),
+                        (value) => docCall(docName, 'replace', [buildPath(segments), value]),
                     )
-                    return docCall(docName, 'replace', [buildPath(segments), next])
                 }
             }
             /* doc array `.push(a, b, …)` → one `add` patch per argument at the array's `-`

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

@@ -91,19 +91,10 @@ export function lowerScript(
     derivedNames: Set<string>
     computedNames: Set<string>
     cellReadNames: Set<string>
-    /* Template-injected + script-level `await` cells (ADR-0042), read via `$$readCellBlocking`. */
-    blockingCellNames: Set<string>
     droppedReactiveImports: Set<string>
 } {
     const source = ts.createSourceFile('component.ts', scriptBody, ts.ScriptTarget.Latest, true)
-    const {
-        transformer,
-        stateNames,
-        derivedNames,
-        computedNames,
-        cellReadNames,
-        blockingCellNames: allBlockingNames,
-    } = desugarSignals(
+    const { transformer, stateNames, derivedNames, computedNames, cellReadNames } = desugarSignals(
         source,
         injectedCellNames,
         blockingCellNames,
@@ -194,7 +185,6 @@ export function lowerScript(
         derivedNames,
         computedNames,
         cellReadNames,
-        blockingCellNames: allBlockingNames,
         droppedReactiveImports,
     }
 }

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

@@ -0,0 +1,32 @@
+import ts from 'typescript'
+
+/*
+Lowers `x++` / `++x` / `x--` / `--x` on reactive state to a write of the stepped value,
+shared by the `$$model` doc path (lowerDocAccess) and the `$$writeCell` linked-cell path
+(renameSignalRefs). `makeRead`/`makeWrite` mirror `lowerCompoundAssignment`. The bare `++`
+can't survive onto the read form (`$$readCell(x)` / `$$model.read(...)` are calls, not
+lvalues), so it becomes an explicit write of `read ± 1`.
+
+Prefix evaluates to the NEW value, which is exactly what the write returns, so
+`write(read ± 1)` is correct as-is. POSTFIX must evaluate to the PREVIOUS value, so its
+result is corrected back by the opposite step (`x++` → `write(read + 1) - 1`) — no temp or
+closure, since the write returns the written value (`Cell.set` / `Doc.replace`). The
+correction is dead when the value is discarded (a statement `x++;`), so it costs nothing
+there.
+*/
+export function lowerUpdateExpression(
+    isPostfix: boolean,
+    isIncrement: boolean,
+    makeRead: () => ts.Expression,
+    makeWrite: (value: ts.Expression) => ts.Expression,
+): ts.Expression {
+    const step = isIncrement ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken
+    const write = makeWrite(
+        ts.factory.createBinaryExpression(makeRead(), step, ts.factory.createNumericLiteral(1)),
+    )
+    if (!isPostfix) {
+        return write
+    }
+    const correction = isIncrement ? ts.SyntaxKind.MinusToken : ts.SyntaxKind.PlusToken
+    return ts.factory.createBinaryExpression(write, correction, ts.factory.createNumericLiteral(1))
+}

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

@@ -1,5 +1,6 @@
 import ts from 'typescript'
-import { COMPOUND_ASSIGNMENT_OPERATORS } from './COMPOUND_ASSIGNMENT_OPERATORS.ts'
+import { lowerCompoundAssignment } from './lowerCompoundAssignment.ts'
+import { lowerUpdateExpression } from './lowerUpdateExpression.ts'
 
 /*
 Rewrites references to a component's signal bindings into the document form the
@@ -53,12 +54,10 @@ export function signalRefsTransformer(
     blockLocalPlain: ReadonlySet<string> = new Set(),
     /* Component signals read through `$$readCell(name)` — every `linked` and every async
        `computed` (see `desugarSignals`). A nearer lexical binding of the same name shadows
-       them like any other signal. */
+       them like any other signal. Whether a read PAUSES (blocking `await` cell) or peeks
+       (streaming) is decided at runtime by the cell itself (`readCell` consults `cell.blocking`),
+       so there is one read form here for every cell and nothing site-specific to thread. */
     cellReadNames: ReadonlySet<string> = new Set(),
-    /* The subset of `cellReadNames` that are BLOCKING `await` cells (ADR-0042), read through
-       `$$readCellBlocking(name)` (suspend-on-pending) instead of `$$readCell`. Non-empty only on
-       the CLIENT template lowering; the script pass and SSR keep it empty (`$$readCell`). */
-    blockingCellNames: ReadonlySet<string> = new Set(),
 ): ts.TransformerFactory<ts.SourceFile> {
     /* The signal names that a nested binding can shadow — only these matter for
        scope tracking, so we ignore every other local binding. */
@@ -120,21 +119,19 @@ export function signalRefsTransformer(
                     !shadowed.has(node.left.text)
                 ) {
                     const target = node.left.text
-                    const right = ts.visitNode(node.right, visit) as ts.Expression
-                    if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-                        return writeCellCall(target, right)
-                    }
-                    const binary = COMPOUND_ASSIGNMENT_OPERATORS.get(node.operatorToken.kind)
-                    if (binary !== undefined) {
-                        return writeCellCall(
-                            target,
-                            ts.factory.createBinaryExpression(cellReadCall(target), binary, right),
-                        )
+                    const lowered = lowerCompoundAssignment(
+                        node.operatorToken.kind,
+                        () => cellReadCall(target),
+                        ts.visitNode(node.right, visit) as ts.Expression,
+                        (value) => writeCellCall(target, value),
+                    )
+                    if (lowered !== undefined) {
+                        return lowered
                     }
                 }
                 /* `draft++` / `++draft` / `draft--` on a `linked` cell → a `$$writeCell` of the
-                   stepped value, mirroring the `+= 1` shape (the bare `++` would otherwise land
-                   on `$$readCell(draft)`, an invalid lvalue). */
+                   stepped value (the bare `++` would otherwise land on `$$readCell(draft)`, an
+                   invalid lvalue). */
                 if (
                     (ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
                     (node.operator === ts.SyntaxKind.PlusPlusToken ||
@@ -143,17 +140,12 @@ export function signalRefsTransformer(
                     cellReadNames.has(node.operand.text) &&
                     !shadowed.has(node.operand.text)
                 ) {
-                    const step =
-                        node.operator === ts.SyntaxKind.PlusPlusToken
-                            ? ts.SyntaxKind.PlusToken
-                            : ts.SyntaxKind.MinusToken
-                    return writeCellCall(
-                        node.operand.text,
-                        ts.factory.createBinaryExpression(
-                            cellReadCall(node.operand.text),
-                            step,
-                            ts.factory.createNumericLiteral(1),
-                        ),
+                    const target = node.operand.text
+                    return lowerUpdateExpression(
+                        ts.isPostfixUnaryExpression(node),
+                        node.operator === ts.SyntaxKind.PlusPlusToken,
+                        () => cellReadCall(target),
+                        (value) => writeCellCall(target, value),
                     )
                 }
                 /* Shorthand `{ count }` → `{ count: $$model.count }` / `{ total: total.value }`,
@@ -166,7 +158,6 @@ export function signalRefsTransformer(
                         computedNames,
                         blockLocal,
                         cellReadNames,
-                        blockingCellNames,
                     )
                     if (replacement !== undefined) {
                         return ts.factory.createPropertyAssignment(node.name.text, replacement)
@@ -180,7 +171,6 @@ export function signalRefsTransformer(
                         computedNames,
                         blockLocal,
                         cellReadNames,
-                        blockingCellNames,
                     )
                     if (replacement !== undefined) {
                         return replacement
@@ -399,7 +389,6 @@ function referenceFor(
     computedNames: ReadonlySet<string>,
     blockLocal: ReadonlySet<string> = new Set(),
     cellReadNames: ReadonlySet<string> = new Set(),
-    blockingCellNames: ReadonlySet<string> = new Set(),
 ): ts.Expression | undefined {
     if (blockLocal.has(name)) {
         return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), 'value')
@@ -409,19 +398,10 @@ function referenceFor(
     if (name === 'scope') {
         return ts.factory.createIdentifier('$$scope')
     }
-    /* A BLOCKING `await` cell → `$$readCellBlocking(name)` (ADR-0042): the throwing peek that
-       SUSPENDS the render region while pending, so an `await` binding reads as a resolved value
-       and its region withholds until it settles. Client template lowering only — `blockingCellNames`
-       is empty in the script pass and SSR, which keep the plain `$$readCell` peek below. */
-    if (blockingCellNames.has(name)) {
-        return ts.factory.createCallExpression(
-            ts.factory.createIdentifier('$$readCellBlocking'),
-            undefined,
-            [ts.factory.createIdentifier(name)],
-        )
-    }
-    /* A `linked` / async `computed` cell → `$$readCell(name)`: one read shape that peeks an
-       async cell and reads `.value` off a sync one. */
+    /* A `linked` / async `computed` cell → `$$readCell(name)`: ONE read shape for every cell,
+       script and template. It peeks a sync cell's `.value`, and for an async cell decides at
+       runtime whether to pause (blocking `await`) or peek `undefined` (streaming) by the cell's
+       own `blocking` bit — so no blocking/streaming distinction is threaded through codegen. */
     if (cellReadNames.has(name)) {
         return ts.factory.createCallExpression(
             ts.factory.createIdentifier('$$readCell'),

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

@@ -1,5 +1,6 @@
+import { cachedShadowProgram } from './cachedShadowProgram.ts'
 import { classifyInterpolationType } from './classifyInterpolationType.ts'
-import { createShadowProgram, type ShadowProgram } from './createShadowProgram.ts'
+import type { ShadowProgram } from './createShadowProgram.ts'
 import { nodeAtShadowOffset } from './nodeAtShadowOffset.ts'
 import { shadowNaming } from './shadowNaming.ts'
 import { sourceToShadowOffset } from './sourceToShadowOffset.ts'
@@ -18,25 +19,19 @@ as `state.computed` — either way the seed sub-expression maps back to source a
 own type), so the identical `sourceToShadowOffset → nodeAtShadowOffset → classifyInterpolation
 Type` pipeline the interpolation half uses resolves a seed with no node-finder variant.
 
-FAIL-OPEN, but NOT to `'sync'`: if the program can't build, the file has no shadow, the seed's
-location doesn't map, no node is found, or the checker throws, the classifier is absent /
-returns `undefined` — the signal the caller reads as "degrade to `isBareCallComputed`", NOT as
-"the seed is sync". Collapsing failure to `'sync'` (as the interpolation classifier does) would
-mis-route a failed stream seed to the lazy `derive` slot instead of today's syntax heuristic.
+FAIL-OPEN, but NOT to `'sync'`: if the program can't build (warned once per root by
+`cachedShadowProgram`), the file has no shadow, the seed's location doesn't map, no node is
+found, or the checker throws, the classifier is absent / returns `undefined` — the signal the
+caller reads as "degrade to `isBareCallComputed`", NOT as "the seed is sync". Collapsing failure
+to `'sync'` (as the interpolation classifier does) would mis-route a failed stream seed to the
+lazy `derive` slot instead of today's syntax heuristic.
 */
 export function seedTypeClassifierForRoot(
     cache: Map<string, ShadowProgram | undefined>,
     root: string,
     abidePath: string,
 ): SeedTypeClassifier | undefined {
-    if (!cache.has(root)) {
-        try {
-            cache.set(root, createShadowProgram(root))
-        } catch {
-            cache.set(root, undefined)
-        }
-    }
-    const shadowProgram = cache.get(root)
+    const shadowProgram = cachedShadowProgram(cache, root)
     if (shadowProgram === undefined) {
         return undefined
     }
@@ -46,9 +41,9 @@ export function seedTypeClassifierForRoot(
         return undefined
     }
     const checker = program.getTypeChecker()
+    const mappings = shadows.get(abidePath)?.mappings ?? []
     return (loc, code) => {
         try {
-            const mappings = shadows.get(abidePath)?.mappings ?? []
             const offset = sourceToShadowOffset(mappings, loc)
             if (offset === undefined) {
                 return undefined

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

@@ -28,9 +28,9 @@ export function shadowInterpolationClassifier(
         return undefined
     }
     const checker = program.getTypeChecker()
+    const mappings = shadows.get(abidePath)?.mappings ?? []
     return (loc, code) => {
         try {
-            const mappings = shadows.get(abidePath)?.mappings ?? []
             const offset = sourceToShadowOffset(mappings, loc)
             if (offset === undefined) {
                 return 'sync'

package/src/lib/ui/compile/types/AnalyzedComponent.ts

@@ -26,12 +26,10 @@ export type AnalyzedComponent = {
     computedNames: Set<string>
     /* Component signals read through `$$readCell(name)`: every `linked` and every async
        `computed`. Threaded to both back-ends so a template reference (`{draft}`) lowers to
-       the unified cell read consistently on client and server. */
+       the unified cell read consistently on client and server. Whether a pending read pauses
+       (blocking `await`) or peeks (streaming) is decided at runtime by the cell's own
+       `blocking` bit (ADR-0042), so no blocking subset is threaded through codegen. */
     cellReadNames: Set<string>
-    /* The subset of `cellReadNames` that are BLOCKING `await` cells (ADR-0042): a template-injected
-       `{await X}` cell or a script `computed(await …)`. The CLIENT back-end reads these via
-       `$$readCellBlocking` (suspend-on-pending) rather than `$$readCell`. */
-    blockingCellNames: Set<string>
     nodes: TemplateNode[]
     /* One entry per non-empty `<style>` in the template (in source order): the scope
        attribute its covered elements carry (annotated onto `nodes`) and the scoped

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

@@ -1,4 +1,5 @@
 import ts from 'typescript'
+import { AbideCompileError } from './AbideCompileError.ts'
 
 /*
 Folds a cell-source `watch(source, handler)` into the auto-tracked thunk form
@@ -51,7 +52,7 @@ export function wrapReactionCellSources(
        expression is read ONCE as a plain value (outside any tracking scope) and handed to the
        runtime as a dead value: nothing subscribes, the reaction never fires. It can't be folded
        like a bare cell (a member access isn't a whole-cell subscription), so return the base
-       name to warn on and leave the source for the author to rewrite. */
+       name to REJECT on and point the author at the corrective forms. */
     function cellMemberBase(source: ts.Expression): string | undefined {
         if (
             (ts.isPropertyAccessExpression(source) || ts.isElementAccessExpression(source)) &&
@@ -95,19 +96,22 @@ export function wrapReactionCellSources(
                 )
                 return ts.factory.createCallExpression(node.expression, undefined, [thunk])
             }
-            /* Warn on the inert member-expression form `watch(s.foo, handler)` — it looks valid but
-               subscribes to nothing (see `cellMemberBase`). Not foldable; the fix is the author's. */
+            /* Reject the inert member-expression form `watch(s.foo, handler)` — it looks valid but
+               subscribes to nothing (see `cellMemberBase`), so the handler silently never fires. Not
+               foldable; a compile error turns the silent no-op into a caught mistake. A member of a
+               cell is never itself a cell (no per-property cells), so this can't reject a valid watch. */
+            const memberBase = sourceArg !== undefined ? cellMemberBase(sourceArg) : undefined
             if (
                 ts.isCallExpression(node) &&
                 ts.isIdentifier(node.expression) &&
                 watchLocalNames.has(node.expression.text) &&
                 node.arguments.length === 2 &&
                 sourceArg !== undefined &&
-                cellMemberBase(sourceArg) !== undefined
+                memberBase !== undefined
             ) {
                 const sourceText = sourceArg.getText(root)
-                console.warn(
-                    `[abide] \`watch(${sourceText}, …)\` does not track \`${sourceText}\` — a member access on a cell is read once as a plain value (abide has no per-property cells), so the reaction is inert. Wrap it in a thunk (\`watch(() => …(${sourceText}))\`) or watch the whole cell (\`watch(${cellMemberBase(sourceArg)}, v => …)\`).`,
+                throw new AbideCompileError(
+                    `[abide] \`watch(${sourceText}, …)\` does not track \`${sourceText}\` — a member access on a cell is read once as a plain value (abide has no per-property cells), so the reaction never fires. Wrap it in a thunk (\`watch(() => …(${sourceText}))\`) or watch the whole cell (\`watch(${memberBase}, v => …)\`).`,
                 )
             }
             return ts.visitEachChild(node, visit, context)

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

@@ -0,0 +1,44 @@
+import ts from 'typescript'
+import { NESTED_REACTIVE_BINDINGS, resolveReactiveExport } from './resolveReactiveExport.ts'
+import { wrapSeed } from './wrapSeed.ts'
+
+/*
+Normalises every `state.computed(seed)` / `state.linked(seed)` in a nested branch
+`<script>` so a BARE-VALUE seed becomes a thunk (`state.computed(a * 2)` →
+`state.computed(() => a * 2)`), exactly as the top-level desugar (`desugarSignals` via
+`wrapSeed`) does. A nested script keeps its reactive calls literal — it is not desugared to
+the doc — so absent this the bare value reaches the runtime primitive, which stores it as
+the compute function and calls it on read (`a * 2 is not a function`, a runtime crash). A
+literal `() => …` / `function` thunk passes through unchanged, so the wrap is a no-op on the
+already-thunked form the author usually writes.
+
+Recognition is name-based (`NESTED_REACTIVE_BINDINGS`) because a nested script carries no
+import of its own — it inherits the surface by the canonical `state` name, the same way
+`nestedBindingNames` resolves it. Only the seed argument (`arguments[0]`) is wrapped; a
+`state.linked(seed, ...)`'s trailing args pass through. Exposed as a `ts.TransformerFactory`
+so the nested-script lowering can chain it ahead of the reference rename over ONE parsed tree.
+*/
+export function wrapReactiveSeedsTransformer(): ts.TransformerFactory<ts.SourceFile> {
+    return (context) => (root) => {
+        const visit = (node: ts.Node): ts.Node => {
+            if (ts.isCallExpression(node) && node.arguments.length > 0) {
+                const primitive = resolveReactiveExport(node.expression, NESTED_REACTIVE_BINDINGS)
+                if (primitive === 'computed' || primitive === 'linked') {
+                    const seed = node.arguments[0] as ts.Expression
+                    const wrapped = wrapSeed(ts.visitNode(seed, visit) as ts.Expression)
+                    const rest = node.arguments
+                        .slice(1)
+                        .map((argument) => ts.visitNode(argument, visit) as ts.Expression)
+                    return ts.factory.updateCallExpression(
+                        node,
+                        node.expression,
+                        node.typeArguments,
+                        [wrapped, ...rest],
+                    )
+                }
+            }
+            return ts.visitEachChild(node, visit, context)
+        }
+        return ts.visitNode(root, visit) as ts.SourceFile
+    }
+}

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

@@ -0,0 +1,28 @@
+import ts from 'typescript'
+import { hasTopLevelAwait } from './hasTopLevelAwait.ts'
+
+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.
+   Shared by the top-level desugar (`desugarSignals`) and the nested-`<script>` lowering
+   (`wrapReactiveSeeds`) so a bare-value seed is normalised identically on both surfaces. */
+export 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,
+    )
+}

package/src/lib/ui/computed.ts

@@ -5,6 +5,7 @@ import { createComputedNode } from './runtime/createComputedNode.ts'
 import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
 import { OWNER } from './runtime/OWNER.ts'
 import { readNode } from './runtime/readNode.ts'
+import { routeBareSeed } from './runtime/routeBareSeed.ts'
 import type { Computed } from './runtime/types/Computed.ts'
 import { unlinkDeps } from './runtime/unlinkDeps.ts'
 
@@ -32,6 +33,21 @@ export function computed<T>(compute: () => T): Computed<T>
 export function computed<T>(
     compute: () => T | Promise<T> | NamedAsyncIterable<T>,
 ): Computed<T> | AsyncComputed<T> {
+    /* A BARE seed that reached the runtime literally — a branch-nested `<script>` (which
+       keeps its `state.computed(...)` calls literal; see lowerScript) or a direct JS caller.
+       The compile-time `wrapSeed` normalization only covers the leading script, so honor the
+       same authored contract (ADR-0045: a bare seed behaves like its thunk form) by VALUE via
+       the shared `routeBareSeed`; a non-async value becomes a constant computed over it.
+       Without this a raw value lands as `node.compute` and the first read calls it
+       (`node.compute is 3` — a dead render mid-stream). */
+    if (typeof compute !== 'function') {
+        const seed: unknown = compute
+        const cell = routeBareSeed(seed, false)
+        if (cell !== undefined) {
+            return cell as AsyncComputed<T>
+        }
+        compute = () => seed as T
+    }
     /* `await` marker: an async-function thunk unwraps its promise into a tracked async cell.
        This is the only classification the read-only primitive can make without running the
        seed — a sync `computed` MUST stay lazy (it does not compute until first read). A stream

package/src/lib/ui/createScope.ts

@@ -4,6 +4,7 @@ import { computed } from './computed.ts'
 import { effect } from './effect.ts'
 import { linked } from './linked.ts'
 import { CURRENT_PATH } from './runtime/CURRENT_PATH.ts'
+import { consumeSeed } from './runtime/consumeSeed.ts'
 import { createDoc } from './runtime/createDoc.ts'
 import { DOC_SEED } from './runtime/DOC_SEED.ts'
 import type { Cell } from './runtime/types/Cell.ts'
@@ -50,13 +51,13 @@ export function createScope(
        on the client, so a uuid/timestamp/random would diverge from the SSR HTML. The server snapshot
        for this scope's render-path id is decoded here and consumed by `replace` on each slot's FIRST
        write (the eager init), keeping the server value while the throwaway init is discarded. One-shot
-       — deleted on read so an SPA re-nav to the same path re-inits fresh; empty on the server. */
+       via `consumeSeed` (two-phase, ADR-0048) — an SPA re-nav to the same path re-inits fresh, and a
+       hydration-desync throw hands the seed to the cold rebuild; empty on the server. */
     let pendingSeed: Map<string, unknown> | undefined
     /* `DOC_SEED` is populated only on the client by `startClient` (empty on the server), so the read
        needs no window guard — it mirrors the async-cell warm read. */
-    const encodedSeed = DOC_SEED[id]
+    const encodedSeed = consumeSeed(DOC_SEED, id)
     if (encodedSeed !== undefined) {
-        delete DOC_SEED[id]
         try {
             pendingSeed = new Map(
                 Object.entries(decodeRefJson(encodedSeed) as Record<string, unknown>),

package/src/lib/ui/dom/anchorCursor.ts

@@ -1,3 +1,4 @@
+import { parkCursor } from '../runtime/parkCursor.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 
 /*
@@ -18,7 +19,7 @@ export function anchorCursor(anchor: Node): Node | null {
     const reference = anchor.nextSibling
     const hydration = RENDER.hydration
     if (hydration !== undefined) {
-        hydration.next.set(anchor.parentNode as Node, reference)
+        parkCursor(hydration, anchor.parentNode as Node, reference)
     }
     return reference
 }

package/src/lib/ui/dom/anchoredBranch.ts

@@ -19,9 +19,10 @@ the accidental copy-paste, notably its two subtle guards:
      rethrowing, so the caller's cold rebuild starts clean).
 
 `anchor` is a mutable field: each block parks its own anchor text node at create /
-hydrate / rebuild time (placement is bespoke), and `place` reads it. The block owns its
-`scopeGroup`; each built branch's disposer is tracked in it so it disposes on owner
-teardown, not only on a swap.
+hydrate / rebuild time via `parkAnchor` (WHERE it parks is bespoke — before the boundary
+close, after a discarded boundary, at the create-mode `before`), and `place` reads it. The
+block owns its `scopeGroup`; each built branch's disposer is tracked in it so it disposes
+on owner teardown, not only on a swap.
 */
 export function anchoredBranch(
     parent: Node,
@@ -29,6 +30,7 @@ export function anchoredBranch(
 ): {
     anchor: Node | undefined
     detach: () => void
+    parkAnchor: (before: Node | null) => void
     place: (build: (host: Node) => void, wrapBuild?: (run: () => void) => void) => void
     adoptStrand: (
         build: (host: Node) => void,
@@ -128,6 +130,14 @@ export function anchoredBranch(
         }
     }
 
+    /* Park a fresh empty text node as the branch's swap anchor at `before` (null appends) —
+       the create/hydrate/rebuild triple every block repeated by hand. */
+    const parkAnchor = (before: Node | null): void => {
+        const node = document.createTextNode('')
+        anchor = node
+        parent.insertBefore(node, before)
+    }
+
     return {
         get anchor(): Node | undefined {
             return anchor
@@ -136,6 +146,7 @@ export function anchoredBranch(
             anchor = node
         },
         detach,
+        parkAnchor,
         place,
         adoptStrand,
     }

package/src/lib/ui/dom/appendStatic.ts

@@ -1,34 +1,25 @@
 import { claimChild } from '../runtime/claimChild.ts'
+import { parkCursor } from '../runtime/parkCursor.ts'
 import { RENDER } from '../runtime/RENDER.ts'
-import { assertClaimedText } from './assertClaimedText.ts'
+import { claimText } from './claimText.ts'
 
 /*
 A static (non-reactive) text node under `parent`: created and appended (create
-mode), or claimed from the server-rendered text (hydrate mode). As with reactive
-text, a merged SSR text node is split at this literal's length so the next claim
-lines up; nothing is bound since the text never changes.
+mode), or claimed from the server-rendered text (hydrate mode) — the shared
+`claimText` asserts, splits the merged SSR node at this literal's length so the
+next claim lines up, and advances. Nothing is bound since the text never changes.
+A static always renders on the server, so a non-text node at the cursor is a
+tolerated desync: advance past it (assertClaimedText's domain is a text mismatch;
+a structural one is claimExpected's).
 */
 // @documentation plumbing
 export function appendStatic(parent: Node, value: string, splitAlways = false): void {
     const hydration = RENDER.hydration
     if (hydration !== undefined) {
-        const node = claimChild(hydration, parent) as unknown as Text
-        const isText = node !== null && typeof node.splitText === 'function'
-        /* The claimed SSR node must begin with this literal, or the split misaligns — throw
-           legibly at the divergence (only when a text node is actually here; a structural
-           mismatch is claimExpected's domain). */
-        if (isText) {
-            assertClaimedText(node, value)
+        if (claimText(hydration, parent, value, splitAlways) === undefined) {
+            const node = claimChild(hydration, parent)
+            parkCursor(hydration, parent, node === null ? null : node.nextSibling)
         }
-        /* Split even on an exact-length consume when a sibling text binding follows
-           (`splitAlways`), so it gets its own node; see appendText for the rationale. */
-        if (
-            isText &&
-            (splitAlways ? value.length <= node.data.length : value.length < node.data.length)
-        ) {
-            node.splitText(value.length)
-        }
-        hydration.next.set(parent, node === null ? null : node.nextSibling)
         return
     }
     parent.appendChild(document.createTextNode(value))