@abide/abide 0.58.0 → 0.100.0

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

@@ -1,27 +0,0 @@
-import type { TemplateAttr } from './types/TemplateAttr.ts'
-
-/*
-The explicitly-authored attribute names on a native element that also carries a
-`{...spread}`. An explicit attribute wins over a spread key of the same name, so
-both back-ends pass this set to skip those keys from the spread — keeping the
-server string and the client DOM congruent (no duplicate attribute, and no
-SSR-first-wins vs client-spread-wins divergence). Excluding by NAME (not by a
-runtime present/absent check) means the two sides agree regardless of a dynamic
-attribute's runtime value. Static, dynamic (`{expr}`), and interpolated
-(`"… {expr} …"`) attrs contribute their name, a `bind:` its property, an
-`on<event>` its `on…` form; `attach`/`spread` carry no attribute name.
-*/
-export function spreadExcludedNames(attrs: TemplateAttr[]): string[] {
-    return attrs.flatMap((attr) => {
-        if (attr.kind === 'static' || attr.kind === 'expression' || attr.kind === 'interpolated') {
-            return [attr.name]
-        }
-        if (attr.kind === 'bind') {
-            return [attr.property]
-        }
-        if (attr.kind === 'event') {
-            return [`on${attr.event}`]
-        }
-        return []
-    })
-}

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

@@ -1,11 +0,0 @@
-import { escapeHtml } from '../../shared/escapeHtml.ts'
-
-/*
-Serializes one static attribute to its markup fragment, leading space included.
-Shared by the SSR generator and the static-clone skeleton generator so the two
-back-ends can't diverge on attribute byte-shape or value escaping — the contract
-that lets the client clone template hydrate the server markup.
-*/
-export function staticAttr(name: string, value: string): string {
-    return ` ${name}="${escapeHtml(value)}"`
-}

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

@@ -1,13 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* The value of a static attribute on an element node, or undefined when absent.
-   Used to read directive attributes like `slot` / `slot name` off the template. */
-export function staticAttrValue(
-    node: Extract<TemplateNode, { kind: 'element' }>,
-    name: string,
-): string | undefined {
-    const attr = node.attrs.find(
-        (candidate) => candidate.kind === 'static' && candidate.name === name,
-    )
-    return attr !== undefined && attr.kind === 'static' ? attr.value : undefined
-}

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

@@ -1,12 +0,0 @@
-import { escapeHtml } from '../../shared/escapeHtml.ts'
-
-/*
-Serializes one static text part to its markup: whitespace-only parts drop (both
-back-ends omit them, so a blank part neither emits markup nor breaks a clone run),
-everything else is HTML-escaped. Shared by the SSR generator and the static-clone
-skeleton generator so server markup and the client clone template agree on both
-the whitespace rule and escaping.
-*/
-export function staticTextPart(value: string): string {
-    return value.trim() === '' ? '' : escapeHtml(value)
-}

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

