@abide/abide 0.58.0 → 0.101.0

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

@@ -1,108 +0,0 @@
-import { interpolatedTemplateLiteral } from './interpolatedTemplateLiteral.ts'
-import type { TemplateAttr } from './types/TemplateAttr.ts'
-
-/*
-The one decision site for how an element's `class`/`style` base attribute composes
-with its `class:`/`style:` directives — lifted out of the two code-gen back-ends
-(`generateBuild`, `generateSSR`) so the load-bearing congruence (which attrs fold
-into a merged value, and HOW that value's parts concatenate) lives once. Each
-back-end RENDERS the returned plan differently — the build into a reactive `effect`,
-SSR into a pushed attribute string — but consults the same decision, so the markup
-the client clones and the server emits can never drift on the merge logic.
-
-The two back-ends differ ONLY in their merge TRIGGER, because their non-merge
-fallbacks differ: the build leaves a STATIC base in the cloned skeleton and toggles
-directives surgically, so it merges only when the base is INTERPOLATED (re-set on
-every update, which would wipe additive toggles) — `mergeClassBuild`/`mergeStyleBuild`.
-SSR must always emit ONE merged attribute string (a duplicate `class`/`style` is
-invalid), so it merges whenever a directive exists — `mergeClass`/`mergeStyle`. The
-PARTS that compose the value (`classParts`/`styleParts`) are identical either way, so
-they are built here once.
-
-`attrs` classified up front; `lower` rewrites the signal surface to `model` (the same
-transformer each back-end already threads through its expressions).
-*/
-
-/* The base class/style attribute (static or interpolated) found on the element. */
-type MergeBase =
-    | Extract<TemplateAttr, { kind: 'static' }>
-    | Extract<TemplateAttr, { kind: 'interpolated' }>
-    | undefined
-
-export type ClassStyleMergePlan = {
-    classBase: MergeBase
-    styleBase: MergeBase
-    classDirectives: Extract<TemplateAttr, { kind: 'class' }>[]
-    styleDirectives: Extract<TemplateAttr, { kind: 'style' }>[]
-    /* SSR trigger: merge whenever a directive exists (must emit one attribute). */
-    mergeClass: boolean
-    mergeStyle: boolean
-    /* Build trigger: merge only when the base is interpolated (a static base stays in
-       the skeleton + surgical toggles). */
-    mergeClassBuild: boolean
-    mergeStyleBuild: boolean
-    /* The JS expression list a merged value joins — base (if any) + directive parts.
-       `class` joins on a space (directive name when truthy); `style` joins on `;`
-       (`property:value`, String-coerced). Identical across back-ends. */
-    classParts: string[]
-    styleParts: string[]
-}
-
-/* The base class/style attribute (static or interpolated) for one property name. */
-function findBase(attrs: TemplateAttr[], name: 'class' | 'style'): MergeBase {
-    return attrs.find(
-        (attr): attr is NonNullable<MergeBase> =>
-            (attr.kind === 'static' || attr.kind === 'interpolated') && attr.name === name,
-    )
-}
-
-/* The base value as a lowered JS string expression, or undefined when there is no
-   base. A static base is a JSON string literal; an interpolated base is its
-   template-literal source run through `lower` (embedded signals → `model`). */
-function baseExpr(base: MergeBase, lower: (code: string) => string): string | undefined {
-    if (base === undefined) {
-        return undefined
-    }
-    return base.kind === 'static'
-        ? JSON.stringify(base.value)
-        : lower(interpolatedTemplateLiteral(base.parts))
-}
-
-/* Classifies an element's attrs into the class/style merge plan. */
-export function classStyleMergePlan(
-    attrs: TemplateAttr[],
-    lower: (code: string) => string,
-): ClassStyleMergePlan {
-    const classBase = findBase(attrs, 'class')
-    const styleBase = findBase(attrs, 'style')
-    const classDirectives = attrs.filter(
-        (attr): attr is Extract<TemplateAttr, { kind: 'class' }> => attr.kind === 'class',
-    )
-    const styleDirectives = attrs.filter(
-        (attr): attr is Extract<TemplateAttr, { kind: 'style' }> => attr.kind === 'style',
-    )
-    const classBaseExpr = baseExpr(classBase, lower)
-    const styleBaseExpr = baseExpr(styleBase, lower)
-    return {
-        classBase,
-        styleBase,
-        classDirectives,
-        styleDirectives,
-        mergeClass: classDirectives.length > 0,
-        mergeStyle: styleDirectives.length > 0,
-        mergeClassBuild: classBase?.kind === 'interpolated' && classDirectives.length > 0,
-        mergeStyleBuild: styleBase?.kind === 'interpolated' && styleDirectives.length > 0,
-        classParts: [
-            ...(classBaseExpr === undefined ? [] : [classBaseExpr]),
-            ...classDirectives.map(
-                (dir) => `((${lower(dir.code)}) ? ${JSON.stringify(dir.name)} : "")`,
-            ),
-        ],
-        styleParts: [
-            ...(styleBaseExpr === undefined ? [] : [styleBaseExpr]),
-            ...styleDirectives.map(
-                (dir) => `(${JSON.stringify(`${dir.property}:`)} + String(${lower(dir.code)}))`,
-            ),
-        ],
-    }
-}

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

