@abide/abide 0.58.0 → 0.100.0

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

@@ -1,92 +0,0 @@
-import ts from 'typescript'
-import { ABIDE_PACKAGE_NAME } from '../../shared/ABIDE_PACKAGE_NAME.ts'
-
-/* The reactive primitive an import binding resolves to — the single recognition
-   vocabulary the desugarer, the nested-script scoper, and the shadow consume.
-   `linked`/`computed` are reached as members of a `state` import (`state.linked`),
-   so they are resolution results but carry no import specifier of their own. */
-export type ReactivePrimitive = 'state' | 'linked' | 'computed' | 'effect' | 'watch' | 'props'
-
-/* The `abide/ui/*` specifier each importable reactive primitive is published at,
-   mapped to its canonical name. Built from the package name so a rename is one edit.
-   `linked`/`computed` are members of `state`, not standalone imports. */
-const REACTIVE_SPECIFIERS: Record<string, ReactivePrimitive> = {
-    [`${ABIDE_PACKAGE_NAME}/ui/state`]: 'state',
-    [`${ABIDE_PACKAGE_NAME}/ui/effect`]: 'effect',
-    [`${ABIDE_PACKAGE_NAME}/ui/watch`]: 'watch',
-    [`${ABIDE_PACKAGE_NAME}/ui/props`]: 'props',
-}
-
-/* The reactive import bindings a source file declares: each local binding (alias-safe)
-   mapped to its canonical primitive, plus the set of locals bound to `state` (so a
-   `state.linked` / `state.computed` member call resolves off the right root). Scans the
-   file's `import` statements once — no checker, no `ts.Program`: recognition is purely
-   syntactic, correct because abide has no barrels (a primitive is imported directly from
-   its `abide/ui/*` module, never a re-export). */
-export type ReactiveImportBindings = {
-    direct: Map<string, ReactivePrimitive>
-    stateRoots: Set<string>
-}
-
-/* The reactive bindings a nested `<template>` <script> resolves against. A nested script
-   cannot carry its own import (imports are module-scoped, hoisted off the leading script or
-   absent entirely), so it inherits the surface by the canonical names — the one recognition
-   site that is name-based because imports structurally cannot reach it. */
-export const NESTED_REACTIVE_BINDINGS: ReactiveImportBindings = {
-    direct: new Map<string, ReactivePrimitive>([
-        ['state', 'state'],
-        ['effect', 'effect'],
-        ['watch', 'watch'],
-        ['props', 'props'],
-    ]),
-    stateRoots: new Set(['state']),
-}
-
-export function reactiveImportBindings(source: ts.SourceFile): ReactiveImportBindings {
-    const direct = new Map<string, ReactivePrimitive>()
-    const stateRoots = new Set<string>()
-    for (const statement of source.statements) {
-        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
-            continue
-        }
-        const canonical = REACTIVE_SPECIFIERS[statement.moduleSpecifier.text]
-        const named = statement.importClause?.namedBindings
-        if (canonical === undefined || named === undefined || !ts.isNamedImports(named)) {
-            continue
-        }
-        for (const element of named.elements) {
-            /* The imported name (`propertyName` when aliased, else `name`) must be the
-               module's canonical export; `name` is the local binding codegen resolves. */
-            if ((element.propertyName ?? element.name).text !== canonical) {
-                continue
-            }
-            direct.set(element.name.text, canonical)
-            if (canonical === 'state') {
-                stateRoots.add(element.name.text)
-            }
-        }
-    }
-    return { direct, stateRoots }
-}
-
-/* The reactive primitive a call's callee resolves to, or undefined. Every bare identifier
-   resolves through the direct import bindings (alias-safe); a `stateRoot.linked` /
-   `.computed` member call resolves off a local bound to `state`. Every other callee is
-   undefined (a user's own function, an unrelated member access). */
-export function resolveReactiveExport(
-    callee: ts.Expression,
-    bindings: ReactiveImportBindings,
-): ReactivePrimitive | undefined {
-    if (ts.isIdentifier(callee)) {
-        return bindings.direct.get(callee.text)
-    }
-    if (
-        ts.isPropertyAccessExpression(callee) &&
-        ts.isIdentifier(callee.expression) &&
-        bindings.stateRoots.has(callee.expression.text) &&
-        (callee.name.text === 'linked' || callee.name.text === 'computed')
-    ) {
-        return callee.name.text
-    }
-    return undefined
-}

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

