@abide/abide 0.58.0 → 0.100.0

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

@@ -1,28 +0,0 @@
-import { staticAttrValue } from './staticAttrValue.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-The pieces a `bind:group` needs from its own element: `valueCode` is the JS source
-of the control's `value` (a string literal for static `value="x"`, the expression
-for `value={expr}`); `isRadio` selects single-value (radio) vs array-membership
-(checkbox) semantics. Throws on the two cases the binding can't mean anything for —
-a missing `value`, or a `type` not statically `radio`/`checkbox` (the semantics are
-chosen at compile time, so the type can't be dynamic).
-*/
-export function groupBindParts(node: Extract<TemplateNode, { kind: 'element' }>): {
-    valueCode: string
-    isRadio: boolean
-} {
-    const value = node.attrs.find(
-        (attr) => (attr.kind === 'static' || attr.kind === 'expression') && attr.name === 'value',
-    )
-    if (value === undefined || (value.kind !== 'static' && value.kind !== 'expression')) {
-        throw new Error('bind:group requires a `value` attribute on the same element')
-    }
-    const valueCode = value.kind === 'static' ? JSON.stringify(value.value) : value.code
-    const type = staticAttrValue(node, 'type')
-    if (type !== 'radio' && type !== 'checkbox') {
-        throw new Error('bind:group requires a static type="radio" or type="checkbox"')
-    }
-    return { valueCode, isRadio: type === 'radio' }
-}

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

@@ -1,28 +0,0 @@
-import ts from 'typescript'
-import { isFunctionScopeBoundary } from './isFunctionScopeBoundary.ts'
-
-/*
-True when `node` contains an `await` at its OWN top level — not nested inside any function scope
-(`isFunctionScopeBoundary`: function/arrow/method/accessor/constructor). The SINGLE seed classifier
-both the build lowering (`desugarSignals`: `await` present → a BLOCKING cell that suspends its render
-region) and the type shadow (`compileShadow`: `$$cellValue` `T` vs `$$cellValuePending` `T | undefined`)
-share, so the runtime blocking flag and the shadow type can never disagree on whether a seed is
-`await`-marked (ADR-0042 D5's "one predicate"). An `await` in an inner callback / method
-(`items.map(async (x) => await f(x))`, `{ async m() { await x } }`) does NOT count — only a
-top-level `await` marks the seed itself.
-*/
-export function hasTopLevelAwait(node: ts.Node): boolean {
-    let found = false
-    const visit = (child: ts.Node): void => {
-        if (found || isFunctionScopeBoundary(child)) {
-            return
-        }
-        if (ts.isAwaitExpression(child)) {
-            found = true
-            return
-        }
-        ts.forEachChild(child, visit)
-    }
-    visit(node)
-    return found
-}

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

@@ -1,120 +0,0 @@
-import ts from 'typescript'
-import { TS_PRINTER } from './TS_PRINTER.ts'
-
-/*
-The perf pass that follows `lowerDocAccess`. Within a render scope, a static path
-is read and written many times; resolving it to a node + parent + key on every
-access (what `read`/`replace` do) is the path-string floor the bench measured.
-This hoists each distinct static path to a `cell` bound once at the top of the
-scope and rewrites accesses to the string-free `get`/`set` — the form that runs
-~20x faster than re-resolving:
-
-  model.read("count")          →  _cell0.get()
-  model.replace("count", v)    →  _cell0.set(v)
-  // with, prepended once:        const _cell0 = model.cell("count")
-
-The input is a render-scope body where `docName` is already in scope (the cell
-decls are prepended to it, so the doc must exist first). Dynamic-path accesses
-(`read(`a/${i}`)`) and structural ops (`add`/`remove`) are left untouched — a
-cell binds one fixed scalar leaf.
-*/
-export function hoistCells(code: string, docName: string): string {
-    const source = ts.createSourceFile('component.ts', code, ts.ScriptTarget.Latest, true)
-    const cellIdForPath = new Map<string, string>()
-
-    /* Pass 1: assign a cell id to each distinct static read/replace path. */
-    const collect = (node: ts.Node): void => {
-        const path = staticDocPath(node, docName, 'read') ?? staticDocPath(node, docName, 'replace')
-        if (path !== undefined && !cellIdForPath.has(path)) {
-            cellIdForPath.set(path, `_cell${cellIdForPath.size}`)
-        }
-        ts.forEachChild(node, collect)
-    }
-    collect(source)
-    if (cellIdForPath.size === 0) {
-        return code
-    }
-
-    const result = ts.transform(source, [hoistTransformer(docName, cellIdForPath)])
-    const output = TS_PRINTER.printFile(result.transformed[0] as ts.SourceFile)
-    result.dispose()
-    return output
-}
-
-/* Returns the literal path of a `docName.method("literal", …)` call, else undefined. */
-function staticDocPath(node: ts.Node, docName: string, method: string): string | undefined {
-    if (
-        ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === docName &&
-        node.expression.name.text === method
-    ) {
-        const first = node.arguments[0]
-        if (first !== undefined && ts.isStringLiteral(first)) {
-            return first.text
-        }
-    }
-    return undefined
-}
-
-function hoistTransformer(
-    docName: string,
-    cellIdForPath: Map<string, string>,
-): ts.TransformerFactory<ts.SourceFile> {
-    return (context) => (root) => {
-        function visit(node: ts.Node): ts.Node {
-            const readPath = staticDocPath(node, docName, 'read')
-            if (readPath !== undefined) {
-                return cellCall(cellIdForPath.get(readPath) as string, 'get', [])
-            }
-            const replacePath = staticDocPath(node, docName, 'replace')
-            if (replacePath !== undefined) {
-                const value = (node as ts.CallExpression).arguments[1]
-                return cellCall(cellIdForPath.get(replacePath) as string, 'set', [
-                    ts.visitNode(value, visit) as ts.Expression,
-                ])
-            }
-            return ts.visitEachChild(node, visit, context)
-        }
-        const visited = ts.visitNode(root, visit) as ts.SourceFile
-        const declarations = [...cellIdForPath].map(([path, id]) =>
-            cellDeclaration(docName, id, path),
-        )
-        return ts.factory.updateSourceFile(visited, [...declarations, ...visited.statements])
-    }
-}
-
-/* Builds `cellId.method(...args)`. */
-function cellCall(cellId: string, method: string, args: ts.Expression[]): ts.CallExpression {
-    return ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(cellId), method),
-        undefined,
-        args,
-    )
-}
-
-/* Builds `const cellId = docName.cell("path")`. */
-function cellDeclaration(docName: string, cellId: string, path: string): ts.VariableStatement {
-    return ts.factory.createVariableStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-            [
-                ts.factory.createVariableDeclaration(
-                    cellId,
-                    undefined,
-                    undefined,
-                    ts.factory.createCallExpression(
-                        ts.factory.createPropertyAccessExpression(
-                            ts.factory.createIdentifier(docName),
-                            'cell',
-                        ),
-                        undefined,
-                        [ts.factory.createStringLiteral(path)],
-                    ),
-                ),
-            ],
-            ts.NodeFlags.Const,
-        ),
-    )
-}

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

