@abide/abide 0.58.0 → 0.100.0

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

@@ -1,215 +0,0 @@
-import ts from 'typescript'
-import { classifyInterpolationType } from './classifyInterpolationType.ts'
-
-/* The three TypeScript diagnostics a bare async read (ADR-0032) raises spuriously in a template.
-   2339 — a property "missing" on the un-awaited `Promise`/`AsyncIterable`; 2801 — a condition the
-   raw promise makes "always defined"; 2488 — a promise source "not iterable" in a plain `{#for}`.
-   All are correct against the raw type but wrong against the runtime PEEK (the resolved value,
-   `undefined` while pending), which the shadow can't see. */
-const PROPERTY_DOES_NOT_EXIST = 2339
-const CONDITION_ALWAYS_DEFINED = 2801
-const SOURCE_NOT_ITERABLE = 2488
-
-/*
-Whether a shadow diagnostic is one the ADR-0032 bare-async-read peek makes spurious. The runtime
-lifts a promise/iterable sub-expression to a cell that reads the RESOLVED value (`undefined` while
-pending), so `getFoo()?.name` composes on the resolved object and `{#if getFoo()}` holds while
-pending — but the type-check shadow checks the RAW expression, where the property sits on the
-un-awaited `Promise` and the promise reads as always-truthy. This recognises those two cases so the
-caller can drop them:
-
-  - 2339 (missing property): an OPTIONAL access (`?.`) on a promise/iterable-typed base whose
-    property EXISTS on the awaited (promise) or frame (iterable) type — the peek's real member.
-  - 2801 (always-defined condition): the flagged subject itself classifies as a promise/iterable —
-    the peek is genuinely nullable (pending → `undefined`), so it is not always-defined.
-  - 2488 (source not iterable): a plain `{#for}` source classifies as a promise whose AWAITED type
-    is itself iterable — the runtime lifts it to a peek-cell reading the resolved collection (empty
-    while pending), so iterating it is valid (matches `typeDirectedInterpolation`'s peek-cell lift).
-
-Deliberately narrow so it never hides a real mistake: only these three codes; 2339 only via `?.`
-(a bare `.name` on a promise stays an error, nudging toward the `?.` the peek needs) and only when
-the property resolves on the awaited/frame type (a typo `?.namex` stays); 2801 only when the
-subject is actually async (a bare `{#if someFn}` — a forgotten call — stays); 2488 only for a
-PROMISE whose awaited type is iterable (a raw `AsyncIterable` source stays the sanctioned D4a error,
-and a `Promise<number>` source stays a real mistake the peek can't rescue). Callers additionally
-gate on the diagnostic mapping into the template region, so `<script>` code (where a forgotten
-`await` must surface) is never touched.
-*/
-export function isSpuriousAsyncReadDiagnostic(
-    shadowFile: ts.SourceFile,
-    checker: ts.TypeChecker,
-    code: number,
-    start: number,
-    length: number,
-): boolean {
-    if (code === PROPERTY_DOES_NOT_EXIST) {
-        return isResolvedOptionalAsyncAccess(shadowFile, checker, start, length)
-    }
-    if (code === CONDITION_ALWAYS_DEFINED) {
-        return isAsyncSubject(shadowFile, checker, start, length)
-    }
-    if (code === SOURCE_NOT_ITERABLE) {
-        return isResolvedIterableAsyncSource(shadowFile, checker, start, length)
-    }
-    return false
-}
-
-/* A 2488 on a plain `{#for}` source whose expression classifies as a PROMISE and whose awaited
-   type is itself iterable — the ADR-0032 peek lifts it to the resolved collection, not an error.
-   Excludes a raw `AsyncIterable` (kind `asyncIterable`, the D4a error) and a promise of a
-   non-iterable (the peek would still not iterate). */
-function isResolvedIterableAsyncSource(
-    shadowFile: ts.SourceFile,
-    checker: ts.TypeChecker,
-    start: number,
-    length: number,
-): boolean {
-    const source = deepestNodeAt(shadowFile, start, length)
-    const sourceType = checker.getTypeAtLocation(source)
-    if (classifyInterpolationType(sourceType, source, checker) !== 'promise') {
-        return false
-    }
-    const awaited = checker.getAwaitedType(sourceType)
-    return awaited !== undefined && hasSyncIterator(awaited, checker)
-}
-
-/* Whether a type is synchronously iterable — an array/tuple or anything carrying the well-known
-   `Symbol.iterator` member (mangled to `__@iterator@<id>`, matched by prefix like
-   `classifyInterpolationType`'s async twin). */
-function hasSyncIterator(type: ts.Type, checker: ts.TypeChecker): boolean {
-    for (const property of checker.getPropertiesOfType(type)) {
-        if ((property.escapedName as string).startsWith('__@iterator')) {
-            return true
-        }
-    }
-    return false
-}
-
-/* A 2339 on the member of an optional (`?.`) access whose base is a promise/iterable and whose
-   accessed property exists on the resolved value — the ADR-0032 peek, not an error. */
-function isResolvedOptionalAsyncAccess(
-    shadowFile: ts.SourceFile,
-    checker: ts.TypeChecker,
-    start: number,
-    length: number,
-): boolean {
-    const access = enclosingOptionalAccess(deepestNodeAt(shadowFile, start, length))
-    if (access === undefined) {
-        return false
-    }
-    const resolved = resolvedAsyncType(access.expression, checker)
-    if (resolved === undefined) {
-        return false
-    }
-    const property = accessedPropertyName(access)
-    return property !== undefined && checker.getPropertyOfType(resolved, property) !== undefined
-}
-
-/* A 2801 whose flagged subject classifies as a promise/iterable — the peek reads `undefined` while
-   pending, so it is genuinely nullable, not always-defined. */
-function isAsyncSubject(
-    shadowFile: ts.SourceFile,
-    checker: ts.TypeChecker,
-    start: number,
-    length: number,
-): boolean {
-    const node = deepestNodeAt(shadowFile, start, length)
-    const kind = classifyInterpolationType(checker.getTypeAtLocation(node), node, checker)
-    return kind === 'promise' || kind === 'asyncIterable'
-}
-
-/* The resolved value an async base peeks: a promise's awaited type, an iterable's frame type,
-   `undefined` when the base isn't actually async. */
-function resolvedAsyncType(base: ts.Node, checker: ts.TypeChecker): ts.Type | undefined {
-    const baseType = checker.getTypeAtLocation(base)
-    const kind = classifyInterpolationType(baseType, base, checker)
-    if (kind === 'promise') {
-        return checker.getAwaitedType(baseType)
-    }
-    if (kind === 'asyncIterable') {
-        return asyncFrameType(baseType, base, checker)
-    }
-    return undefined
-}
-
-/* The deepest AST node whose range contains the diagnostic span. */
-function deepestNodeAt(sourceFile: ts.SourceFile, start: number, length: number): ts.Node {
-    let best: ts.Node = sourceFile
-    const end = start + length
-    const visit = (node: ts.Node): void => {
-        if (node.getStart(sourceFile) <= start && node.getEnd() >= end) {
-            best = node
-            node.forEachChild(visit)
-        }
-    }
-    visit(sourceFile)
-    return best
-}
-
-/* The optional (`?.`) property/element access that OWNS `node` as its accessed member — walking
-   up from the name identifier. `undefined` when `node` isn't the member of an optional access
-   (a bare `.name`, or the base rather than the member). */
-function enclosingOptionalAccess(
-    node: ts.Node,
-): ts.PropertyAccessExpression | ts.ElementAccessExpression | undefined {
-    const parent = node.parent
-    if (parent === undefined) {
-        return undefined
-    }
-    if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
-        return parent.questionDotToken === undefined ? undefined : parent
-    }
-    if (ts.isElementAccessExpression(parent) && parent.argumentExpression === node) {
-        return parent.questionDotToken === undefined ? undefined : parent
-    }
-    return undefined
-}
-
-/* The property name an access reads — the identifier for `a?.b`, the string literal for
-   `a?.['b']`. A computed non-literal element access has no static name. */
-function accessedPropertyName(
-    access: ts.PropertyAccessExpression | ts.ElementAccessExpression,
-): string | undefined {
-    if (ts.isPropertyAccessExpression(access)) {
-        return access.name.text
-    }
-    return ts.isStringLiteralLike(access.argumentExpression)
-        ? access.argumentExpression.text
-        : undefined
-}
-
-/* The frame type of an `AsyncIterable<T>` — `T`, which is what the runtime peek reads (the latest
-   frame). The named async-iterable types (`AsyncIterable`/`AsyncGenerator`/`AsyncIterableIterator`)
-   all carry `T` as their first type argument, so read it directly; a structurally-typed iterable
-   with no type arguments falls back to resolving `[Symbol.asyncIterator]().next()`'s yielded value.
-   `location` is any node in the program, needed to resolve the iterator symbol's type. `undefined`
-   when neither yields a frame, so the caller keeps the diagnostic. */
-function asyncFrameType(
-    type: ts.Type,
-    location: ts.Node,
-    checker: ts.TypeChecker,
-): ts.Type | undefined {
-    const directArgument = checker.getTypeArguments(type as ts.TypeReference)[0]
-    if (directArgument !== undefined) {
-        return directArgument
-    }
-    /* The `Symbol.asyncIterator` member mangles to `__@asyncIterator@<id>`, so match by prefix. */
-    const iterator = checker
-        .getPropertiesOfType(type)
-        .find((property) => (property.escapedName as string).startsWith('__@asyncIterator'))
-    if (iterator === undefined) {
-        return undefined
-    }
-    const factory = checker.getTypeOfSymbolAtLocation(iterator, location).getCallSignatures()[0]
-    const next = factory && checker.getPropertyOfType(factory.getReturnType(), 'next')
-    const nextSignature =
-        next && checker.getTypeOfSymbolAtLocation(next, location).getCallSignatures()[0]
-    if (!nextSignature) {
-        return undefined
-    }
-    /* `next()` resolves to `IteratorResult<T, TReturn>`, whose first type argument is the yielded
-       `T` (its `value` PROPERTY widens to `T | TReturn` across the done/not-done union, so read the
-       argument, not the property). */
-    const result = checker.getAwaitedType(nextSignature.getReturnType())
-    return result && checker.getTypeArguments(result as ts.TypeReference)[0]
-}

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

