@abide/abide 0.57.1 → 0.100.0

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

@@ -1,15 +0,0 @@
-import type { InterpolationKind } from './InterpolationKind.ts'
-
-/*
-Classifies a `computed`/`linked` SEED expression from its checker type, keyed by the
-seed's source offset (`loc`) and verbatim `code` — the cell-transform counterpart of
-`InterpolationClassifier` (ADR-0023). Built by the bundler plugin over the SAME warm
-shadow program and threaded, OPTIONAL, through the compile front-end to `desugarSignals`.
-
-Unlike `InterpolationClassifier`, a resolution failure returns `undefined`, NOT `'sync'`:
-for a seed, fail-open means degrade to today's `isBareCallComputed` syntax heuristic, so a
-failure must be DISTINGUISHABLE from a genuine `sync` type (which routes to the lazy
-`derive` slot). Absent classifier ⇒ every seed resolves `undefined` ⇒ exactly today's
-behavior.
-*/
-export type SeedTypeClassifier = (loc: number, code: string) => InterpolationKind | undefined

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

@@ -1,11 +0,0 @@
-/*
-A semantic-highlighting token in original `.abide` source coordinates. `type` and
-`modifiers` are legend names (see ABIDE_SEMANTIC_TOKENS_LEGEND), resolved to wire
-indices only at encode time.
-*/
-export type SemanticToken = {
-    start: number
-    length: number
-    type: string
-    modifiers: string[]
-}

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

@@ -1,9 +0,0 @@
-/*
-Which deref a branch-local shadow name lowers to. A block value param either binds
-as a reactive `.value` cell (`derived` — read as `name.value`, the client back-end's
-keyed-each item / `await then` value) or as a plain JS local holding the resolved
-value (`plain` — read as the bare identifier, the SSR back-end's inline `await` value
-and both back-ends' snippet/catch params). A name MUST be registered under the kind
-its emitted code reads it as, or it mis-lowers to the component signal it shadows.
-*/
-export type ShadowKind = 'derived' | 'plain'

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

@@ -1,19 +0,0 @@
-import type { ShadowKind } from './ShadowKind.ts'
-
-/*
-The typed branch-local shadow stack both lowering back-ends thread through. Replaces
-the two loose `Set`s reached via closure with one value owning both kinds, and the
-manual push-then-pop with a single structured `withShadow` that pushes on entry and
-pops in a `finally` — so a branch's shadows cannot outlive the branch even if the body
-throws (the SSR `await then` TDZ path threw mid-body and leaked under the old hand pop).
-
-`names` snapshots a kind for the expression transformer: a binding pushed mid-compile
-must be honoured AND shadow a same-named component signal.
-*/
-export type ShadowScope = {
-    /* Push the names not already present (under `kind`) for the duration of `body`, then
-       pop exactly what was added — in a `finally`, so a throw cannot leak the shadow. */
-    withShadow: <T>(names: Iterable<string>, kind: ShadowKind, body: () => T) => T
-    /* A snapshot of the names currently shadowing under `kind`, for the transformer. */
-    names: (kind: ShadowKind) => ReadonlySet<string>
-}

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

@@ -1,21 +0,0 @@
-import type { TemplateNode } from './TemplateNode.ts'
-
-/*
-The per-node skeleton position both back-ends consult so their marker placement
-cannot drift. `inSkeleton` is true when a node sits inside a parser-backed skeleton
-clone (so control-flow blocks and `<slot>`s take an `<!--a-->` anchor at their
-position); `markText` is true when, additionally, the node's reactive text is
-interleaved with element siblings (so it takes an `<!--a-->` anchor rather than
-binding marker-free on a text-leaf element). Keyed by node identity — both maps are
-filled by one shared `skeletonContext` pass over the parsed tree.
-*/
-export type SkeletonContext = {
-    inSkeleton: WeakMap<TemplateNode, boolean>
-    markText: WeakMap<TemplateNode, boolean>
-    /* Per-hole indices assigned in the same walk, so `generateBuild` reads its `sk.el`/`sk.an`
-       numbering rather than re-deriving it. `elIndex` keyed by element/component node;
-       `anIndex` keyed by control-flow/slot node OR by a reactive text PART object (a text node
-       carries one anchor per reactive part). */
-    elIndex: WeakMap<TemplateNode, number>
-    anIndex: WeakMap<object, number>
-}

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