@@ -1,9 +0,0 @@
-/*
-Serializes one `<style>` scope marker to its empty-valued attribute fragment,
-leading space included. Shared by the SSR generator and the static-clone skeleton
-generator so server markup and the client clone template stamp the same scope
-attributes in the same byte-shape.
-*/
-export function scopeAttr(scope: string): string {
-    return ` ${scope}=""`
-}

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

@@ -1,138 +0,0 @@
-/*
-Scopes a component's CSS to its own elements by appending an attribute selector
-(`[data-a-<hash>]`) to each rule's key compound selector — the proven approach
-(every element the component renders carries the attribute, so descendant
-selectors still resolve, but styles never leak out). At-rule preludes (`@media`,
-etc.) pass through untouched while the nested rules inside them are still scoped.
-The attribute is inserted before any pseudo (`a:hover` → `a[attr]:hover`) so the
-selector stays valid.
-*/
-export function scopeCss(css: string, attribute: string): string {
-    let result = ''
-    let prelude = '' // chars accumulated since the last brace
-    let depth = 0
-    let keyframesDepth = -1 // brace depth of the open @keyframes block, or -1 when outside one
-    for (const char of css) {
-        if (char === '{') {
-            const insideKeyframes = keyframesDepth !== -1 && depth >= keyframesDepth
-            if (prelude.trim().startsWith('@')) {
-                /* At-rule prelude: leave it; its inner rules scope on their own. A
-                   @keyframes block is the exception — its `from`/`to`/`%` steps aren't
-                   selectors, so track its depth and leave the steps inside it bare. */
-                if (/^@(-[a-z]+-)?keyframes\b/i.test(prelude.trim())) {
-                    keyframesDepth = depth + 1
-                }
-                result += `${prelude}{`
-            } else if (insideKeyframes) {
-                result += `${prelude}{` // a keyframe step (from/to/%) — not a selector
-            } else {
-                result += `${scopeSelectorList(prelude, attribute)} {`
-            }
-            depth += 1
-            prelude = ''
-        } else if (char === '}') {
-            result += `${prelude}}`
-            prelude = ''
-            depth -= 1
-            if (keyframesDepth !== -1 && depth < keyframesDepth) {
-                keyframesDepth = -1
-            }
-        } else {
-            prelude += char
-        }
-    }
-    return result + prelude
-}
-
-/* Scopes each selector in a comma-separated list, splitting at top-level commas
-   only so a `,` inside `:is(.a, .b)` / `[attr=","]` doesn't fragment a selector. */
-function scopeSelectorList(prelude: string, attribute: string): string {
-    return splitSelectorList(prelude)
-        .map((selector) => scopeSelector(selector.trim(), attribute))
-        .join(', ')
-}
-
-/* Splits a selector list on commas that aren't nested inside `()` or `[]`. */
-function splitSelectorList(prelude: string): string[] {
-    const selectors: string[] = []
-    let current = ''
-    let nesting = 0
-    for (const char of prelude) {
-        if (char === '(' || char === '[') {
-            nesting += 1
-        } else if (char === ')' || char === ']') {
-            nesting -= 1
-        }
-        if (char === ',' && nesting === 0) {
-            selectors.push(current)
-            current = ''
-        } else {
-            current += char
-        }
-    }
-    selectors.push(current)
-    return selectors
-}
-
-/* Appends `[attribute]` to a selector's last compound, before any pseudo. */
-function scopeSelector(selector: string, attribute: string): string {
-    if (selector === '') {
-        return selector
-    }
-    /* The last compound begins just after the final combinator (whitespace / `>` / `+` / `~`)
-       at bracket depth zero. Bracket-aware so a space inside a quoted attribute value
-       (`[data-label="Read more"]`) is NOT mistaken for a descendant combinator — a plain
-       `/\s/` split there desyncs pseudoIndex's bracket count and drops the whole rule. */
-    let depth = 0
-    let lastCompoundStart = 0
-    for (let index = 0; index < selector.length; index += 1) {
-        const char = selector[index] as string
-        if (char === '[') {
-            depth += 1
-        } else if (char === ']') {
-            depth -= 1
-        } else if (
-            depth === 0 &&
-            (char === ' ' ||
-                char === '\t' ||
-                char === '\n' ||
-                char === '>' ||
-                char === '+' ||
-                char === '~')
-        ) {
-            lastCompoundStart = index + 1
-        }
-    }
-    const prefix = selector.slice(0, lastCompoundStart)
-    const last = selector.slice(lastCompoundStart)
-    if (last === '') {
-        return `${selector}[${attribute}]`
-    }
-    const pseudo = pseudoIndex(last)
-    const scopedLast =
-        pseudo === -1
-            ? `${last}[${attribute}]`
-            : `${last.slice(0, pseudo)}[${attribute}]${last.slice(pseudo)}`
-    return `${prefix}${scopedLast}`
-}
-
-/*
-Index of the first pseudo-class/element colon in a compound — i.e. a `:` at
-bracket depth zero. Skips colons inside an attribute selector's value
-(e.g. `a[href='http://x']`), which must not be treated as a pseudo boundary.
-Returns -1 when the compound has no pseudo.
-*/
-function pseudoIndex(compound: string): number {
-    let depth = 0
-    for (let index = 0; index < compound.length; index += 1) {
-        const char = compound[index]
-        if (char === '[') {
-            depth += 1
-        } else if (char === ']') {
-            depth -= 1
-        } else if (char === ':' && depth === 0) {
-            return index
-        }
-    }
-    return -1
-}

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