@@ -1,16 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-An element whose children are ONLY text and `<style>` — the common `<h1>{x}</h1>` shape.
-The anchor-placement decision for reactive text: `skeletonContext` consults this once and
-records the result in `markText`; both back-ends read that map so they agree on where a
-text anchor goes. A text-leaf binds its reactive text marker-free on the located element
-(`generateBuild`) / emits it without an `<!--a-->` prefix (`generateSSR`); reactive text
-interleaved with element children is anchor-positioned instead. Computing it once keeps
-the SSR string and the client skeleton from disagreeing about a `<!--a-->` — the first
-slice of lifting the positional model out of the two parallel traversals, alongside the
-already-shared `isControlFlow` and `skeletonable`.
-*/
-export function isTextLeaf(node: Extract<TemplateNode, { kind: 'element' }>): boolean {
-    return node.children.every((child) => child.kind === 'text' || child.kind === 'style')
-}

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

@@ -1,19 +0,0 @@
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* Only HTML-collapsible whitespace — space, tab, LF, CR, FF. Deliberately EXCLUDES
-   U+00A0 (` `), which browsers neither collapse nor trim; `.trim()`/`\s` would
-   wrongly count it, so a `<span>&nbsp;</span>` spacer would be dropped as blank. */
-const COLLAPSIBLE_WHITESPACE = /[^ \t\n\r\f]/
-
-/* A text node that is purely whitespace (no interpolation, only blank static
-   parts). Both back-ends drop it, so it neither contributes markup nor breaks a
-   static clone run — it stays transparent so `<a/>\n<b/>` still coalesces. A part
-   holding a non-breaking space is renderable content, not blank. */
-export function isWhitespaceText(node: TemplateNode): boolean {
-    return (
-        node.kind === 'text' &&
-        node.parts.every(
-            (part) => part.kind === 'static' && !COLLAPSIBLE_WHITESPACE.test(part.value),
-        )
-    )
-}

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

