@abide/abide 0.58.0 → 0.101.0

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

@@ -1,39 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-Document-order (pre-order) numbering of every `<Child/>` mount site in a template — the
-ordinal a child's render-path roots under (`mountChild` on the client, `$$withPath(ordinal)`
-/ `$$renderPath(ordinal)` on the server). ONE walk both back-ends read (the `skeletonContext`
-pattern), replacing the per-back-end `childOrdinal++` counters that numbered components in
-each generator's own EMISSION order — an order that could silently diverge (build emits a
-component's slot content before taking its own ordinal; SSR emits a switch's default case
-after later cases). Numbering from the tree, not the emission, makes SSR↔client ordinal
-congruence hold by construction.
-
-Returns the lookup, not the map, so the missing-entry policy lives here too: a miss means a
-back-end reached a mount site the shared walk didn't number — a structural divergence,
-surfaced loudly at compile time rather than as a runtime warm-seed/boundary desync.
-*/
-export function componentOrdinals(nodes: TemplateNode[]): (node: TemplateNode) => number {
-    const ordinals = new WeakMap<TemplateNode, number>()
-    let next = 0
-    const walk = (children: TemplateNode[]): void => {
-        for (const child of children) {
-            if (child.kind === 'component') {
-                ordinals.set(child, next)
-                next += 1
-            }
-            if ('children' in child) {
-                walk(child.children)
-            }
-        }
-    }
-    walk(nodes)
-    return (node: TemplateNode): number => {
-        const ordinal = ordinals.get(node)
-        if (ordinal === undefined) {
-            throw new Error('[abide] component mount site not numbered by the shared ordinal walk')
-        }
-        return ordinal
-    }
-}

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

@@ -1,64 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* The authored props of a child-component node (each attribute lowered to a prop;
-   a `spread` entry carries no `name`). */
-type ComponentProps = Extract<TemplateNode, { kind: 'component' }>['props']
-
-/*
-The props-bag source expression a child mount/render receives, shared by the build
-and SSR back-ends so their last-wins layering stays byte-identical — the invariant
-SSR/client prop congruence rests on. No spread → the plain object literal of named
-value thunks (+ the trailing slot). With a `{...expr}` spread → a `mergeProps` of
-ordered layers — explicit-prop runs, `$$spreadProps(expr)` spreads, the slot —
-resolved last-wins per key, so source order decides overrides (like JSX).
-`lowerExpression` is the caller's expression lowering; `slotPart` is its `children`
-layer — slotted content as a `Snippet` under the `children` prop key (a builder-
-returning callable for the client, a `$snip`-string-returning callable for SSR) — or
-undefined when the component has no slotted children.
-*/
-export function composeProps(
-    props: ComponentProps,
-    lowerExpression: (code: string) => string,
-    slotPart: string | undefined,
-    /* The two-way bind accessors (`lowerContext`): `bindRead` lowers a target to its
-       current value, `bindWrite` to the statement that writes a value back. Shared with
-       element `bind:`, so a component bind accepts the same lvalue / `{ get, set }` targets. */
-    bindRead: (code: string) => string,
-    bindWrite: (code: string, valueExpr: string) => string,
-): string {
-    /* A `bind:<name>={target}` prop: the normal `() => value` entry, annotated with a
-       `set` write-back channel (`bindProp`) so the child can push changes upstream. A
-       read-only consumer still just calls the thunk; the setter rides along unseen. */
-    const propThunk = (prop: { name: string; code: string; bind?: true }): string =>
-        prop.bind === true
-            ? `${JSON.stringify(prop.name)}: $$bindProp(() => (${bindRead(prop.code)}), ($value) => { ${bindWrite(prop.code, '$value')} })`
-            : `${JSON.stringify(prop.name)}: () => (${lowerExpression(prop.code)})`
-    if (!props.some((prop) => prop.spread)) {
-        const parts = props.map(propThunk)
-        if (slotPart !== undefined) {
-            parts.push(slotPart)
-        }
-        return `{ ${parts.join(', ')} }`
-    }
-    const layers: string[] = []
-    let run: string[] = []
-    const flushRun = (): void => {
-        if (run.length > 0) {
-            layers.push(`{ ${run.join(', ')} }`)
-            run = []
-        }
-    }
-    for (const prop of props) {
-        if (prop.spread) {
-            flushRun()
-            layers.push(`$$spreadProps(() => (${lowerExpression(prop.code)}))`)
-        } else {
-            run.push(propThunk(prop))
-        }
-    }
-    flushRun()
-    if (slotPart !== undefined) {
-        layers.push(`{ ${slotPart} }`)
-    }
-    return `$$mergeProps([${layers.join(', ')}])`
-}

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