@@ -1,46 +0,0 @@
-import type ts from 'typescript'
-import type { InterpolationKind } from './types/InterpolationKind.ts'
-
-/*
-Whether a type carries the well-known `Symbol.asyncIterator` member. That member's
-property is mangled to the escaped name `__@asyncIterator@<id>`, so an exact-name
-`getPropertyOfType(t, '__@asyncIterator')` misses it and `ts.getPropertyNameFor
-KnownSymbolName` isn't exported — a prefix scan over the type's properties is the
-only reliable check (validated against the installed TS).
-*/
-function hasAsyncIterator(type: ts.Type, checker: ts.TypeChecker): boolean {
-    for (const property of checker.getPropertiesOfType(type)) {
-        if ((property.escapedName as string).startsWith('__@asyncIterator')) {
-            return true
-        }
-    }
-    return false
-}
-
-/*
-Classifies a template interpolation's checker type into how it binds at runtime.
-Strips nullability and splits a union, then for each constituent tests async
-iterables FIRST (an async generator is also thenable-adjacent, so order matters),
-then a thenable (a callable `then` member), falling back to `sync`.
-*/
-export function classifyInterpolationType(
-    type: ts.Type,
-    at: ts.Node,
-    checker: ts.TypeChecker,
-): InterpolationKind {
-    const nonNullable = type.getNonNullableType()
-    const constituents = nonNullable.isUnion() ? nonNullable.types : [nonNullable]
-    for (const constituent of constituents) {
-        if (hasAsyncIterator(constituent, checker)) {
-            return 'asyncIterable'
-        }
-        const then = checker.getPropertyOfType(constituent, 'then')
-        if (
-            then !== undefined &&
-            checker.getTypeOfSymbolAtLocation(then, at).getCallSignatures().length > 0
-        ) {
-            return 'promise'
-        }
-    }
-    return 'sync'
-}

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