@@ -1,48 +0,0 @@
-import ts from 'typescript'
-import { TS_PRINTER } from './TS_PRINTER.ts'
-
-/*
-Removes effect/watch reaction calls from a script for the SSR back-end. Reactions are
-client lifecycle — they touch the DOM / run side effects and emit no HTML, so the server
-render (a snapshot of the pre-effect markup, like every framework) must not run
-them. Stripped: the bare `effect(<args>)` and its authored scope form
-`scope().effect(<args>)` / `c.effect(<args>)`, and the bare reaction `watch(<args>)`
-(its replacement) — each replaced by `undefined`, so an `effect(() => …)` /
-`watch(src, …)` statement becomes a no-op and a `const stop = watch(…)` binding keeps a
-defined (unused) name. `watch` matches bare only (never a member — unlike the legacy
-`.effect` scope method — so an unrelated `x.watch(...)` is untouched). Client
-compilation keeps reactions untouched.
-*/
-export function stripEffects(code: string): string {
-    const source = ts.createSourceFile('script.ts', code, ts.ScriptTarget.Latest, true)
-    const result = ts.transform(source, [stripEffectsTransformer()])
-    const output = TS_PRINTER.printFile(result.transformed[0] as ts.SourceFile)
-    result.dispose()
-    return output
-}
-
-/* The effect-stripping as a `ts.TransformerFactory`, so the SSR script path can run it
-   over the tree `lowerScript` already built (one extra print, no reparse). `stripEffects`
-   is the standalone string wrapper kept for the per-nested-`<script>` SSR callers. */
-export function stripEffectsTransformer(): ts.TransformerFactory<ts.SourceFile> {
-    return (context) => (root) => {
-        const visit = (node: ts.Node): ts.Node => {
-            if (ts.isCallExpression(node) && isEffectCallee(node.expression)) {
-                return ts.factory.createIdentifier('undefined')
-            }
-            return ts.visitEachChild(node, visit, context)
-        }
-        return ts.visitNode(root, visit) as ts.SourceFile
-    }
-}
-
-/* A reaction callee to strip: the bare runtime helpers (`effect` / `watch`) or the
-   scope-method form (`scope().effect`, `c.effect`). Receiver-agnostic on the `.effect`
-   member name (effect was a scope primitive); `watch` matches bare only, so an unrelated
-   `x.watch(...)` member call is left intact. */
-function isEffectCallee(expression: ts.Expression): boolean {
-    if (ts.isIdentifier(expression)) {
-        return expression.text === 'effect' || expression.text === 'watch'
-    }
-    return ts.isPropertyAccessExpression(expression) && expression.name.text === 'effect'
-}

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

@@ -1,107 +0,0 @@
-import { BLOCK_CONNECTORS, BLOCK_OPENERS } from './BLOCK_KEYWORDS.ts'
-import type { SemanticToken } from './types/SemanticToken.ts'
-
-/*
-Semantic tokens for a `{#…}`/`{:…}`/`{/…}` control-block head, driven by the parse
-walk (`readBlockToken`) rather than a raw source regex — so the SAME grammar that
-builds the block tree colors it, and a `{#for}` sitting inside a `{expr}`/string/
-backtick region (which the walk skips as opaque expression text) is never miscolored.
-Emits an `operator` token for the `{`+sigil opener and a `keyword` token for the
-block word, plus the `of`/`by` connectors inside a `{#for …}` head. A keyword
-allowlist after the sigil keeps an arbitrary `{:foo}` uncolored (nothing emitted).
-*/
-/* The scan vocabulary, derived from the shared BLOCK_KEYWORDS source of truth (plus the
-   `for await` async-each phrase) so it can't drift from the parser. Sorted longest-first so
-   the match takes the whole phrase — `for await` beats `for`, `else if` beats `else` —
-   since a shorter prefix checked first would win otherwise. */
-const BLOCK_KEYWORDS = [...BLOCK_OPENERS, ...BLOCK_CONNECTORS, 'for await'].sort(
-    (a, b) => b.length - a.length,
-)
-
-const WORD_CHAR = /\w/
-
-/*
-Emits the head tokens for a block whose `{` sits at `braceStart`, whose sigil is
-`#`/`:`/`/`, and whose first directive word begins at `keywordStart` (already past the
-leading whitespace `{#  for}` allows). Matches the longest allowlist keyword at
-`keywordStart` requiring a trailing word boundary; if no keyword matches, emits NOTHING
-(not even the opener) — mirroring the old regex, which only colored an allowlist match.
-*/
-export function structuralHeadTokens(
-    source: string,
-    braceStart: number,
-    sigil: string,
-    keywordStart: number,
-): SemanticToken[] {
-    let matched: string | undefined
-    for (const keyword of BLOCK_KEYWORDS) {
-        if (
-            source.startsWith(keyword, keywordStart) &&
-            !WORD_CHAR.test(source.charAt(keywordStart + keyword.length))
-        ) {
-            matched = keyword
-            break
-        }
-    }
-    if (matched === undefined) {
-        return []
-    }
-    const tokens: SemanticToken[] = [
-        { start: braceStart, length: 2, type: 'operator', modifiers: [] },
-        { start: keywordStart, length: matched.length, type: 'keyword', modifiers: [] },
-    ]
-    /* A `{#for …}` head carries abide-only connectors `of`/`by` that the shadow lowers
-       away (`of`) or never emits (`by`), so color them here. */
-    if (sigil === '#' && (matched === 'for' || matched === 'for await')) {
-        forHeadConnectors(source, keywordStart + matched.length, tokens)
-    }
-    return tokens
-}
-
-/*
-Scans a `{#for …}` head from `from` to its closing `}`, pushing `keyword` tokens for the
-`of`/`by` connectors at brace depth 0 — skipping any `of`/`by` nested in a destructure,
-call, or string so an identifier or object key is never miscolored.
-*/
-function forHeadConnectors(source: string, from: number, tokens: SemanticToken[]): void {
-    let depth = 0
-    let cursor = from
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '"' || char === "'" || char === '`') {
-            cursor += 1
-            while (cursor < source.length && source.charAt(cursor) !== char) {
-                if (source.charAt(cursor) === '\\') {
-                    cursor += 1
-                }
-                cursor += 1
-            }
-        } else if (char === '{' || char === '(' || char === '[') {
-            depth += 1
-        } else if (char === ')' || char === ']') {
-            depth -= 1
-        } else if (char === '}') {
-            if (depth === 0) {
-                break
-            }
-            depth -= 1
-        } else if (depth === 0 && (char === 'o' || char === 'b')) {
-            const word = source.startsWith('of', cursor)
-                ? 'of'
-                : source.startsWith('by', cursor)
-                  ? 'by'
-                  : undefined
-            const isWordBoundary = (offset: number): boolean => /\s/.test(source.charAt(offset))
-            if (
-                word !== undefined &&
-                isWordBoundary(cursor - 1) &&
-                isWordBoundary(cursor + word.length)
-            ) {
-                tokens.push({ start: cursor, length: word.length, type: 'keyword', modifiers: [] })
-                cursor += word.length
-                continue
-            }
-        }
-        cursor += 1
-    }
-}

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