@@ -1,183 +0,0 @@
-import ts from 'typescript'
-import { declaredNames } from './declaredNames.ts'
-import { expressionIsPrefixEvaluable } from './expressionIsPrefixEvaluable.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* One hoistable await: the node whose promise-start moves to the SSR prefix, and the
-   `$flightN` const name that holds the in-flight promise. */
-export type HoistedFlight = {
-    node: Extract<TemplateNode, { kind: 'await' }>
-    name: string
-}
-
-/*
-ADR-0034 — the SSR-only pass that picks which `await` blocks may start their promise in the
-synchronous render prefix so independent flights overlap instead of serializing. An await is
-HOISTABLE iff its promise is evaluable at prefix time and its content is unconditionally rendered:
-
-  1. Its promise's referenced identifiers avoid every enclosing TEMPLATE-LOCAL binder (a `{#for}`
-     item/index, a `{:then}`/`{:catch}`/`then v` value, a snippet param, a nested `<script>`
-     local) — those don't exist in the prefix — AND every ASYNC-CELL name (`cellReadNames`, still
-     pending at prefix time).
-  2. It is not inside a CONDITIONALLY-rendered branch (`{#if}`/`{#switch}`/`{#try}`, a snippet/slot
-     body, or another await's pending/then/catch branch) — starting its flight eagerly would fetch
-     for a branch that may never render, or surface an error prematurely.
-  3. It is STATICALLY-SINGLE: on the top-level spine, or inside a single-element-literal
-     `{#for k of [expr] by k}` whose body renders exactly once (so one hoisted flight == one row).
-
-Fail-closed: identifiers are over-collected and any doubt blocks the hoist, so a mis-classified
-row-local flight can never collapse a multi-row `{#for}` to one shared value. Server-only — the
-returned nodes are rewired only in `generateSSR`; the client build and the wire are untouched.
-*/
-export function hoistableAwaits(
-    nodes: TemplateNode[],
-    cellReadNames: ReadonlySet<string>,
-): HoistedFlight[] {
-    const flights: HoistedFlight[] = []
-    const counter = { next: 0 }
-    walkList(nodes, new Set<string>(), false, false, cellReadNames, flights, counter)
-    return flights
-}
-
-/* Walk a sibling list left-to-right so a nested `<script>`'s declared locals extend the binder
-   set for the siblings that follow it (they are in that script's lexical scope). */
-function walkList(
-    list: TemplateNode[],
-    binders: ReadonlySet<string>,
-    conditional: boolean,
-    multiRow: boolean,
-    cellReadNames: ReadonlySet<string>,
-    flights: HoistedFlight[],
-    counter: { next: number },
-): void {
-    /* A running binder set for this list: a `<script>` sibling adds its top-level declarations,
-       so a later sibling's await that reads one is (conservatively) not hoistable. */
-    let listBinders = binders
-    for (const node of list) {
-        if (node.kind === 'script') {
-            listBinders = union(listBinders, declaredNames(node.code))
-            continue
-        }
-        walkNode(node, listBinders, conditional, multiRow, cellReadNames, flights, counter)
-    }
-}
-
-function walkNode(
-    node: TemplateNode,
-    binders: ReadonlySet<string>,
-    conditional: boolean,
-    multiRow: boolean,
-    cellReadNames: ReadonlySet<string>,
-    flights: HoistedFlight[],
-    counter: { next: number },
-): void {
-    if (node.kind === 'await') {
-        /* Hoistability is judged in the INCOMING context — the block's promise starts when the
-           block mounts (its pending branch always renders), so it is not gated by its own
-           branches, only by an enclosing conditional/multi-row. */
-        if (
-            !conditional &&
-            !multiRow &&
-            expressionIsPrefixEvaluable(node.promise, binders, cellReadNames)
-        ) {
-            flights.push({ node, name: `$flight${counter.next++}` })
-        }
-        /* The resolved/catch/pending branches are conditionally shown and bind the resolved value
-           (`node.as` for `{#await p then v}`; a `{:then v}`/`{:catch e}` branch binds via its own
-           `as`, added when that branch node is walked). */
-        const inner = node.as === undefined ? binders : union(binders, new Set([node.as]))
-        walkList(node.children, inner, true, multiRow, cellReadNames, flights, counter)
-        return
-    }
-    if (node.kind === 'each') {
-        /* Row/index bindings are template-local; the body is multi-row unless the source is a
-           single-element array literal (then it renders exactly once). `{#for await}` drains a
-           stream — its body is still per-frame, so treat it as multi-row. */
-        const rowBinders = new Set<string>()
-        rowBinders.add(node.as)
-        if (node.index !== undefined) {
-            rowBinders.add(node.index)
-        }
-        const rowMulti = multiRow || node.async === true || !isSingleElementLiteral(node.items)
-        walkList(
-            node.children,
-            union(binders, rowBinders),
-            conditional,
-            rowMulti,
-            cellReadNames,
-            flights,
-            counter,
-        )
-        return
-    }
-    if (
-        node.kind === 'if' ||
-        node.kind === 'switch' ||
-        node.kind === 'case' ||
-        node.kind === 'try'
-    ) {
-        /* Conditionally-rendered subtrees — never hoist a flight out of them. */
-        walkList(node.children, binders, true, multiRow, cellReadNames, flights, counter)
-        return
-    }
-    if (node.kind === 'branch') {
-        const inner = node.as === undefined ? binders : union(binders, new Set([node.as]))
-        walkList(node.children, inner, true, multiRow, cellReadNames, flights, counter)
-        return
-    }
-    if (node.kind === 'snippet') {
-        /* A snippet is a builder called conditionally; its params are locals. */
-        const params =
-            node.params === undefined
-                ? new Set<string>()
-                : declaredNames(`const [${node.params}] = []`)
-        walkList(
-            node.children,
-            union(binders, params),
-            true,
-            multiRow,
-            cellReadNames,
-            flights,
-            counter,
-        )
-        return
-    }
-    if (node.kind === 'component') {
-        /* Slot content is a fresh, lazily-built scope rendered at the child's `<slot>`. */
-        walkList(node.children, binders, true, multiRow, cellReadNames, flights, counter)
-        return
-    }
-    if (node.kind === 'element' && 'children' in node) {
-        walkList(node.children, binders, conditional, multiRow, cellReadNames, flights, counter)
-    }
-}
-
-/* A single-element array literal like `[remountKey]` — the only `{#for}` source that renders its
-   body exactly once, so a hoisted flight inside it maps to one row (no shared-flight hazard). */
-function isSingleElementLiteral(items: string): boolean {
-    let source: ts.SourceFile
-    try {
-        source = ts.createSourceFile('items.ts', items, ts.ScriptTarget.Latest, true)
-    } catch {
-        return false
-    }
-    const statement = source.statements[0]
-    if (
-        statement === undefined ||
-        source.statements.length !== 1 ||
-        !ts.isExpressionStatement(statement) ||
-        !ts.isArrayLiteralExpression(statement.expression)
-    ) {
-        return false
-    }
-    const elements = statement.expression.elements
-    return elements.length === 1 && !ts.isSpreadElement(elements[0] as ts.Expression)
-}
-
-function union(a: ReadonlySet<string>, b: ReadonlySet<string>): Set<string> {
-    const result = new Set(a)
-    for (const value of b) {
-        result.add(value)
-    }
-    return result
-}

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

