@abide/abide 0.58.0 → 0.101.0

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

@@ -1,79 +0,0 @@
-import ts from 'typescript'
-
-/*
-The LSP semantic-tokens legend abide lsp advertises, and the decoders from
-TypeScript's encoded classifications to legend names. TypeScript encodes a
-*semantic* classification as `((tokenType + 1) << 8) + modifierBitset`; its
-TokenType and TokenModifier enums fix the orders below. `keyword`/`operator` carry
-the `{#…}` block framing the structural tokenizer emits; `string`/`number`/`regexp`
-carry the literal *syntactic* classifications the semantic classifier never reports
-(so a template-literal string inside `{…}` gets string coloring); `tag`/`attribute`/
-`comment` carry the HTML markup structure the markup tokenizer emits, so the LSP
-owns element/attribute/comment coloring instead of leaning on tree-sitter (which
-desyncs on abide's `attr={expr}` values).
-*/
-
-/* TS TokenType order (class=0 … member=11) → LSP token-type name. */
-const TS_TYPE_TO_LSP = [
-    'class',
-    'enum',
-    'interface',
-    'namespace',
-    'typeParameter',
-    'type',
-    'parameter',
-    'variable',
-    'enumMember',
-    'property',
-    'function',
-    'method',
-]
-
-/* TS TokenModifier order (declaration=bit 0 … local=bit 5). */
-const TS_MODIFIERS = ['declaration', 'static', 'async', 'readonly', 'defaultLibrary', 'local']
-
-/* TS syntactic `ClassificationType` (legacy direct enum value) → literal legend
-   type. Only the literals the semantic classifier omits; identifiers, keywords, and
-   punctuation are left to the semantic pass (or untouched). */
-const SYNTACTIC_LITERAL_TO_LSP: Partial<Record<ts.ClassificationType, string>> = {
-    [ts.ClassificationType.stringLiteral]: 'string',
-    [ts.ClassificationType.numericLiteral]: 'number',
-    [ts.ClassificationType.bigintLiteral]: 'number',
-    [ts.ClassificationType.regularExpressionLiteral]: 'regexp',
-}
-
-export const ABIDE_SEMANTIC_TOKENS_LEGEND = {
-    tokenTypes: [
-        ...TS_TYPE_TO_LSP,
-        'keyword',
-        'operator',
-        'string',
-        'number',
-        'regexp',
-        'tag',
-        'attribute',
-        'comment',
-    ],
-    tokenModifiers: TS_MODIFIERS,
-}
-
-/* Decodes one TypeScript encoded *semantic* classification into legend names. */
-export function mapTsClassification(
-    classification: number,
-): { type: string; modifiers: string[] } | undefined {
-    const tokenType = (classification >> 8) - 1
-    const type = TS_TYPE_TO_LSP[tokenType]
-    if (type === undefined) {
-        return undefined
-    }
-    const modifierSet = classification & 255
-    const modifiers = TS_MODIFIERS.filter((_, bit) => (modifierSet & (1 << bit)) !== 0)
-    return { type, modifiers }
-}
-
-/* Decodes one TypeScript *syntactic* classification (the legacy direct enum value,
-   not the bit-shifted semantic form) into a literal legend type, or undefined for
-   classifications the semantic pass already covers. */
-export function mapSyntacticClassification(classification: number): string | undefined {
-    return SYNTACTIC_LITERAL_TO_LSP[classification as ts.ClassificationType]
-}

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

@@ -1,16 +0,0 @@
-/*
-A compile-time `.abide` error carrying the absolute source offset of the
-offending node (when the parser tracked one). The loader catches it, resolves the
-offset to `line:col` against the file, and re-throws with the component path and
-position in the message — so a failed build names the exact file and line, not the
-entry page at offset 0 (Bun frames plugin throws at `<file>:0` regardless).
-*/
-export class AbideCompileError extends Error {
-    readonly offset: number | undefined
-
-    constructor(message: string, offset?: number) {
-        super(message)
-        this.name = 'AbideCompileError'
-        this.offset = offset
-    }
-}

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