@@ -1,28 +0,0 @@
-import type { Binding } from './types/Binding.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-type Case = Extract<TemplateNode, { kind: 'case' }>
-
-/* The structural shape of a `switch`, resolved once so the build and SSR back-ends share one
-   reading of its cases and only own emission. Both previously recomputed the `case` filter;
-   SSR additionally located the match-less default. A `switch` introduces no names, so
-   `bindings` is empty — present so every block plan answers the single binding source
-   uniformly. */
-export type SwitchPlan = {
-    /* The `case` branches in source order (`match` set; the default leaves it unset). */
-    cases: Case[]
-    /* The match-less default branch, if present. */
-    fallback: Case | undefined
-    /* A `switch` binds no names. */
-    bindings: Binding[]
-}
-
-/* Resolves a `switch` node's cases into the shared structural plan. */
-export function switchPlan(node: Extract<TemplateNode, { kind: 'switch' }>): SwitchPlan {
-    const cases = node.children.filter((child): child is Case => child.kind === 'case')
-    return {
-        cases,
-        fallback: cases.find((branch) => branch.match === undefined),
-        bindings: [],
-    }
-}

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

@@ -1,61 +0,0 @@
-import { isAnchorPositioned } from './isAnchorPositioned.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-import type { AnchorRole, AnchorWalkAdapter } from './walkAnchorOrder.ts'
-
-/*
-The template-AST side of the shared anchor-ordering rule (`walkAnchorOrder`). Classifies each
-parsed node by the SAME positions the realized-DOM side recovers, so the compiler's `anIndex`
-numbering and the runtime's `scanAnchors` collection cannot disagree.
-
-Anchor positions, in document order: a control-flow/component node and a `<slot>`/outlet
-element each contribute themselves (one anchor, fresh-context body — not descended); a text
-node whose reactive parts are interleaved contributes one anchor per non-static part. A
-skeleton-structure element is a container we descend; everything else (static text, a
-text-leaf's marker-free text, script/style, a node outside any skeleton) contributes nothing.
-
-`inSkeleton`/`markText` come from the context pass (the element-hole + boundary axes), read here
-so the adapter stays a pure classifier — the anchor counter never re-derives the context.
-*/
-export function templateAnchorAdapter(
-    inSkeleton: WeakMap<TemplateNode, boolean>,
-    markText: WeakMap<TemplateNode, boolean>,
-): AnchorWalkAdapter<TemplateNode> {
-    return {
-        classify: (node: TemplateNode): AnchorRole => {
-            /* A node outside an active skeleton numbers nothing — its block/text mounts on the
-               host directly (top-level / inside a branch), no anchor. */
-            if (inSkeleton.get(node) !== true) {
-                /* It may still be a non-skeleton CONTAINER whose descendants open their own
-                   skeletons (a static wrapper element), so recurse into elements, skip leaves. */
-                return node.kind === 'element' ? { kind: 'recurse' } : { kind: 'skip' }
-            }
-            /* An anchor-positioned node IS one anchor and its body is a fresh context. */
-            if (isAnchorPositioned(node)) {
-                return { kind: 'anchor', positions: [node] }
-            }
-            /* A component/snippet inside a skeleton that isn't anchor-positioned (a snippet
-               declares a builder) — fresh context, no anchor, no descent. */
-            if (node.kind === 'component' || node.kind === 'snippet') {
-                return { kind: 'skip' }
-            }
-            /* Interleaved reactive text: one anchor per non-static part, document order. */
-            if (node.kind === 'text') {
-                return markText.get(node) === true
-                    ? {
-                          kind: 'anchor',
-                          positions: node.parts.filter((part) => part.kind !== 'static'),
-                      }
-                    : { kind: 'skip' }
-            }
-            /* A skeleton-structure element — descend into its children. */
-            if (node.kind === 'element') {
-                return { kind: 'recurse' }
-            }
-            return { kind: 'skip' }
-        },
-        /* A branch/case is a transparent grouping inside its block — the context pass already
-           records its children's reset state, so the walk descends straight through it. */
-        childrenOf: (node: TemplateNode): readonly TemplateNode[] =>
-            'children' in node ? node.children : [],
-    }
-}

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