@@ -1,60 +0,0 @@
-import { cachedShadowProgram } from './cachedShadowProgram.ts'
-import { classifyInterpolationType } from './classifyInterpolationType.ts'
-import type { ShadowProgram } from './createShadowProgram.ts'
-import { nodeAtShadowOffset } from './nodeAtShadowOffset.ts'
-import { shadowNaming } from './shadowNaming.ts'
-import { sourceToShadowOffset } from './sourceToShadowOffset.ts'
-import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
-
-/*
-Builds the type-directed SEED classifier for one `.abide` file (ADR-0023) — the cell
-transform's counterpart to `interpolationClassifierForRoot`, resolving a `computed`/`linked`
-seed's checker type through the SAME warm shadow program (kept once per project root, ADR-0019
-Stage B). Shares the `cache` the interpolation classifier populates, so no second program is
-built: whichever classifier is requested first for a root warms it, the other reuses it.
-
-A `computed(SEED)` declaration is emitted into the shadow's script region with `SEED` wrapped
-in parens (verbatim if the callee is unrecognized, or projected as `(SEED)()` when recognized
-as `state.computed` — either way the seed sub-expression maps back to source and resolves its
-own type), so the identical `sourceToShadowOffset → nodeAtShadowOffset → classifyInterpolation
-Type` pipeline the interpolation half uses resolves a seed with no node-finder variant.
-
-FAIL-OPEN, but NOT to `'sync'`: if the program can't build (warned once per root by
-`cachedShadowProgram`), the file has no shadow, the seed's location doesn't map, no node is
-found, or the checker throws, the classifier is absent / returns `undefined` — the signal the
-caller reads as "degrade to `isBareCallComputed`", NOT as "the seed is sync". Collapsing failure
-to `'sync'` (as the interpolation classifier does) would mis-route a failed stream seed to the
-lazy `derive` slot instead of today's syntax heuristic.
-*/
-export function seedTypeClassifierForRoot(
-    cache: Map<string, ShadowProgram | undefined>,
-    root: string,
-    abidePath: string,
-): SeedTypeClassifier | undefined {
-    const shadowProgram = cachedShadowProgram(cache, root)
-    if (shadowProgram === undefined) {
-        return undefined
-    }
-    const { program, shadows } = shadowProgram
-    const shadowFile = program.getSourceFile(shadowNaming.suffixed(abidePath))
-    if (shadowFile === undefined) {
-        return undefined
-    }
-    const checker = program.getTypeChecker()
-    const mappings = shadows.get(abidePath)?.mappings ?? []
-    return (loc, code) => {
-        try {
-            const offset = sourceToShadowOffset(mappings, loc)
-            if (offset === undefined) {
-                return undefined
-            }
-            const node = nodeAtShadowOffset(shadowFile, offset, code.length)
-            if (node === undefined) {
-                return undefined
-            }
-            return classifyInterpolationType(checker.getTypeAtLocation(node), node, checker)
-        } catch {
-            return undefined
-        }
-    }
-}

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