@@ -1,21 +0,0 @@
-/*
-The control-block vocabulary — the ONE source of truth shared by the parser
-(`parseTemplate`'s dispatch/error) and the LSP highlighter (`structuralHeadTokens`, driven
-by the parse walk), so the keywords the highlighter colors can't drift from the blocks the
-parser accepts (the `{#snippet}` head once went uncolored because a hand-copy omitted it).
-
-`BLOCK_OPENERS` follow `{#`, `BLOCK_CONNECTORS` follow `{:`. `for await` is the async-each
-opener form the highlighter colors as one phrase (the parser reads the `await` inside a
-`for` head); it is not a distinct opener.
-*/
-export const BLOCK_OPENERS = ['if', 'for', 'await', 'switch', 'try', 'snippet'] as const
-
-export const BLOCK_CONNECTORS = [
-    'else if',
-    'else',
-    'then',
-    'catch',
-    'finally',
-    'case',
-    'default',
-] as const

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

@@ -1,40 +0,0 @@
-import { SNIPPET_CLOSE, SNIPPET_OPEN } from '../runtime/RANGE_MARKER.ts'
-
-/*
-Source text for the `$esc` / `$attr` / `$spread` / `$text` / `$snip` helpers injected
-into every SSR render body. `$esc` escapes the five HTML-significant characters. `$attr`
-renders a dynamic `{expr}` attribute with the same present/absent semantics the
-client `attr` binding uses: false/null/undefined drops it, true emits the bare
-attribute, anything else emits `name="escaped"`. `$spread` renders a `{...obj}`
-element spread — each key as an attribute via `$attr`, skipping functions (event
-handlers, wired client-side by `spreadAttrs`) and any key in the `skip` list (a key the
-element names explicitly, which wins over the spread) — mirroring that client runtime. `$snip` brands a snippet's
-rendered string. `$text` is what `{expr}` interpolations push: a snippet call's
-value is emitted raw between `<!--abide:snippet-->` markers (the client runs its
-builder there to claim the nodes); a `html\`…\`` value raw between `<!--abide:html-->`
-markers; anything else is escaped. The brands are registered Symbols so they match
-across bundles. Emitted inline (not imported) so the generated render module is
-self-contained.
-*/
-export const SSR_ESCAPE =
-    // Nullish escapes to empty text, never the literal `"undefined"` — a pending async
-    // read (ADR-0032 D3) renders nothing. `$attr` guards nullish before it calls `$esc`,
-    // so its whole-value undefined still drops the attribute.
-    'const $esc = (v) => (v == null ? "" : String(v)).replace(/[&<>"\']/g, (c) => ' +
-    "({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '\"': '&quot;', \"'\": '&#39;' })[c]);\n" +
-    'const $attr = (n, v) => (v === false || v === null || v === undefined) ? "" ' +
-    ': v === true ? (" " + n) : (" " + n + \'="\' + $esc(v) + \'"\');\n' +
-    'const $spread = (o, skip) => { let s = ""; for (const k in o) { ' +
-    'if (skip && skip.indexOf(k) >= 0) continue; ' +
-    /* Skip keys that aren't valid attribute names: $attr emits the name verbatim, so a
-       runtime-controlled key with whitespace/quotes/`>`/`=`/`/` would inject markup. The
-       client's setAttribute throws on these, so dropping them matches that behaviour. */
-    'if (/[\\s"\'>\\/=]/.test(k)) continue; ' +
-    'const v = o[k]; if (typeof v !== "function") s += $attr(k, v); } return s; };\n' +
-    "const $RAW = Symbol.for('abide.rawHtml');\n" +
-    "const $SNIP = Symbol.for('abide.snippet');\n" +
-    'const $snip = (s) => ({ [$SNIP]: s });\n' +
-    'const $text = (v) => (v !== null && typeof v === "object" && $SNIP in v) ' +
-    `? ('<!--${SNIPPET_OPEN}-->' + v[$SNIP] + '<!--${SNIPPET_CLOSE}-->') ` +
-    ': (v !== null && typeof v === "object" && $RAW in v) ' +
-    "? ('<!--abide:html-->' + v[$RAW] + '<!--/abide:html-->') : $esc(v);"

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

@@ -1,7 +0,0 @@
-import ts from 'typescript'
-
-/* The shared TypeScript printer every compile pass prints its transformed tree with.
-   A `ts.Printer` is stateless and reusable, so the passes share one instance rather
-   than each re-creating the same `{ newLine: LineFeed }` printer. LineFeed keeps the
-   emitted source `\n`-delimited regardless of the host platform. */
-export const TS_PRINTER = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })

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