@@ -1,44 +0,0 @@
-import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
-import { isControlFlow } from './isControlFlow.ts'
-import { isTextLeaf } from './isTextLeaf.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-import type { ElementRole, ElementWalkAdapter } from './walkElementOrder.ts'
-
-/*
-The template-AST side of the shared element-hole numbering rule (`walkElementOrder`). Classifies
-each parsed node by the SAME holes the parsed-DOM side recovers (`domElementAdapter`), so the
-compiler's `elIndex` numbering and the runtime's `HOLE_ATTRIBUTE` path collection cannot
-disagree.
-
-A skeleton element is a numbered element (descended into); it is a HOLE when it carries a
-reactive attribute/listener/bind, or binds reactive text marker-free as a text leaf — exactly
-the elements `generateSkeleton` stamps with `HOLE_ATTRIBUTE`. A control-flow block, component,
-snippet, `<slot>`, or outlet is a fresh build context (its content numbers in its own skeleton),
-and a text/script/style/branch/case carries no element index — all skip.
-*/
-export const templateElementAdapter: ElementWalkAdapter<TemplateNode> = {
-    classify: (node: TemplateNode): ElementRole => {
-        /* Fresh build contexts — their content is numbered by their own skeleton, not here. */
-        if (isControlFlow(node) || node.kind === 'component' || node.kind === 'snippet') {
-            return { kind: 'skip' }
-        }
-        if (node.kind !== 'element') {
-            return { kind: 'skip' } // text / script / style / standalone branch|case
-        }
-        /* A `<slot>` fill point or a layout outlet — fresh context (slot fallback / outlet has
-           none), anchor-positioned, never an element hole. */
-        if (node.tag === 'slot' || node.tag === OUTLET_TAG) {
-            return { kind: 'skip' }
-        }
-        const hasReactiveAttr = node.attrs.some((attr) => attr.kind !== 'static')
-        const hasReactiveTextChild = node.children.some(
-            (child) => child.kind === 'text' && child.parts.some((part) => part.kind !== 'static'),
-        )
-        return {
-            kind: 'element',
-            isHole: hasReactiveAttr || (hasReactiveTextChild && isTextLeaf(node)),
-        }
-    },
-    childrenOf: (node: TemplateNode): readonly TemplateNode[] =>
-        'children' in node ? node.children : [],
-}

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