@@ -1,34 +0,0 @@
-import type { TextPart } from './TextPart.ts'
-
-/*
-An element attribute. `static` is a literal — `bare` marks a valueless attribute
-(`disabled`, not `disabled=""`), letting a component coerce it to `true` while a
-native element still serialises it as `name=""`; `expression` is `name={code}` bound
-reactively; `event` is `on<event>={code}` where `code` evaluates to the handler;
-`bind` is `bind:<property>={lvalue}`, a two-way binding whose `code` is the
-writable doc path read into the property and written back on input; `attach` is
-`attach={code}` where `code` evaluates to an attachment `(node) => teardown` run
-at build with node-lifetime teardown; `spread` is `{...code}` where `code`
-evaluates to an object whose own keys each become a prop on a component or an
-attribute on a native element. `loc` is the
-absolute offset of `code` in the original `.abide` source (see TextPart) —
-optional, set only when the parser tracks positions for the type-checking shadow.
-*/
-export type TemplateAttr =
-    | { kind: 'static'; name: string; value: string; bare?: true; nameLoc?: number }
-    | { kind: 'expression'; name: string; code: string; loc?: number; nameLoc?: number }
-    /* `name="literal {expr}"` — a quoted value mixing literal text with `{expr}`
-       interpolations (the text-node `parts` model on an attribute). Bound reactively
-       as the template-literal concatenation of its parts; always yields a string, so
-       the attribute is always present. */
-    | { kind: 'interpolated'; name: string; parts: TextPart[]; nameLoc?: number }
-    | { kind: 'event'; event: string; code: string; loc?: number }
-    | { kind: 'bind'; property: string; code: string; loc?: number }
-    /* `class:<name>={code}` — toggles the class on/off by `code`'s truthiness, written
-       surgically (classList.toggle) without re-rendering the element. */
-    | { kind: 'class'; name: string; code: string; loc?: number }
-    /* `style:<property>={code}` — writes one inline style/custom property (style.setProperty)
-       reactively, again without a re-render. `property` may be a CSS custom prop (`--pct`). */
-    | { kind: 'style'; property: string; code: string; loc?: number }
-    | { kind: 'attach'; code: string; loc?: number }
-    | { kind: 'spread'; code: string; loc?: number }

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