@@ -1,86 +0,0 @@
-/*
-The abide-ui runtime names every compiled component module depends on, each
-paired with its package subpath (after the package name). One source of truth for
-the import block `compileModule` emits at the head of every component module, so the
-emitted imports can't drift from the real package exports (a test checks each
-resolves). Order is the emit order.
-
-`alias` (when set) is the LOCAL name codegen emits — a `$$`-prefixed form reserved
-for the compiler so a user variable of the helper's bare name can never collide
-(`each as $$each`). It defaults to `name`. As each helper's emit sites flip to its
-`$$` alias, set `alias` here in lockstep.
-*/
-export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: string }[] = [
-    { name: 'snippet', specifier: 'shared/snippet', alias: '$$snippet' },
-    /* `scope` is the internal lowering host (no longer author-facing), imported from the
-       plumbing `ui/currentScope` path and lowered to the reserved `$$scope` alias:
-       `referenceFor` rewrites a bare `scope` read (compiler-generated) to `$$scope` only
-       when not lexically shadowed, so the aliased import is the binding emitted code
-       resolves to. `enterScope`/`exitScope` bracket an SSR render's scope (plumbing paths). */
-    { name: 'scope', specifier: 'ui/currentScope', alias: '$$scope' },
-    { name: 'enterScope', specifier: 'ui/enterRenderScope', alias: '$$enterScope' },
-    { name: 'exitScope', specifier: 'ui/exitRenderScope', alias: '$$exitScope' },
-    { name: 'effect', specifier: 'ui/effect', alias: '$$effect' },
-    { name: 'watch', specifier: 'ui/watch', alias: '$$watch' },
-    { name: 'mount', specifier: 'ui/dom/mount', alias: '$$mount' },
-    { name: 'appendText', specifier: 'ui/dom/appendText', alias: '$$appendText' },
-    { name: 'appendTextAt', specifier: 'ui/dom/appendTextAt', alias: '$$appendTextAt' },
-    { name: 'appendSnippet', specifier: 'ui/dom/appendSnippet', alias: '$$appendSnippet' },
-    { name: 'appendStatic', specifier: 'ui/dom/appendStatic', alias: '$$appendStatic' },
-    { name: 'cloneStatic', specifier: 'ui/dom/cloneStatic', alias: '$$cloneStatic' },
-    { name: 'skeleton', specifier: 'ui/dom/skeleton', alias: '$$skeleton' },
-    { name: 'anchorCursor', specifier: 'ui/dom/anchorCursor', alias: '$$anchorCursor' },
-    { name: 'attr', specifier: 'ui/dom/attr', alias: '$$attr' },
-    { name: 'on', specifier: 'ui/dom/on', alias: '$$on' },
-    { name: 'attach', specifier: 'ui/dom/attach', alias: '$$attach' },
-    { name: 'bindSelectValue', specifier: 'ui/dom/bindSelectValue', alias: '$$bindSelectValue' },
-    { name: 'each', specifier: 'ui/dom/each', alias: '$$each' },
-    { name: 'eachAsync', specifier: 'ui/dom/eachAsync', alias: '$$eachAsync' },
-    { name: 'when', specifier: 'ui/dom/when', alias: '$$when' },
-    { name: 'awaitBlock', specifier: 'ui/dom/awaitBlock', alias: '$$awaitBlock' },
-    { name: 'awaitSubject', specifier: 'ui/dom/awaitSubject', alias: '$$awaitSubject' },
-    { name: 'tryBlock', specifier: 'ui/dom/tryBlock', alias: '$$tryBlock' },
-    { name: 'switchBlock', specifier: 'ui/dom/switchBlock', alias: '$$switchBlock' },
-    { name: 'mountSlot', specifier: 'ui/dom/mountSlot', alias: '$$mountSlot' },
-    { name: 'outlet', specifier: 'ui/dom/outlet', alias: '$$outlet' },
-    { name: 'mountChild', specifier: 'ui/dom/mountChild', alias: '$$mountChild' },
-    { name: 'mergeProps', specifier: 'ui/dom/mergeProps', alias: '$$mergeProps' },
-    { name: 'spreadProps', specifier: 'ui/dom/spreadProps', alias: '$$spreadProps' },
-    { name: 'restProps', specifier: 'ui/dom/restProps', alias: '$$restProps' },
-    { name: 'bindProp', specifier: 'ui/dom/bindProp', alias: '$$bindProp' },
-    { name: 'bindableProp', specifier: 'ui/dom/bindableProp', alias: '$$bindableProp' },
-    { name: 'spreadAttrs', specifier: 'ui/dom/spreadAttrs', alias: '$$spreadAttrs' },
-    { name: 'readCall', specifier: 'ui/dom/readCall', alias: '$$readCall' },
-    { name: 'readCell', specifier: 'ui/dom/readCell', alias: '$$readCell' },
-    { name: 'writeCell', specifier: 'ui/dom/writeCell', alias: '$$writeCell' },
-    { name: 'cellPending', specifier: 'ui/dom/cellPending', alias: '$$cellPending' },
-    { name: 'withPath', specifier: 'ui/runtime/withPath', alias: '$$withPath' },
-    { name: 'settleAsyncCells', specifier: 'ui/settleAsyncCells', alias: '$$settleAsyncCells' },
-    { name: 'flight', specifier: 'ui/flight', alias: '$$flight' },
-    {
-        name: 'isolateCellBarrier',
-        specifier: 'ui/isolateCellBarrier',
-        alias: '$$isolateCellBarrier',
-    },
-    { name: 'renderPath', specifier: 'ui/runtime/renderPath', alias: '$$renderPath' },
-    {
-        name: 'finalizeStreamedChildren',
-        specifier: 'ui/finalizeStreamedChildren',
-        alias: '$$finalizeStreamedChildren',
-    },
-    {
-        name: 'mutateDocContainer',
-        specifier: 'ui/dom/mutateDocContainer',
-        alias: '$$mutateDocContainer',
-    },
-    { name: 'hydrate', specifier: 'ui/dom/hydrate', alias: '$$hydrate' },
-    { name: 'escapeKey', specifier: 'ui/runtime/escapeKey', alias: '$$escapeKey' },
-    { name: 'nextBlockId', specifier: 'ui/runtime/nextBlockId', alias: '$$nextBlockId' },
-    { name: 'blockId', specifier: 'ui/runtime/blockId', alias: '$$blockId' },
-    {
-        name: 'enterRenderPass',
-        specifier: 'ui/runtime/enterRenderPass',
-        alias: '$$enterRenderPass',
-    },
-    { name: 'exitRenderPass', specifier: 'ui/runtime/exitRenderPass', alias: '$$exitRenderPass' },
-]

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