@@ -1,166 +0,0 @@
-import ts from 'typescript'
-import { asyncValuePositionError } from './asyncValuePositionError.ts'
-import { asyncValuePositionInterpolations } from './asyncValuePositionInterpolations.ts'
-import { classifyInterpolationType } from './classifyInterpolationType.ts'
-import type { ShadowProgram } from './createShadowProgram.ts'
-import { isSpuriousAsyncReadDiagnostic } from './isSpuriousAsyncReadDiagnostic.ts'
-import { nodeAtShadowOffset } from './nodeAtShadowOffset.ts'
-import { parseTemplateRecovering } from './parseTemplateRecovering.ts'
-import { remapShadowDiagnostic } from './remapShadowDiagnostic.ts'
-import { sourceToShadowOffset } from './sourceToShadowOffset.ts'
-import { templateStartOffset } from './templateStartOffset.ts'
-import type { AbideDiagnostic } from './types/AbideDiagnostic.ts'
-import type { ShadowMapping } from './types/CompiledShadow.ts'
-
-/*
-Runs the shadow program's type-checker over every `.abide` shadow and relocates
-each diagnostic onto its source component. Only diagnostics that fall inside a
-mapped expression survive (remapShadowDiagnostic drops shadow-internal noise);
-a template that failed to parse contributes a single error at the file head.
-Shared by `abide check` (one-shot render) and the LSP (per-file publish).
-*/
-export function collectAbideDiagnostics(shadow: ShadowProgram): AbideDiagnostic[] {
-    const { program, shadows, parseErrors, abidePaths } = shadow
-    const checker = program.getTypeChecker()
-    const diagnostics: AbideDiagnostic[] = []
-    for (const abidePath of abidePaths) {
-        const parseError = parseErrors.get(abidePath)
-        if (parseError !== undefined) {
-            diagnostics.push({
-                file: abidePath,
-                start: 0,
-                length: 0,
-                message: parseError,
-                category: ts.DiagnosticCategory.Error,
-            })
-            continue
-        }
-        /* Shadow-raised author rules (e.g. importing a compiler-internal helper) are
-           already in source coordinates — emit them directly, no segment remap. */
-        for (const diagnostic of shadows.get(abidePath)?.diagnostics ?? []) {
-            diagnostics.push({
-                file: abidePath,
-                start: diagnostic.start,
-                length: diagnostic.length,
-                message: diagnostic.message,
-                category: ts.DiagnosticCategory.Error,
-            })
-        }
-        const sourceFile = program.getSourceFile(`${abidePath}.ts`)
-        const mappings = shadows.get(abidePath)?.mappings
-        if (sourceFile === undefined || mappings === undefined) {
-            continue
-        }
-        /* The template boundary: a diagnostic mapping at/after it is a template expression, so
-           eligible for the ADR-0032 bare-async-read suppression; anything before it is `<script>`
-           code, where a forgotten `await` must still surface. If the source can't be read, DON'T
-           fall back to 0 — that treats the whole file (including `<script>`) as template and would
-           silently suppress a genuine forgotten-await error. Use +Infinity so nothing is eligible
-           for suppression and every real diagnostic surfaces (fail toward reporting). */
-        const abideSource = ts.sys.readFile(abidePath)
-        const templateStart =
-            abideSource === undefined ? Number.POSITIVE_INFINITY : templateStartOffset(abideSource)
-        const raw = [
-            ...program.getSyntacticDiagnostics(sourceFile),
-            ...program.getSemanticDiagnostics(sourceFile),
-        ]
-        for (const diagnostic of raw) {
-            if (diagnostic.start === undefined) {
-                continue
-            }
-            const located = remapShadowDiagnostic(
-                mappings,
-                diagnostic.start,
-                diagnostic.length ?? 0,
-            )
-            if (located === undefined) {
-                continue
-            }
-            /* Drop the diagnostics a bare async read (ADR-0032) provokes spuriously: the runtime
-               peeks the resolved value (`undefined` while pending), so a `?.` read of a real member
-               and an `{#if}` on the promise are valid — the raw-`Promise` shadow can't see that. */
-            if (
-                located.start >= templateStart &&
-                isSpuriousAsyncReadDiagnostic(
-                    sourceFile,
-                    checker,
-                    diagnostic.code,
-                    diagnostic.start,
-                    diagnostic.length ?? 0,
-                )
-            ) {
-                continue
-            }
-            diagnostics.push({
-                file: abidePath,
-                start: located.start,
-                length: located.length,
-                message: ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
-                category: diagnostic.category,
-            })
-        }
-        /* Stage E parity (ADR-0019): the build front-end (`lowerAsyncInterpolations`) throws on a
-           promise/asyncIterable in a NON-content value position; mirror it here as a diagnostic so
-           `abide check`/the LSP surface the same error. The shadow already type-checks these
-           spans, so their offsets map through the same `mappings`; classify each against the
-           checker and emit an Error for any async value the guard rejects. */
-        collectValuePositionDiagnostics(abidePath, sourceFile, mappings, checker, diagnostics)
-    }
-    return diagnostics
-}
-
-/* Parses the component template, walks its value-position interpolations, and pushes a diagnostic
-   for any promise/asyncIterable the Stage E guard rejects. Classifies via the shadow: map the
-   expression's source offset into shadow coordinates, find its emitted expression node, read its
-   checker type. Fail-open — an unparseable template or unmappable span contributes nothing, so a
-   type hiccup degrades to no extra diagnostic instead of throwing. */
-function collectValuePositionDiagnostics(
-    abidePath: string,
-    shadowFile: ts.SourceFile,
-    mappings: ShadowMapping[],
-    checker: ts.TypeChecker,
-    diagnostics: AbideDiagnostic[],
-): void {
-    const source = ts.sys.readFile(abidePath)
-    if (source === undefined) {
-        return
-    }
-    /* The template starts just past the leading `<script>` — the SAME base `compileShadow` parses
-       from, so each interpolation's `loc` lines up with the shadow's source→shadow `mappings`. */
-    const templateStart = templateStartOffset(source)
-    /* The recovering core never throws — it returns best-effort `nodes` PLUS every parse
-       diagnostic. Surface each with the `file` + `category` the parser can't know, so the LSP
-       reports parse errors from mid-edit source instead of fail-opening on the first throw. */
-    const parsed = parseTemplateRecovering(source.slice(templateStart), templateStart)
-    const nodes = parsed.nodes
-    for (const parseDiagnostic of parsed.diagnostics) {
-        diagnostics.push({
-            file: abidePath,
-            start: parseDiagnostic.start,
-            length: parseDiagnostic.length,
-            message: parseDiagnostic.message,
-            category: ts.DiagnosticCategory.Error,
-        })
-    }
-    for (const interpolation of asyncValuePositionInterpolations(nodes)) {
-        const shadowOffset = sourceToShadowOffset(mappings, interpolation.loc)
-        if (shadowOffset === undefined) {
-            continue
-        }
-        const node = nodeAtShadowOffset(shadowFile, shadowOffset, interpolation.code.length)
-        if (node === undefined) {
-            continue
-        }
-        const kind = classifyInterpolationType(checker.getTypeAtLocation(node), node, checker)
-        const message = asyncValuePositionError(kind, interpolation.position)
-        if (message !== undefined) {
-            diagnostics.push({
-                file: abidePath,
-                start: interpolation.loc,
-                length: interpolation.code.length,
-                message,
-                category: ts.DiagnosticCategory.Error,
-            })
-        }
-    }
-}

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