@@ -1,166 +0,0 @@
-import ts from 'typescript'
-import { AbideCompileError } from './AbideCompileError.ts'
-import type { InjectedCell } from './lowerAsyncInterpolations.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-import type { InterpolationKind } from './types/InterpolationKind.ts'
-
-/* The value/content position a lifted (sub)expression sits in — only `each` (a plain `{#for}`
-   source) forbids an `AsyncIterable` (D4a). Every other position renders a stream's latest frame. */
-export type LiftPosition = 'content' | 'attribute' | 'if' | 'switch' | 'each'
-
-/* A lifted (sub)expression's span within the interpolation `code` and how it lifts: `start`/`end`
-   index `code`, `kind` picks the peek flavour, `blocking` marks a leading `await`. The runtime uses
-   these to rewrite the span to a cell ref; the type-check shadow uses the non-blocking ones to wrap
-   the seed in a peek helper so its resolved type composes (ADR-0032). */
-export type LiftSpan = {
-    start: number
-    end: number
-    kind: 'promise' | 'asyncIterable'
-    blocking: boolean
-}
-
-/* The binary operators whose result reacts to a pending-`undefined` operand: the walk does NOT
-   lift the composition, it descends into the operands so the operator composes the peek(s)
-   (ADR-0032 D1). `?.` needs no entry — a member/call on a promise is sync-typed, so the default
-   sync-recurse already reaches and lifts the async base. */
-const PENDING_TOLERANT = new Set<ts.SyntaxKind>([
-    ts.SyntaxKind.QuestionQuestionToken,
-    ts.SyntaxKind.BarBarToken,
-    ts.SyntaxKind.AmpersandAmpersandToken,
-])
-
-/*
-ADR-0032 — the sub-expression walk. Given an interpolation's verbatim `code`, its absolute source
-offset `loc`, and the warm classifier, lifts every promise/`AsyncIterable`-typed (sub)expression
-into an injected peek-cell and rewrites it in place to a bare `__vN` reference, returning the
-rewritten code and the cells to inject. Pending is `undefined` at the value level, so `??` / `?.` /
-member access compose around the peek (`getFoo() ?? 'Loading…'` shows the fallback while pending).
-
-Three rules, top-down (ADR D1 "The walk"):
-  1. `await X`             → lift `X` BLOCKING (SSR-inline); syntactic, needs no classifier.
-  2. `a ?? b` / `||` / `&&`→ NOT lifted; recurse into the operands (pending stays visible to the op).
-  3. any other promise/`AsyncIterable` node → lift as a unit, STREAMING; a sync node recurses
-     (a sync parent can wrap an async child: `String(getFoo())`, `` `${getFoo()}` ``).
-
-`classify` absent (no warm program) ⇒ only rule 1 fires — fail-open: `await` still works, a bare
-async position degrades to today's stringify. A promise seed is emitted `await X` so the cell
-UNWRAPS to the resolved value; an `AsyncIterable` seed stays bare (its latest frame). D4: an
-`AsyncIterable` in a plain `{#for}` source, or an `await` on an `AsyncIterable`, throw.
-*/
-export function liftAsyncSubExpressions(
-    code: string,
-    loc: number,
-    classify: InterpolationClassifier | undefined,
-    mint: () => string,
-    position: LiftPosition = 'content',
-): { code: string; lifts: InjectedCell[]; spans: LiftSpan[] } {
-    const source = ts.createSourceFile('__lift.ts', code, ts.ScriptTarget.Latest, true)
-    const first = source.statements[0]
-    /* Only a single bare expression is walkable; anything else (a statement, empty) passes through. */
-    if (first === undefined || source.statements.length !== 1 || !ts.isExpressionStatement(first)) {
-        return { code, lifts: [], spans: [] }
-    }
-    const lifts: InjectedCell[] = []
-    /* Each lifted span, in walk (source) order; spliced right-to-left so earlier offsets stay valid.
-       `start`/`end` index `code`; `name` replaces that span. */
-    const edits: { start: number; end: number; name: string }[] = []
-    /* The same lifted spans with their kind/tier — the shadow's peek-wrap consumes these directly. */
-    const spans: LiftSpan[] = []
-
-    const text = (node: ts.Node): string => code.slice(node.getStart(source), node.getEnd())
-
-    /* The checker kind of a sub-node, keyed by its absolute source offset through the linear
-       interpolation→shadow mapping. `undefined` when no classifier (only `await` lifts then). */
-    const kindOf = (node: ts.Node): InterpolationKind | undefined => {
-        if (classify === undefined) {
-            return undefined
-        }
-        const start = node.getStart(source)
-        return classify(loc + start, code.slice(start, node.getEnd()))
-    }
-
-    /* Record a lift of `node`'s span. `seed` is the RAW (sub)expression text — `analyzeComponent`
-       wraps a `promise` seed as `computed(async () => await (<seed>))` (so `await` is a keyword in
-       an async context — a bare-text `await (X)` reparsed at module scope becomes a call to a
-       function `await`) and an `asyncIterable` seed as `computed(<seed>)` (a bare stream thunk). */
-    const lift = (
-        node: ts.Node,
-        seed: string,
-        kind: 'promise' | 'asyncIterable',
-        blocking: boolean,
-    ): void => {
-        const name = mint()
-        const start = node.getStart(source)
-        const end = node.getEnd()
-        lifts.push({ name, code: seed, kind, blocking })
-        edits.push({ start, end, name })
-        spans.push({ start, end, kind, blocking })
-    }
-
-    const visit = (node: ts.Node): void => {
-        /* A nested function is its own evaluation scope — an async (sub)expression inside a callback
-           (`items.map(x => fetchName(x))`, `items.map(async x => await load(x))`) must NOT be hoisted
-           to a top-level cell: its parameters/closure vars would become free identifiers, and it
-           would run once instead of per row. Stop at the boundary, mirroring the shared
-           `hasTopLevelAwait` walk. */
-        if (
-            ts.isArrowFunction(node) ||
-            ts.isFunctionExpression(node) ||
-            ts.isFunctionDeclaration(node)
-        ) {
-            return
-        }
-        if (ts.isAwaitExpression(node)) {
-            /* `await X` → a BLOCKING promise cell (its operand). D4b: `await` on a stream is
-               meaningless. The operand text is already a bounded unary — no parens needed. */
-            if (kindOf(node.expression) === 'asyncIterable') {
-                throw new AbideCompileError(
-                    '[abide] `await` unwraps a promise, but this is an `AsyncIterable` — drop the `await`; a stream auto-tracks (render its frames, or `{#for await}`).',
-                    loc + node.getStart(source),
-                )
-            }
-            lift(node, text(node.expression), 'promise', true)
-            return
-        }
-        if (ts.isBinaryExpression(node) && PENDING_TOLERANT.has(node.operatorToken.kind)) {
-            /* Pending-tolerant: don't lift the composition — descend so the operator sees the
-               operands' `undefined` (`getFoo() ?? 'Loading…'`, `x || getFoo()`). */
-            visit(node.left)
-            visit(node.right)
-            return
-        }
-        const kind = kindOf(node)
-        if (kind === 'promise') {
-            /* Lift as a unit, streaming; the cell unwraps the seed to its resolved value. */
-            lift(node, text(node), 'promise', false)
-            return
-        }
-        if (kind === 'asyncIterable') {
-            if (position === 'each') {
-                throw new AbideCompileError(
-                    "[abide] an `AsyncIterable` can't drive a plain `{#for}` — iterate its frames with `{#for await}`.",
-                    loc + node.getStart(source),
-                )
-            }
-            /* A stream cell: its latest frame. */
-            lift(node, text(node), 'asyncIterable', false)
-            return
-        }
-        /* Sync (or classifier-absent): a sync parent can still wrap an async child. */
-        ts.forEachChild(node, visit)
-    }
-
-    visit(first.expression)
-
-    if (edits.length === 0) {
-        return { code, lifts: [], spans: [] }
-    }
-    edits.sort((a, b) => b.start - a.start)
-    let rewritten = code
-    for (const edit of edits) {
-        rewritten = rewritten.slice(0, edit.start) + edit.name + rewritten.slice(edit.end)
-    }
-    /* Spans in ascending source order — the shadow's peek-wrap walks them left-to-right. */
-    spans.sort((a, b) => a.start - b.start)
-    return { code: rewritten, lifts, spans }
-}

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