@@ -1,137 +0,0 @@
-import type { TemplateAttr } from './TemplateAttr.ts'
-import type { TextPart } from './TextPart.ts'
-
-/*
-A parsed template node. `text` carries interpolation parts; `element` carries
-attributes and children; `each` is the `{#for items as item}` control flow over a
-list; `if`/`await`/`switch`/`try` are its control-flow siblings.
-
-`loc` (where present) is the absolute offset of the node's primary expression in
-the original `.abide` source — additive, set only when the parser tracks
-positions for the type-checking shadow, ignored by the runtime back-ends.
-*/
-export type TemplateNode =
-    | { kind: 'text'; parts: TextPart[] }
-    | { kind: 'script'; code: string; loc?: number }
-    /* A `<style>` declared in the template. `css` is its raw body, read structurally
-       so a `<style>` inside an expression isn't mistaken for one. The node stays in
-       place: it scopes its sibling subtree, so the front-end derives each scope
-       attribute and the elements it covers from the node's position (see
-       `analyzeComponent`). Emits no DOM/markup. */
-    | { kind: 'style'; css: string }
-    | {
-          kind: 'element'
-          tag: string
-          attrs: TemplateAttr[]
-          children: TemplateNode[]
-          /* The scope attributes (`data-a-…`) this element carries — one per `<style>`
-             active at its position (its own sibling list plus every ancestor's),
-             filled by `analyzeComponent`. Absent until annotated. */
-          scopes?: string[]
-      }
-    | {
-          kind: 'each'
-          items: string
-          as: string
-          key: string | undefined
-          /* `index="i"` → the row's reactive position, bound to this name; absent → unbound. */
-          index: string | undefined
-          /* `await` on the tag → `items` is an AsyncIterable, drained on the client. */
-          async: boolean
-          children: TemplateNode[]
-          loc?: number
-          /* Source offsets of the binding name, `by` key, and index — so the shadow
-             maps hover/highlighting onto them (absent for synthesised/missing parts). */
-          asLoc?: number
-          keyLoc?: number
-          indexLoc?: number
-      }
-    | {
-          kind: 'if'
-          condition: string
-          children: TemplateNode[]
-          loc?: number
-          /* `condition` is a bare async subject — the WHOLE test was one promise/stream that
-             `lowerAsyncInterpolations` lifted to a single peek-cell (`{#if getX()}`). The binary
-             back-ends then read its pending facet so a still-loading subject renders NO branch,
-             not the falsy `{:else}`. Unset (or on an `{:elseif}` chain) → the plain truthy test. */
-          asyncSubject?: boolean
-      }
-    | {
-          kind: 'await'
-          promise: string
-          /* `then` in the await head (`{#await p then v}`) makes the block BLOCKING:
-             no pending branch, children are the resolved content bound to `as`, SSR
-             settles before the first flush. Absent → streaming. */
-          blocking: boolean
-          as: string | undefined
-          children: TemplateNode[]
-          loc?: number
-          /* Source offset of an inline blocking `then` binding (`{#await p then v}`). */
-          asLoc?: number
-      }
-    | { kind: 'try'; children: TemplateNode[] }
-    | {
-          kind: 'branch'
-          branch: 'then' | 'catch' | 'finally'
-          as: string | undefined
-          children: TemplateNode[]
-          /* Source offset of the `then`/`catch` binding, so the shadow maps it. */
-          asLoc?: number
-      }
-    | {
-          kind: 'component'
-          name: string
-          /* Source offset of the tag name — the anchor for a whole-mount diagnostic
-             (a missing required prop, which has no supplied expression to point at). */
-          loc?: number
-          /* Each authored attribute as a prop. A `spread` entry (`{...code}`) carries no
-             `name`; its keys merge in at runtime (`mergeProps`/`spreadProps`). `nameLoc` is
-             the prop name's source offset — the anchor for an excess-prop diagnostic. `bind`
-             marks a `bind:<name>={target}` two-way prop: `code` is the writable target (an
-             lvalue or a `{ get, set }` accessor), passed with a write-back channel so the
-             child can push changes upstream (`bindProp`/`bindableProp`). */
-          props: {
-              name: string
-              code: string
-              loc?: number
-              nameLoc?: number
-              spread?: boolean
-              bind?: true
-          }[]
-          children: TemplateNode[]
-      }
-    | {
-          kind: 'switch'
-          subject: string
-          children: TemplateNode[]
-          loc?: number
-          /* `subject` is a bare async subject (the whole expression lifted to one peek-cell) —
-             a still-loading subject selects no case (not even the default) until it settles. */
-          asyncSubject?: boolean
-      }
-    /* A branch of a `<template switch>` (`match` set) or `<template if>` chain. Inside an
-       `if`, `<template elseif={c}>` sets `condition` (match-less, truthy-tested), and
-       `<template else>` leaves both unset (the default). `loc` points at whichever
-       expression the node carries (`match` or `condition`). */
-    | {
-          kind: 'case'
-          match: string | undefined
-          condition?: string
-          children: TemplateNode[]
-          loc?: number
-          /* An `{:elseif}` whose `condition` is a bare async subject (the whole test lifted to one
-             peek-cell) — the cond-chain holds at this branch while the cell is pending, resuming the
-             top-down walk (skip it / match it / fall to the next branch) once it settles. */
-          asyncSubject?: boolean
-      }
-    /* A `{#snippet row(item)}` snippet: a named, scope-capturing builder declared
-       once and called like a function (`{row(item)}`). `params` is the raw
-       parameter list from the parens (absent when there are no parameters). */
-    | {
-          kind: 'snippet'
-          name: string
-          params: string | undefined
-          children: TemplateNode[]
-          loc?: number
-      }

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

