@abide/abide 0.57.1 → 0.100.0

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

@@ -1,167 +0,0 @@
-import ts from 'typescript'
-import { createShadowScope } from './createShadowScope.ts'
-import { docAccessTransformer } from './lowerDocAccess.ts'
-import { nestedBindingNames, nestedPlainLocalNames } from './prepareNestedScript.ts'
-import { signalRefsTransformer } from './renameSignalRefs.ts'
-import { TS_PRINTER } from './TS_PRINTER.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-import { unwrapParens } from './unwrapParens.ts'
-import { wrapReactiveSeedsTransformer } from './wrapReactiveSeeds.ts'
-
-/* Compiled once — strips the trailing `;` off every lowered expression. */
-const TRAILING_SEMICOLON = /;$/
-
-/*
-The shared expression-lowering context both back-ends build on: the signal→`model`
-rewrite and doc-access lowering that turns the signal surface the author writes
-(`count` → `model.count` → patch/read) into the doc API, plus the branch-scoped
-nested-`<script>` deref scope. Identical on both sides by design — server and
-client must lower an expression the same way or their markup diverges and
-hydration breaks — so it lives in one place: a new sugar token or a paren/scope
-fix lands here once instead of in lockstep across `generateBuild`/`generateSSR`.
-SSR's effect-stripping stays a caller-side wrap (`stripEffects`), the one real
-asymmetry; the node-walk skeletons stay in each back-end.
-*/
-export function lowerContext(
-    stateNames: ReadonlySet<string>,
-    derivedNames: ReadonlySet<string>,
-    computedNames: ReadonlySet<string> = new Set(),
-    /* `linked` / async `computed` names, read through `$$readCell(name)` — one read form
-       whose pause-vs-peek is decided at runtime by the cell's own `blocking` bit (ADR-0042),
-       so both back-ends lower a cell read identically with nothing site-specific to thread. */
-    cellReadNames: ReadonlySet<string> = new Set(),
-) {
-    /* The typed branch-local shadow stack: one auto-popping value owning both kinds.
-       `derived` names deref to `.value` like a `computed` (block value params the client
-       binds as a reactive cell, and nested-`<script>` bindings); `plain` names deref as
-       the bare identifier (block value params SSR binds as a real JS local). Both, as a
-       nearer lexical scope, SHADOW a same-named component signal. `withShadow` pushes on
-       entry and pops in a `finally`, so a branch's shadows cannot outlive the branch even
-       if its body throws — the leak the old hand-written pop allowed. */
-    const scope = createShadowScope()
-
-    /* Parse `code` once and chain the reference rename and doc-access lowering over the
-       one tree — the two string passes would each parse + reprint. `localDerived` is
-       snapshotted per call (as the transformer's block-local shadow set) so a binding
-       pushed mid-compile is honoured AND shadows a same-named component signal. */
-    function lowerOnce(
-        code: string,
-        leadingTransformers: ts.TransformerFactory<ts.SourceFile>[] = [],
-    ): string {
-        const source = ts.createSourceFile('expr.ts', code, ts.ScriptTarget.Latest, true)
-        const result = ts.transform(source, [
-            ...leadingTransformers,
-            signalRefsTransformer(
-                stateNames,
-                derivedNames,
-                computedNames,
-                new Set(scope.names('derived')),
-                new Set(scope.names('plain')),
-                cellReadNames,
-            ),
-            docAccessTransformer('$$model'),
-        ])
-        const output = TS_PRINTER.printFile(result.transformed[0] as ts.SourceFile).trim()
-        result.dispose()
-        return output
-    }
-
-    /* Lowers a single expression (no trailing `;`). Wrapped in parens so a bare object
-       literal (`{ a: 1 }`) parses as an expression, not a block of labeled statements,
-       through the rewrite; the wrapper is then peeled back off. */
-    function expression(code: string): string {
-        return unwrapParens(lowerOnce(`(${code})`).replace(TRAILING_SEMICOLON, ''))
-    }
-
-    /* As above but keeps the trailing `;` for a statement/handler body. */
-    function statement(code: string): string {
-        return lowerOnce(code)
-    }
-
-    /* A nested branch `<script>` body. Same lowering as `statement`, but first normalises its
-       literal `state.computed`/`state.linked` seeds into thunks (`wrapReactiveSeeds`) so a bare-
-       value seed (`state.computed(a * 2)`) matches the top-level desugar rather than reaching the
-       runtime primitive un-thunked (which would call the value as the compute function and crash).
-       The wrap runs BEFORE the reference rename so it wraps the raw seed and the renamed refs land
-       inside the thunk. */
-    function script(code: string): string {
-        return lowerOnce(code, [wrapReactiveSeedsTransformer()])
-    }
-
-    /* A two-way bind target is either an LVALUE (`count`, `model.lines[i]`) — reads as
-       itself, writes by assignment — or an ACCESSOR object from `bind:value={{ get, set }}`
-       — reads via `.get()`, writes via `.set(v)`. The accessor is the only way to bind a
-       value whose write goes somewhere other than the read target (the replacement for the
-       old writable `computed(compute, set)` lens). A read-only `computed` is NOT an lvalue,
-       so binding one bare is a compile error pointing at the accessor form. */
-    const isAccessorBind = (code: string): boolean => code.trim().startsWith('{')
-
-    function guardWritableBind(code: string): void {
-        const name = code.trim()
-        if (computedNames.has(name)) {
-            throw new Error(
-                `bind: \`${name}\` is a read-only computed — bind a writable target, or an accessor: bind:value={{ get: () => ${name}, set: (next) => { /* write the source */ } }}`,
-            )
-        }
-    }
-
-    /* The expression a two-way bind reads its current value from. */
-    function bindRead(code: string): string {
-        if (isAccessorBind(code)) {
-            return `(${expression(code)}).get()`
-        }
-        guardWritableBind(code)
-        return expression(code)
-    }
-
-    /* The statement a two-way bind runs to write `valueExpr` (a raw runtime expression,
-       e.g. `el.value`) back into its target. */
-    function bindWrite(code: string, valueExpr: string): string {
-        if (isAccessorBind(code)) {
-            return `(${expression(code)}).set(${valueExpr});`
-        }
-        guardWritableBind(code)
-        /* A `linked` cell (a writable `State`) is read through `$$readCell`, but that call is
-           not an lvalue — the WRITE goes straight to the cell's `.value` setter (`NAME.value =
-           …`). The name is a real local holding the cell, so it needs no reference lowering. */
-        const name = code.trim()
-        if (cellReadNames.has(name)) {
-            return `${name}.value = ${valueExpr};`
-        }
-        return statement(`${code} = ${valueExpr}`)
-    }
-
-    /* Adds any `<script>` children's binding names to the deref scope (so the script
-       bodies and the branch's markup auto-deref them) for the duration of `body`. Reactive
-       bindings register as `derived` `.value` cells; the script's PLAIN top-level locals
-       register as `plain` bare locals so a local that shares a name with a component signal
-       shadows it (else the reference lowers to `$$model.read(...)`, ignoring the local). */
-    function withNestedScripts<T>(children: TemplateNode[], body: () => T): T {
-        const derived = children.flatMap((child) =>
-            child.kind === 'script' ? [...nestedBindingNames(child.code)] : [],
-        )
-        const plain = children.flatMap((child) =>
-            child.kind === 'script' ? [...nestedPlainLocalNames(child.code)] : [],
-        )
-        return scope.withShadow(derived, 'derived', () => scope.withShadow(plain, 'plain', body))
-    }
-
-    return {
-        expression,
-        statement,
-        script,
-        withNestedScripts,
-        /* The raw branch-local shadow registration both back-ends drive `withBindings`
-           through: a block's bindings flow to a `ShadowKind` only via that one shared loop,
-           never through a per-block `scope.withShadow` call here. */
-        withShadow: scope.withShadow,
-        /* Whether `name` is currently shadowed by a block binding (either kind) at this point
-           of the walk — the live query classification sites (e.g. `awaitSubjectExpr`) consult
-           so a binder that shadows a component cell name is lowered as the local it is, never
-           wrapped as the cell it hides. */
-        isShadowed: (name: string): boolean =>
-            scope.names('plain').has(name) || scope.names('derived').has(name),
-        bindRead,
-        bindWrite,
-    }
-}

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