@@ -1,47 +0,0 @@
-import type ts from 'typescript'
-import { classifyInterpolationType } from './classifyInterpolationType.ts'
-import { nodeAtShadowOffset } from './nodeAtShadowOffset.ts'
-import { shadowNaming } from './shadowNaming.ts'
-import { sourceToShadowOffset } from './sourceToShadowOffset.ts'
-import type { CompiledShadow } from './types/CompiledShadow.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-
-/*
-Builds the type-directed interpolation classifier for one `.abide` file against an already-built
-shadow `program` (its `shadows` map carries each file's source→shadow `mappings`). Given an
-interpolation's absolute source offset and text, it maps into shadow coordinates, finds the emitted
-expression node, and reads its checker type — the shared core behind both `interpolationClassifier
-ForRoot` (the runtime lowering, over `createShadowProgram`) and the type-check shadow's own peek-wrap
-(over the check/LSP program). The classifier reads a VERBATIM shadow — one whose interpolations were
-NOT peek-wrapped — so `getFoo()` still types as `Promise<…>` and classifies as `promise`.
-
-FAIL-OPEN: no shadow file for the path ⇒ `undefined` (caller degrades to no wrap / plain binding);
-the returned closure wraps its body so ANY throw (missing node, checker hiccup) returns `'sync'`.
-*/
-export function shadowInterpolationClassifier(
-    program: ts.Program,
-    shadows: Map<string, CompiledShadow>,
-    abidePath: string,
-): InterpolationClassifier | undefined {
-    const shadowFile = program.getSourceFile(shadowNaming.suffixed(abidePath))
-    if (shadowFile === undefined) {
-        return undefined
-    }
-    const checker = program.getTypeChecker()
-    const mappings = shadows.get(abidePath)?.mappings ?? []
-    return (loc, code) => {
-        try {
-            const offset = sourceToShadowOffset(mappings, loc)
-            if (offset === undefined) {
-                return 'sync'
-            }
-            const node = nodeAtShadowOffset(shadowFile, offset, code.length)
-            if (node === undefined) {
-                return 'sync'
-            }
-            return classifyInterpolationType(checker.getTypeAtLocation(node), node, checker)
-        } catch {
-            return 'sync'
-        }
-    }
-}

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

@@ -1,11 +0,0 @@
-/*
-A `.abide` component's virtual shadow is the same absolute path with `.ts`
-appended (`Foo.abide` → `Foo.abide.ts`). The suffix lets a TypeScript host tell a
-shadow apart from a real file and recover the source path. Shared by the one-shot
-Program (`createShadowProgram`) and the incremental LanguageService (the LSP).
-*/
-export const shadowNaming = {
-    suffixed: (abidePath: string): string => `${abidePath}.ts`,
-    isShadow: (fileName: string): boolean => fileName.endsWith('.abide.ts'),
-    sourceOf: (shadowName: string): string => shadowName.slice(0, -'.ts'.length),
-}

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

@@ -1,24 +0,0 @@
-import ts from 'typescript'
-import {
-    type ReactiveImportBindings,
-    type ReactivePrimitive,
-    resolveReactiveExport,
-} from './resolveReactiveExport.ts'
-
-/*
-The canonical reactive primitive a `NAME = state(...)` declaration's callee resolves to,
-else undefined. Import-resolution is the SOLE recognition path (alias-safe: an
-`import { state as s }` still resolves `s(...)` to `state`); the legacy member forms are
-not recognised. Shared by the desugar, shadow type-check, and nested-script passes so all
-three agree on what is reactive — a divergence here silently mis-classifies a declaration.
-*/
-export function signalCallee(
-    declaration: ts.VariableDeclaration,
-    bindings: ReactiveImportBindings,
-): ReactivePrimitive | undefined {
-    const initializer = declaration.initializer
-    if (initializer === undefined || !ts.isCallExpression(initializer)) {
-        return undefined
-    }
-    return resolveReactiveExport(initializer.expression, bindings)
-}

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