@@ -1,348 +0,0 @@
-import { resolve } from 'node:path'
-import ts from 'typescript'
-import { messageFromError } from '../../shared/messageFromError.ts'
-import { mapSyntacticClassification, mapTsClassification } from './ABIDE_SEMANTIC_TOKENS_LEGEND.ts'
-import { assetModulesFile } from './assetModulesFile.ts'
-import { compileShadow } from './compileShadow.ts'
-import { isSpuriousAsyncReadDiagnostic } from './isSpuriousAsyncReadDiagnostic.ts'
-import { loadShadowTsConfig } from './loadShadowTsConfig.ts'
-import { pagePropsType } from './pagePropsType.ts'
-import { remapShadowDiagnostic } from './remapShadowDiagnostic.ts'
-import { resolveAbideImports } from './resolveAbideImports.ts'
-import { shadowInterpolationClassifier } from './shadowInterpolationClassifier.ts'
-import { shadowNaming } from './shadowNaming.ts'
-import { sourceToShadowOffset } from './sourceToShadowOffset.ts'
-import { templateStartOffset } from './templateStartOffset.ts'
-import type { AbideDiagnostic } from './types/AbideDiagnostic.ts'
-import type { CompiledShadow } from './types/CompiledShadow.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-import type { SemanticToken } from './types/SemanticToken.ts'
-
-const { suffixed, isShadow, sourceOf } = shadowNaming
-
-/* Hover quick-info for a source position: TypeScript's signature line and doc
-   comment, with the covered span mapped back onto the `.abide` source. */
-export type ShadowQuickInfo = { text: string; documentation: string; start: number; length: number }
-
-export type ShadowLanguageService = {
-    /* Record/replace an open document's in-memory text (overrides disk). */
-    update: (abidePath: string, text: string) => void
-    /* Forget an open document; subsequent reads fall back to disk. */
-    close: (abidePath: string) => void
-    /* Current diagnostics for one component, mapped onto its source. */
-    diagnostics: (abidePath: string) => AbideDiagnostic[]
-    /* Hover info at a source offset, or undefined if the offset isn't a checked
-       expression (markup, whitespace) or TypeScript has nothing to report. */
-    quickInfo: (abidePath: string, sourceOffset: number) => ShadowQuickInfo | undefined
-    /* Type-aware semantic tokens for every checked expression, in source coords. */
-    semanticClassifications: (abidePath: string) => SemanticToken[]
-}
-
-/*
-An incremental `ts.LanguageService` over the shadow world, for the LSP. Open
-documents are held as in-memory overlays that override disk, so diagnostics
-reflect unsaved edits; every other file (real `.ts`, unopened `.abide`) reads from
-disk. Shares the shadow compiler, module resolver, and tsconfig with the one-shot
-check Program — the editor and CLI report identically.
-*/
-export function createShadowLanguageService(cwd: string): ShadowLanguageService {
-    const { options, fileNames } = loadShadowTsConfig(cwd)
-    const overlays = new Map<string, string>()
-    const versions = new Map<string, number>()
-    /* Memo of `pagePropsType` (route re-parse) per source path; the path → props
-       type mapping is immutable, so no version tag is needed. */
-    const propsTypes = new Map<string, string | undefined>()
-
-    /* The route props type for a component, parsed once and reused. */
-    const propsTypeOf = (abidePath: string): string | undefined => {
-        if (!propsTypes.has(abidePath)) {
-            propsTypes.set(abidePath, pagePropsType(abidePath))
-        }
-        return propsTypes.get(abidePath)
-    }
-
-    /* Ambient declarations for bundler-handled asset imports (`*.css`, …). */
-    const assets = assetModulesFile(cwd)
-
-    const exists = (abidePath: string): boolean =>
-        overlays.has(abidePath) || ts.sys.fileExists(abidePath)
-
-    /* All component shadows: those on disk plus any opened (possibly unsaved) ones. */
-    const shadowNames = (): string[] => {
-        const disk = [...new Bun.Glob('**/*.abide').scanSync({ cwd, onlyFiles: true })]
-            .filter((relative) => !relative.includes('node_modules'))
-            .map((relative) => resolve(cwd, relative))
-        return [...new Set([...disk, ...overlays.keys()])].map(suffixed)
-    }
-
-    /* One incremental language service over the shadow world, its shadows built by `compile`. Two
-       are made: a VERBATIM one (the classifier source — interpolations un-wrapped, so `getFoo()`
-       still types as `Promise`), and the WRAPPED main one (async interpolations peek-wrapped, ADR-
-       0032, so hover/completions/diagnostics see the RESOLVED value). They share `overlays`/`versions`
-       so both reflect unsaved edits, but hold SEPARATE shadow caches + document registries (the same
-       shadow file name carries different text in each). */
-    const buildService = (compile: (source: string, abidePath: string) => CompiledShadow) => {
-        const shadows = new Map<string, CompiledShadow>()
-        const parseErrors = new Map<string, string>()
-        /* Memo of `shadowText` output keyed by source path, tagged with the shadow version it was
-           compiled at; a stale tag forces recompilation. `update`/`close` bump that version. */
-        const compiledAt = new Map<string, { version: number; code: string }>()
-        const shadowText = (abidePath: string): string => {
-            const version = versions.get(suffixed(abidePath)) ?? 0
-            const memo = compiledAt.get(abidePath)
-            if (memo !== undefined && memo.version === version) {
-                return memo.code
-            }
-            const source = overlays.get(abidePath) ?? ts.sys.readFile(abidePath) ?? ''
-            try {
-                const compiled = compile(source, abidePath)
-                shadows.set(abidePath, compiled)
-                parseErrors.delete(abidePath)
-                compiledAt.set(abidePath, { version, code: compiled.code })
-                return compiled.code
-            } catch (error) {
-                shadows.set(abidePath, { code: '', mappings: [] })
-                parseErrors.set(abidePath, messageFromError(error))
-                const code = 'export default function (): void {}\n'
-                compiledAt.set(abidePath, { version, code })
-                return code
-            }
-        }
-        const moduleResolutionHost: ts.ModuleResolutionHost = {
-            fileExists: (fileName) =>
-                fileName === assets.path ||
-                (isShadow(fileName) ? exists(sourceOf(fileName)) : ts.sys.fileExists(fileName)),
-            readFile: (fileName) =>
-                fileName === assets.path
-                    ? assets.content
-                    : isShadow(fileName)
-                      ? shadowText(sourceOf(fileName))
-                      : ts.sys.readFile(fileName),
-        }
-        const host: ts.LanguageServiceHost = {
-            getScriptFileNames: () => [assets.path, ...fileNames, ...shadowNames()],
-            getScriptVersion: (fileName) => String(versions.get(fileName) ?? 0),
-            getScriptSnapshot: (fileName) => {
-                if (fileName === assets.path) {
-                    return ts.ScriptSnapshot.fromString(assets.content)
-                }
-                if (isShadow(fileName)) {
-                    return exists(sourceOf(fileName))
-                        ? ts.ScriptSnapshot.fromString(shadowText(sourceOf(fileName)))
-                        : undefined
-                }
-                const text = ts.sys.readFile(fileName)
-                return text === undefined ? undefined : ts.ScriptSnapshot.fromString(text)
-            },
-            getCurrentDirectory: () => cwd,
-            getCompilationSettings: () => options,
-            getDefaultLibFileName: (compilerOptions) => ts.getDefaultLibFilePath(compilerOptions),
-            fileExists: moduleResolutionHost.fileExists,
-            readFile: moduleResolutionHost.readFile,
-            readDirectory: ts.sys.readDirectory,
-            directoryExists: ts.sys.directoryExists,
-            getDirectories: ts.sys.getDirectories,
-            resolveModuleNames: resolveAbideImports(options, moduleResolutionHost),
-        }
-        return {
-            service: ts.createLanguageService(host, ts.createDocumentRegistry()),
-            shadows,
-            parseErrors,
-            shadowText,
-        }
-    }
-
-    const verbatim = buildService((source, abidePath) =>
-        compileShadow(source, propsTypeOf(abidePath)),
-    )
-    /* The wrapped shadow's peek-wrap is type-directed: it asks the verbatim program which
-       sub-expressions are async. `getProgram()` reflects the shared overlays/versions, so the
-       classifier tracks unsaved edits; fail-open to `undefined` (verbatim shadow) if unavailable. */
-    const classifierFor = (abidePath: string): InterpolationClassifier | undefined => {
-        const program = verbatim.service.getProgram()
-        return program === undefined
-            ? undefined
-            : shadowInterpolationClassifier(program, verbatim.shadows, abidePath)
-    }
-    const main = buildService((source, abidePath) =>
-        compileShadow(source, propsTypeOf(abidePath), classifierFor(abidePath)),
-    )
-    const { service, shadows, parseErrors, shadowText } = main
-
-    const bump = (abidePath: string): void => {
-        const fileName = suffixed(abidePath)
-        versions.set(fileName, (versions.get(fileName) ?? 0) + 1)
-    }
-
-    return {
-        update(abidePath, text) {
-            overlays.set(abidePath, text)
-            bump(abidePath)
-        },
-        close(abidePath) {
-            overlays.delete(abidePath)
-            bump(abidePath)
-        },
-        diagnostics(abidePath) {
-            const fileName = suffixed(abidePath)
-            /* Fetching diagnostics drives getScriptSnapshot → shadowText, so the
-               shadows/parseErrors caches are current before we read them. */
-            const raw = [
-                ...service.getSyntacticDiagnostics(fileName),
-                ...service.getSemanticDiagnostics(fileName),
-            ]
-            const parseError = parseErrors.get(abidePath)
-            if (parseError !== undefined) {
-                return [
-                    {
-                        file: abidePath,
-                        start: 0,
-                        length: 0,
-                        message: parseError,
-                        category: ts.DiagnosticCategory.Error,
-                    },
-                ]
-            }
-            const mappings = shadows.get(abidePath)?.mappings ?? []
-            /* The shadow file + checker + template boundary, for the ADR-0032 bare-async-read
-               suppression (mirrors `collectAbideDiagnostics` so the editor and CLI agree). */
-            const shadowFile = service.getProgram()?.getSourceFile(fileName)
-            const checker = service.getProgram()?.getTypeChecker()
-            const source = overlays.get(abidePath) ?? ts.sys.readFile(abidePath) ?? ''
-            const templateStart = templateStartOffset(source)
-            return raw.flatMap((diagnostic) => {
-                if (diagnostic.start === undefined) {
-                    return []
-                }
-                const located = remapShadowDiagnostic(
-                    mappings,
-                    diagnostic.start,
-                    diagnostic.length ?? 0,
-                )
-                if (located === undefined) {
-                    return []
-                }
-                /* Drop the spurious "property missing on Promise" / "condition always defined" a
-                   bare async read provokes — the runtime peeks the resolved value (ADR-0032). */
-                if (
-                    shadowFile !== undefined &&
-                    checker !== undefined &&
-                    located.start >= templateStart &&
-                    isSpuriousAsyncReadDiagnostic(
-                        shadowFile,
-                        checker,
-                        diagnostic.code,
-                        diagnostic.start,
-                        diagnostic.length ?? 0,
-                    )
-                ) {
-                    return []
-                }
-                return [
-                    {
-                        file: abidePath,
-                        start: located.start,
-                        length: located.length,
-                        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
-                        category: diagnostic.category,
-                    },
-                ]
-            })
-        },
-        quickInfo(abidePath, sourceOffset) {
-            const fileName = suffixed(abidePath)
-            /* Compile the shadow first so its mappings are current before we
-               translate the source offset into shadow coordinates. */
-            shadowText(abidePath)
-            const mappings = shadows.get(abidePath)?.mappings ?? []
-            const shadowOffset = sourceToShadowOffset(mappings, sourceOffset)
-            if (shadowOffset === undefined) {
-                return undefined
-            }
-            const info = service.getQuickInfoAtPosition(fileName, shadowOffset)
-            if (info === undefined) {
-                return undefined
-            }
-            /* The reported span is in shadow coordinates; map it back so the editor
-               highlights the matching source. Falls back to the hovered offset. */
-            const span = remapShadowDiagnostic(mappings, info.textSpan.start, info.textSpan.length)
-            return {
-                text: ts.displayPartsToString(info.displayParts),
-                documentation: ts.displayPartsToString(info.documentation),
-                start: span?.start ?? sourceOffset,
-                length: span?.length ?? 1,
-            }
-        },
-        semanticClassifications(abidePath) {
-            const fileName = suffixed(abidePath)
-            /* Compile first so the mappings cache is current. */
-            shadowText(abidePath)
-            const shadow = shadows.get(abidePath)
-            if (shadow === undefined) {
-                return []
-            }
-            const { spans } = service.getEncodedSemanticClassifications(
-                fileName,
-                { start: 0, length: shadow.code.length },
-                ts.SemanticClassificationFormat.TwentyTwenty,
-            )
-            /* `spans` is flat triples [start, length, classification, …] in shadow
-               coords; keep only those overlapping a mapped expression segment. */
-            const tokens: SemanticToken[] = []
-            for (let index = 0; index + 2 < spans.length; index += 3) {
-                const spanStart = spans[index]
-                const spanLength = spans[index + 1]
-                const classification = spans[index + 2]
-                if (
-                    spanStart === undefined ||
-                    spanLength === undefined ||
-                    classification === undefined
-                ) {
-                    continue
-                }
-                const mapped = mapTsClassification(classification)
-                if (mapped === undefined) {
-                    continue
-                }
-                const located = remapShadowDiagnostic(shadow.mappings, spanStart, spanLength)
-                if (located === undefined) {
-                    continue
-                }
-                tokens.push({
-                    start: located.start,
-                    length: located.length,
-                    type: mapped.type,
-                    modifiers: mapped.modifiers,
-                })
-            }
-            /* Literal syntactic tokens (string/number/regex) the semantic classifier
-               never emits — so a template-literal string inside `{…}` gets colored. */
-            const syntactic = service.getEncodedSyntacticClassifications(fileName, {
-                start: 0,
-                length: shadow.code.length,
-            })
-            for (let index = 0; index + 2 < syntactic.spans.length; index += 3) {
-                const spanStart = syntactic.spans[index]
-                const spanLength = syntactic.spans[index + 1]
-                const classification = syntactic.spans[index + 2]
-                if (
-                    spanStart === undefined ||
-                    spanLength === undefined ||
-                    classification === undefined
-                ) {
-                    continue
-                }
-                const type = mapSyntacticClassification(classification)
-                if (type === undefined) {
-                    continue
-                }
-                const located = remapShadowDiagnostic(shadow.mappings, spanStart, spanLength)
-                if (located === undefined) {
-                    continue
-                }
-                tokens.push({ start: located.start, length: located.length, type, modifiers: [] })
-            }
-            return tokens
-        },
-    }
-}

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