@@ -1,112 +0,0 @@
-import { declaredNames } from './declaredNames.ts'
-import { expressionIsPrefixEvaluable } from './expressionIsPrefixEvaluable.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-type ComponentNode = Extract<TemplateNode, { kind: 'component' }>
-
-/*
-ADR-0037 Phase 2 — which `<Child/>` renders may START in the synchronous SSR prefix (as a `$$flight`
-awaited at its structural position) so sibling child renders overlap instead of serializing behind
-each other's `await Child.render(...)`. A child render is HOISTABLE iff it is on the TOP-LEVEL SPINE
-— reachable from the template root through only plain elements, so no control-flow / await-branch /
-snippet / slot binder is in scope — AND:
-
-  1. its component reference and every prop value (including a `{...spread}`) are prefix-evaluable:
-     no async-cell name (still pending at the prefix, before the barrier) and no nested-`<script>`
-     local declared earlier on the spine (those lower at their body position, not the prefix);
-  2. it carries NO slot content (`children` empty) — lazily-built slot content would need its own
-     prefix-evaluability proof; a childless card is the common parallel case;
-  3. no `bind:` prop — a two-way write-back channel that must wire at its structural position.
-
-Off-spine components (inside `{#if}`/`{#for}`/`{#await}`, a snippet, or another component's slot) stay
-sequential: conservatively excluded rather than proven row/branch-safe. Fail-closed throughout — any
-doubt leaves the render sequential, never wrong. Server-only; the client build is untouched.
-*/
-export function hoistableChildRenders(
-    nodes: TemplateNode[],
-    cellReadNames: ReadonlySet<string>,
-): Set<ComponentNode> {
-    const hoistable = new Set<ComponentNode>()
-    /* Every `{#snippet name}` in the component is a hoisted builder that may itself render an
-       async cell / await; a prop passing one to a child (`<List item={row}/>`) must therefore NOT
-       hoist — calling `row()` early, in the prefix, would render it out of order. Seed the binder set
-       with all snippet names (collected tree-wide, since a snippet is in scope for the whole
-       component) so any prop referencing one fails the prefix-evaluability check. */
-    const binders = new Set<string>()
-    collectSnippetNames(nodes, binders)
-    walkSpine(nodes, binders, cellReadNames, hoistable)
-    return hoistable
-}
-
-/* Recursively collect every `{#snippet name}` name in the subtree into `into`. */
-function collectSnippetNames(list: TemplateNode[], into: Set<string>): void {
-    for (const node of list) {
-        if (node.kind === 'snippet') {
-            into.add(node.name)
-        }
-        if ('children' in node && Array.isArray(node.children)) {
-            collectSnippetNames(node.children, into)
-        }
-    }
-}
-
-/* Walk a spine sibling list left-to-right: a `<script>` sibling's locals bind the siblings that
-   follow it; a component is judged in the running binder context; a plain element descends (still on
-   the spine). Every other node kind leaves the spine and is not descended — its components stay
-   sequential. */
-function walkSpine(
-    list: TemplateNode[],
-    binders: ReadonlySet<string>,
-    cellReadNames: ReadonlySet<string>,
-    hoistable: Set<ComponentNode>,
-): void {
-    let running = binders
-    for (const node of list) {
-        if (node.kind === 'script') {
-            running = union(running, declaredNames(node.code))
-            continue
-        }
-        if (node.kind === 'component') {
-            if (componentIsHoistable(node, running, cellReadNames)) {
-                hoistable.add(node)
-            }
-            /* Slot children are off-spine (built lazily inside the child) — not descended. */
-            continue
-        }
-        if (node.kind === 'element' && 'children' in node) {
-            walkSpine(node.children, running, cellReadNames, hoistable)
-        }
-        /* if / switch / each / await / try / snippet / branch: off the spine, skip. */
-    }
-}
-
-/* Childless, bind-free, with a prefix-evaluable tag and every prop value prefix-evaluable. */
-function componentIsHoistable(
-    node: ComponentNode,
-    binders: ReadonlySet<string>,
-    cellReadNames: ReadonlySet<string>,
-): boolean {
-    if (node.children.length > 0) {
-        return false
-    }
-    if (!expressionIsPrefixEvaluable(node.name, binders, cellReadNames)) {
-        return false
-    }
-    for (const prop of node.props) {
-        if (prop.bind === true) {
-            return false
-        }
-        if (!expressionIsPrefixEvaluable(prop.code, binders, cellReadNames)) {
-            return false
-        }
-    }
-    return true
-}
-
-function union(a: ReadonlySet<string>, b: ReadonlySet<string>): Set<string> {
-    const result = new Set(a)
-    for (const value of b) {
-        result.add(value)
-    }
-    return result
-}

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