@@ -1,8 +0,0 @@
-/* A piece of a text node: literal characters, or a `{expr}` interpolation whose
-   `code` is lowered and bound reactively. `loc` is the absolute offset of the
-   expression's first character in the original `.abide` source — present only
-   when the parser was given the source's base offset; the runtime back-ends
-   ignore it, the type-checking shadow maps diagnostics through it. */
-export type TextPart =
-    | { kind: 'static'; value: string }
-    | { kind: 'expression'; code: string; loc?: number }

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

@@ -1,13 +0,0 @@
-/*
-A template interpolation sitting in a NON-content value position — where a
-`Promise`/`AsyncIterable` can't be rendered over time and would silently stringify
-to `[object Promise]` (Stage E of type-directed lowering, ADR-0019). `loc`/`code`
-are the expression's source offset and verbatim text (the classifier's key), and
-`position` names the position for the diagnostic. `for await` is the sanctioned
-`{#for await}` iterable — the one value position where an `AsyncIterable` is allowed.
-*/
-export type ValuePositionInterpolation = {
-    loc: number
-    code: string
-    position: 'attribute' | 'if' | 'switch' | 'each' | 'for await'
-}

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

@@ -1,10 +0,0 @@
-/*
-Peels one outer paren pair off a lowered expression. The lowering passes wrap an
-expression in `(…)` to force expression-position parsing (so a bare object literal
-isn't read as a block); the printer preserves that wrapper, so the result is
-always `(EXPR)` and the outermost pair is the one we added. Removed for clean,
-canonical output.
-*/
-export function unwrapParens(code: string): string {
-    return code.startsWith('(') && code.endsWith(')') ? code.slice(1, -1) : code
-}

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

@@ -1,57 +0,0 @@
-/*
-The ONE document-order anchor-numbering rule, shared by every side that recovers a skeleton's
-`<!--a-->` anchor positions. The same "why" — assign every block anchor, slot, and
-interleaved-reactive-text part a position in document order, recover it on the other side — was
-computed twice with no shared definition: `skeletonContext` re-derived it over the template AST
-(assigning `anIndex`), `scanAnchors` re-derived it over the realized DOM (collecting the live
-`a` comments). Each hand-mirrored the same traversal, so a change to one drifted silently from
-the other — the index-desync class the runtime anchor guards exist to catch.
-
-This module owns the traversal SHAPE as a sibling-list scan. A per-substrate
-`AnchorWalkAdapter` classifies each node it meets into one of three roles, and that
-classification — plus the document-order scan over it — IS the shared rule. The two substrates
-differ only in how a fresh-context region is delimited (a control-flow/component/slot SUBTREE on
-the AST side; a `[`…`]` / `abide:` marker-bracketed sibling RUN on the realized-DOM side), so
-the adapter, not this walk, skips the region; the walk guarantees both sides emit the same
-positions in the same order.
-*/
-
-/* What a node contributes as the scan reaches it, in document order. */
-export type AnchorRole =
-    /* Emit this node's anchor positions (zero or more — a reactive text node carries one per
-       non-static part), then do NOT descend. A block/component/slot is itself one anchor whose
-       body is a fresh context; an interleaved reactive text node is several. */
-    | { kind: 'anchor'; positions: readonly object[] }
-    /* An own-skeleton container — descend into its children, contributing no anchor itself (a
-       static/host element). */
-    | { kind: 'recurse' }
-    /* Contribute nothing and do not descend — a static text leaf, a script/style, or a
-       boundary the adapter handles out-of-band (range markers on the DOM side). */
-    | { kind: 'skip' }
-
-/* The single substrate fact the shared walk needs: classify a node. The adapter owns substrate
-   detail (what an anchor is, what a fresh-context boundary is, how to reach children); the walk
-   owns only document order. */
-export type AnchorWalkAdapter<TNode> = {
-    classify: (node: TNode) => AnchorRole
-    childrenOf: (node: TNode) => readonly TNode[]
-}
-
-/* Scan `nodes` in document order, calling `emit` once per anchor position in the order both
-   sides must agree on. Pure: the adapter decides roles, this owns only the order. */
-export function walkAnchorOrder<TNode>(
-    nodes: readonly TNode[],
-    adapter: AnchorWalkAdapter<TNode>,
-    emit: (position: object) => void,
-): void {
-    for (const node of nodes) {
-        const role = adapter.classify(node)
-        if (role.kind === 'anchor') {
-            for (const position of role.positions) {
-                emit(position)
-            }
-        } else if (role.kind === 'recurse') {
-            walkAnchorOrder(adapter.childrenOf(node), adapter, emit)
-        }
-    }
-}

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