@@ -1,127 +0,0 @@
-import { resolve } from 'node:path'
-import ts from 'typescript'
-import { messageFromError } from '../../shared/messageFromError.ts'
-import { assetModulesFile } from './assetModulesFile.ts'
-import { cachedSourceFile } from './cachedSourceFile.ts'
-import { compileShadow } from './compileShadow.ts'
-import { loadShadowTsConfig } from './loadShadowTsConfig.ts'
-import { pagePropsType } from './pagePropsType.ts'
-import { resolveAbideImports } from './resolveAbideImports.ts'
-import { shadowNaming } from './shadowNaming.ts'
-import { sourceFileOptionsSignature } from './sourceFileOptionsSignature.ts'
-import type { CompiledShadow } from './types/CompiledShadow.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-
-const { suffixed, isShadow, sourceOf } = shadowNaming
-
-export type ShadowProgram = {
-    program: ts.Program
-    /* Compiled shadow (code + mappings) per `.abide` path, populated as the host
-       materialises each source file; the diagnostic remapper reads the mappings. */
-    shadows: Map<string, CompiledShadow>
-    /* Files whose template failed to parse — surfaced as a diagnostic at offset 0. */
-    parseErrors: Map<string, string>
-    abidePaths: string[]
-}
-
-/*
-Builds a `ts.Program` over the project's real `.ts` files plus a virtual shadow
-`.ts` for every `.abide` component, behind a CompilerHost that serves shadow text
-for any `*.abide.ts` name and resolves `.abide` imports to their shadows. Reuses
-the project's tsconfig (lib/paths/baseUrl) so the shadows type-check against the
-same world the app does; `noUnusedLocals`/`noUnusedParameters` are forced off
-because the shadow legitimately declares scope bindings a template may not read.
-*/
-export function createShadowProgram(
-    cwd: string,
-    abidePaths?: string[],
-    /* Per-file interpolation classifier (ADR-0032). When provided, each shadow peek-wraps its async
-       sub-expressions so they type-check against the RESOLVED value; it must be backed by a SEPARATE
-       verbatim program (see `checkAbide`), since a classifier reading these same wrapped shadows
-       would be circular. Absent ⇒ verbatim shadows (the classifier-source pass, and any caller that
-       doesn't need the peek types). */
-    classifierFor?: (abidePath: string) => InterpolationClassifier | undefined,
-): ShadowProgram {
-    const { options, fileNames } = loadShadowTsConfig(cwd)
-    const shadows = new Map<string, CompiledShadow>()
-    const parseErrors = new Map<string, string>()
-    /* The components to root the program at — caller-supplied (one project's files)
-       or, by default, every `.abide` under `cwd`. Imported components resolve on
-       demand through the host, so an explicit subset still type-checks fully. */
-    const rootAbidePaths =
-        abidePaths ??
-        [...new Bun.Glob('**/*.abide').scanSync({ cwd, onlyFiles: true })]
-            .filter((relative) => !relative.includes('node_modules'))
-            .map((relative) => resolve(cwd, relative))
-
-    /* Compiles (and caches) a `.abide` file's shadow; a template parse error yields
-       a minimal valid module and a recorded message so the program still builds. */
-    const shadowText = (abidePath: string): string => {
-        const source = ts.sys.readFile(abidePath) ?? ''
-        try {
-            const compiled = compileShadow(
-                source,
-                pagePropsType(abidePath),
-                classifierFor?.(abidePath),
-            )
-            shadows.set(abidePath, compiled)
-            parseErrors.delete(abidePath)
-            return compiled.code
-        } catch (error) {
-            shadows.set(abidePath, { code: '', mappings: [] })
-            parseErrors.set(abidePath, messageFromError(error))
-            return 'export default function (): void {}\n'
-        }
-    }
-
-    /* Ambient declarations for bundler-handled asset imports (`*.css`, …). */
-    const assets = assetModulesFile(cwd)
-
-    /* The parse/bind-affecting options are identical for every source in a program, so compute
-       the cache signature once and reuse it for every file (see `cachedSourceFile`). */
-    const signature = sourceFileOptionsSignature(options)
-
-    const host = ts.createCompilerHost(options, true)
-    const originalGetSourceFile = host.getSourceFile.bind(host)
-    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreate) => {
-        if (fileName === assets.path) {
-            return cachedSourceFile(fileName, assets.content, languageVersionOrOptions, signature)
-        }
-        if (isShadow(fileName)) {
-            /* `shadowText` populates the per-program `shadows`/`parseErrors` maps as a side effect,
-               so it must run on every call — only its expensive TS parse is memoised by `cachedSourceFile`. */
-            return cachedSourceFile(
-                fileName,
-                shadowText(sourceOf(fileName)),
-                languageVersionOrOptions,
-                signature,
-                ts.ScriptKind.TS,
-            )
-        }
-        /* Real `.ts`/`.d.ts` inputs (the ~3MB of default libs plus resolved dependencies) — read the
-           text and reuse the parsed file across programs when it is byte-identical. Fall back to the
-           default host on a read failure so its missing-file / `onError` handling is preserved. */
-        const text = ts.sys.readFile(fileName)
-        if (text === undefined) {
-            return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreate)
-        }
-        return cachedSourceFile(fileName, text, languageVersionOrOptions, signature)
-    }
-    host.fileExists = (fileName) =>
-        fileName === assets.path ||
-        (isShadow(fileName) ? ts.sys.fileExists(sourceOf(fileName)) : ts.sys.fileExists(fileName))
-    host.readFile = (fileName) => {
-        if (fileName === assets.path) {
-            return assets.content
-        }
-        return isShadow(fileName) ? shadowText(sourceOf(fileName)) : ts.sys.readFile(fileName)
-    }
-    host.resolveModuleNames = resolveAbideImports(options, host)
-
-    const program = ts.createProgram({
-        rootNames: [assets.path, ...fileNames, ...rootAbidePaths.map((path) => suffixed(path))],
-        options,
-        host,
-    })
-    return { program, shadows, parseErrors, abidePaths: rootAbidePaths }
-}

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