@@ -1,13 +0,0 @@
-import { escapeRegex } from '../../shared/escapeRegex.ts'
-
-/*
-A RegExp that matches `name` used as a whole identifier in a body of code.
-Boundaries are `(?<![$\w]) … (?![$\w])`, NOT `\b`: `\b` never fires before a
-`$`-leading identifier (`$` is a non-word char, so there's no word boundary
-before it), so `\b$e\b` silently matches nothing — the exact miss that made an
-aliased reactive import (`import { effect as $e }`) read as dead. The name is
-regex-escaped so a `$` or other metachar in it is literal, not an anchor.
-*/
-export function identifierReferencePattern(name: string): RegExp {
-    return new RegExp(`(?<![$\\w])${escapeRegex(name)}(?![$\\w])`)
-}

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

@@ -1,36 +0,0 @@
-import type { Binding } from './types/Binding.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-type Case = Extract<TemplateNode, { kind: 'case' }>
-
-/* The structural shape of an `if` chain, resolved once so the build and SSR back-ends share
-   one partition of its children and only own emission. Both previously recomputed the
-   then-content / branch split and the elseif/else classification. An `if`/`elseif`/`else`
-   introduces no names, so `bindings` is empty — present so every block plan answers the
-   single binding source uniformly. */
-export type IfPlan = {
-    /* The `then` content — every child that is not an `elseif`/`else` branch. */
-    thenChildren: TemplateNode[]
-    /* The `elseif`/`else` branches in source order (each a `case` node: `condition` set for
-       `elseif`, both unset for `else`). */
-    branches: Case[]
-    /* Any branch carries a condition → a cond-chain (the build lowers it through `switchBlock`);
-       otherwise a binary `if`/`else`. */
-    hasElseif: boolean
-    /* The match-less `else` branch, if present. */
-    elseBranch: Case | undefined
-    /* An `if` chain binds no names. */
-    bindings: Binding[]
-}
-
-/* Partitions an `if` node's children into the shared structural plan. */
-export function ifPlan(node: Extract<TemplateNode, { kind: 'if' }>): IfPlan {
-    const branches = node.children.filter((child): child is Case => child.kind === 'case')
-    return {
-        thenChildren: node.children.filter((child) => child.kind !== 'case'),
-        branches,
-        hasElseif: branches.some((branch) => branch.condition !== undefined),
-        elseBranch: branches.find((branch) => branch.condition === undefined),
-        bindings: [],
-    }
-}

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