@@ -1,46 +0,0 @@
-import { analyzeComponent } from './analyzeComponent.ts'
-import { generateBuild } from './generateBuild.ts'
-import { hoistCells } from './hoistCells.ts'
-import type { AnalyzedComponent } from './types/AnalyzedComponent.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
-
-/*
-Compiles a single-file abide component into the body of a client build function.
-Runs the shared front-end (`analyzeComponent`), generates the DOM build from the
-template, and hoists static paths to cells. The returned body operates on `host`
-with the `$$`-prefixed dom bindings and `$$model` in scope (the latter emitted by
-`desugarSignals`). `compileModule` wraps it (and the SSR body) into
-a real module; tests wrap it with `new Function`.
-
-`analyzed` is a lazy default: a direct caller (tests) omits it and the front-end
-runs here, but `compileModule` analyzes once and passes the result to both
-back-ends, so the shared front-end runs once per build instead of three times.
-*/
-export function compileComponent(
-    source: string,
-    isLayout = false,
-    scopeSeed?: string,
-    analyzed?: AnalyzedComponent,
-    classify?: InterpolationClassifier,
-    seedClassify?: SeedTypeClassifier,
-): string {
-    /* `analyzed` is shared by `compileModule` (analyzed once, classifiers already applied);
-       a direct caller (tests) omits it and the front-end runs here — threading `classify` and
-       `seedClassify` so type-directed interpolation + cell lowering happen on this path too. */
-    const resolved = analyzed ?? analyzeComponent(source, scopeSeed, classify, seedClassify)
-    const { script, stateNames, derivedNames, computedNames, cellReadNames, nodes } = resolved
-    const build = generateBuild(
-        nodes,
-        'host',
-        stateNames,
-        derivedNames,
-        computedNames,
-        isLayout,
-        cellReadNames,
-    )
-    /* The scoped CSS is bundled into the entry stylesheet (see `abideUiPlugin`), not
-       injected at runtime; the build only needs the `data-a-…` scope attributes on
-       elements, which `generateBuild` reads from each node's annotated `scopes`. */
-    return `${script}\n${hoistCells(build, '$$model')}`
-}

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