@@ -1,302 +0,0 @@
-import ts from 'typescript'
-import { escapeKey } from '../runtime/escapeKey.ts'
-import { lowerCompoundAssignment } from './lowerCompoundAssignment.ts'
-import { lowerUpdateExpression } from './lowerUpdateExpression.ts'
-
-/*
-The linchpin compiler pass. Rewrites idiomatic data access on a reactive document
-binding into the document's patch/read API, so an author writes plain property
-syntax and the runtime gets addressed change — the thing that makes a real
-component hit the fast path instead of building path strings by hand:
-
-  model.note = 'x'        →  model.replace("note", 'x')
-  model.count += 1        →  model.replace("count", model.read("count") + 1)
-  model.lines.push(v)     →  model.add("lines/-", v)
-  delete model.byId[key]  →  model.remove("byId/" + escapeKey(key))
-  model.lines[0].sku      →  model.read("lines/0/sku")
-  model.lines[i].sku      →  model.read("lines/" + escapeKey(i) + "/sku")
-
-A member/element-access chain rooted at `docName` becomes a `/`-joined path:
-literal keys and numeric indices fold into one string literal; a non-literal
-index makes the path a template (a dynamic segment). Path segments are
-JSON-Pointer-escaped so a key holding `/` or `~` addresses one segment, not
-many — literal keys at compile time, dynamic ones wrapped in a runtime
-`escapeKey(...)`. Reads are lowered to `read(path)`; a later pass hoists
-static-path reads to a `cell` bound once at component init (the string-free hot
-path the bench measured). Index expressions are themselves visited, so a read
-used as an index lowers too. Exposed as `docAccessTransformer` (a
-`ts.TransformerFactory`) so the script pipeline chains it after
-`signalRefsTransformer` over a single parsed tree (see `lowerScript`).
-*/
-
-/* A path segment is either a literal key or a runtime expression (a dynamic index). */
-type Segment = { kind: 'literal'; value: string } | { kind: 'expression'; node: ts.Expression }
-
-/* Methods that mutate a doc-rooted container in place — Array, Map and Set (the three
-   mutable containers the doc codec serializes). Called on a doc value these can't lower to
-   a bare `readCall` (which would mutate the live tree by reference and never emit a patch —
-   so nothing re-renders); they route through `$$mutateDocContainer`, which
-   clones-applies-replaces so a real patch fires. The names are disjoint across the three
-   container kinds, so one set routes them all and the runtime helper decides the kind by the
-   value's type. `push` is handled separately above (fine-grained `add` patches). */
-const MUTATING_CONTAINER_METHODS = new Set([
-    // Array
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-    'fill',
-    'copyWithin',
-    // Map / Set (`delete` + `clear` shared; `set` is Map, `add` is Set)
-    'set',
-    'add',
-    'delete',
-    'clear',
-])
-
-export function docAccessTransformer(docName: string): ts.TransformerFactory<ts.SourceFile> {
-    return (context) => (root) => {
-        /* Collects the path of an access chain rooted at `docName`, visiting any
-           dynamic index so reads inside it lower too. undefined if not our doc. */
-        function pathSegments(node: ts.Expression): Segment[] | undefined {
-            const segments: Segment[] = []
-            let current: ts.Expression = node
-            while (true) {
-                if (ts.isPropertyAccessExpression(current)) {
-                    /* A property name is an identifier — escapeKey is a no-op on it, but
-                       a string-literal element key (`model["a/b"]`) can carry `/`|`~` and
-                       must escape at compile time so the `/`-joined path doesn't mis-split. */
-                    segments.unshift({ kind: 'literal', value: escapeKey(current.name.text) })
-                    current = current.expression
-                } else if (ts.isElementAccessExpression(current)) {
-                    const argument = current.argumentExpression
-                    if (ts.isStringLiteral(argument) || ts.isNumericLiteral(argument)) {
-                        segments.unshift({ kind: 'literal', value: escapeKey(argument.text) })
-                    } else {
-                        segments.unshift({
-                            kind: 'expression',
-                            node: ts.visitNode(argument, visit) as ts.Expression,
-                        })
-                    }
-                    current = current.expression
-                } else {
-                    break
-                }
-            }
-            if (ts.isIdentifier(current) && current.text === docName && segments.length > 0) {
-                return segments
-            }
-            return undefined
-        }
-
-        function visit(node: ts.Node): ts.Node {
-            /* 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 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. 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 (
-                (ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
-                (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                    node.operator === ts.SyntaxKind.MinusMinusToken)
-            ) {
-                const segments = pathSegments(node.operand)
-                if (segments) {
-                    return lowerUpdateExpression(
-                        ts.isPostfixUnaryExpression(node),
-                        node.operator === ts.SyntaxKind.PlusPlusToken,
-                        () => docCall(docName, 'read', [buildPath(segments)]),
-                        (value) => docCall(docName, 'replace', [buildPath(segments), value]),
-                    )
-                }
-            }
-            /* doc array `.push(a, b, …)` → one `add` patch per argument at the array's `-`
-               slot, matching native multi-arg push (each lands at the end in order). */
-            if (
-                ts.isCallExpression(node) &&
-                ts.isPropertyAccessExpression(node.expression) &&
-                node.expression.name.text === 'push'
-            ) {
-                const segments = pathSegments(node.expression.expression)
-                if (segments && node.arguments.length > 0) {
-                    const adds = node.arguments.map(
-                        (pushed) =>
-                            docCall(docName, 'add', [
-                                buildPath([...segments, { kind: 'literal', value: '-' }]),
-                                ts.visitNode(pushed, visit) as ts.Expression,
-                            ]) as ts.Expression,
-                    )
-                    /* `node.arguments.length > 0` above guarantees `adds` is non-empty, so the
-                       single-element branch's `adds[0]` is defined. */
-                    // biome-ignore lint/style/noNonNullAssertion: length === 1 guarantees adds[0] is defined
-                    return adds.length === 1 ? adds[0]! : ts.factory.createCommaListExpression(adds)
-                }
-            }
-            /* A called member on a doc chain is a method on the read value, not a
-               deeper path: `model.draft.trim()` → `readCall(model.read("draft"), …)`,
-               `model.items.map(f)` → `readCall(model.read("items"), …)`. (Array `.push`
-               above is the exception — it lowers to an `add` patch.) */
-            if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-                const access = node.expression
-                const segments = pathSegments(access.expression)
-                if (segments) {
-                    const args = node.arguments.map(
-                        (arg) => ts.visitNode(arg, visit) as ts.Expression,
-                    )
-                    /* An in-place-mutating container method (Array/Map/Set) on a doc path →
-                       route through `$$mutateDocContainer(doc, path, member, [args])` so the
-                       mutation lands as a patch instead of silently mutating the live tree by
-                       reference. Optional chaining (`model.items?.splice(…)`) keeps the bare-call
-                       semantics below — skip-if-absent is the author's explicit choice, and a
-                       nullish container has nothing to mutate. */
-                    if (
-                        MUTATING_CONTAINER_METHODS.has(access.name.text) &&
-                        !access.questionDotToken &&
-                        !node.questionDotToken
-                    ) {
-                        return ts.factory.createCallExpression(
-                            ts.factory.createIdentifier('$$mutateDocContainer'),
-                            undefined,
-                            [
-                                ts.factory.createIdentifier(docName),
-                                buildPath(segments),
-                                ts.factory.createStringLiteral(access.name.text),
-                                ts.factory.createArrayLiteralExpression(args),
-                            ],
-                        )
-                    }
-                    const read = docCall(docName, 'read', [buildPath(segments)])
-                    /* Optional chaining is the author's explicit skip-if-absent: a nullish
-                       read short-circuits the whole call to `undefined`. Keep it bare —
-                       routing it through the throwing guard would invert that semantics.
-                       The call continues the chain whenever the access OR the call carries a
-                       `?.`, so `model.x?.m()` short-circuits the call too. */
-                    if (access.questionDotToken || node.questionDotToken) {
-                        const member = access.questionDotToken
-                            ? ts.factory.createPropertyAccessChain(
-                                  read,
-                                  access.questionDotToken,
-                                  access.name,
-                              )
-                            : ts.factory.createPropertyAccessExpression(read, access.name.text)
-                        return ts.factory.createCallChain(
-                            member,
-                            node.questionDotToken,
-                            node.typeArguments,
-                            args,
-                        )
-                    }
-                    /* A non-optional call on an absent read throws the engine's opaque
-                       `undefined is not an object`. Route it through `readCall`, which throws
-                       naming the authored scope path and member — the key and member are both
-                       in hand here, the `.abide` location comes free off the mapped stack. */
-                    return ts.factory.createCallExpression(
-                        ts.factory.createIdentifier('$$readCall'),
-                        undefined,
-                        [
-                            read,
-                            buildPath(segments),
-                            ts.factory.createStringLiteral(access.name.text),
-                            ts.factory.createArrayLiteralExpression(args),
-                        ],
-                    )
-                }
-            }
-            /* delete doc.path → remove patch. */
-            if (ts.isDeleteExpression(node)) {
-                const segments = pathSegments(node.expression)
-                if (segments) {
-                    return docCall(docName, 'remove', [buildPath(segments)])
-                }
-            }
-            /* Any remaining doc access chain is a read. */
-            if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
-                const segments = pathSegments(node)
-                if (segments) {
-                    return docCall(docName, 'read', [buildPath(segments)])
-                }
-            }
-            return ts.visitEachChild(node, visit, context)
-        }
-
-        return ts.visitNode(root, visit) as ts.SourceFile
-    }
-}
-
-/* Builds `docName.method(...args)`. */
-function docCall(docName: string, method: string, args: ts.Expression[]): ts.CallExpression {
-    return ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(docName), method),
-        undefined,
-        args,
-    )
-}
-
-/*
-Turns segments into a path expression: an all-literal path is one string literal
-(`"lines/0/sku"`); a path with a dynamic segment is a string-concatenation that
-evaluates to the path at runtime (`"lines/" + escapeKey(i) + "/sku"`), kept
-string-typed by leading with a literal.
-*/
-function buildPath(segments: Segment[]): ts.Expression {
-    if (segments.every((segment) => segment.kind === 'literal')) {
-        return ts.factory.createStringLiteral(
-            segments.map((segment) => (segment as { value: string }).value).join('/'),
-        )
-    }
-    const fragments: ts.Expression[] = []
-    /* Append text to the trailing string fragment when there is one, so a `/`
-       separator folds into the preceding literal (`"lines/" + i`) rather than
-       printing as its own term (`"lines" + "/" + i`). */
-    const appendText = (text: string): void => {
-        const last = fragments[fragments.length - 1]
-        if (last !== undefined && ts.isStringLiteral(last)) {
-            fragments[fragments.length - 1] = ts.factory.createStringLiteral(last.text + text)
-        } else {
-            fragments.push(ts.factory.createStringLiteral(text))
-        }
-    }
-    segments.forEach((segment, index) => {
-        const separator = index === 0 ? '' : '/'
-        if (segment.kind === 'literal') {
-            appendText(separator + segment.value)
-        } else {
-            if (separator !== '') {
-                appendText(separator)
-            }
-            /* A dynamic key's value is unknown at compile time — escape it at runtime so a
-               key holding `/`|`~` (a date, a composite id) addresses one segment, not many. */
-            fragments.push(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier('$$escapeKey'),
-                    undefined,
-                    [segment.node],
-                ),
-            )
-        }
-    })
-    const head = fragments[0]
-    if (head === undefined || !ts.isStringLiteral(head)) {
-        fragments.unshift(ts.factory.createStringLiteral(''))
-    }
-    return fragments.reduce((left, right) =>
-        ts.factory.createBinaryExpression(left, ts.SyntaxKind.PlusToken, right),
-    )
-}

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