@@ -1,27 +0,0 @@
-import type { TextPart } from './types/TextPart.ts'
-
-/* Escapes a literal attribute chunk for embedding in a JS template literal: a
-   backslash, backtick, or `${` would otherwise start an escape/expression. */
-function escapeTemplateChunk(value: string): string {
-    return value.replace(/[\\`]/g, '\\$&').replace(/\$\{/g, '\\${')
-}
-
-/*
-Builds the RAW (un-lowered) template-literal source for an interpolated attribute
-or prop value — static parts escaped, each `{expr}` spliced as `${code}`. The caller
-lowers the whole result through its signal transformer, so the embedded expressions
-are rewritten exactly like any other template expression. Both back-ends and the
-component-prop path share this one builder, so server markup, client binding, and
-prop value can't diverge on the concatenation. Always yields a string, so an
-interpolated attribute is always present.
-*/
-export function interpolatedTemplateLiteral(parts: TextPart[]): string {
-    /* A dynamic slot coerces nullish to empty so `attr="a {v} b"` with a pending/undefined
-       `v` yields `"a  b"`, never `"a undefined b"` (ADR-0032 D3). */
-    const body = parts
-        .map((part) =>
-            part.kind === 'static' ? escapeTemplateChunk(part.value) : `\${(${part.code}) ?? ''}`,
-        )
-        .join('')
-    return `\`${body}\``
-}

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

@@ -1,32 +0,0 @@
-import { cachedShadowProgram } from './cachedShadowProgram.ts'
-import type { ShadowProgram } from './createShadowProgram.ts'
-import { shadowInterpolationClassifier } from './shadowInterpolationClassifier.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-
-/*
-Builds the type-directed interpolation classifier for one `.abide` file, backed by
-a WARM shadow program kept once per project root (ADR-0019, Stage B). The shadow
-program (checker + every component's source→shadow `mappings`) is expensive to
-build, so it is created lazily on first request for a root and reused for every
-component in that root — the coupling that makes type-directed lowering affordable.
-The incremental `createShadowLanguageService` does not expose the checker, shadow
-`ts.SourceFile`, or per-file mappings publicly, so v1 uses the one-shot
-`createShadowProgram` (reused per root) rather than the LS overlay path.
-
-FAIL-OPEN throughout: if the program can't be built (warned once per root by
-`cachedShadowProgram`), or the file has no shadow, the classifier is absent (→ today's
-plain-value binding); and the returned closure wraps its whole body so ANY throw
-(resolution failure, missing node, checker hiccup) returns `'sync'`. A type-resolution
-problem degrades to today's behavior, never breaks the build.
-*/
-export function interpolationClassifierForRoot(
-    cache: Map<string, ShadowProgram | undefined>,
-    root: string,
-    abidePath: string,
-): InterpolationClassifier | undefined {
-    const shadowProgram = cachedShadowProgram(cache, root)
-    if (shadowProgram === undefined) {
-        return undefined
-    }
-    return shadowInterpolationClassifier(shadowProgram.program, shadowProgram.shadows, abidePath)
-}

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

@@ -1,19 +0,0 @@
-import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
-import { isControlFlow } from './isControlFlow.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-The node kinds that mount as a marker range and so take an `<!--a-->` anchor when in a
-skeleton — control-flow, child component, and the two outlet elements (a layout's
-`OUTLET_TAG`, a component's `<slot>`). The single positioning predicate every back-end
-shares — `generateSSR` gates its anchor emission on it, `skeletonContext` gates its anchor
-indexing on it — so SSR, the client clone, and the shared numberer cannot disagree on which
-nodes anchor.
-*/
-export function isAnchorPositioned(node: TemplateNode): boolean {
-    return (
-        isControlFlow(node) ||
-        node.kind === 'component' ||
-        (node.kind === 'element' && (node.tag === OUTLET_TAG || node.tag === 'slot'))
-    )
-}

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

@@ -1,20 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-A control-flow block — `if`/`each`/`await`/`switch`/`try`. In a skeleton each mounts at an
-`<!--a-->` anchor cloned into its located parent at the block's position (see `anchorCursor`),
-so a block can sit ANYWHERE among static siblings. The shared classification under block
-anchor placement: both back-ends — and `skeletonable` — consult this so they agree on which
-nodes are anchor-positioned. A child component is anchor-positioned too (it mounts as a
-`[`…`]` range like a block, see `mountRange`); the back-ends OR this with `kind ===
-'component'` rather than folding it in here, since a standalone component routes differently.
-*/
-export function isControlFlow(node: TemplateNode): boolean {
-    return (
-        node.kind === 'if' ||
-        node.kind === 'each' ||
-        node.kind === 'await' ||
-        node.kind === 'switch' ||
-        node.kind === 'try'
-    )
-}

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

@@ -1,20 +0,0 @@
-import ts from 'typescript'
-
-/*
-A node that opens its own (possibly async) function scope — awaits inside it are that scope's
-concern, not the enclosing seed's. Both the top-level-await walk (`hasTopLevelAwait`) and the
-top-level-await diagnostics stop descending here, so a seed classifies the same way a value read
-inside such a scope would behave. One predicate shared by the build lowering and the type shadow so
-they can never disagree on a boundary (ADR-0042 D5's "one predicate").
-*/
-export function isFunctionScopeBoundary(node: ts.Node): boolean {
-    return (
-        ts.isFunctionDeclaration(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isArrowFunction(node) ||
-        ts.isMethodDeclaration(node) ||
-        ts.isGetAccessorDeclaration(node) ||
-        ts.isSetAccessorDeclaration(node) ||
-        ts.isConstructorDeclaration(node)
-    )
-}

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

@@ -1,7 +0,0 @@
-/* Compiled once at module load — re-evaluating the literal per call would recompile it. */
-const PLAIN_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/
-
-/* Matches a JS identifier — a plain binding `as`/index that reads/keys directly, vs a
-   destructuring pattern that re-applies per read. Shared by `reactiveBinding` (cell deref)
-   and `each` key derivation so the one identifier test stays single-source. */
-export const isPlainIdentifier = (name: string): boolean => PLAIN_IDENTIFIER.test(name)