@abide/abide 0.57.1 → 0.100.0

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

@@ -1,62 +0,0 @@
-import ts from 'typescript'
-import { NESTED_REACTIVE_BINDINGS } from './resolveReactiveExport.ts'
-import { signalCallee } from './signalCallee.ts'
-
-/*
-The signal binding names a `<script>` nested in a control-flow branch declares
-(`state`/`linked`/`computed`). The back-end adds them to the deref scope so both the
-script body and the branch's markup rewrite `{a}` → `a.value` — these stay PLAIN
-signals (local to the branch's render, owned by its scope, re-seeded from the
-in-scope data each mount), unlike the top-level component script which desugars to
-the serializable `doc`.
-*/
-export function nestedBindingNames(code: string): Set<string> {
-    const source = ts.createSourceFile('nested.ts', code, ts.ScriptTarget.Latest, true)
-    const names = new Set<string>()
-    for (const statement of source.statements) {
-        if (!ts.isVariableStatement(statement)) {
-            continue
-        }
-        for (const declaration of statement.declarationList.declarations) {
-            const callee = signalCallee(declaration, NESTED_REACTIVE_BINDINGS)
-            /* `effect`/`watch` bind no readable value (they return a disposer, not a cell), so
-               they never join the deref scope; every other recognised primitive
-               (state/linked/computed/props) does. */
-            if (
-                callee !== undefined &&
-                callee !== 'effect' &&
-                callee !== 'watch' &&
-                ts.isIdentifier(declaration.name)
-            ) {
-                names.add(declaration.name.text)
-            }
-        }
-    }
-    return names
-}
-
-/* The PLAIN (non-reactive) local names a nested branch `<script>` declares at its top
-   level — a `const title = deriveLocal()` that is neither a signal nor an effect/watch.
-   These must shadow a same-named component signal so a later reference in the script or
-   branch reads the nearer local, not `$$model.read("title")`; registered as `plain`
-   shadows (bare locals), the counterpart to `nestedBindingNames`' `derived` cells. */
-export function nestedPlainLocalNames(code: string): Set<string> {
-    const source = ts.createSourceFile('nested.ts', code, ts.ScriptTarget.Latest, true)
-    const names = new Set<string>()
-    for (const statement of source.statements) {
-        if (!ts.isVariableStatement(statement)) {
-            continue
-        }
-        for (const declaration of statement.declarationList.declarations) {
-            /* Reactive declarations are the `derived` cells `nestedBindingNames` owns; a
-               plain identifier declaration with a non-reactive callee (or no call) is a
-               local. Skip destructuring patterns — the reactive path does too. */
-            const callee = signalCallee(declaration, NESTED_REACTIVE_BINDINGS)
-            const isReactive = callee !== undefined && callee !== 'effect' && callee !== 'watch'
-            if (!isReactive && ts.isIdentifier(declaration.name)) {
-                names.add(declaration.name.text)
-            }
-        }
-    }
-    return names
-}

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

