@abide/abide 0.40.0 → 0.40.2

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

@@ -1,6 +1,7 @@
 import ts from 'typescript'
 import { REACTIVE_CALLEES } from './REACTIVE_CALLEES.ts'
-import { renameSignalRefs } from './renameSignalRefs.ts'
+
+const factory = ts.factory
 
 /* The reactive primitives that must be reached through a scope. A bare call to one of
    these is a compile error: reactive state is owned by a scope and the surface must show
@@ -34,28 +35,28 @@ function assertScopedPrimitives(source: ts.SourceFile): void {
 Desugars the signal surface into the document form. A component's `<script>`
 declares reactive state as signals:
 
-  let count = state(0)
-  let items = state([])
-  const total = computed(() => count + items.length)
+  let count = scope().state(0)
+  let items = scope().state([])
+  const total = scope().computed(() => count() + items.length)
 
-This collects the binding names, turns each plain `state(initial)` declaration
-into an initialising assignment on a shared `model` document (in source order, so
-a later state can read an earlier one), keeps the rest, then renames every
-reference through `renameSignalRefs`. Plain `state` becomes `model.x` access that
-`lowerDocAccess` lowers to patches/reads — the document substrate's deep,
-fine-grained, serializable reactivity for free. `linked`, `computed`, and
-`state(initial, transform)` stay verbatim as runtime `.value` cells (referenced
-as `name.value`): they own no doc slot, so they reseed/recompute on resume rather
-than serialize. No reactive declarations → the script is returned untouched (the
-explicit `const model = doc(...)` form still works).
+This walks the already-parsed script once to collect the binding names, then returns
+a `ts.TransformerFactory` that rewrites the declarations onto a shared `model`
+document: each plain `state(initial)` becomes an initialising assignment (`model.x =
+initial`, in source order so a later state can read an earlier one), each `computed`
+and destructured prop becomes a `scope().derive` slot, and `linked` /
+`state(initial, transform)` stay `.value` cells routed onto the scope. Returning a
+TRANSFORMER (not rebuilt source text) lets the caller (`lowerScript`) chain it with
+reference renaming and doc-access lowering over ONE parsed tree — no print-then-reparse
+between passes. Plain `state` becomes `model.x` access that `lowerDocAccess` lowers to
+patches/reads. No reactive declarations → an identity transformer (the explicit
+`const model = doc(...)` form still works).
 */
-export function desugarSignals(scriptBody: string): {
-    code: string
+export function desugarSignals(source: ts.SourceFile): {
+    transformer: ts.TransformerFactory<ts.SourceFile>
     stateNames: Set<string>
     derivedNames: Set<string>
     computedNames: Set<string>
 } {
-    const source = ts.createSourceFile('script.ts', scriptBody, ts.ScriptTarget.Latest, true)
     assertScopedPrimitives(source)
     const stateNames = new Set<string>()
     const derivedNames = new Set<string>()
@@ -103,43 +104,70 @@ export function desugarSignals(scriptBody: string): {
             }
         }
     }