@@ -1,60 +0,0 @@
-/*
-The ONE pre-order element-hole numbering rule, shared by every side that positions a skeleton's
-located elements. The same "why" — number the bound elements in pre-order, recover them on the
-other side — was computed twice with no shared definition: `skeletonContext` threaded an `el`
-counter over the template AST (assigning `elIndex`), `indexElementHoles` re-walked the parsed
-skeleton DOM (recording each `HOLE_ATTRIBUTE` element's path). Each hand-mirrored the same
-element-only pre-order, so a change to one drifted silently from the other — the index-desync
-class `resolveElementHole` exists to catch.
-
-This module owns the traversal SHAPE: an element-only pre-order over a sibling list, threading
-an element-only path. A per-substrate `ElementWalkAdapter` classifies each node — a numbered
-element (a hole emits, all elements descend) or a skip (non-element / fresh-context boundary) —
-and that classification, plus the path-threading scan over it, IS the shared rule. The two
-substrates differ only in what marks a hole (a reactive attr/text-leaf on the AST side, the
-`HOLE_ATTRIBUTE` on the parsed-DOM side) and where a fresh context begins (a control-flow/
-component/slot SUBTREE on the AST side; the parsed skeleton already prunes those to `<!--a-->`
-anchors, so the DOM side only meets its own elements), which the adapter owns — the walk
-guarantees both number the same elements in the same element-only order.
-*/
-
-/* What a node contributes as the pre-order scan reaches it. */
-export type ElementRole =
-    /* An element in this skeleton: it consumes an element-only index (so a later sibling's
-       path stays stable), emits its hole position when `isHole`, and is descended into. */
-    | { kind: 'element'; isHole: boolean }
-    /* A non-element (text/comment) or a fresh-context boundary (control-flow/component/slot):
-       contributes no index, no hole, and is not descended. */
-    | { kind: 'skip' }
-
-/* The substrate facts the shared walk needs: classify a node, reach its children. The adapter
-   owns substrate detail (what an element hole is, how to reach children); the walk owns only
-   the element-only pre-order and the path it threads. */
-export type ElementWalkAdapter<TNode> = {
-    classify: (node: TNode) => ElementRole
-    childrenOf: (node: TNode) => readonly TNode[]
-}
-
-/* Scan `nodes` in element-only pre-order, calling `emit` once per hole with its element-only
-   path — the order and path both sides must agree on. Pure: the adapter decides roles, this
-   owns only the order and the path prefix. */
-export function walkElementOrder<TNode>(
-    nodes: readonly TNode[],
-    adapter: ElementWalkAdapter<TNode>,
-    emit: (node: TNode, path: number[]) => void,
-    prefix: number[] = [],
-): void {
-    let elementIndex = 0
-    for (const node of nodes) {
-        const role = adapter.classify(node)
-        if (role.kind === 'skip') {
-            continue
-        }
-        const path = [...prefix, elementIndex]
-        elementIndex += 1
-        if (role.isHole) {
-            emit(node, path)
-        }
-        walkElementOrder(adapter.childrenOf(node), adapter, emit, path)
-    }
-}

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