@@ -1,42 +0,0 @@
-import type { ShadowKind } from './types/ShadowKind.ts'
-import type { ShadowScope } from './types/ShadowScope.ts'
-
-/*
-Builds a fresh `ShadowScope` — the typed, auto-popping branch-local shadow stack. One
-`Set` per `ShadowKind`, reached only through `withShadow` (push on entry, pop in a
-`finally`), never directly. The `finally` is the safety move: the old hand-written
-pop ran after the body returned, so any throw inside the body (e.g. SSR's `await then`
-TDZ path) leaked the branch's shadows into every later sibling. Here the pop is
-unconditional, so a branch's shadows cannot outlive the branch.
-*/
-export function createShadowScope(): ShadowScope {
-    const byKind: Record<ShadowKind, Set<string>> = {
-        derived: new Set<string>(),
-        plain: new Set<string>(),
-    }
-
-    function withShadow<T>(names: Iterable<string>, kind: ShadowKind, body: () => T): T {
-        const scope = byKind[kind]
-        /* Track only the names this call newly added, so a name already shadowing from an
-           outer branch survives this branch's pop. */
-        const added: string[] = []
-        for (const name of names) {
-            if (!scope.has(name)) {
-                scope.add(name)
-                added.push(name)
-            }
-        }
-        try {
-            return body()
-        } finally {
-            for (const name of added) {
-                scope.delete(name)
-            }
-        }
-    }
-
-    return {
-        withShadow,
-        names: (kind) => byKind[kind],
-    }
-}

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