@@ -1,47 +0,0 @@
-import { liftAsyncSubExpressions } from './liftAsyncSubExpressions.ts'
-import type { InjectedCell } from './lowerAsyncInterpolations.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-
-/* The pieces a script-seed lift yields: the async sub-expressions hoisted out of a
-   `state`/`linked`/`computed` seed argument (each an injected peek-cell) plus the seed
-   rewritten to reference them by bare `__vsN`. `desugarSignals` turns `cells` into
-   `scope().trackedComputed(...)` consts emitted BEFORE the owning declaration and parses
-   `rewrittenSeedText` back into the lowered seed. */
-export type ScriptSeedLift = { cells: InjectedCell[]; rewrittenSeedText: string }
-
-/*
-The script-side twin of the template `lowerAsyncInterpolations` walk (ADR-0032): runs
-`liftAsyncSubExpressions` over a `state`/`state.linked`/`state.computed` seed ARGUMENT so a
-buried promise/stream sub-expression (`getSession()?.filteredSources ?? []`) lifts to an
-injected streaming peek-cell — reading `undefined` while pending so `?.`/`??` compose — exactly
-as it would in a `{#if getSession()?.x}` template position. Only PROPER sub-expressions lift: a
-seed that IS a single async expression (`computed(getSession())`, `linked(getStream())`) is left
-whole for the existing whole-seed classification / runtime probe, so this never double-wraps.
-
-`classify` absent (no warm program) ⇒ no lift — a buried bare-async sub-expression needs the
-checker to know it is a promise, and a seed carrying a top-level `await` is already routed by the
-caller's whole-seed classification, so fail-open here is a plain no-op. `seedLoc` is the seed's
-absolute source offset, so each lifted span resolves against the shadow's source→shadow mappings.
-*/
-export function liftScriptSeed(
-    seedText: string,
-    seedLoc: number,
-    classify: InterpolationClassifier | undefined,
-    mint: () => string,
-): ScriptSeedLift | undefined {
-    if (classify === undefined) {
-        return undefined
-    }
-    const result = liftAsyncSubExpressions(seedText, seedLoc, classify, mint, 'content')
-    if (result.lifts.length === 0) {
-        return undefined
-    }
-    /* A single span covering the whole seed is the whole-seed case (`computed(getSession())`) —
-       leave it to the existing classification (`isPromiseComputed`) / the runtime probe rather
-       than pointlessly wrapping the seed in its own cell. Only proper sub-expressions lift. */
-    const only = result.spans.length === 1 ? result.spans[0] : undefined
-    if (only !== undefined && seedText.slice(only.start, only.end).trim() === seedText.trim()) {
-        return undefined
-    }
-    return { cells: result.lifts, rewrittenSeedText: result.code }
-}

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