@@ -1,45 +0,0 @@
-import { destructureBindingNames } from './destructureBindingNames.ts'
-import type { Binding } from './types/Binding.ts'
-import type { ShadowKind } from './types/ShadowKind.ts'
-import type { ShadowScope } from './types/ShadowScope.ts'
-
-/*
-The ONE shared registration path for a block's bindings, built on `withShadow`. Iterates
-a plan's `Binding[]` once, derives each binding's leaf names (`destructureBindingNames` —
-the single name derivation), and registers them under the `ShadowKind` the injected
-`kindMapping` returns, for the duration of `body`. The back-ends differ ONLY in the
-mapping they inject: the client maps `reactive → derived` (a `.value` cell, its wiring
-arranged separately via `reactiveBinding`) and `plain → plain`; SSR has no cells, so it
-maps every binding → `plain`. A name a block introduces therefore flows to exactly one
-shadow kind, decided by the plan's classification and one mapping — `block-binding-shadow`
-(a name registered on one back-end but not the other, or under the wrong kind) is designed
-out, not test-caught.
-*/
-export function withBindings<T>(
-    withShadow: ShadowScope['withShadow'],
-    bindings: Binding[],
-    kindMapping: (binding: Binding) => ShadowKind,
-    body: () => T,
-): T {
-    /* Group each binding's leaf names by the kind the mapping assigns, so one `withShadow`
-       per kind registers them all (nested, so both kinds shadow simultaneously). */
-    const byKind = new Map<ShadowKind, string[]>()
-    for (const binding of bindings) {
-        const kind = kindMapping(binding)
-        const names = byKind.get(kind) ?? []
-        names.push(...destructureBindingNames(binding.name))
-        byKind.set(kind, names)
-    }
-    /* Fold the per-kind `withShadow` calls around `body` — each pushes its names on entry
-       and pops them in a `finally`, so no branch's shadows outlive the branch. */
-    const entries = [...byKind]
-    const run = (index: number): T => {
-        const entry = entries[index]
-        if (entry === undefined) {
-            return body()
-        }
-        const [kind, names] = entry
-        return withShadow(names, kind, () => run(index + 1))
-    }
-    return run(0)
-}

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