@@ -1,133 +0,0 @@
-import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
-import { isControlFlow } from './isControlFlow.ts'
-import { isTextLeaf } from './isTextLeaf.ts'
-import { skeletonable } from './skeletonable.ts'
-import { templateAnchorAdapter } from './templateAnchorAdapter.ts'
-import { templateElementAdapter } from './templateElementAdapter.ts'
-import type { SkeletonContext } from './types/SkeletonContext.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-import { walkAnchorOrder } from './walkAnchorOrder.ts'
-import { walkElementOrder } from './walkElementOrder.ts'
-
-/*
-The single source of truth for where skeleton markers go AND what their hole indices are.
-One top-down `visit` walk records, per node, whether it sits inside a parser-backed skeleton
-clone (`inSkeleton`), whether its reactive text is interleaved (`markText`), and which
-`skeletonable` elements OPEN a skeleton (`skeletonRoots`). Both hole axes are then numbered by
-the two shared ordering rules — `walkElementOrder` (`el`) and `walkAnchorOrder` (`an`) — run
-once per root, so `generateBuild` reads `sk.el`/`sk.an` rather than re-deriving the numbering,
-and the runtime recovers the same positions through the SAME two walks. One rule per axis, both
-sides; the numbering cannot drift from the decisions.
-
-The index assignment is scoped per skeleton root (a `skeletonable` element not already in a
-skeleton — the unit `generateSkeleton` instantiates with a fresh `{ el: 0, an: 0 }`). `el`
-numbers element holes in pre-order (the root element itself can be one); `an` numbers anchor
-holes (interleaved reactive text PARTS, control-flow blocks, child components, `<slot>` outlets)
-in document order.
-
-A fresh-context boundary resets to NOT-in-skeleton, because the content there is built by its
-own runtime (a control-flow block's branch, a component's slot content, a `<slot>`'s fallback,
-a snippet's body) — never cloned by the enclosing skeleton.
-*/
-export function skeletonContext(nodes: TemplateNode[]): SkeletonContext {
-    const inSkeleton = new WeakMap<TemplateNode, boolean>()
-    const markText = new WeakMap<TemplateNode, boolean>()
-    /* Element holes keyed by node; anchor holes keyed by node (control-flow/component/slot) OR
-       by the reactive text PART object (a text node carries one anchor per reactive part). Both
-       numbered AFTER this context pass by the shared walks, once per skeleton root. */
-    const elIndex = new WeakMap<TemplateNode, number>()
-    const anIndex = new WeakMap<object, number>()
-    /* The skeletonable elements that OPEN a skeleton — each owns a fresh `el`/`an` numbering, so
-       the shared walks run once per root. Collected in pre-order here, numbered below. */
-    const skeletonRoots: TemplateNode[] = []
-
-    /* Record the boundary context (`inSkeleton`/`markText`) at `node` and collect skeleton
-       roots. Hole NUMBERING is no longer threaded here — the two shared walks own it. */
-    function visit(node: TemplateNode, nodeInSkeleton: boolean, nodeMarkText: boolean): void {
-        inSkeleton.set(node, nodeInSkeleton)
-        markText.set(node, nodeMarkText)
-
-        /* Control-flow blocks, components, and snippets are fresh build contexts. The node
-           ITSELF is an anchor in the enclosing skeleton (a block OR a component mounts as a
-           marker-bounded range at that anchor); its children re-enter the skeleton only via
-           their own roots. */
-        if (isControlFlow(node) || node.kind === 'component' || node.kind === 'snippet') {
-            for (const child of childrenOf(node)) {
-                visit(child, false, false)
-            }
-            return
-        }
-        /* A `branch`/`case` is a transparent grouping inside its control-flow block — pass the
-           already-reset context through so a skeletonable element inside it opens its own
-           skeleton. */
-        if (node.kind === 'branch' || node.kind === 'case') {
-            for (const child of node.children) {
-                visit(child, nodeInSkeleton, nodeMarkText)
-            }
-            return
-        }
-        if (node.kind === 'text') {
-            return
-        }
-        if (node.kind !== 'element') {
-            return // script / style carry no skeleton children and no hole
-        }
-        if (node.tag === 'slot' || node.tag === OUTLET_TAG) {
-            /* A component `<slot>` content fill OR a layout's `OUTLET_TAG` router fill point
-               (`asOutlet`): its children are a fresh context (the `<slot>` fallback / an outlet
-               has none). The slot's own anchor is numbered by the shared walk. */
-            for (const child of node.children) {
-                visit(child, false, false)
-            }
-            return
-        }
-        /* A skeletonable element not already in a skeleton OPENS one (the `generateSkeleton`
-           unit). An element already in a skeleton stays in it. A static element outside any
-           skeleton numbers nothing. */
-        const opensSkeleton = !nodeInSkeleton && skeletonable(node)
-        const childInSkeleton = nodeInSkeleton || skeletonable(node)
-        const childMarkText = childInSkeleton && !isTextLeaf(node)
-
-        if (opensSkeleton) {
-            skeletonRoots.push(node)
-        }
-        for (const child of node.children) {
-            visit(child, childInSkeleton, childMarkText)
-        }
-    }
-
-    for (const node of nodes) {
-        visit(node, false, false)
-    }
-
-    /* Number element holes via the ONE shared rule (`walkElementOrder`), once per skeleton root
-       so each root's holes start at 0 — the element-only pre-order the runtime's clone walk
-       re-derives. The walk starts AT the root: the root element itself is a located hole when it
-       binds. */
-    for (const root of skeletonRoots) {
-        let next = 0
-        walkElementOrder([root], templateElementAdapter, (node) => {
-            elIndex.set(node, next++)
-        })
-    }
-
-    /* Number anchor holes via the ONE shared rule (`walkAnchorOrder`), once per skeleton root.
-       The root's own children are walked — the root element is a located hole, never an
-       anchor. */
-    const anchorAdapter = templateAnchorAdapter(inSkeleton, markText)
-    for (const root of skeletonRoots) {
-        let next = 0
-        walkAnchorOrder(childrenOf(root), anchorAdapter, (position) => {
-            anIndex.set(position, next++)
-        })
-    }
-
-    return { inSkeleton, markText, elIndex, anIndex }
-}
-
-/* The child list of any node that has one (control-flow, component, snippet, element);
-   `[]` for the leaf kinds (text/script/style). `isControlFlow` is not a type guard, so the
-   `in` check is what narrows the union for the fresh-context branch. */
-function childrenOf(node: TemplateNode): TemplateNode[] {
-    return 'children' in node ? node.children : []
-}

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