@@ -1,21 +0,0 @@
-import { parseTemplateRecovering } from './parseTemplateRecovering.ts'
-import type { SemanticToken } from './types/SemanticToken.ts'
-
-/*
-The LSP's markup + structural highlighting for a full `.abide` component, driven by
-the ONE parse walk (`parseTemplateRecovering`) instead of a pair of hand-rolled
-lexers — so the same grammar that builds the tree colors it, and no coloring can
-drift from what the parser accepts. Runs over the FULL source at `baseOffset 0` with
-token collection on: element/component tag names (`tag`/`type`), attribute names
-(`attribute`), quoted/unquoted values (`string`), comments (`comment`), the
-`<`/`>`/`=`/`/` punctuation (`operator`), and the `{#…}`/`{:…}`/`{/…}` block framing
-(`operator` + `keyword`). The leading `<script>…</script>` reads through the same
-`readElement` path as a nested script, so its open+close tags color with no separate
-leading-region lexer. `{…}` expression interiors and raw `<script>`/`<style>` bodies
-are skipped — those are the type-checking shadow's job. The parse's `nodes` and
-`diagnostics` (including the spurious leading-script diagnostics a full-source parse
-raises) are discarded; only `.tokens` is used.
-*/
-export function templateSemanticTokens(source: string): SemanticToken[] {
-    return parseTemplateRecovering(source, 0, true).tokens
-}

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

@@ -1,15 +0,0 @@
-/* The regex that isolates a `.abide` file's leading `<script>` block, capturing its body (`[1]`) —
-   the single source `analyzeComponent`, `compileShadow`, and `templateStartOffset` all match on to
-   split script from template, so the three can never drift. Stateless (no `/g`), safe to share. */
-export const LEADING_SCRIPT = /^\s*<script[^>]*>([\s\S]*?)<\/script>/
-
-/*
-The source offset where the template markup begins — just past the closing `</script>` of a
-leading `<script>` block, or `0` when the file is template-only. A component's template
-interpolations all map to source offsets at or after this point, so it doubles as the boundary
-that separates template expressions from `<script>` code.
-*/
-export function templateStartOffset(source: string): number {
-    const leadingScript = source.match(LEADING_SCRIPT)
-    return leadingScript ? (leadingScript.index ?? 0) + leadingScript[0].length : 0
-}

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

@@ -1,37 +0,0 @@
-import { catchBinding } from './catchBinding.ts'
-import { resolveBranches } from './resolveBranches.ts'
-import type { Binding } from './types/Binding.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* The structural shape of a `try` error boundary, resolved once so the build and SSR
-   back-ends share one reading and only own emission. Both previously recomputed branch
-   resolution, the `finallyChildren` default, the guarded (children-minus-branch) split, and
-   the catch binding / presence. */
-export type TryPlan = {
-    /* The guarded content — every child except the `catch`/`finally` branch nodes. */
-    guarded: TemplateNode[]
-    /* The catch content + its bound name (`_error` default); empty when no catch branch. */
-    catchChildren: TemplateNode[]
-    catchAs: string
-    finallyChildren: TemplateNode[]
-    /* No catch → a throw propagates to the enclosing boundary (re-throw / `undefined` thunk). */
-    hasCatch: boolean
-    /* The catch branch's binding (`catchAs`, `reactive`); empty when no catch branch. The
-       error is a `.value` cell so a catch→catch swap updates `err` in place. The guarded and
-       `finally` branches bind nothing. */
-    catchBindings: Binding[]
-}
-
-/* Resolves a `try` node's branches into the shared structural plan. */
-export function tryPlan(node: Extract<TemplateNode, { kind: 'try' }>): TryPlan {
-    const [catchBranch, finallyBranch] = resolveBranches(node, 'catch', 'finally')
-    const catchAs = catchBranch?.as ?? '_error'
-    return {
-        guarded: node.children.filter((child) => child.kind !== 'branch'),
-        catchChildren: catchBranch?.children ?? [],
-        catchAs,
-        finallyChildren: finallyBranch?.children ?? [],
-        hasCatch: catchBranch !== undefined,
-        catchBindings: catchBinding(catchAs, catchBranch !== undefined, true),
-    }
-}