@@ -1,121 +0,0 @@
-import ts from 'typescript'
-import { AbideCompileError } from './AbideCompileError.ts'
-
-/*
-Folds a cell-source `watch(source, handler)` into the auto-tracked thunk form
-`watch(() => (handler)(source))`, so the reaction reads the cell reactively
-instead of receiving a one-time value.
-
-The plain-variable ergonomic makes a bare `count` a VALUE read everywhere the
-read-lowering runs (`renameSignalRefs` → `docAccessTransformer`). That is right
-for `{count}` / `count + 1`, but it also lowered `watch(count, handler)`'s source
-to `$$model.read("count")` — a number — so the runtime `watch` (which expects a
-`State` and reads `.value` inside an effect) never subscribed: the reaction was
-inert. The `watch(count, n => …)` form was documented but silently dead.
-
-This runs BEFORE the read-lowering, so the `source` moved inside the new thunk is
-lowered to its normal reactive read there — one rewrite covers every cell kind
-(doc-slot `state`, `.value` cell, `computed`, `linked`), because it reuses the
-read the rest of the pipeline already emits. The runtime `watch(thunk)` is the
-same auto-tracked effect the compiler's own bindings use, so semantics match the
-old `effect(() => handler(cell.value))` cell branch exactly.
-
-Only a bare cell reference (or an array literal of them — the `watch([a, b], …)`
-form) is folded. A socket / rpc / arbitrary object source is left untouched so the
-runtime's own source dispatch (`cache.on` / `reactToRpc`) still handles it; the
-thunk (`watch(() => …)`) and rpc-with-args (`watch(fn, args, handler)`) forms are
-already correct and are matched out by arity.
-*/
-export function wrapReactionCellSources(
-    cellNames: ReadonlySet<string>,
-    watchLocalNames: ReadonlySet<string>,
-): ts.TransformerFactory<ts.SourceFile> {
-    /* A source that names a reactive cell: a bare cell identifier, or a non-empty array
-       literal whose every element is one (the multi-cell `watch([a, b], …)` form). */
-    function isCellSource(source: ts.Expression): boolean {
-        if (ts.isIdentifier(source)) {
-            return cellNames.has(source.text)
-        }
-        if (ts.isArrayLiteralExpression(source)) {
-            return (
-                source.elements.length > 0 &&
-                source.elements.every(
-                    (element) => ts.isIdentifier(element) && cellNames.has(element.text),
-                )
-            )
-        }
-        return false
-    }
-
-    /* The inert footgun: a member access (`s.foo`, `s['foo']`) whose base is a known cell.
-       abide has no per-property cells — the whole object lives in the one cell — so a member
-       expression is read ONCE as a plain value (outside any tracking scope) and handed to the
-       runtime as a dead value: nothing subscribes, the reaction never fires. It can't be folded
-       like a bare cell (a member access isn't a whole-cell subscription), so return the base
-       name to REJECT on and point the author at the corrective forms. */
-    function cellMemberBase(source: ts.Expression): string | undefined {
-        if (
-            (ts.isPropertyAccessExpression(source) || ts.isElementAccessExpression(source)) &&
-            ts.isIdentifier(source.expression) &&
-            cellNames.has(source.expression.text)
-        ) {
-            return source.expression.text
-        }
-        return undefined
-    }
-
-    return (context) => (root) => {
-        function visit(node: ts.Node): ts.Node {
-            const [sourceArg, handlerArg] = ts.isCallExpression(node) ? node.arguments : []
-            if (
-                ts.isCallExpression(node) &&
-                ts.isIdentifier(node.expression) &&
-                watchLocalNames.has(node.expression.text) &&
-                node.arguments.length === 2 &&
-                sourceArg !== undefined &&
-                handlerArg !== undefined &&
-                isCellSource(sourceArg)
-            ) {
-                /* Visit the operands first — a handler body may itself contain a nested cell-source
-                   watch, and the source stays a plain identifier the read-lowering rewrites next. */
-                const source = ts.visitNode(sourceArg, visit) as ts.Expression
-                const handler = ts.visitNode(handlerArg, visit) as ts.Expression
-                /* `(handler)(source)` — parenthesise the handler so an arrow callee prints callable. */
-                const call = ts.factory.createCallExpression(
-                    ts.factory.createParenthesizedExpression(handler),
-                    undefined,
-                    [source],
-                )
-                const thunk = ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [],
-                    undefined,
-                    ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-                    call,
-                )
-                return ts.factory.createCallExpression(node.expression, undefined, [thunk])
-            }
-            /* Reject the inert member-expression form `watch(s.foo, handler)` — it looks valid but
-               subscribes to nothing (see `cellMemberBase`), so the handler silently never fires. Not
-               foldable; a compile error turns the silent no-op into a caught mistake. A member of a
-               cell is never itself a cell (no per-property cells), so this can't reject a valid watch. */
-            const memberBase = sourceArg !== undefined ? cellMemberBase(sourceArg) : undefined
-            if (
-                ts.isCallExpression(node) &&
-                ts.isIdentifier(node.expression) &&
-                watchLocalNames.has(node.expression.text) &&
-                node.arguments.length === 2 &&
-                sourceArg !== undefined &&
-                memberBase !== undefined
-            ) {
-                const sourceText = sourceArg.getText(root)
-                throw new AbideCompileError(
-                    `[abide] \`watch(${sourceText}, …)\` does not track \`${sourceText}\` — a member access on a cell is read once as a plain value (abide has no per-property cells), so the reaction never fires. Wrap it in a thunk (\`watch(() => …(${sourceText}))\`) or watch the whole cell (\`watch(${memberBase}, v => …)\`).`,
-                )
-            }
-            return ts.visitEachChild(node, visit, context)
-        }
-        return ts.visitNode(root, visit) as ts.SourceFile
-    }
-}

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