@@ -1,22 +0,0 @@
-/*
-HTML void elements — they have no closing tag and no children. Shared by the
-template parser, the SSR generator, and the static-clone skeleton generator so
-all self-close consistently and the back-ends emit `<img>` not `<img></img>`,
-keeping server markup and the client clone template identical.
-*/
-export const VOID_TAGS: ReadonlySet<string> = new Set([
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-])

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

@@ -1,109 +0,0 @@
-import { relative } from 'node:path'
-import type { BunPlugin } from 'bun'
-import { isLayoutFile } from '../../shared/isLayoutFile.ts'
-import { messageFromError } from '../../shared/messageFromError.ts'
-import { AbideCompileError } from './AbideCompileError.ts'
-import { compileModule } from './compileModule.ts'
-import type { ShadowProgram } from './createShadowProgram.ts'
-import { interpolationClassifierForRoot } from './interpolationClassifierForRoot.ts'
-import { nearestProjectRoot } from './nearestProjectRoot.ts'
-import { offsetToLineColumn } from './offsetToLineColumn.ts'
-import { seedTypeClassifierForRoot } from './seedTypeClassifierForRoot.ts'
-
-/*
-Bun plugin that loads `.abide` single-file components: compiles each to the ES
-module `compileModule` emits, so they import and mount like any other module. The
-only UI loader in the dev/build/preload pipeline; the emitted module's
-`abide/ui/*` imports resolve through the package exports.
-
-A `layout.abide` compiles as a layout: its `<slot/>` lowers to the router's page
-outlet (a `<!--abide:outlet-->…<!--/abide:outlet-->` comment boundary the router fills) rather than a passed-children slot — the file's role is
-its name, so the loader flags it from the path stem.
-
-The emitted module embeds the component's `<script>` and `{expr}` bodies verbatim,
-so it carries the author's TypeScript (a typed `prop`, an annotated handler). The
-`ts` loader strips those annotations — the generated runtime code is valid TS too —
-keeping `.abide` scripts the TypeScript that `abide check` type-checks them as.
-
-A component's scoped `<style>`(s) are bundled, not inlined: in the BROWSER build the
-module imports a virtual `abide-style:` CSS module holding every block's scoped CSS
-concatenated, so Bun folds it into the entry stylesheet (`client.css`, already linked
-by the shell). Server builds (target `bun`) omit the import — SSR styling comes from
-that same linked sheet, so a page renders styled before the client bundle loads, with
-no inlined `<style>`. The elements still carry their `data-a-…` scope attributes
-either way (one per `<style>` covering them — see `analyzeComponent`).
-*/
-// @documentation plumbing
-export const abideUiPlugin: BunPlugin = {
-    name: 'abide-ui',
-    setup(build) {
-        const toBrowser = build.config?.target === 'browser'
-        /* Scoped CSS keyed by its virtual specifier, filled as each `.abide` loads and
-           read back when Bun resolves the matching `abide-style:` import (browser only). */
-        const cssByVirtual = new Map<string, string>()
-        /* One WARM shadow program per project root (ADR-0019, Stage B): the checker +
-           per-file mappings type-directed lowering needs, built lazily on first `.abide`
-           in a root and reused for every component there — not rebuilt per module. */
-        const shadowByRoot = new Map<string, ShadowProgram | undefined>()
-
-        build.onLoad({ filter: /\.abide$/ }, async (args) => {
-            const source = await Bun.file(args.path).text()
-            const root = nearestProjectRoot(args.path, process.cwd())
-            const moduleId = relative(root, args.path)
-            const isLayout = isLayoutFile(args.path)
-            /* The classifier for this file over its root's warm shadow program. Fail-open:
-               a program that can't build (or a file with no shadow) yields `undefined`, so
-               the module compiles exactly as before. */
-            const classify = interpolationClassifierForRoot(shadowByRoot, root, args.path)
-            /* The seed classifier for this file over the SAME warm shadow program (ADR-0023):
-               reuses the `shadowByRoot` cache `classify` just warmed, so no second program is
-               built. Fail-open identically — a no-marker `computed(seed)` routes by type when
-               it resolves, else by the `isBareCallComputed` syntax heuristic. */
-            const seedClassify = seedTypeClassifierForRoot(shadowByRoot, root, args.path)
-            /* Bun frames a plugin throw at `<file>:0` regardless of the real spot, so
-               carry the component path + resolved line:col in the message — otherwise a
-               control-flow / compile error reads as `:0` and (in deep imports) can look
-               like it came from the entry page rather than this component. */
-            const compileAbide = <T>(step: () => T): T => {
-                try {
-                    return step()
-                } catch (error) {
-                    const offset = error instanceof AbideCompileError ? error.offset : undefined
-                    const at =
-                        offset === undefined
-                            ? moduleId
-                            : (({ line, column }) => `${moduleId}:${line}:${column}`)(
-                                  offsetToLineColumn(source, offset),
-                              )
-                    const message = messageFromError(error)
-                    throw new Error(`${message.replace(/^\[abide\]\s*/, `[abide] ${at} — `)}`)
-                }
-            }
-            /* One compile pass yields both the module code and its scoped `<style>` blocks —
-               the styles come from the analysis `compileModule` already ran, so the loader no
-               longer re-analyzes the source just to recover them. */
-            const { code, styles } = compileAbide(() =>
-                compileModule(source, { isLayout, moduleId, classify, seedClassify }),
-            )
-            /* Browser build with `<style>`(s): concatenate every scoped block's CSS and
-               pull it into the bundle via one virtual import, keyed by `moduleId` so the
-               registry id and the CSS id agree. Server builds skip the import (SSR styling
-               comes from the already-linked sheet). */
-            if (!toBrowser || styles.length === 0) {
-                return { contents: code, loader: 'ts' }
-            }
-            const virtual = `abide-style:${moduleId}`
-            cssByVirtual.set(virtual, styles.map((style) => style.css).join('\n'))
-            return { contents: `import ${JSON.stringify(virtual)}\n${code}`, loader: 'ts' }
-        })
-
-        build.onResolve({ filter: /^abide-style:/ }, (args) => ({
-            path: args.path,
-            namespace: 'abide-style',
-        }))
-        build.onLoad({ filter: /.*/, namespace: 'abide-style' }, (args) => ({
-            contents: cssByVirtual.get(args.path) ?? '',
-            loader: 'css',
-        }))
-    },
-}

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