@@ -1,47 +0,0 @@
-import { destructureBindingNames } from './destructureBindingNames.ts'
-import { isPlainIdentifier } from './isPlainIdentifier.ts'
-import type { Binding } from './types/Binding.ts'
-
-/* How the client back-end binds a `reactive` Binding (an `await` `then` value, a keyed
-   `each` item / index): the value arrives as a `.value` cell the runtime can update in
-   place, so the consuming branch/row re-runs in place on a re-settle/re-key rather than
-   being rebuilt. THE RENDERER of a `reactive` classification — it takes the Binding the
-   plan declared, never a raw author param, so a back-end can only render what the plan
-   classified. `param` is the thunk's value parameter (the cell), `prefix` declares any
-   per-leaf readers, `localNames` (the Binding's leaf names) enter the deref scope for the
-   body. A plain identifier reads the cell directly (`item` → `item.value`); a destructure
-   re-applies over the cell per read so each leaf stays reactive (JS handles
-   defaults/rest/rename/nesting). */
-export type ReactiveBindingWiring = {
-    param: string
-    prefix: string
-    localNames: string[]
-}
-
-/* Renders a `reactive` Binding's cell wiring for the client back-end. `nextVar` mints the
-   synthetic cell/derive vars; `lowerStatement` lowers the destructure declaration so a
-   default/computed-key initializer referencing a component signal is rewritten to its
-   `model`/cell form (the bound leaf names are name-slots, untouched). */
-export function reactiveBinding(
-    binding: Binding,
-    nextVar: (hint: string) => string,
-    lowerStatement: (code: string) => string,
-): ReactiveBindingWiring {
-    const authorParam = binding.name
-    if (isPlainIdentifier(authorParam)) {
-        return { param: authorParam, prefix: '', localNames: [authorParam] }
-    }
-    const cellParam = nextVar('aw')
-    const deriveVar = nextVar('ad')
-    const leaves = destructureBindingNames(authorParam)
-    const declaration = lowerStatement(`const ${authorParam} = ${cellParam}.value`)
-    const prefix =
-        `const ${deriveVar} = { get value() { ${declaration} return { ${leaves.join(', ')} }; } };\n` +
-        leaves
-            .map(
-                (leaf) =>
-                    `const ${leaf} = { get value() { return ${deriveVar}.value.${leaf}; } };\n`,
-            )
-            .join('')
-    return { param: cellParam, prefix, localNames: leaves }
-}

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

@@ -1,35 +0,0 @@
-import ts from 'typescript'
-
-/* Every identifier read as a value in `code` — excludes property member names (`.name`) and object
-   literal keys, which are not free variable references. Deliberately generous elsewhere: an inner
-   arrow's param is still collected, so an expression shadowing a binder name inside a callback is
-   judged conservatively (NOT prefix-evaluable) rather than risking a false hoist. Shared by the
-   await-flight and child-render-flight prefix-evaluability checks (ADR-0034 / ADR-0037). */
-export function referencedIdentifiers(code: string): Set<string> {
-    const names = new Set<string>()
-    let source: ts.SourceFile
-    try {
-        source = ts.createSourceFile('expression.ts', code, ts.ScriptTarget.Latest, true)
-    } catch {
-        /* Unparseable expression → treat as non-hoistable by returning a sentinel the caller's
-           binder check can never clear; simplest is a name no scope defines. */
-        return new Set(['\0unparseable'])
-    }
-    const visit = (node: ts.Node): void => {
-        if (ts.isPropertyAccessExpression(node)) {
-            visit(node.expression)
-            return
-        }
-        if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
-            visit(node.initializer)
-            return
-        }
-        if (ts.isIdentifier(node)) {
-            names.add(node.text)
-            return
-        }
-        ts.forEachChild(node, visit)
-    }
-    visit(source)
-    return names
-}

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

@@ -1,30 +0,0 @@
-import type { ShadowMapping } from './types/CompiledShadow.ts'
-
-/*
-Relocates a diagnostic's shadow span back to the original `.abide` source. The
-diagnostic must *overlap* a mapped segment (a verbatim-emitted expression);
-diagnostics confined to synthesised scaffolding overlap nothing and are dropped —
-that is the filter that keeps shadow-internal noise out of the editor. Overlap
-(not containment) is required because TypeScript often reports a whole-expression
-mismatch at the synthetic wrapping `(`, one char before the mapped span; the
-result is clamped into the segment so it lands on real source either way.
-*/
-export function remapShadowDiagnostic(
-    mappings: ShadowMapping[],
-    shadowStart: number,
-    shadowLength: number,
-): { start: number; length: number } | undefined {
-    const shadowEnd = shadowStart + Math.max(shadowLength, 1)
-    const mapping = mappings.find(
-        (entry) => shadowStart < entry.shadowStart + entry.length && entry.shadowStart < shadowEnd,
-    )
-    if (mapping === undefined) {
-        return undefined
-    }
-    const clampedStart = Math.max(shadowStart, mapping.shadowStart)
-    const segmentEnd = mapping.shadowStart + mapping.length
-    return {
-        start: mapping.sourceStart + (clampedStart - mapping.shadowStart),
-        length: Math.max(1, Math.min(shadowEnd, segmentEnd) - clampedStart),
-    }
-}

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