-    if (
-        stateNames.size === 0 &&
-        derivedNames.size === 0 &&
-        computedNames.size === 0 &&
-        !hasPropsDestructure
-    ) {
-        return { code: scriptBody, stateNames, derivedNames, computedNames }
-    }
 
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
-    const lines: string[] = []
-    if (stateNames.size > 0) {
-        lines.push('const model = scope()')
-    }
-    for (const statement of source.statements) {
-        const stateAssignments = stateDeclarationAssignments(statement, printer, source)
-        const computedDeclarations = computedDeclarationLines(statement, printer, source)
-        const propsDestructure = propsDestructureLines(statement, printer, source)
-        const cellDeclarations = cellDeclarationLines(statement, printer, source)
-        if (stateAssignments !== undefined) {
-            lines.push(...stateAssignments)
-        } else if (computedDeclarations !== undefined) {
-            lines.push(...computedDeclarations)
-        } else if (propsDestructure !== undefined) {
-            lines.push(...propsDestructure)
-        } else if (cellDeclarations !== undefined) {
-            lines.push(...cellDeclarations)
-        } else {
-            lines.push(printer.printNode(ts.EmitHint.Unspecified, statement, source))
+    const hasReactive =
+        stateNames.size > 0 ||
+        derivedNames.size > 0 ||
+        computedNames.size > 0 ||
+        hasPropsDestructure
+
+    const transformer: ts.TransformerFactory<ts.SourceFile> = () => (root) => {
+        if (!hasReactive) {
+            return root
         }
+        const statements: ts.Statement[] = []
+        /* A shared `model = scope()` host for the state slots, prepended once. */
+        if (stateNames.size > 0) {
+            statements.push(
+                constDeclaration(
+                    'model',
+                    factory.createCallExpression(factory.createIdentifier('scope'), undefined, []),
+                ),
+            )
+        }
+        for (const statement of root.statements) {
+            statements.push(...loweredStatement(statement))
+        }
+        return factory.updateSourceFile(root, statements)
     }
-    return {
-        code: renameSignalRefs(lines.join('\n'), stateNames, derivedNames, computedNames),
-        stateNames,
-        derivedNames,
-        computedNames,
-    }
+
+    return { transformer, stateNames, derivedNames, computedNames }
+}
+
+/* The lowered form of a top-level statement: state slots → `model.x = init`
+   assignments, computed → `scope().derive` consts, props → derive consts (+ restProps),
+   cells → `scope().<callee>(...)` consts; anything else passes through verbatim. The
+   per-statement dispatch mirrors the name-collection pass. */
+function loweredStatement(statement: ts.Statement): ts.Statement[] {
+    return (
+        stateAssignmentStatements(statement) ??
+        computedStatements(statement) ??
+        propsStatements(statement) ??
+        cellStatements(statement) ?? [statement]
+    )
+}
+
+/* `const NAME = <init>` — a fresh const declaration reusing the original initializer node. */
+function constDeclaration(name: string, initializer: ts.Expression): ts.VariableStatement {
+    return factory.createVariableStatement(
+        undefined,
+        factory.createVariableDeclarationList(
+            [factory.createVariableDeclaration(name, undefined, undefined, initializer)],
+            ts.NodeFlags.Const,
+        ),
+    )
+}
+
+/* `scope().<method>(...args)` — the reactive method routed onto the ambient scope. */
+function scopeMethodCall(method: string, args: readonly ts.Expression[]): ts.CallExpression {
+    return factory.createCallExpression(
+        factory.createPropertyAccessExpression(
+            factory.createCallExpression(factory.createIdentifier('scope'), undefined, []),
+            method,
+        ),
+        undefined,
+        args,
+    )
 }
 
 /* True for a read-only computed slot — `computed(compute)` with no write-through
@@ -159,15 +187,11 @@ function isComputedSlot(declaration: ts.VariableDeclaration): boolean {
    routed onto the scope: `linked(seed)` → `const x = scope().linked(seed)`. The cell
    stays a standalone non-serializing cell (its refs stay `name.value`); the rewrite only
    removes the bare runtime import so the sole reactive surface is `scope()`. */
-function cellDeclarationLines(
-    statement: ts.Statement,
-    printer: ts.Printer,
-    source: ts.SourceFile,
-): string[] | undefined {
+function cellStatements(statement: ts.Statement): ts.Statement[] | undefined {
     if (!ts.isVariableStatement(statement)) {
         return undefined
     }
-    const lines: string[] = []
+    const statements: ts.Statement[] = []
     for (const declaration of statement.declarationList.declarations) {
         const callee = signalCallee(declaration)
         if (
@@ -178,24 +202,18 @@ function cellDeclarationLines(
             return undefined
         }
         const args = (declaration.initializer as ts.CallExpression).arguments
-            .map((argument) => printer.printNode(ts.EmitHint.Unspecified, argument, source))
-            .join(', ')
-        lines.push(`const ${declaration.name.text} = scope().${callee}(${args})`)
+        statements.push(constDeclaration(declaration.name.text, scopeMethodCall(callee, args)))
     }
-    return lines
+    return statements
 }
 
 /* `let total = computed(compute)` → `const total = scope().derive("total", compute)`
    — a computed doc slot whose reader the references lower to `total()`. */
-function computedDeclarationLines(
-    statement: ts.Statement,
-    printer: ts.Printer,
-    source: ts.SourceFile,
-): string[] | undefined {
+function computedStatements(statement: ts.Statement): ts.Statement[] | undefined {
     if (!ts.isVariableStatement(statement)) {
         return undefined
     }
-    const lines: string[] = []
+    const statements: ts.Statement[] = []
     for (const declaration of statement.declarationList.declarations) {
         if (
             !ts.isIdentifier(declaration.name) ||
@@ -204,16 +222,25 @@ function computedDeclarationLines(
         ) {
             return undefined
         }
-        const compute = (declaration.initializer as ts.CallExpression).arguments[0]
-        const computeText =
-            compute === undefined
-                ? '() => undefined'
-                : printer.printNode(ts.EmitHint.Unspecified, compute, source)
-        lines.push(
-            `const ${declaration.name.text} = scope().derive(${JSON.stringify(declaration.name.text)}, ${computeText})`,
+        const name = declaration.name.text
+        const compute =
+            (declaration.initializer as ts.CallExpression).arguments[0] ??
+            factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+                factory.createIdentifier('undefined'),
+            )
+        statements.push(
+            constDeclaration(
+                name,
+                scopeMethodCall('derive', [factory.createStringLiteral(name), compute]),
+            ),
         )
     }
-    return lines
+    return statements
 }
 
 /* True for `state(initial, transform)` — the write-coercion transform forces a
@@ -308,65 +335,99 @@ function propsBindingKey(element: ts.BindingElement): string {
 
 /* If `statement` is a `const {…, ...rest} = props()` destructure, returns one reactive
    computed per named binding — `scope().derive("name", () => $props["key"]?.() ?? default)`,
-   read as `name()` — plus a `const rest = restProps($props, [consumed])` line for a rest
-   binding; otherwise undefined. The `?? default` applies the binding's `= default` fallback
-   when the prop is absent. */
-function propsDestructureLines(
-    statement: ts.Statement,
-    printer: ts.Printer,
-    source: ts.SourceFile,
-): string[] | undefined {
+   read as `name()` — plus a `const rest = restProps($props, [consumed])` for a rest
+   binding; otherwise undefined. The `?? default` applies the binding's `= default`
+   fallback when the prop is absent. */
+function propsStatements(statement: ts.Statement): ts.Statement[] | undefined {
     if (!ts.isVariableStatement(statement)) {
         return undefined
     }
-    const lines: string[] = []
+    const statements: ts.Statement[] = []
     for (const declaration of statement.declarationList.declarations) {
         if (signalCallee(declaration) !== 'props' || !ts.isObjectBindingPattern(declaration.name)) {
             return undefined
         }
         const { bindings, rest } = propsDestructure(declaration)
         for (const { local, key, initializer } of bindings) {
-            const fallback =
+            /* `$props["key"]?.()` — the parent thunk, optionally called. */
+            const read = factory.createCallChain(
+                factory.createElementAccessExpression(
+                    factory.createIdentifier('$props'),
+                    factory.createStringLiteral(key),
+                ),
+                factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                undefined,
+                [],
+            )
+            /* `?? default` only when the binding declared a `= default` fallback. */
+            const body =
                 initializer === undefined
-                    ? ''
-                    : ` ?? (${printer.printNode(ts.EmitHint.Unspecified, initializer, source)})`
-            lines.push(
-                `const ${local} = scope().derive(${JSON.stringify(local)}, () => $props[${JSON.stringify(key)}]?.()${fallback})`,
+                    ? read
+                    : factory.createBinaryExpression(
+                          read,
+                          factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+                          factory.createParenthesizedExpression(initializer),
+                      )
+            const thunk = factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+                body,
+            )
+            statements.push(
+                constDeclaration(
+                    local,
+                    scopeMethodCall('derive', [factory.createStringLiteral(local), thunk]),
+                ),
             )
         }
         /* The rest bag gathers every prop not named above (and not `$children`). */
         if (rest !== undefined) {
-            const consumed = bindings.map((binding) => binding.key)
-            lines.push(`const ${rest} = restProps($props, ${JSON.stringify(consumed)})`)
+            const consumed = bindings.map((binding) => factory.createStringLiteral(binding.key))
+            statements.push(
+                constDeclaration(
+                    rest,
+                    factory.createCallExpression(factory.createIdentifier('restProps'), undefined, [
+                        factory.createIdentifier('$props'),
+                        factory.createArrayLiteralExpression(consumed),
+                    ]),
+                ),
+            )
         }
     }
-    return lines
+    return statements
 }
 
 /* If `statement` declares `state(...)` bindings, returns `model.<name> = <init>`
-   assignment lines (one per declaration); otherwise undefined. */
-function stateDeclarationAssignments(
-    statement: ts.Statement,
-    printer: ts.Printer,
-    source: ts.SourceFile,
-): string[] | undefined {
+   assignment statements (one per declaration); otherwise undefined. */
+function stateAssignmentStatements(statement: ts.Statement): ts.Statement[] | undefined {
     if (!ts.isVariableStatement(statement)) {
         return undefined
     }
-    const assignments: string[] = []
+    const statements: ts.Statement[] = []
     for (const declaration of statement.declarationList.declarations) {
         if (!ts.isIdentifier(declaration.name) || !isPlainStateSlot(declaration)) {
             /* Only a plain `state(initial)` becomes a slot; `state(initial, transform)`
-               (and everything else) is a `.value` cell — print it verbatim so the
+               (and everything else) is a `.value` cell — pass it through so the
                runtime call (and its transform) survives. */
             return undefined
         }
-        const initial = (declaration.initializer as ts.CallExpression).arguments[0]
-        const initialText =
-            initial === undefined
-                ? 'undefined'
-                : printer.printNode(ts.EmitHint.Unspecified, initial, source)
-        assignments.push(`model.${declaration.name.text} = ${initialText}`)
+        const initial =
+            (declaration.initializer as ts.CallExpression).arguments[0] ??
+            factory.createIdentifier('undefined')
+        statements.push(
+            factory.createExpressionStatement(
+                factory.createAssignment(
+                    factory.createPropertyAccessExpression(
+                        factory.createIdentifier('model'),
+                        declaration.name.text,
+                    ),
+                    initial,
+                ),
+            ),
+        )
     }
-    return assignments
+    return statements
 }

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

@@ -1,3 +1,4 @@
+import { assertExhaustive } from '../../shared/assertExhaustive.ts'
 import { HOLE_ATTRIBUTE } from '../runtime/HOLE_ATTRIBUTE.ts'
 import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
 import { asOutlet } from './asOutlet.ts'
@@ -371,7 +372,13 @@ export function generateBuild(
         if (node.kind === 'snippet') {
             return generateSnippet(node)
         }
-        return generateEach(node, parentVar, before)
+        if (node.kind === 'each') {
+            return generateEach(node, parentVar, before)
+        }
+        /* Every TemplateNode kind is handled above; `node` is `never` here. A new kind
+           reaching this point is a compiler gap — fail loud instead of silently routing
+           it to the wrong branch. */
+        return assertExhaustive(node, 'template node kind')
     }
 
     /* Builds a sibling list, coalescing maximal runs of fully-static element subtrees

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

@@ -1,3 +1,4 @@
+import { assertExhaustive } from '../../shared/assertExhaustive.ts'
 import { OUTLET_CLOSE, OUTLET_OPEN } from '../runtime/OUTLET_MARKER.ts'
 import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
 import { asOutlet } from './asOutlet.ts'
@@ -341,6 +342,12 @@ export function generateSSR(
             }
             return generateSlot(node, target, anchor)
         }
+        /* Every non-element kind returned above; a kind reaching the element builder
+           that isn't an element is a compiler gap — fail loud rather than emit it as a
+           bogus `<undefined>` tag. (`node` narrows to `never` in this branch.) */
+        if (node.kind !== 'element') {
+            return assertExhaustive(node, 'template node kind')
+        }
         let code = push(target, `<${node.tag}`)
         /* Every `<style>` active at this element (own siblings + ancestors) — same set
            the client stamps, so server and client markup carry identical attributes. */

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

@@ -1,4 +1,5 @@
 import ts from 'typescript'
+import { TS_PRINTER } from './TS_PRINTER.ts'
 
 /*
 The perf pass that follows `lowerDocAccess`. Within a render scope, a static path
@@ -35,8 +36,7 @@ export function hoistCells(code: string, docName: string): string {
     }
 
     const result = ts.transform(source, [hoistTransformer(docName, cellIdForPath)])
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
-    const output = printer.printFile(result.transformed[0] as ts.SourceFile)
+    const output = TS_PRINTER.printFile(result.transformed[0] as ts.SourceFile)
     result.dispose()
     return output
 }

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

@@ -1,6 +1,8 @@
-import { lowerDocAccess } from './lowerDocAccess.ts'
+import ts from 'typescript'
+import { docAccessTransformer } from './lowerDocAccess.ts'
 import { nestedBindingNames } from './prepareNestedScript.ts'
-import { renameSignalRefs } from './renameSignalRefs.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'
 
@@ -27,19 +29,30 @@ export function lowerContext(
     const derefScope = (): ReadonlySet<string> =>
         localDerived.size === 0 ? derivedNames : new Set([...derivedNames, ...localDerived])
 
-    /* Rewrites signal refs, then 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 both rewrite passes;
-       the wrapper is then peeled back off. */
+    /* Parse `code` once and chain the reference rename and doc-access lowering over the
+       one tree — the two string passes would each parse + reprint. `derefScope()` is read
+       per call so a nested-`<script>` binding pushed mid-compile is honoured. */
+    function lowerOnce(code: string): string {
+        const source = ts.createSourceFile('expr.ts', code, ts.ScriptTarget.Latest, true)
+        const result = ts.transform(source, [
+            signalRefsTransformer(stateNames, derefScope(), computedNames),
+            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 {
-        const renamed = renameSignalRefs(`(${code})`, stateNames, derefScope(), computedNames)
-        return unwrapParens(lowerDocAccess(renamed, 'model').trim().replace(/;$/, ''))
+        return unwrapParens(lowerOnce(`(${code})`).replace(/;$/, ''))
     }
 
     /* As above but keeps the trailing `;` for a statement/handler body. */
     function statement(code: string): string {
-        const renamed = renameSignalRefs(code, stateNames, derefScope(), computedNames)
-        return lowerDocAccess(renamed, 'model').trim()
+        return lowerOnce(code)
     }
 
     /* A two-way bind target is either an LVALUE (`count`, `model.lines[i]`) — reads as

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

@@ -1,5 +1,6 @@
 import ts from 'typescript'
 import { escapeKey } from '../runtime/escapeKey.ts'
+import { TS_PRINTER } from './TS_PRINTER.ts'
 
 /*
 The linchpin compiler pass. Rewrites idiomatic data access on a reactive document
@@ -27,8 +28,7 @@ used as an index lowers too.
 export function lowerDocAccess(code: string, docName: string): string {
     const source = ts.createSourceFile('component.ts', code, ts.ScriptTarget.Latest, true)
     const result = ts.transform(source, [docAccessTransformer(docName)])
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
-    const output = printer.printFile(result.transformed[0] as ts.SourceFile)
+    const output = TS_PRINTER.printFile(result.transformed[0] as ts.SourceFile)
     result.dispose()
     return output
 }
@@ -49,7 +49,7 @@ const COMPOUND_OPERATORS = new Map<ts.SyntaxKind, ts.BinaryOperator>([
     [ts.SyntaxKind.QuestionQuestionEqualsToken, ts.SyntaxKind.QuestionQuestionToken],
 ])
 
-function docAccessTransformer(docName: string): ts.TransformerFactory<ts.SourceFile> {
+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. */
@@ -107,6 +107,32 @@ function docAccessTransformer(docName: string): ts.TransformerFactory<ts.SourceF
                     }
                 }
             }
+            /* `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
+               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) {
+                    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 docCall(docName, 'replace', [buildPath(segments), next])
+                }
+            }
             /* 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 (

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

@@ -0,0 +1,64 @@
+import ts from 'typescript'
+import { assertTranspiles } from './assertTranspiles.ts'
+import { desugarSignals } from './desugarSignals.ts'
+import { docAccessTransformer } from './lowerDocAccess.ts'
+import { signalRefsTransformer } from './renameSignalRefs.ts'
+import { stripEffectsTransformer } from './stripEffects.ts'
+import { TS_PRINTER } from './TS_PRINTER.ts'
+
+/*
+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): {
+    body: string
+    imports: string
+    ssrBody: string
+    stateNames: Set<string>
+    derivedNames: Set<string>
+    computedNames: Set<string>
+} {
+    const source = ts.createSourceFile('component.ts', scriptBody, ts.ScriptTarget.Latest, true)
+    const { transformer, stateNames, derivedNames, computedNames } = desugarSignals(source)
+    const result = ts.transform(source, [
+        transformer,
+        signalRefsTransformer(stateNames, derivedNames, computedNames),
+        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 imports = importStatements
+        .map((statement) => TS_PRINTER.printNode(ts.EmitHint.Unspecified, statement, transformed))
+        .join('\n')
+    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()
+
+    assertTranspiles(
+        [imports, body].filter((part) => part !== '').join('\n'),
+        'component script lowering',
+    )
+    return { body, imports, ssrBody, stateNames, derivedNames, computedNames }
+}