@@ -1,36 +0,0 @@
-import ts from 'typescript'
-
-/* Top-level declared names of a code block — a nested `<script>`'s locals, or a snippet's params
-   parsed as a destructuring pattern. Best-effort; on a parse miss returns empty (fail-open on the
-   binder side is safe: a script's names only ADD conservatism to a prefix-evaluability check when
-   present). Shared by the await-flight and child-render-flight classifiers (ADR-0034 / ADR-0037). */
-export function declaredNames(code: string): Set<string> {
-    const names = new Set<string>()
-    let source: ts.SourceFile
-    try {
-        source = ts.createSourceFile('script.ts', code, ts.ScriptTarget.Latest, true)
-    } catch {
-        return names
-    }
-    const collectBinding = (name: ts.BindingName): void => {
-        if (ts.isIdentifier(name)) {
-            names.add(name.text)
-            return
-        }
-        for (const element of name.elements) {
-            if (ts.isBindingElement(element)) {
-                collectBinding(element.name)
-            }
-        }
-    }
-    for (const statement of source.statements) {
-        if (ts.isVariableStatement(statement)) {
-            for (const declaration of statement.declarationList.declarations) {
-                collectBinding(declaration.name)
-            }
-        } else if (ts.isFunctionDeclaration(statement) && statement.name !== undefined) {
-            names.add(statement.name.text)
-        }
-    }
-    return names
-}