@@ -1,31 +0,0 @@
-import ts from 'typescript'
-
-/*
-Loads the project's tsconfig (for lib/paths/baseUrl/strictness — the shadows must
-type-check against the same world the app does), then forces the overrides the
-shadow needs: `noUnusedLocals`/`noUnusedParameters` off because the shadow
-legitimately declares scope bindings a template may not read, and `noEmit`/
-`skipLibCheck` because it only ever type-checks. Falls back to permissive defaults
-when no tsconfig is found. Shared by the check Program and the LSP LanguageService.
-*/
-export function loadShadowTsConfig(cwd: string): ts.ParsedCommandLine {
-    const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, 'tsconfig.json')
-    const base = configPath
-        ? ts.parseJsonConfigFileContent(
-              ts.readConfigFile(configPath, ts.sys.readFile).config,
-              ts.sys,
-              cwd,
-          )
-        : { options: {}, fileNames: [], errors: [] }
-    return {
-        ...base,
-        options: {
-            ...base.options,
-            noEmit: true,
-            skipLibCheck: true,
-            noUnusedLocals: false,
-            noUnusedParameters: false,
-            allowUnreachableCode: true,
-        },
-    }
-}

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

@@ -1,92 +0,0 @@
-import { asyncInterpolationFields } from './asyncInterpolationFields.ts'
-import { liftAsyncSubExpressions } from './liftAsyncSubExpressions.ts'
-import type { InterpolationClassifier } from './types/InterpolationClassifier.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/* A synthetic peek-cell an async (sub)expression lowers to: a unique local name, the RAW seed
-   expression, its `kind` (a `promise` cell UNWRAPS to the resolved value; an `asyncIterable` cell
-   tracks its latest frame), and whether the author wrote `await` (BLOCKING: joins the SSR barrier,
-   resolved inline; else STREAMING: ships pending-`undefined`, resolves on the client). By kind,
-   `analyzeComponent` prepends `const <name> = computed(async () => await (<code>))` (promise) or
-   `const <name> = computed(<code>)` (stream); `desugarSignals` routes it (by injected name) to a
-   `trackedComputed` cell read via `$$readCell(<name>)`. */
-export type InjectedCell = {
-    name: string
-    code: string
-    kind: 'promise' | 'asyncIterable'
-    blocking: boolean
-}
-
-/* The result of the async-interpolation lowering: the (mutated-in-place) template plus the cells
-   the lifted (sub)expressions were rewritten into (empty when none). */
-export type LoweredInterpolations = { nodes: TemplateNode[]; cells: InjectedCell[] }
-
-/*
-ADR-0032 type-directed lowering of async (sub)expressions, in EVERY position — content
-interpolations and value positions (attribute, `{#if}`/`{#switch}` subject, plain `{#for}` source)
-alike. Each interpolation is walked (`liftAsyncSubExpressions`): a promise/`AsyncIterable`-typed
-(sub)expression is lifted to an injected peek-cell and rewritten IN PLACE to a bare `__vN`
-reference, so pending reads as `undefined` and composes with `??`/`?.`. A leading `await` marks the
-SSR BLOCKING tier; no `await` is STREAMING. Runs even without a classifier — then only syntactic
-`await`s lift (fail-open), matching the pre-classifier path for everything else.
-*/
-export function lowerAsyncInterpolations(
-    nodes: TemplateNode[],
-    classify: InterpolationClassifier | undefined,
-): LoweredInterpolations {
-    const counter = { n: 0 }
-    const mint = (): string => `__v${counter.n++}`
-    const cells: InjectedCell[] = []
-    lowerList(nodes, classify, mint, cells)
-    return { nodes, cells }
-}
-
-/* Lifts every async (sub)expression in a sibling list, then recurses into children. Each node's
-   async-liftable fields come from the shared `asyncInterpolationFields` plan (the single reading the
-   shadow front-end also drives from), so the two can't disagree on which interpolations are async;
-   this side owns the RENDERING — lift the field to a peek-cell, write the `__vN` reference back, and
-   for a control-flow subject that collapsed to one bare cell mark `asyncSubject`. */
-function lowerList(
-    nodes: TemplateNode[],
-    classify: InterpolationClassifier | undefined,
-    mint: () => string,
-    cells: InjectedCell[],
-): void {
-    for (const node of nodes) {
-        for (const field of asyncInterpolationFields(node)) {
-            const lifted = cells.length
-            const result = liftAsyncSubExpressions(
-                field.code,
-                field.loc,
-                classify,
-                mint,
-                field.position,
-            )
-            for (const lift of result.lifts) {
-                cells.push(lift)
-            }
-            field.write(result.code)
-            if (field.subject) {
-                field.setAsyncSubject(isBareLiftedCell(result.code, cells, lifted))
-            }
-        }
-        if ('children' in node) {
-            lowerList(node.children, classify, mint, cells)
-        }
-    }
-}
-
-/* True when a control-flow subject's WHOLE expression was lifted to one peek-cell — the
-   rewritten code is exactly a single injected name (`{#if getX()}` → `__v3`), not a compound
-   the peek composes into (`{#if getX()?.ok}` → `__v3?.ok`, still the falsy-else peek). `cells`
-   past index `lifted` are the ones this subject minted, so an equal name means the subject IS
-   that bare cell. Only then do the back-ends read its pending facet to hold the block. */
-function isBareLiftedCell(code: string, cells: InjectedCell[], lifted: number): boolean {
-    const name = code.trim()
-    for (let index = lifted; index < cells.length; index++) {
-        if (cells[index]?.name === name) {
-            return true
-        }
-    }
-    return false
-}

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