@@ -1,68 +0,0 @@
-import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
-import { isControlFlow } from './isControlFlow.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* Whether a subtree is skeleton STRUCTURE — anything the parser-backed clone can carry with
-   its holes mounted in place: elements, `<style>`, text (static OR reactive), child
-   components (anchor-positioned via an `<!--a-->` marker in the skeleton), control-flow
-   blocks and `<slot>` outlets (each anchor-mounted at its position), and emit-nothing nodes
-   — a nested `<script>` (a scoped reactive block) and a `{#snippet}` block (a hoisted
-   builder), both of which the skeleton's bind list runs in document order, scoped like
-   `generateChild` does. Only a standalone `branch`/`case` (consumed by its block, never a
-   loose child) disqualifies. */
-function skeletonStructure(node: TemplateNode): boolean {
-    if (isControlFlow(node) || node.kind === 'component') {
-        return true
-    }
-    if (node.kind === 'style' || node.kind === 'text') {
-        return true
-    }
-    if (node.kind === 'script' || node.kind === 'snippet') {
-        return true
-    }
-    if (node.kind !== 'element') {
-        return false // standalone branch|case
-    }
-    if (node.tag === 'slot' || node.tag === OUTLET_TAG) {
-        return true
-    }
-    return node.children.every(skeletonStructure)
-}
-
-/* Whether a subtree carries at least one hole — anything needing a runtime bind rather than
-   constant markup: a reactive attribute/listener/bind on an element, a reactive text part, a
-   control-flow block, a `<slot>` outlet, a child component (each needs a located node or an
-   anchor), or a nested `<script>`/snippet (emits no markup but must run). */
-function hasHole(node: TemplateNode): boolean {
-    if (isControlFlow(node) || node.kind === 'component') {
-        return true
-    }
-    if (node.kind === 'script' || node.kind === 'snippet') {
-        return true
-    }
-    if (node.kind === 'text') {
-        return node.parts.some((part) => part.kind !== 'static')
-    }
-    if (node.kind === 'element') {
-        if (node.tag === 'slot' || node.tag === OUTLET_TAG) {
-            return true
-        }
-        return node.attrs.some((attr) => attr.kind !== 'static') || node.children.some(hasHole)
-    }
-    return false
-}
-
-/*
-A subtree of skeleton structure carrying one or more holes. It builds through the
-parser-backed `skeleton` (one clone, correct foreign namespaces) — element holes located by
-element-only path, anchor holes (reactive text interleaved with elements, control flow,
-slots) by document-order scan — instead of the imperative path. A bound element's reactive
-attributes wire to the located node; a text-leaf element's reactive text binds via
-`appendText` on it (marker-free, so SSR === client). Fully-static subtrees (no hole) stay on
-`cloneStatic`.
-*/
-export function skeletonable(node: TemplateNode): boolean {
-    return (
-        node.kind === 'element' && node.tag !== 'slot' && skeletonStructure(node) && hasHole(node)
-    )
-}

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