@@ -1,190 +0,0 @@
-import ts from 'typescript'
-import { ABIDE_PACKAGE_NAME } from '../../shared/ABIDE_PACKAGE_NAME.ts'
-import { assertTranspiles } from './assertTranspiles.ts'
-import { desugarSignals } from './desugarSignals.ts'
-import { identifierReferencePattern } from './identifierReferencePattern.ts'
-import { docAccessTransformer } from './lowerDocAccess.ts'
-import { signalRefsTransformer } from './renameSignalRefs.ts'
-import { reactiveImportBindings } from './resolveReactiveExport.ts'
-import { stripEffectsTransformer } from './stripEffects.ts'
-import { TS_PRINTER } from './TS_PRINTER.ts'
-import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
-import { wrapReactionCellSources } from './wrapReactionCellSources.ts'
-
-/* The `abide/ui/*` modules the reactive surface is imported from. An author's import of
-   one is compiler-recognised and lowered, so its binding is often fully consumed — a plain
-   `state(...)` becomes `$$model`/`$$scope` with no `state` reference left. Such a dead
-   import is dropped from the emitted module (see `deadReactiveImport`) so the output carries
-   no spurious static `@abide/ui` dependency — a dead import a bundler would still resolve. */
-const REACTIVE_IMPORT_SPECIFIERS = new Set([
-    `${ABIDE_PACKAGE_NAME}/ui/state`,
-    `${ABIDE_PACKAGE_NAME}/ui/effect`,
-])
-
-/* True when `statement` imports the reactive surface and none of its local bindings survive
-   into the lowered output (`used` = body + ssr body) — so emitting it would be a dead,
-   spurious runtime import. A binding that DOES survive (`state.share`, a bare `effect(...)`)
-   keeps the import. */
-function deadReactiveImport(statement: ts.ImportDeclaration, used: string): boolean {
-    if (
-        !ts.isStringLiteral(statement.moduleSpecifier) ||
-        !REACTIVE_IMPORT_SPECIFIERS.has(statement.moduleSpecifier.text)
-    ) {
-        return false
-    }
-    const named = statement.importClause?.namedBindings
-    if (named === undefined || !ts.isNamedImports(named)) {
-        return false
-    }
-    return named.elements.every(
-        (element) => !identifierReferencePattern(element.name.text).test(used),
-    )
-}
-
-/*
-The component-script lowering, done in ONE parse. The script is parsed once, then
-`desugarSignals` (signal declarations → `model` slots / `scope().derive`), reference
-renaming (`count` → `model.count`), and doc-access lowering (`model.count` → patch/read)
-run as a chained `ts.transform` over the SAME tree — each as a standalone string pass
-would parse + reprint. desugar returns a transformer rather than rebuilt source text
-precisely so it can chain here; the name sets it collects feed the rename transformer.
-
-Imports are partitioned off the transformed tree structurally (`ts.isImportDeclaration`),
-not by regex, so a multi-line import hoists correctly regardless of formatting. The
-reassembled output is transpiled as a fail-loud guard: if a future un-handled rewrite
-position corrupts the script (the failure mode the syntax fuzz corpus also guards), it
-surfaces here as a located compile error instead of shipping a broken bundle.
-*/
-
-export function lowerScript(
-    scriptBody: string,
-    /* Reactive-surface identifiers referenced OUTSIDE this script — the nested branch
-       `<script>`s, which keep their `state.computed(...)` calls literal and so still need
-       the module-level import even after the leading script's own `state(...)` all
-       desugared away. Folded into the dead-import usage check so a live import isn't dropped
-       (→ `ReferenceError: state is not defined` in the branch). Empty for a nested script. */
-    externalUsage = '',
-    /* Names of synthetic `const __cN = computed(...)` cells `analyzeComponent` prepended for
-       asyncIterable interpolations (ADR-0019 Stage D). `computed` here is an unimported callee,
-       so `desugarSignals` recognizes these declarations by name — routing each to an eager
-       `trackedComputed` stream cell — rather than by import resolution. Empty on every other path. */
-    injectedCellNames: ReadonlySet<string> = new Set(),
-    /* The subset of `injectedCellNames` whose author wrote `await` (ADR-0032): a BLOCKING peek-cell
-       that joins the SSR barrier (resolved inline), vs a streaming one that ships pending. Threaded
-       to `desugarSignals` so `injectedComputedStatements` passes the right `trackedComputed`
-       streaming flag. Empty on every other path. */
-    blockingCellNames: ReadonlySet<string> = new Set(),
-    /* Names the template writes/forwards (`writtenTemplateNames`), so a `props()` binding used
-       two-way is desugared to a writable cell rather than a read-only derive. Empty for a nested
-       script (which declares no props). */
-    templateWrittenNames: ReadonlySet<string> = new Set(),
-    /* Type-directed seed classifier + this script's absolute source base (ADR-0023), threaded
-       to `desugarSignals` so a no-marker `computed(seed)` routes on the seed's checker type.
-       Absent ⇒ fail-open to the `isBareCallComputed` syntax heuristic (today's behavior). */
-    seedClassify?: SeedTypeClassifier,
-    scriptBase = 0,
-): {
-    body: string
-    imports: string
-    ssrBody: string
-    stateNames: Set<string>
-    derivedNames: Set<string>
-    computedNames: Set<string>
-    cellReadNames: Set<string>
-    droppedReactiveImports: Set<string>
-} {
-    const source = ts.createSourceFile('component.ts', scriptBody, ts.ScriptTarget.Latest, true)
-    const { transformer, stateNames, derivedNames, computedNames, cellReadNames } = desugarSignals(
-        source,
-        injectedCellNames,
-        blockingCellNames,
-        templateWrittenNames,
-        seedClassify,
-        scriptBase,
-    )
-    /* The local names bound to `watch` (alias-safe), and the full set of read-rewritten cell
-       names — together they let `wrapReactionCellSources` fold a `watch(cell, handler)` into
-       the thunk form BEFORE the read-lowering turns the cell reference into a value read. */
-    const watchLocalNames = new Set<string>()
-    for (const [local, canonical] of reactiveImportBindings(source).direct) {
-        if (canonical === 'watch') {
-            watchLocalNames.add(local)
-        }
-    }
-    const cellNames = new Set<string>([
-        ...stateNames,
-        ...derivedNames,
-        ...computedNames,
-        ...cellReadNames,
-    ])
-    /* `wrapReactionCellSources` only folds `watch(cell, …)` calls, so it's a pure
-       identity walk when the script imports no `watch` (the common case) — skip the
-       extra full-tree pass entirely then. */
-    const reactionTransforms =
-        watchLocalNames.size > 0 ? [wrapReactionCellSources(cellNames, watchLocalNames)] : []
-    const result = ts.transform(source, [
-        transformer,
-        ...reactionTransforms,
-        signalRefsTransformer(
-            stateNames,
-            derivedNames,
-            computedNames,
-            new Set(),
-            new Set(),
-            cellReadNames,
-        ),
-        docAccessTransformer('$$model'),
-    ])
-    const transformed = result.transformed[0] as ts.SourceFile
-    /* Top-level imports must live at module scope, not inside the mount/render
-       function the script body becomes — hoist them off the tree. */
-    const importStatements = transformed.statements.filter(ts.isImportDeclaration)
-    const bodyStatements = transformed.statements.filter(
-        (statement) => !ts.isImportDeclaration(statement),
-    )
-    const bodyFile = ts.factory.updateSourceFile(transformed, bodyStatements)
-    const body = TS_PRINTER.printFile(bodyFile).trim()
-    /* The SSR variant strips client-only `effect(...)` calls — run over the SAME lowered
-       tree (one extra transform + print, no reparse) instead of re-parsing the printed
-       script downstream. */
-    const ssrResult = ts.transform(bodyFile, [stripEffectsTransformer()])
-    const ssrBody = TS_PRINTER.printFile(ssrResult.transformed[0] as ts.SourceFile).trim()
-    ssrResult.dispose()
-    result.dispose()
-    /* Drop reactive-surface imports fully consumed by lowering — keeping them would leave a
-       dead, spurious `@abide/ui` runtime dependency (checked against both back-ends' output). */
-    const used = `${body}\n${ssrBody}\n${externalUsage}`
-    const droppedReactiveImports = new Set<string>()
-    const imports = importStatements
-        .filter((statement) => {
-            if (!deadReactiveImport(statement, used)) {
-                return true
-            }
-            /* Record the local names of a dropped reactive import so the module wrapper can
-               independently confirm the drop stranded no live reference. */
-            const named = statement.importClause?.namedBindings
-            if (named !== undefined && ts.isNamedImports(named)) {
-                for (const element of named.elements) {
-                    droppedReactiveImports.add(element.name.text)
-                }
-            }
-            return false
-        })
-        .map((statement) => TS_PRINTER.printNode(ts.EmitHint.Unspecified, statement, transformed))
-        .join('\n')
-
-    assertTranspiles(
-        [imports, body].filter((part) => part !== '').join('\n'),
-        'component script lowering',
-    )
-    return {
-        body,
-        imports,
-        ssrBody,
-        stateNames,
-        derivedNames,
-        computedNames,
-        cellReadNames,
-        droppedReactiveImports,
-    }
-}