package/src/lib/ui/compile/types/AbideDiagnostic.ts

@@ -1,14 +0,0 @@
-import type ts from 'typescript'
-
-/*
-A type-check diagnostic relocated onto a `.abide` source file: `start`/`length`
-are an offset range in the original component file (not the shadow), ready for a
-CLI to render or the LSP to convert to a line/character range.
-*/
-export type AbideDiagnostic = {
-    file: string
-    start: number
-    length: number
-    message: string
-    category: ts.DiagnosticCategory
-}

package/src/lib/ui/compile/types/AnalyzedComponent.ts

@@ -1,42 +0,0 @@
-import type { TemplateNode } from './TemplateNode.ts'
-
-/*
-The shared front-end result for a component, consumed by both the client
-(`generateBuild`) and server (`generateSSR`) code generators: the lowered script
-(signal surface desugared to the doc patch/read API), the signal binding names
-(so template expressions rewrite consistently), and the parsed template tree.
-*/
-export type AnalyzedComponent = {
-    /* The lowered client script — keeps `effect(...)` calls (client lifecycle). */
-    script: string
-    /* The same lowered script with `effect(...)` calls stripped, for the SSR render
-       (effects emit no HTML and must not run on the server). Produced from the one
-       parse `script` came from, not a downstream re-parse. */
-    ssrScript: string
-    /* Top-level import statements hoisted out of the script (e.g. child
-       components), placed at module scope by the module wrapper. */
-    imports: string
-    /* The local binding names of reactive-surface imports (`state`/`effect`) the dead-import
-       filter dropped as unused. The module wrapper's backstop asserts none of them still
-       appears in the generated output — an independent check that the drop didn't strand a
-       live reference (e.g. one a nested branch script keeps literal). */
-    droppedReactiveImports: Set<string>
-    stateNames: Set<string>
-    derivedNames: Set<string>
-    computedNames: Set<string>
-    /* Component signals read through `$$readCell(name)`: every `linked` and every async
-       `computed`. Threaded to both back-ends so a template reference (`{draft}`) lowers to
-       the unified cell read consistently on client and server. Whether a pending read pauses
-       (blocking `await`) or peeks (streaming) is decided at runtime by the cell's own
-       `blocking` bit (ADR-0042), so no blocking subset is threaded through codegen. */
-    cellReadNames: Set<string>
-    nodes: TemplateNode[]
-    /* One entry per non-empty `<style>` in the template (in source order): the scope
-       attribute its covered elements carry (annotated onto `nodes`) and the scoped
-       CSS to bundle. A top-level `<style>` covers the whole component; a nested one
-       covers only its sibling subtree. Empty for a component with no style. */
-    styles: { attribute: string; css: string }[]
-    /* Always `true` — hydration adopts every block in place, including `await`
-       (streamed value seeded through the resume manifest). */
-    hydratable: boolean
-}

package/src/lib/ui/compile/types/AsyncInterpolationField.ts