@@ -1,222 +0,0 @@
-import { lowerAsyncInterpolations } from './lowerAsyncInterpolations.ts'
-import { lowerScript } from './lowerScript.ts'
-import { parseTemplate } from './parseTemplate.ts'
-import { scopeCss } from './scopeCss.ts'
-import { LEADING_SCRIPT } from './templateStartOffset.ts'
-import type { AnalyzedComponent } from './types/AnalyzedComponent.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-import type { SeedTypeClassifier } from './types/SeedTypeClassifier.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-import { writtenTemplateNames } from './writtenTemplateNames.ts'
-
-/*
-The shared compile front-end: splits the leading `<script>` off the template,
-desugars the signal surface to the doc form, lowers the script's data access, and
-parses the template (which keeps each `<style>` as an in-place node). Each `<style>`
-is scoped to its own attribute (`data-a-<hash>`); `annotateScopes` stamps that
-attribute onto every element in the style's sibling subtree, so a top-level
-`<style>` covers the whole component while a nested one covers only the branch it
-sits in. Both client and SSR back-ends read the per-element `scopes`, so the targets
-always agree.
-
-`scopeSeed` (the component's stable module id, supplied by the loader) seeds each
-hash — combined with the style's source-order index — so the attribute tracks
-component+position identity, not CSS text: an edit to a `<style>` keeps the same
-`data-a-…`, so the live elements still match and the CSS can hot-swap in place.
-Absent (direct compile calls / tests) it falls back to hashing the style body.
-*/
-export function analyzeComponent(
-    source: string,
-    scopeSeed?: string,
-    classify?: InterpolationClassifier,
-    /* Type-directed SEED classifier (ADR-0023): resolves a no-marker `computed(seed)`'s
-       async-ness from the seed's checker type over the SAME warm shadow program `classify`
-       uses. Optional and fail-open — absent, every seed routes by the `isBareCallComputed`
-       syntax heuristic (today's behavior). */
-    seedClassify?: SeedTypeClassifier,
-): AnalyzedComponent {
-    /* Only the LEADING `<script>` is the component script; scripts nested in the
-       template (scoped reactive blocks) survive into the parsed nodes. The `<style>`
-       is left in the template for the parser to extract structurally (below), so a
-       `<style>` quoted inside an expression is never mistaken for the component's. */
-    const scriptMatch = source.match(LEADING_SCRIPT)
-    const rawScriptBody = scriptMatch?.[1] ?? ''
-    const scriptBody = rawScriptBody.trim()
-    /* Absolute `.abide` source offset where the TRIMMED `<script>` body begins — the base that
-       maps a desugared `computed(seed)` node (offset-relative to the trimmed body) back to an
-       original source location, so the type-directed seed classifier (ADR-0023) resolves it
-       against the shadow's source→shadow `mappings`, exactly as `templateBase` anchors each
-       interpolation's `loc`. `indexOf('>')` lands just past the opening `<script …>` (matching
-       `compileShadow`'s `scriptStart`); the trim delta re-adds the leading whitespace the parsed
-       script dropped. */
-    const scriptContentBase =
-        (scriptMatch ? source.indexOf('>', scriptMatch.index) + 1 : 0) +
-        (rawScriptBody.length - rawScriptBody.trimStart().length)
-    const afterScript = scriptMatch ? source.slice(scriptMatch[0].length) : source
-    const template = afterScript.trim()
-    /* Absolute source offset of the trimmed template's first char (script length + the
-       remainder's leading whitespace). Passed as the parse base so each interpolation's
-       `loc` is an offset into the ORIGINAL source — the coordinate the shadow's
-       source→shadow `mappings` use, so a type-directed classifier resolves against it.
-       The runtime back-ends ignore `loc`, so this only affects the classifier's lookup. */
-    const templateBase =
-        (scriptMatch ? scriptMatch[0].length : 0) +
-        (afterScript.length - afterScript.trimStart().length)
-
-    /* Parse the template first so the nested branch `<script>`s are in hand before the
-       leading script lowers: their raw code feeds the dead-import usage check, keeping a
-       reactive import (`state`) alive when only a nested branch uses it (its
-       `state.computed(...)` stays literal, unlike the desugared leading script). */
-    const parsed = parseTemplate(template, templateBase)
-    /* Type-directed async lowering (ADR-0032): lift every promise/`AsyncIterable`-typed
-       (sub)expression — in content AND value positions — to an injected peek-cell, rewriting it
-       in place to a bare `{__vN}` reference BEFORE the script lowers and scopes annotate, so it
-       reads `undefined` while pending and composes with `??`/`?.`. Runs unconditionally: with no
-       classifier only syntactic `await`s lift (fail-open), so a value-position `{await …}` still
-       works while a bare async position degrades to today's plain binding. */
-    const { nodes, cells } = lowerAsyncInterpolations(parsed.nodes, classify)
-    /* Each lifted async (sub)expression was rewritten to a bare `{__vN}` reference; APPEND a
-       matching `const __vN = computed(<seed>)` to the script so the seed's author-signal reads
-       lower through the normal pipeline and the declaration desugars to a `trackedComputed` cell
-       (read via `$$readCell(__vN)`). `computed` here is a bare, unimported callee — `desugarSignals`
-       recognizes it by the injected name (`injectedCellNames`), not by import resolution. A
-       BLOCKING cell (author `await`, `blockingCellNames`) joins the SSR barrier; a streaming one
-       ships pending. Appended (after the author's `state(...)` inits, not before) so a signal-arg
-       seed `{getStream(count)}` reads the INITIALIZED `count`; the cell only feeds the render,
-       which runs after the whole script, so end-of-script placement is safe. */
-    const injectedCellNames = new Set(cells.map((cell) => cell.name))
-    const blockingCellNames = new Set(
-        cells.filter((cell) => cell.blocking).map((cell) => cell.name),
-    )
-    /* A promise seed is wrapped as an async thunk `async () => await (<code>)` — inside an async
-       arrow `await` is a keyword and the parens are unambiguous (a bare-text `computed(await (X))`
-       reparsed at module scope reads `await(X)` as a call). A stream seed stays a bare
-       `computed(<code>)` (byte-identical to an explicit `state.computed(getStream())`). */
-    const injectedScript = cells.map((cell) =>
-        cell.kind === 'promise'
-            ? `const ${cell.name} = computed(async () => await (${cell.code}));`
-            : `const ${cell.name} = computed(${cell.code});`,
-    )
-    const fullScriptBody =
-        injectedScript.length === 0
-            ? scriptBody
-            : scriptBody.length > 0
-              ? `${scriptBody}\n${injectedScript.join('\n')}`
-              : injectedScript.join('\n')
-    const nestedScriptCode = collectNestedScriptCode(nodes)
-    /* Names the markup writes or forwards as a `bind:` target — unioned (in `desugarSignals`)
-       with the script's own writes so a `props()` binding used two-way desugars to a writable
-       cell (`bindableProp`) rather than a read-only derive. */
-    const templateWrittenNames = writtenTemplateNames(nodes)
-    /* `lowerScript` parses the script ONCE and chains signal desugaring, reference
-       renaming, and doc-access lowering over that single tree, then hoists top-level
-       imports off the tree structurally — imports live at module scope, not inside the
-       mount/render function the body becomes. It returns the collected signal name sets. */
-    const {
-        body: script,
-        ssrBody: ssrScript,
-        imports,
-        stateNames,
-        derivedNames,
-        computedNames,
-        cellReadNames,
-        droppedReactiveImports,
-    } = lowerScript(
-        fullScriptBody,
-        nestedScriptCode,
-        injectedCellNames,
-        blockingCellNames,
-        templateWrittenNames,
-        seedClassify,
-        scriptContentBase,
-    )
-    /* `annotateScopes` mutates the tree — assigning each style its scope attribute and
-       stamping covered elements — and returns the scoped CSS per block for the bundler. */
-    const styles = annotateScopes(nodes, [], scopeSeed, { count: 0 })
-    return {
-        script,
-        ssrScript,
-        imports,
-        droppedReactiveImports,
-        stateNames,
-        derivedNames,
-        computedNames,
-        cellReadNames,
-        nodes,
-        styles,
-        /* Hydration adopts every block in place — including `await`, which resumes
-           from the streamed value in the resume manifest (see `runtime/RESUME`). */
-        hydratable: true,
-    }
-}
-
-/* The children of a control-flow / element / component node, or undefined for a
-   leaf (text/script/style). Every children-bearing kind carries `children`. */
-function childrenOf(node: TemplateNode): TemplateNode[] | undefined {
-    return 'children' in node ? node.children : undefined
-}
-
-/* The concatenated source of every nested `<script>` anywhere in the tree — the branch-local
-   reactive blocks. Used only to keep the leading script's reactive imports alive when a nested
-   branch is their sole consumer; the raw text is enough to spot the identifier reference. */
-function collectNestedScriptCode(nodes: TemplateNode[]): string {
-    let code = ''
-    for (const node of nodes) {
-        if (node.kind === 'script') {
-            code += `\n${node.code}`
-        }
-        const children = childrenOf(node)
-        if (children !== undefined) {
-            code += collectNestedScriptCode(children)
-        }
-    }
-    return code
-}
-
-/*
-Walks `nodes` in source order, scoping each `<style>` to its sibling subtree: a
-style among a sibling list covers every element in that list AND every descendant
-(so its attribute reaches the whole branch it sits in, like the nested-`<script>`
-rule). `inherited` is the scope attributes already active from ancestors; this
-level adds its own styles' attributes, stamps the resulting set onto each element
-here, and recurses with it. `index.count` is the running source-order ordinal that
-(with `scopeSeed`) keeps each attribute stable across CSS edits. Returns the scoped
-CSS for every non-empty style, in source order, for the bundler to concatenate.
-*/
-function annotateScopes(
-    nodes: TemplateNode[],
-    inherited: string[],
-    scopeSeed: string | undefined,
-    index: { count: number },
-): { attribute: string; css: string }[] {
-    const collected: { attribute: string; css: string }[] = []
-    /* This sibling list's own style attributes — active for every element here. */
-    const here = [...inherited]
-    for (const node of nodes) {
-        if (node.kind === 'style' && node.css.trim() !== '') {
-            const attribute = `data-a-${hashString(`${scopeSeed ?? node.css}#${index.count}`)}`
-            index.count += 1
-            collected.push({ attribute, css: scopeCss(node.css, attribute) })
-            here.push(attribute)
-        }
-    }
-    for (const node of nodes) {
-        if (node.kind === 'element') {
-            node.scopes = here
-        }
-        const children = childrenOf(node)
-        if (children !== undefined) {
-            collected.push(...annotateScopes(children, here, scopeSeed, index))
-        }
-    }
-    return collected
-}
-
-/* Small stable hash (djb2 → base36) for a per-style scope attribute. */
-function hashString(value: string): string {
-    let hash = 5381
-    for (let index = 0; index < value.length; index += 1) {
-        hash = (hash * 33) ^ value.charCodeAt(index)
-    }
-    return (hash >>> 0).toString(36)
-}

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