@@ -1,425 +0,0 @@
-import ts from 'typescript'
-import { lowerCompoundAssignment } from './lowerCompoundAssignment.ts'
-import { lowerUpdateExpression } from './lowerUpdateExpression.ts'
-
-/*
-Rewrites references to a component's signal bindings into the document form the
-rest of the pipeline understands: a `state` binding `count` becomes `$$model.count`
-(data access `docAccessTransformer` then lowers to a patch/read), and a `computed`
-binding `total` becomes `total.value`. Only value-position identifiers are
-touched — declaration names, parameter names, and property names are collected
-into a skip set first, and object shorthand (`{ count }`) is expanded to
-`{ count: $$model.count }`. This is the bridge from the signal surface the author
-writes to the patch substrate underneath.
-
-The rewrite is lexically scope-aware: a reference whose name is re-bound by an
-enclosing scope (a function/arrow parameter or a nested local declaration) refers
-to that inner binding, not the component signal, so it is left untouched. Without
-this, a callback like `list.map(option => option.toUpperCase())` in a component
-that also has an `option` prop (`const { option } = props()`) would have its loop
-variable rewritten to `option()` and blow up at runtime (`option is not a function`).
-
-Exposed as a `ts.TransformerFactory`, so the script pipeline can chain it with
-`docAccessTransformer` over a SINGLE parsed tree (see `lowerScript`) instead of
-print-then-reparse between passes.
-*/
-/* `$$readCell(name)` — the unified cell read (peek async / `.value` sync). */
-function cellReadCall(name: string): ts.Expression {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier('$$readCell'), undefined, [
-        ts.factory.createIdentifier(name),
-    ])
-}
-
-/* `$$writeCell(name, value)` — the unified cell write (`.value =` sync / `.set(...)` async). */
-function writeCellCall(name: string, value: ts.Expression): ts.Expression {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier('$$writeCell'), undefined, [
-        ts.factory.createIdentifier(name),
-        value,
-    ])
-}
-
-export function signalRefsTransformer(
-    stateNames: ReadonlySet<string>,
-    derivedNames: ReadonlySet<string>,
-    computedNames: ReadonlySet<string> = new Set(),
-    /* Block-local signal bindings (an `await` `then` / keyed `each` value param, a nested
-       `<script>` declaration) — a nearer lexical scope than the component signals, so a
-       name here shadows a same-named `state`/`computed`/`derived` and derefs as a cell. */
-    blockLocal: ReadonlySet<string> = new Set(),
-    /* Block-local PLAIN bindings — an SSR `await` `then` value bound as a real JS local
-       holding the plain resolved value, not a reactive cell. Like `blockLocal` it shadows
-       a same-named component signal (it is a nearer lexical scope), but it derefs as the
-       bare identifier, not `.value`: SSR declares `const foo = <resolved>`, so a reference
-       reads the local directly. Seeded into the root shadow set so it is left untouched. */
-    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. 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(),
-): 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. */
-    const signalNames = new Set<string>([
-        ...stateNames,
-        ...derivedNames,
-        ...computedNames,
-        ...cellReadNames,
-        ...blockLocal,
-        /* `scope` is the author-facing reactive entry (`scope().state(...)`), lowered to the
-           reserved `$$scope` import so a user variable named `scope` can never collide — but
-           shadowably: a `const scope`/param `scope` re-binds it for that subtree and is left
-           untouched, exactly like a signal name. */
-        'scope',
-    ])
-    return (context) => (root) => {
-        /* The identifier nodes that are names, not value reads — collected by walking
-           each parent and recording its name children (`parent.name`, a label, a
-           specifier). Read structurally, NOT via `child.parent`, so it holds on
-           synthesized nodes too — `desugar`'s rewritten declarations carry no parent
-           pointers, and chaining this transformer after `desugarTransformer` over one
-           tree must still classify their refs correctly. */
-        const nameSlots = collectNameSlots(root)
-        /* Each visitor carries the set of signal names shadowed by the scopes it sits
-           inside; entering a scope that re-binds a signal name produces a fresh visitor
-           with that name added, so shadowing is per-branch (a sibling scope is unaffected). */
-        const makeVisitor = (shadowed: ReadonlySet<string>): ts.Visitor => {
-            const visit = (node: ts.Node): ts.Node => {
-                /* Type space never holds a value read. A type alias, an interface, or any
-                   type annotation can name a signal — a prop-type member `option?: …`, a
-                   `typeof x` — without it being a runtime reference. Leave the whole type
-                   subtree untouched so it isn't rewritten into a call/access (`option()`)
-                   and emitted as broken code (types erase at build anyway). */
-                if (
-                    ts.isTypeAliasDeclaration(node) ||
-                    ts.isInterfaceDeclaration(node) ||
-                    ts.isTypeNode(node)
-                ) {
-                    return node
-                }
-                /* Import/export specifiers are binding/module names, never value reads.
-                   An aliased import whose original name collides with a signal
-                   (`import { pending as p }` next to a `pending` prop) would otherwise
-                   have its `pending` specifier rewritten to the reader form, corrupting
-                   the declaration. Leave the whole subtree untouched. */
-                if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-                    return node
-                }
-                /* An assignment to a `linked` cell (a `cellReadNames` name) — its read form
-                   is `$$readCell(name)`, a call, so it can't sit on an assignment's left.
-                   Lower the write to `$$writeCell(name, value)`, which dispatches `.value =`
-                   (sync `State`) vs `.set(...)` (async `AsyncState`). A compound/logical
-                   assignment folds the current value in through the read form. `state` and
-                   `derived` writes stay on their own paths (`$$model.replace` / `.value =`). */
-                if (
-                    ts.isBinaryExpression(node) &&
-                    ts.isIdentifier(node.left) &&
-                    cellReadNames.has(node.left.text) &&
-                    !shadowed.has(node.left.text)
-                ) {
-                    const target = node.left.text
-                    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 (the bare `++` would otherwise land on `$$readCell(draft)`, an
-                   invalid lvalue). */
-                if (
-                    (ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
-                    (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                        node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                    ts.isIdentifier(node.operand) &&
-                    cellReadNames.has(node.operand.text) &&
-                    !shadowed.has(node.operand.text)
-                ) {
-                    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 }`,
-                   unless a nearer scope shadows the name. */
-                if (ts.isShorthandPropertyAssignment(node) && !shadowed.has(node.name.text)) {
-                    const replacement = referenceFor(
-                        node.name.text,
-                        stateNames,
-                        derivedNames,
-                        computedNames,
-                        blockLocal,
-                        cellReadNames,
-                    )
-                    if (replacement !== undefined) {
-                        return ts.factory.createPropertyAssignment(node.name.text, replacement)
-                    }
-                }
-                if (ts.isIdentifier(node) && !nameSlots.has(node) && !shadowed.has(node.text)) {
-                    const replacement = referenceFor(
-                        node.text,
-                        stateNames,
-                        derivedNames,
-                        computedNames,
-                        blockLocal,
-                        cellReadNames,
-                    )
-                    if (replacement !== undefined) {
-                        return replacement
-                    }
-                }
-                /* Recurse with the scope this node introduces folded in (same visitor when
-                   it adds no shadowing name, so unscoped subtrees allocate nothing extra). */
-                const inner = extendShadowed(node, shadowed, signalNames)
-                return ts.visitEachChild(
-                    node,
-                    inner === shadowed ? visit : makeVisitor(inner),
-                    context,
-                )
-            }
-            return visit
-        }
-        return ts.visitNode(root, makeVisitor(new Set(blockLocalPlain))) as ts.SourceFile
-    }
-}
-
-/*
-Collects every identifier NODE that occupies a name/label/specifier slot — a position
-that DECLARES, NAMES, or LABELS rather than READS. Walks each PARENT and records its
-name children (`parent.name`, a label, a specifier), so it reads structure top-down
-and never touches `child.parent` — it therefore holds on synthesized nodes (e.g.
-`desugar`'s rewritten declarations), which carry no parent pointers. The visitor then
-rewrites any identifier NOT in this set (rewrite is the default — value reads appear
-under almost any expression parent and can't be allow-listed), so this set is the
-exhaustive list of non-read slots. It is positional, so `pending` in
-`import { pending as p }` and `pending` in `pending(query)` are told apart by where
-they sit. A non-read slot missing here would be misread as a value read and rewritten
-into broken syntax, so completeness is NOT self-evident — it is guarded empirically by
-the syntax fuzz corpus (`uiCompileSyntaxFuzz.test.ts`), which transpiles each pass's
-output and fails on any corruption.
-*/
-function collectNameSlots(root: ts.Node): Set<ts.Node> {
-    const slots = new Set<ts.Node>()
-    const add = (name: ts.Node | undefined): void => {
-        if (name !== undefined && ts.isIdentifier(name)) {
-            slots.add(name)
-        }
-    }
-    const visit = (node: ts.Node): void => {
-        /* `obj.NAME` — the member name; the object side (`.expression`) is the read. */
-        if (ts.isPropertyAccessExpression(node)) {
-            add(node.name)
-        }
-        /* `NAME: value`, and method/property/accessor/enum-member names in classes,
-           object literals, and type members. */
-        if (
-            ts.isPropertyAssignment(node) ||
-            ts.isMethodDeclaration(node) ||
-            ts.isPropertyDeclaration(node) ||
-            ts.isGetAccessorDeclaration(node) ||
-            ts.isSetAccessorDeclaration(node) ||
-            ts.isMethodSignature(node) ||
-            ts.isPropertySignature(node) ||
-            ts.isEnumMember(node)
-        ) {
-            add(node.name)
-        }
-        /* Declaration names: const/let/var, parameters, named functions and classes. */
-        if (
-            ts.isVariableDeclaration(node) ||
-            ts.isParameter(node) ||
-            ts.isFunctionDeclaration(node) ||
-            ts.isFunctionExpression(node) ||
-            ts.isClassDeclaration(node) ||
-            ts.isClassExpression(node)
-        ) {
-            add(node.name)
-        }
-        /* A destructure element binds (`{ a }` / `[a]`) or renames (`{ a: b }`): both
-           the bound name and the source key are names, not reads. */
-        if (ts.isBindingElement(node)) {
-            add(node.name)
-            add(node.propertyName)
-        }
-        /* Labels: `NAME:` and `break NAME` / `continue NAME`. */
-        if (ts.isLabeledStatement(node)) {
-            add(node.label)
-        }
-        if (ts.isBreakStatement(node) || ts.isContinueStatement(node)) {
-            add(node.label)
-        }
-        /* Import/export specifier and clause names. */
-        if (ts.isImportSpecifier(node) || ts.isExportSpecifier(node)) {
-            add(node.name)
-            add(node.propertyName)
-        }
-        if (ts.isImportClause(node) || ts.isNamespaceImport(node) || ts.isNamespaceExport(node)) {
-            add(node.name)
-        }
-        ts.forEachChild(node, visit)
-    }
-    visit(root)
-    return slots
-}
-
-/* The shadowed-name set for `node`'s children: the parent set plus any signal name
-   that `node` re-binds as a new scope. Returns the parent set unchanged (same
-   reference) when `node` introduces no colliding binding, so the caller can skip
-   allocating a new visitor. */
-function extendShadowed(
-    node: ts.Node,
-    shadowed: ReadonlySet<string>,
-    signalNames: ReadonlySet<string>,
-): ReadonlySet<string> {
-    const introduced = new Set<string>()
-    collectScopeBindings(node, introduced)
-    const added = [...introduced].filter((name) => signalNames.has(name) && !shadowed.has(name))
-    if (added.length === 0) {
-        return shadowed
-    }
-    return new Set<string>([...shadowed, ...added])
-}
-
-/* The names `node` binds when it opens a lexical scope — function/arrow parameters
-   (and the function's own name), block-level `let`/`const`/`function`/`class`,
-   `for`-header declarations, and the `catch` binding. Only names bound directly at
-   this scope; deeper scopes are folded in as the walk descends into them. */
-function collectScopeBindings(node: ts.Node, into: Set<string>): void {
-    const parameters = functionParameters(node)
-    if (parameters !== undefined) {
-        for (const parameter of parameters) {
-            collectBindingNames(parameter.name, into)
-        }
-        if (
-            (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) &&
-            node.name !== undefined
-        ) {
-            into.add(node.name.text)
-        }
-        return
-    }
-    if (ts.isBlock(node) || ts.isModuleBlock(node) || ts.isCaseBlock(node)) {
-        const statements = ts.isCaseBlock(node)
-            ? node.clauses.flatMap((clause) => [...clause.statements])
-            : node.statements
-        for (const statement of statements) {
-            collectStatementBindings(statement, into)
-        }
-        return
-    }
-    if (ts.isCatchClause(node) && node.variableDeclaration !== undefined) {
-        collectBindingNames(node.variableDeclaration.name, into)
-        return
-    }
-    if (ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) {
-        const initializer = node.initializer
-        if (initializer !== undefined && ts.isVariableDeclarationList(initializer)) {
-            for (const declaration of initializer.declarations) {
-                collectBindingNames(declaration.name, into)
-            }
-        }
-    }
-}
-
-/* The names a single block-level statement binds: `var`/`let`/`const`, and named
-   `function`/`class` declarations. */
-function collectStatementBindings(statement: ts.Statement, into: Set<string>): void {
-    if (ts.isVariableStatement(statement)) {
-        for (const declaration of statement.declarationList.declarations) {
-            collectBindingNames(declaration.name, into)
-        }
-    }
-    if (
-        (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) &&
-        statement.name !== undefined
-    ) {
-        into.add(statement.name.text)
-    }
-}
-
-/* Every identifier bound by a binding name — a plain identifier or the leaves of a
-   destructuring pattern (object/array, including rest elements). */
-function collectBindingNames(name: ts.BindingName, into: Set<string>): void {
-    if (ts.isIdentifier(name)) {
-        into.add(name.text)
-        return
-    }
-    for (const element of name.elements) {
-        if (ts.isBindingElement(element)) {
-            collectBindingNames(element.name, into)
-        }
-    }
-}
-
-/* The parameter list of a function-like node, or undefined if `node` is not one. */
-function functionParameters(node: ts.Node): ts.NodeArray<ts.ParameterDeclaration> | undefined {
-    if (
-        ts.isArrowFunction(node) ||
-        ts.isFunctionDeclaration(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isMethodDeclaration(node) ||
-        ts.isConstructorDeclaration(node) ||
-        ts.isGetAccessorDeclaration(node) ||
-        ts.isSetAccessorDeclaration(node)
-    ) {
-        return node.parameters
-    }
-    return undefined
-}
-
-/* `$$model.<name>` for a state binding, `<name>()` for a computed doc-slot (the
-   string-free reader `scope().derive` returns), `<name>.value` for a runtime cell
-   (linked / lens / transform-state), else undefined. A `blockLocal` binding shadows
-   any same-named component signal — it is a nearer lexical scope — so it derefs as a
-   cell (`<name>.value`) regardless of a colliding `state`/`computed`/`derived`.
-   `children` is an ordinary destructured prop now — it rewrites via the `derivedNames`
-   branch below like any other, with no special case. */
-function referenceFor(
-    name: string,
-    stateNames: ReadonlySet<string>,
-    derivedNames: ReadonlySet<string>,
-    computedNames: ReadonlySet<string>,
-    blockLocal: ReadonlySet<string> = new Set(),
-    cellReadNames: ReadonlySet<string> = new Set(),
-): ts.Expression | undefined {
-    if (blockLocal.has(name)) {
-        return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), 'value')
-    }
-    /* The author-facing reactive entry `scope` lowers to its reserved `$$scope` import (the
-       value read only — a `.scope` member or a shadowing local is never reached here). */
-    if (name === 'scope') {
-        return ts.factory.createIdentifier('$$scope')
-    }
-    /* 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'),
-            undefined,
-            [ts.factory.createIdentifier(name)],
-        )
-    }
-    if (stateNames.has(name)) {
-        return ts.factory.createPropertyAccessExpression(
-            ts.factory.createIdentifier('$$model'),
-            name,
-        )
-    }
-    if (computedNames.has(name)) {
-        return ts.factory.createCallExpression(ts.factory.createIdentifier(name), undefined, [])
-    }
-    if (derivedNames.has(name)) {
-        return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), 'value')
-    }
-    return undefined
-}

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

@@ -1,29 +0,0 @@
-import { dirname, resolve } from 'node:path'
-import ts from 'typescript'
-
-/*
-A module-name resolver shared by the shadow Program (check) and LanguageService
-(LSP). A relative `./X.abide` import resolves directly to its virtual shadow
-`./X.abide.ts` (the host serves shadow text for any `*.abide.ts` name), so
-cross-component prop checking works. An aliased `.abide` (`$ui/X.abide`) falls
-through to TypeScript's own resolver, which applies the tsconfig `paths` and —
-because the host reports the shadow `.abide.ts` exists — lands on the same
-shadow. Every other specifier (`abide/*`, `$server/*`, plain relative `.ts`,
-asset modules covered by the ambient declarations) resolves through TypeScript
-directly, exactly as for the real module.
-*/
-export function resolveAbideImports(
-    options: ts.CompilerOptions,
-    host: ts.ModuleResolutionHost,
-): (moduleNames: string[], containingFile: string) => (ts.ResolvedModule | undefined)[] {
-    return (moduleNames, containingFile) =>
-        moduleNames.map((name) => {
-            if (name.endsWith('.abide')) {
-                const relative = resolve(dirname(containingFile), name)
-                if (ts.sys.fileExists(relative)) {
-                    return { resolvedFileName: `${relative}.ts`, extension: ts.Extension.Ts }
-                }
-            }
-            return ts.resolveModuleName(name, containingFile, options, host).resolvedModule
-        })
-}

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

@@ -1,21 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-type Branch = Extract<TemplateNode, { kind: 'branch' }>
-type BranchName = Branch['branch']
-
-/* Extracts the `then`/`catch`/`finally` branch children of a control-flow block
-   (await/try), one slot per requested name in the order asked, so callers
-   destructure them directly. A requested branch that is absent yields `undefined`
-   — the caller reads `?.children`/`?.as` for its content and bound var. This is
-   the one branch-lookup site both back-ends share, replacing the per-generator
-   `findBranch`/`branchNamed`/`branchChildren`/`branchVar` copies. */
-export function resolveBranches(
-    node: Extract<TemplateNode, { children: TemplateNode[] }>,
-    ...which: BranchName[]
-): (Branch | undefined)[] {
-    return which.map((name) =>
-        node.children.find(
-            (child): child is Branch => child.kind === 'branch' && child.branch === name,
-        ),
-    )
-}