@@ -1,44 +0,0 @@
-import ts from 'typescript'
-import { NESTED_REACTIVE_BINDINGS, resolveReactiveExport } from './resolveReactiveExport.ts'
-import { wrapSeed } from './wrapSeed.ts'
-
-/*
-Normalises every `state.computed(seed)` / `state.linked(seed)` in a nested branch
-`<script>` so a BARE-VALUE seed becomes a thunk (`state.computed(a * 2)` →
-`state.computed(() => a * 2)`), exactly as the top-level desugar (`desugarSignals` via
-`wrapSeed`) does. A nested script keeps its reactive calls literal — it is not desugared to
-the doc — so absent this the bare value reaches the runtime primitive, which stores it as
-the compute function and calls it on read (`a * 2 is not a function`, a runtime crash). A
-literal `() => …` / `function` thunk passes through unchanged, so the wrap is a no-op on the
-already-thunked form the author usually writes.
-
-Recognition is name-based (`NESTED_REACTIVE_BINDINGS`) because a nested script carries no
-import of its own — it inherits the surface by the canonical `state` name, the same way
-`nestedBindingNames` resolves it. Only the seed argument (`arguments[0]`) is wrapped; a
-`state.linked(seed, ...)`'s trailing args pass through. Exposed as a `ts.TransformerFactory`
-so the nested-script lowering can chain it ahead of the reference rename over ONE parsed tree.
-*/
-export function wrapReactiveSeedsTransformer(): ts.TransformerFactory<ts.SourceFile> {
-    return (context) => (root) => {
-        const visit = (node: ts.Node): ts.Node => {
-            if (ts.isCallExpression(node) && node.arguments.length > 0) {
-                const primitive = resolveReactiveExport(node.expression, NESTED_REACTIVE_BINDINGS)
-                if (primitive === 'computed' || primitive === 'linked') {
-                    const seed = node.arguments[0] as ts.Expression
-                    const wrapped = wrapSeed(ts.visitNode(seed, visit) as ts.Expression)
-                    const rest = node.arguments
-                        .slice(1)
-                        .map((argument) => ts.visitNode(argument, visit) as ts.Expression)
-                    return ts.factory.updateCallExpression(
-                        node,
-                        node.expression,
-                        node.typeArguments,
-                        [wrapped, ...rest],
-                    )
-                }
-            }
-            return ts.visitEachChild(node, visit, context)
-        }
-        return ts.visitNode(root, visit) as ts.SourceFile
-    }
-}

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

@@ -1,28 +0,0 @@
-import ts from 'typescript'
-import { hasTopLevelAwait } from './hasTopLevelAwait.ts'
-
-const factory = ts.factory
-
-/* Normalises a `computed`/`linked` argument into a seed THUNK: a literal `() => …` /
-   `function` argument passes through unchanged (the author already wrote the thunk), any
-   other expression is wrapped as `() => arg`. The wrapper arrow is made ASYNC when the
-   expression contains a top-level `await` (`computed(await load())` → `async () => await
-   load()`), which is exactly the marker the runtime primitive uses to route to an async cell.
-   Shared by the top-level desugar (`desugarSignals`) and the nested-`<script>` lowering
-   (`wrapReactiveSeeds`) so a bare-value seed is normalised identically on both surfaces. */
-export function wrapSeed(argument: ts.Expression): ts.Expression {
-    if (ts.isArrowFunction(argument) || ts.isFunctionExpression(argument)) {
-        return argument
-    }
-    const modifiers = hasTopLevelAwait(argument)
-        ? [factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-        : undefined
-    return factory.createArrowFunction(
-        modifiers,
-        undefined,
-        [],
-        undefined,
-        factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-        argument,
-    )
-}