@@ -1,30 +0,0 @@
-import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-In a layout the `<slot/>` page outlet is a bare empty `OUTLET_TAG` element the router fills
-later. Rewriting it to an element node up front lets the static-clone path carry it as ordinary
-structure AND lets BOTH back-ends feed the same tree to `skeletonContext` — one decision site
-for "a layout slot is an outlet, not an anchor", instead of the client running `asOutlet` while
-SSR mirrors it with an inline special-case.
-
-The outlet is a structural mount point, not styled content, so it carries NO attrs and NO style
-scope — both back-ends lower it to the bare `<!--abide:outlet-->`…`<!--/abide:outlet-->` boundary
-`renderChain` folds the child layer into (matching its `OUTLET_PLACEHOLDER`). Stripping `scopes`
-is what makes the two back-ends agree: SSR emits the boundary bare, but without this the client
-clone would read the slot's annotated `scopes` and stamp them — a hydration mismatch for any
-scoped layout.
-
-Control-flow children are fresh build contexts (their own runtime mounts a nested slot), so they
-are not descended into — a `<slot>` inside an `{#if}` stays a slot node, handled at its own
-mount site in each back-end.
-*/
-export function asOutlet(node: TemplateNode): TemplateNode {
-    if (node.kind !== 'element') {
-        return node
-    }
-    if (node.tag === 'slot') {
-        return { ...node, tag: OUTLET_TAG, attrs: [], children: [], scopes: [] }
-    }
-    return { ...node, children: node.children.map(asOutlet) }
-}