@@ -1,49 +0,0 @@
-import ts from 'typescript'
-
-/* Arithmetic compound assignments → their plain binary counterpart, lowered to a
-   read-combine-write (`x += y` → `write(read + y)`). */
-const ARITHMETIC_COMPOUND_OPERATORS = new Map<ts.SyntaxKind, ts.BinaryOperator>([
-    [ts.SyntaxKind.PlusEqualsToken, ts.SyntaxKind.PlusToken],
-    [ts.SyntaxKind.MinusEqualsToken, ts.SyntaxKind.MinusToken],
-    [ts.SyntaxKind.AsteriskEqualsToken, ts.SyntaxKind.AsteriskToken],
-    [ts.SyntaxKind.SlashEqualsToken, ts.SyntaxKind.SlashToken],
-])
-
-/* Logical compound assignments SHORT-CIRCUIT: the write fires only when the guard
-   passes (`x ??= v` is `x ?? (x = v)`), so they lower to `read <op> write(right)`, NOT
-   an unconditional write — matching JS, so a non-nullish/truthy/falsy guard does no
-   needless patch or cell reseed. */
-const LOGICAL_ASSIGNMENT_OPERATORS = new Map<ts.SyntaxKind, ts.BinaryOperator>([
-    [ts.SyntaxKind.QuestionQuestionEqualsToken, ts.SyntaxKind.QuestionQuestionToken],
-    [ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.BarBarToken],
-    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, ts.SyntaxKind.AmpersandAmpersandToken],
-])
-
-/*
-Lowers an assignment (`=`, arithmetic `+=`, or logical `??=`/`||=`/`&&=`) to a reactive
-write, shared by the `$$model` doc path (lowerDocAccess) and the `$$writeCell` linked-cell
-path (renameSignalRefs) so the two lowerings can't drift. `makeRead` builds the target's
-read expression (only called for compound operators); `makeWrite` wraps a value in the
-write call. Returns undefined for an operator this doesn't handle so the caller can leave
-the node untouched. The write must evaluate to the written value (see `Cell.set` /
-`Doc.replace`) for the logical short-circuit to yield the right result.
-*/
-export function lowerCompoundAssignment(
-    operator: ts.SyntaxKind,
-    makeRead: () => ts.Expression,
-    right: ts.Expression,
-    makeWrite: (value: ts.Expression) => ts.Expression,
-): ts.Expression | undefined {
-    if (operator === ts.SyntaxKind.EqualsToken) {
-        return makeWrite(right)
-    }
-    const arithmetic = ARITHMETIC_COMPOUND_OPERATORS.get(operator)
-    if (arithmetic !== undefined) {
-        return makeWrite(ts.factory.createBinaryExpression(makeRead(), arithmetic, right))
-    }
-    const logical = LOGICAL_ASSIGNMENT_OPERATORS.get(operator)
-    if (logical !== undefined) {
-        return ts.factory.createBinaryExpression(makeRead(), logical, makeWrite(right))
-    }
-    return undefined
-}