@@ -1,306 +0,0 @@
-import ts from 'typescript'
-import { ABIDE_PACKAGE_NAME } from '../../shared/ABIDE_PACKAGE_NAME.ts'
-import { analyzeComponent } from './analyzeComponent.ts'
-import { assertTranspiles } from './assertTranspiles.ts'
-import { compileComponent } from './compileComponent.ts'
-import { compileSSR } from './compileSSR.ts'
-import type { AnalyzedComponent } from './types/AnalyzedComponent.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
-import { UI_RUNTIME_IMPORTS } from './UI_RUNTIME_IMPORTS.ts'
-
-/*
-Wraps a component into a complete ES module with two entry points:
-
-  - default `component(host, $props)` — mounts the client build, returns the
-    disposer (`import Counter from './Counter.abide'; const stop = Counter(host)`);
-  - `render($props, $ctx)` — async, server-renders to `{ html, state, awaits, resume }`
-    for SSR. `$ctx` is the request-local block-id counter, threaded so a child's
-    `await`/`try` ids share the page's depth-first numbering; omitted at the top level
-    (a fresh counter defaults in).
-
-`render` is also attached to the default export (`component.render`) so a parent
-can server-render a child it imported by its default name. Both entry points share
-the lowered script and template (via the shared front-end), so client and server
-always agree. The `abide/ui/*` imports resolve through the package exports. This is
-what the `.abide` bundler loader emits.
-*/
-export function compileModule(
-    source: string,
-    options: {
-        isLayout?: boolean
-        moduleId?: string
-        /* Type-directed interpolation lowering (ADR-0019): the warm shadow classifier the
-           bundler plugin builds per `.abide`. Optional and fail-open — absent, the module
-           compiles exactly as before (every interpolation binds as a plain value). */
-        classify?: InterpolationClassifier
-        /* Type-directed cell lowering (ADR-0023): the seed classifier the plugin builds over
-           the SAME warm shadow program. Optional and fail-open — absent, a no-marker
-           `computed(seed)` routes by the `isBareCallComputed` syntax heuristic (today's behavior). */
-        seedClassify?: SeedTypeClassifier
-    } = {},
-): { code: string; styles: AnalyzedComponent['styles'] } {
-    const isLayout = options.isLayout ?? false
-    /* Run the shared front-end once and feed it to both back-ends — the analysis is
-       pure over (source, moduleId), so the client and SSR builds reuse one parse
-       instead of re-running it. `imports` (hoisted child-component imports) and the
-       per-element scopes both come from this single pass. The classifier (when present)
-       lowers promise-typed interpolations here, so both back-ends see one lowered tree. */
-    const analyzed = analyzeComponent(
-        source,
-        options.moduleId,
-        options.classify,
-        options.seedClassify,
-    )
-    const userImports = analyzed.imports
-    const body = indent(compileComponent(source, isLayout, options.moduleId, analyzed))
-
-    const ssrBody = indent(compileSSR(source, isLayout, options.moduleId, analyzed))
-    const moduleBody = `function build(host, $props) {
-${body}
-}
-
-export default function component(host, $props) {
-    return $$mount(host, build, $props)
-}
-
-/* Adopt the server-rendered DOM in place instead of rebuilding it. */
-export function hydrateInto(host, $props) {
-    return $$hydrate(host, build, $props)
-}
-
-export function render($props, $ctx) {
-${ssrBody}
-}
-
-component.render = render
-component.hydrate = hydrateInto
-/* The bare build, so a parent can range-mount this as a nested child (no wrapper). */
-component.build = build
-component.hydratable = ${analyzed.hydratable}
-`
-    /* Per-component dead-import elimination: emit only the runtime helpers this module
-       references. A component using no `each`/`await`/`html` shouldn't drag those modules
-       into its chunk, and the package isn't globally side-effect-free (the dev/runtime
-       entries register globals), so a bundler can't tree-shake them for us.
-       Which to keep: tokenize the generated body and keep the names it genuinely
-       references. Reading the ACTUAL output (not hand-tracking emit sites) is safe by
-       construction — it can never drop a needed import, the way a missed emit-site tag
-       could. Tokenizing rather than substring-matching (`\bname\b`) means a name inside a
-       string/comment/HTML literal (e.g. an `on`-attribute in static markup) no longer
-       forces a spurious import, so no per-surface scoping is needed: a client-only helper
-       simply doesn't appear as an identifier in the SSR body. */
-    /* Parse the generated bodies ONCE and feed the tree to the dead-import filter
-       (`collectIdentifiers`) and the reactive-import backstop below. The import block isn't in
-       this tree yet — it is derived from the filter's result. `setParentNodes` lets
-       `collectValueReferences` distinguish a value use from a property name. */
-    const bodySource = ts.createSourceFile(
-        'module.ts',
-        `${userImports}\n${moduleBody}`,
-        ts.ScriptTarget.Latest,
-        /* setParentNodes */ true,
-    )
-    const referenced = collectIdentifiers(bodySource)
-    /* Independent backstop on the reactive-import drop (`deadReactiveImport`): it decides an
-       import is dead from the leading script's own lowered body plus the nested scripts' raw
-       text. This re-checks the SAME question against the FINAL generated output — so a drop that
-       stranded a live reference (e.g. a nested branch's literal `state.computed`) surfaces as a
-       located compile error, not a runtime `ReferenceError: state is not defined`. Mirrors
-       `assertRuntimeHelpersBound`, which guards the parallel runtime-helper drop. Uses VALUE
-       references (not every identifier): the SSR return object `{ html, state, awaits, resume }`
-       names a property `state`, which is not a use of the reactive binding. */
-    if (analyzed.droppedReactiveImports.size > 0) {
-        const valueReferences = collectValueReferences(bodySource)
-        for (const name of analyzed.droppedReactiveImports) {
-            if (valueReferences.has(name)) {
-                throw new Error(
-                    `[abide] component module generation dropped the reactive import \`${name}\` as unused, but the generated output still references it — the dead-import filter undercounted. Please report this with the component source.`,
-                )
-            }
-        }
-    }
-    const keptImports = UI_RUNTIME_IMPORTS.filter((entry) =>
-        referenced.has(entry.alias ?? entry.name),
-    )
-    const importBlock = keptImports
-        .map((entry) => {
-            const local =
-                entry.alias === undefined || entry.alias === entry.name
-                    ? entry.name
-                    : `${entry.name} as ${entry.alias}`
-            return `import { ${local} } from '${ABIDE_PACKAGE_NAME}/${entry.specifier}'`
-        })
-        .join('\n')
-    const module = `${importBlock}
-${userImports}
-
-${moduleBody}`
-    /* Fail-loud over the WHOLE module, not just the script: the `generateBuild` /
-       `generateSSR` back-ends emit the build and render bodies as string-codegen, the
-       largest un-typed surface in the pipeline. A corruption there (a bad emit on a
-       template shape no test exercises) otherwise ships as a broken bundle; this surfaces
-       it as a located compile error for every component. */
-    assertTranspiles(module, 'component module generation')
-    return { code: module, styles: analyzed.styles }
-}
-
-/* Indents a body block for embedding inside a wrapper function. Lines whose start
-   sits inside a multi-line template literal are left untouched — their leading
-   whitespace is significant string content (e.g. a CodeBlock's `code={`…`}`
-   snippet), and indenting it would corrupt the rendered sample. An odd count of
-   unescaped backticks on a line flips in/out of a literal. */
-function indent(body: string): string {
-    let insideTemplateLiteral = false
-    return body
-        .split('\n')
-        .map((line) => {
-            const indented = insideTemplateLiteral || line === '' ? line : `    ${line}`
-            insideTemplateLiteral = templateLiteralStateAfter(line, insideTemplateLiteral)
-            return indented
-        })
-        .join('\n')
-}
-
-/* Whether the line ENDS inside a multi-line template literal, given whether it
-   STARTED inside one. A plain backtick-parity count is wrong: a backtick inside a
-   double-quoted string literal (the JSON.stringify'd skeleton markup, e.g.
-   `$$skeleton(host, "<p>tick \`here</p>")`) is not a template delimiter, but counting
-   it would flip the in-literal state and mis-indent a later real template literal's
-   significant whitespace. So skip `'…'`/`"…"` strings when outside a template, and treat
-   a template's `${…}` interpolation as code (its own strings/backticks don't toggle the
-   outer literal). Escapes are honoured throughout. */
-function templateLiteralStateAfter(line: string, startInside: boolean): boolean {
-    let inside = startInside
-    let index = 0
-    while (index < line.length) {
-        const char = line[index]
-        if (char === '\\') {
-            index += 2
-            continue
-        }
-        if (inside) {
-            if (char === '`') {
-                inside = false
-            } else if (char === '$' && line[index + 1] === '{') {
-                index = skipInterpolation(line, index + 2)
-                continue
-            }
-            index += 1
-            continue
-        }
-        if (char === '`') {
-            inside = true
-        } else if (char === '"' || char === "'") {
-            index = skipQuoted(line, index + 1, char)
-            continue
-        }
-        index += 1
-    }
-    return inside
-}
-
-/* Advances past a `'…'`/`"…"` string opened at `index` (the char after the quote),
-   returning the index after the closing quote (or end of line). Emitted JS string
-   literals never carry a raw newline, so they always close on their own line. */
-function skipQuoted(line: string, index: number, quote: string): number {
-    while (index < line.length) {
-        if (line[index] === '\\') {
-            index += 2
-            continue
-        }
-        if (line[index] === quote) {
-            return index + 1
-        }
-        index += 1
-    }
-    return index
-}
-
-/* Advances past a template `${…}` interpolation opened at `index` (the char after `{`),
-   returning the index after the matching `}` (or end of line). Balances nested braces and
-   skips nested strings/templates so their delimiters don't leak into the outer scan. */
-function skipInterpolation(line: string, index: number): number {
-    let depth = 1
-    while (index < line.length && depth > 0) {
-        const char = line[index]
-        if (char === '\\') {
-            index += 2
-            continue
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            index = skipQuoted(line, index + 1, char)
-            continue
-        }
-        if (char === '{') {
-            depth += 1
-        } else if (char === '}') {
-            depth -= 1
-        }
-        index += 1
-    }
-    return index
-}
-
-/* The identifier names a generated module references — every Identifier node, walked
-   from the real output's AST so string / comment / HTML-literal contents are excluded.
-   Used to decide which runtime helpers to import; reading the output (vs hand-tracking
-   emit sites) can never drop a needed import. A full parse (not a raw token scan) is what
-   keeps template literals honest: a `${…}` substitution — e.g. `navigate(`/p?ts=${Date.now()}`)`
-   in a handler — leaves the scanner unable to find the substitution's closing `}` without
-   the parser's re-scan, so a token-only pass mis-reads the rest of the module as template
-   text and drops every helper referenced after it (an `import`-less `effect`/`mountChild`
-   → a `ReferenceError` at mount → the router's reload fallback → a refresh loop). Takes the
-   already-parsed source so the one tree feeds this pass and the binding backstop both. */
-function collectIdentifiers(source: ts.SourceFile): Set<string> {
-    const names = new Set<string>()
-    const visit = (node: ts.Node): void => {
-        if (ts.isIdentifier(node)) {
-            names.add(node.text)
-        }
-        node.forEachChild(visit)
-    }
-    visit(source)
-    return names
-}
-
-/* The identifiers a module references AS VALUES — the subset of `collectIdentifiers` that
-   excludes name-only positions: a property name (`obj.state`), an object-literal key
-   (`{ state: v }`), and a declaration/import binding name (the definition, not a use). Used by
-   the reactive-import backstop, where a bare identifier presence over-counts: the synthesized
-   SSR return `{ html, state, awaits, resume }` names a property `state` that is not a use of the
-   reactive binding, so the raw-identifier set would false-positive. */
-function collectValueReferences(source: ts.SourceFile): Set<string> {
-    const names = new Set<string>()
-    const visit = (node: ts.Node): void => {
-        if (ts.isIdentifier(node) && isValuePosition(node)) {
-            names.add(node.text)
-        }
-        node.forEachChild(visit)
-    }
-    visit(source)
-    return names
-}
-
-/* True when `id` stands in a value position — i.e. a reference to a binding, not a name that
-   merely labels a property or declares a binding. */
-function isValuePosition(id: ts.Identifier): boolean {
-    const parent = id.parent
-    if (ts.isPropertyAccessExpression(parent) && parent.name === id) {
-        return false
-    }
-    if (ts.isPropertyAssignment(parent) && parent.name === id) {
-        return false
-    }
-    if (
-        (ts.isVariableDeclaration(parent) ||
-            ts.isParameter(parent) ||
-            ts.isFunctionDeclaration(parent) ||
-            ts.isBindingElement(parent) ||
-            ts.isImportSpecifier(parent) ||
-            ts.isImportClause(parent)) &&
-        parent.name === id
-    ) {
-        return false
-    }
-    return true
-}