@@ -1,28 +0,0 @@
-import type { Binding } from './types/Binding.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* The structural shape of a `snippet` declaration (`<template name="row" args={item}>`),
-   resolved once so the build and SSR back-ends share one reading of it and only own emission.
-   Both previously read the name, the raw `args` source, and the body straight off the node.
-   The `args` params are now classified ONCE here as `bindings` (`plain` — real call
-   parameters, not cells), the single source both back-ends register through `withBindings`. */
-export type SnippetPlan = {
-    /* The snippet's name — the hoisted builder function's identifier and call name. */
-    name: string
-    /* The raw `args` source spliced into the builder's parameter list, or undefined. */
-    params: string | undefined
-    /* The snippet body. */
-    children: TemplateNode[]
-    /* The body's bindings: the `args` params (`plain`); empty when the snippet takes none. */
-    bindings: Binding[]
-}
-
-/* Reads a `snippet` node's structure into the shared structural plan. */
-export function snippetPlan(node: Extract<TemplateNode, { kind: 'snippet' }>): SnippetPlan {
-    return {
-        name: node.name,
-        params: node.params,
-        children: node.children,
-        bindings: node.params === undefined ? [] : [{ name: node.params, classification: 'plain' }],
-    }
-}

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

@@ -1,20 +0,0 @@
-import type ts from 'typescript'
-
-/* The compiler-option fields that change how a source file parses or binds — the only inputs
-   (besides the text) that make two parses of the same path differ, so the `cachedSourceFile`
-   key folds them in to keep two projects with different targets/libs from sharing a file. */
-export function sourceFileOptionsSignature(options: ts.CompilerOptions): string {
-    return JSON.stringify([
-        options.target,
-        options.module,
-        options.moduleDetection,
-        options.jsx,
-        options.jsxImportSource,
-        options.useDefineForClassFields,
-        options.alwaysStrict,
-        options.strict,
-        options.verbatimModuleSyntax,
-        options.isolatedModules,
-        options.lib,
-    ])
-}

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

@@ -1,24 +0,0 @@
-import type { ShadowMapping } from './types/CompiledShadow.ts'
-
-/*
-Translates an offset in the original `.abide` source to the equivalent offset in
-its type-checking shadow — the inverse of `remapShadowDiagnostic`. Drives
-position-based language-service queries (hover, completion, …) from an editor
-position: find the verbatim-emitted segment whose source span covers the offset
-and shift it into shadow coordinates. An offset outside every mapped span
-(whitespace, markup, framework syntax the shadow doesn't emit verbatim) has no
-shadow position, so the query is skipped.
-*/
-export function sourceToShadowOffset(
-    mappings: ShadowMapping[],
-    sourceOffset: number,
-): number | undefined {
-    const mapping = mappings.find(
-        (entry) =>
-            entry.sourceStart <= sourceOffset && sourceOffset < entry.sourceStart + entry.length,
-    )
-    if (mapping === undefined) {
-        return undefined
-    }
-    return mapping.shadowStart + (sourceOffset - mapping.sourceStart)
-}