@@ -1,19 +0,0 @@
-import type { LiftPosition } from '../liftAsyncSubExpressions.ts'
-
-/* One async-liftable interpolation field of a template node — the shared reading both compile
-   front-ends drive their async lowering from (the block-Plan pattern of `ifPlan`/`awaitPlan`,
-   applied to interpolations instead of block structure). `code`/`loc` are the authored expression
-   and its absolute source offset; `position` is its value/content position (which feeds the shared
-   sub-expression walk's `each`-forbids-`AsyncIterable` rule). `subject` marks a control-flow test
-   (`{#if}` / `{:elseif}` / `{#switch}`) whose WHOLE expression lifting to one cell makes the block
-   hold while the cell is pending. `write` reseeds the field with the runtime's rewritten reference
-   and `setAsyncSubject` records the subject verdict — both are no-ops for a READER like the shadow,
-   which needs only `code`/`loc`/`position` to peek-wrap its projection. */
-export type AsyncInterpolationField = {
-    code: string
-    loc: number
-    position: LiftPosition
-    subject: boolean
-    write: (code: string) => void
-    setAsyncSubject: (asyncSubject: boolean) => void
-}

package/src/lib/ui/compile/types/Binding.ts

@@ -1,24 +0,0 @@
-/*
-A name a block introduces into a body's scope, carried on its Plan and classified
-ONCE as the single source of truth both back-ends read. `name` is the author param
-as written (a plain identifier or a destructuring pattern — `item`, `i`, `_error`,
-`{ a, b }`); its leaf names are derived where it is registered (`withBindings`),
-never re-derived in a back-end. `classification` decides how each back-end RENDERS
-the binding — the only per-back-end choice left:
-
-- `reactive` — an `await` `then` value, an `each` item / index. The client binds a
-  `.value` cell the runtime can update in place (read as a deref via `reactiveBinding`);
-  SSR has no cells, so it renders it as a plain shadow.
-- `plain` — a `catch` error, `snippet` args. A real JS local on both back-ends, read
-  as the bare identifier.
-
-A binding that mis-lowers to the enclosing component signal is the `block-binding-shadow`
-bug this model designs out: there is one name set and one classification per block, and
-one registration loop (`withBindings`).
-*/
-export type Binding = {
-    /* The author param as written — a plain identifier or a destructuring pattern. */
-    name: string
-    /* How each back-end renders it: a reactive `.value` cell (client) vs a plain local. */
-    classification: 'reactive' | 'plain'
-}

package/src/lib/ui/compile/types/CompiledShadow.ts

@@ -1,27 +0,0 @@
-/*
-The type-checking shadow of a `.abide` component: a synthetic `.ts` module that
-reconstructs the author-facing scope with value types and references every
-template expression in a checkable position, plus the segment map that relocates
-a diagnostic in the shadow back to the original `.abide` source.
-
-Each mapping covers one verbatim-emitted span: `length` characters at `shadowStart`
-in the shadow correspond to the same `length` characters at `sourceStart` in the
-`.abide` file (expressions are emitted unchanged, so the spans are equal length).
-A shadow offset inside a mapping translates to `sourceStart + (offset - shadowStart)`;
-an offset in no mapping is synthesised scaffolding and its diagnostic is dropped.
-*/
-export type ShadowMapping = { shadowStart: number; sourceStart: number; length: number }
-
-/*
-A diagnostic the shadow compiler raises itself (not from `tsc`), already located
-in `.abide` source coordinates — `start`/`length` are an offset range in the
-original file, so it needs no segment remap. Used for author rules the type
-system can't express, e.g. importing a compiler-internal runtime helper.
-*/
-export type ShadowDiagnostic = { start: number; length: number; message: string }
-
-export type CompiledShadow = {
-    code: string
-    mappings: ShadowMapping[]
-    diagnostics?: ShadowDiagnostic[]
-}

package/src/lib/ui/compile/types/ElementPlan.ts

@@ -1,43 +0,0 @@
-import type { ClassStyleMergePlan } from '../classStyleMergePlan.ts'
-import type { TemplateAttr } from './TemplateAttr.ts'
-
-/*
-The per-element shared compile decision both back-ends render from — the element-level
-sibling of `skeletonContext`'s tree-level positional model, layered over it (ADR-0013).
-It centralizes the DECISIONS the two code-gen back-ends (`generateBuild`, `generateSSR`)
-previously made twice in hand-mirrored per-attribute dispatch: each attribute's kind, the
-class/style/directive merge, which attrs are folded into that merge (so both skip them),
-and whether the tag is void. Each back-end still RENDERS per kind — build wires live
-effects/thunks, SSR escapes strings — but consults ONE classification, so the markup the
-client clones and the server emits can never drift on the attribute set or merge logic.
-
-The positional holes/anchors are NOT recomputed here — they stay in `skeletonContext` and
-each back-end reads `elIndex`/`anIndex`/`markText` from it. `elementPlan` is the decision
-on TOP of that positional pass, not a second positional model.
-*/
-
-/* One classified attribute on an element. `attr` is the original `TemplateAttr`; `merged*`
-   flags it as folded into the class/style merge for that back-end (so the back-end skips it
-   in its per-attr dispatch). The merge TRIGGERS differ — build merges only when the base is
-   interpolated (a static base stays in the cloned skeleton with surgical toggles), SSR merges
-   whenever a directive exists (it must emit one attribute string) — so each side reads its own
-   flag. */
-export type ElementPlanAttr = {
-    attr: TemplateAttr
-    /* Folded into the class/style merge on the build back-end (skip in build's dispatch). */
-    mergedBuild: boolean
-    /* Folded into the class/style merge on the SSR back-end (skip in SSR's dispatch). */
-    mergedSSR: boolean
-}
-
-export type ElementPlan = {
-    /* Every attribute classified in author order, each tagged with its per-back-end merge
-       status. Both back-ends iterate this one list and render per `attr.kind`. */
-    attrs: ElementPlanAttr[]
-    /* The class/style/directive merge decision (`classStyleMergePlan`) folded in as this
-       plan's class/style branch — both back-ends render the merged value from its parts. */
-    merge: ClassStyleMergePlan
-    /* A void tag (`<img>`, `<input>`) has no closing tag and no children — both back-ends
-       emit the open tag only. From the shared `VOID_TAGS` set. */
-    isVoid: boolean
-}

package/src/lib/ui/compile/types/InterpolationClassifier.ts

@@ -1,12 +0,0 @@
-import type { InterpolationKind } from './InterpolationKind.ts'
-
-/*
-Classifies a text-position `{expr}` interpolation from its checker type, keyed by
-the expression's source offset (`loc`) and verbatim `code`. Built by the bundler
-plugin over a warm shadow program (see `abideUiPlugin`) and threaded, OPTIONAL,
-through the compile front-end: when absent the pipeline behaves exactly as before
-(every interpolation binds as a plain value). Always fail-open — a resolution
-failure returns `'sync'`, never throws — so a type hiccup degrades to today's
-behavior instead of breaking the build.
-*/
-export type InterpolationClassifier = (loc: number, code: string) => InterpolationKind

package/src/lib/ui/compile/types/InterpolationKind.ts

@@ -1,7 +0,0 @@
-/*
-How a `{expr}` template interpolation resolves at runtime, from its checker type:
-`promise` (thenable — awaited), `asyncIterable` (drained over time), or `sync`
-(bound as a plain value). Stage A of type-directed interpolation lowering
-classifies into this; later stages pick the binding back-end from it.
-*/
-export type InterpolationKind = 'promise' | 'asyncIterable' | 'sync'

package/src/lib/ui/compile/types/ParseDiagnostic.ts

@@ -1,8 +0,0 @@
-/*
-A parser-local diagnostic — deliberately smaller than `AbideDiagnostic`, which
-additionally needs the `file` + `category` the parser cannot know. `start` is the
-absolute, `baseOffset`-relative offset (the same coordinate space every node `loc`
-uses, so it round-trips through the shadow `mappings`); `length` is 0 for a point
-diagnostic. Callers (`collectAbideDiagnostics`) adapt it to `AbideDiagnostic`.
-*/
-export type ParseDiagnostic = { message: string; start: number; length: number }