@abide/abide 0.58.0 → 0.101.0

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

@@ -1,84 +0,0 @@
-import ts from 'typescript'
-import { assignmentTargetNames } from './assignmentTargetNames.ts'
-import { isPlainIdentifier } from './isPlainIdentifier.ts'
-import type { TemplateNode } from './types/TemplateNode.ts'
-
-/*
-Every name the TEMPLATE writes — the counterpart to the leading script's own write
-scan. Two ways a prop's name shows up written in markup:
-  • forwarded as a `bind:` target — `bind:value={value}` on a child element or component
-    passes the name as a two-way target, so it must be a writable cell (a bare identifier
-    only; a `{ get, set }` accessor carries its own write path and reads the prop plainly);
-  • assigned in a template expression — an event handler like `onclick={() => value += 1}`.
-
-Collected across every JS fragment the markup carries (attribute/prop/event/text
-expressions and nested `<script>` bodies), then intersected with the actual prop names by
-the caller. Syntactic and conservative — see `assignmentTargetNames`.
-*/
-export function writtenTemplateNames(nodes: TemplateNode[]): Set<string> {
-    const names = new Set<string>()
-    /* One synthetic source of every expression fragment, parsed once for its write targets. */
-    let fragments = ''
-    const addFragment = (code: string | undefined): void => {
-        if (code !== undefined && code.trim() !== '') {
-            fragments += `${code};\n`
-        }
-    }
-    /* A bare-identifier `bind:` target names a prop forwarded as a two-way channel. */
-    const addBindTarget = (code: string): void => {
-        if (isPlainIdentifier(code.trim())) {
-            names.add(code.trim())
-        }
-    }
-    const walk = (node: TemplateNode): void => {
-        if (node.kind === 'text') {
-            for (const part of node.parts) {
-                if (part.kind === 'expression') {
-                    addFragment(part.code)
-                }
-            }
-            return
-        }
-        if (node.kind === 'script') {
-            addFragment(node.code)
-            return
-        }
-        if (node.kind === 'element') {
-            for (const attr of node.attrs) {
-                if (attr.kind === 'bind') {
-                    addBindTarget(attr.code)
-                    addFragment(attr.code)
-                } else if (attr.kind === 'interpolated') {
-                    for (const part of attr.parts) {
-                        if (part.kind === 'expression') {
-                            addFragment(part.code)
-                        }
-                    }
-                } else if (attr.kind !== 'static') {
-                    addFragment(attr.code)
-                }
-            }
-        }
-        if (node.kind === 'component') {
-            for (const prop of node.props) {
-                if (prop.bind === true) {
-                    addBindTarget(prop.code)
-                }
-                addFragment(prop.code)
-            }
-        }
-        if ('children' in node) {
-            for (const child of node.children) {
-                walk(child)
-            }
-        }
-    }
-    for (const node of nodes) {
-        walk(node)
-    }
-    if (fragments.trim() !== '') {
-        const source = ts.createSourceFile('template.ts', fragments, ts.ScriptTarget.Latest, true)
-        assignmentTargetNames(source, names)
-    }
-    return names
-}

package/src/lib/ui/computed.ts

@@ -1,75 +0,0 @@
-import type { AsyncComputed } from '../shared/types/AsyncComputed.ts'
-import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
-import { createAsyncCell } from './runtime/createAsyncCell.ts'
-import { createComputedNode } from './runtime/createComputedNode.ts'
-import { isAsyncFunction } from './runtime/isAsyncFunction.ts'
-import { OWNER } from './runtime/OWNER.ts'
-import { readNode } from './runtime/readNode.ts'
-import { routeBareSeed } from './runtime/routeBareSeed.ts'
-import type { Computed } from './runtime/types/Computed.ts'
-import { unlinkDeps } from './runtime/unlinkDeps.ts'
-
-/*
-A reactive cell computed from other cells — the abide replacement for `$derived`.
-Named `computed` (not `derived`) and ALWAYS read-only: unlike Svelte's reassignable
-`$derived`, a computed is purely a function of its inputs, the way Vue/Angular
-`computed` is. There is no local store and nothing to assign — a write to a computed
-would be a write to its *sources*, which is expressed at the binding site instead
-(`bind:value={{ get, set }}`), where the write actually originates. Lazy: it
-recomputes on read only when a dependency changed, and never serializes (it is
-re-derived from its inputs on resume). Read via `.value`.
-
-When the seed *tracks* an async source it becomes an async cell instead (ADR-0019
-D1): an `async () => await …` thunk (the compiler's `await` lowering) unwraps the
-promise, and a thunk producing a `NamedAsyncIterable` (socket / streaming rpc)
-auto-tracks its frames. Both yield an `AsyncComputed<T>` — no `.value`, read through
-the probe family (`peek`/`pending`/`refreshing`/`error`/`refresh`). A thunk that
-returns a *bare* promise (no `await`) is held opaquely as a normal `Computed<Promise<T>>`
-— render it with `{#await}`.
-*/
-export function computed<T>(compute: () => NamedAsyncIterable<T>): AsyncComputed<T>
-export function computed<T>(compute: () => Promise<T>): AsyncComputed<T>
-export function computed<T>(compute: () => T): Computed<T>
-export function computed<T>(
-    compute: () => T | Promise<T> | NamedAsyncIterable<T>,
-): Computed<T> | AsyncComputed<T> {
-    /* A BARE seed that reached the runtime literally — a branch-nested `<script>` (which
-       keeps its `state.computed(...)` calls literal; see lowerScript) or a direct JS caller.
-       The compile-time `wrapSeed` normalization only covers the leading script, so honor the
-       same authored contract (ADR-0045: a bare seed behaves like its thunk form) by VALUE via
-       the shared `routeBareSeed`; a non-async value becomes a constant computed over it.
-       Without this a raw value lands as `node.compute` and the first read calls it
-       (`node.compute is 3` — a dead render mid-stream). */
-    if (typeof compute !== 'function') {
-        const seed: unknown = compute
-        const cell = routeBareSeed(seed, false)
-        if (cell !== undefined) {
-            return cell as AsyncComputed<T>
-        }
-        compute = () => seed as T
-    }
-    /* `await` marker: an async-function thunk unwraps its promise into a tracked async cell.
-       This is the only classification the read-only primitive can make without running the
-       seed — a sync `computed` MUST stay lazy (it does not compute until first read). A stream
-       seed (`computed(getStream())`) can only be told from a sync seed by running it, which
-       laziness forbids here; the compiler routes that eager path to `createAsyncCell` directly.
-       A bare (un-awaited) promise stays a lazy `Computed<Promise<T>>` — render it with `{#await}`. */
-    if (isAsyncFunction(compute)) {
-        return createAsyncCell(compute as () => unknown, { writable: false }) as AsyncComputed<T>
-    }
-    /* Sync value or a bare (opaque) promise: the lazy computed, unchanged. */
-    const node = createComputedNode(compute as () => unknown)
-    /* Tear down with the enclosing scope, the way an effect does. A computed only
-       unlinks from its sources when it re-runs (`runNode` re-tracking); one read
-       once and then abandoned never re-runs, so absent this it would sit in its
-       source signals' subscriber lists forever — re-marked dirty on every write to
-       them — for the source's lifetime. Outside a scope it owns its own life (no-op). */
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => unlinkDeps(node))
-    }
-    return {
-        get value(): T {
-            return readNode(node) as T
-        },
-    }
-}

package/src/lib/ui/createScope.ts

@@ -1,157 +0,0 @@
-import { decodeRefJson } from '../shared/decodeRefJson.ts'
-import { docSnapshotsSlot } from '../shared/docSnapshotsSlot.ts'
-import { computed } from './computed.ts'
-import { effect } from './effect.ts'
-import { linked } from './linked.ts'
-import { CURRENT_PATH } from './runtime/CURRENT_PATH.ts'
-import { consumeSeed } from './runtime/consumeSeed.ts'
-import { createDoc } from './runtime/createDoc.ts'
-import { DOC_SEED } from './runtime/DOC_SEED.ts'
-import type { Cell } from './runtime/types/Cell.ts'
-import type { Doc } from './runtime/types/Doc.ts'
-import { state } from './state.ts'
-import { trackedComputed } from './trackedComputed.ts'
-import type { Scope } from './types/Scope.ts'
-
-/* The counter fallback for a DETACHED scope — one created outside any render (a bare
-   `scope()` on first use), where the ambient render-path is empty.
-   A rendered scope instead takes the serialization-stable render-path id (`CURRENT_PATH`,
-   route + tree position), so an async cell's warm-seed key (`${scope.id}:${index}`) is
-   stable across the SSR→client handoff; only the counter path remains merely run-unique. */
-let nextId = 0
-
-/*
-Builds a lexical scope. Its data is a document — created eagerly from `initial`,
-or (when `awaiting`) ADOPTED from the first `doc()` a component body creates under
-it, so a scope can wrap the component's own model without changing the data
-lowering. Data methods mirror `Doc` and delegate to that document; `child` nests;
-`dispose` tears the subtree down children-first.
-*/
-export function createScope(
-    initial: unknown = {},
-    parent: Scope | undefined = undefined,
-    awaiting = false,
-): Scope {
-    /* Eager unless awaiting adoption; `data()` lazily mints an empty doc if a body
-       never created one (a stateless component that still reaches for its scope). */
-    let document: Doc | undefined = awaiting ? undefined : createDoc(initial)
-    const data = (): Doc => (document ??= createDoc({}))
-    /* The scope's serialization-stable id: the ambient render-path when created inside a render
-       (route + layout + branch/row + component ordinal, composed by `withPath` at each nesting
-       site), else the run-unique counter for a detached scope. Snapshotted at creation, so a
-       nested push doesn't mutate an ancestor's id. */
-    const renderPath = CURRENT_PATH.current
-    const id =
-        renderPath !== ''
-            ? renderPath
-            : parent === undefined
-              ? `scope-${nextId++}`
-              : `${parent.id}.${nextId++}`
-    /* Doc-state warm-seed (client hydration only): a plain `state(initial)` re-runs its initializer
-       on the client, so a uuid/timestamp/random would diverge from the SSR HTML. The server snapshot
-       for this scope's render-path id is decoded here and consumed by `replace` on each slot's FIRST
-       write (the eager init), keeping the server value while the throwaway init is discarded. One-shot
-       via `consumeSeed` (two-phase, ADR-0048) — an SPA re-nav to the same path re-inits fresh, and a
-       hydration-desync throw hands the seed to the cold rebuild; empty on the server. */
-    let pendingSeed: Map<string, unknown> | undefined
-    /* `DOC_SEED` is populated only on the client by `startClient` (empty on the server), so the read
-       needs no window guard — it mirrors the async-cell warm read. */
-    const encodedSeed = consumeSeed(DOC_SEED, id)
-    if (encodedSeed !== undefined) {
-        try {
-            pendingSeed = new Map(
-                Object.entries(decodeRefJson(encodedSeed) as Record<string, unknown>),
-            )
-        } catch {
-            /* A corrupt seed falls back to a cold init — the same failure mode as a warm cell. */
-        }
-    }
-    /* Server: register this scope's doc snapshot for the `__SSR__.docs` warm-seed, keyed by its
-       render-path id. Lazy — taken at render-return, after the synchronous state inits have run.
-       Only a rendered scope (stable render-path id) registers; a detached scope (counter id) and the
-       client never do. An empty/unused doc is dropped at the stamp, so a stateless scope costs only
-       the push. */
-    if (typeof window === 'undefined' && renderPath !== '') {
-        docSnapshotsSlot.get()?.entries.push({ id, take: () => document?.snapshot() })
-    }
-    /* Adopted build teardowns (the reactivity stopper from the mount core). Disposed
-       first and in reverse on teardown — so the one `dispose` runs the order the call sites
-       hand-composed as `stop(); lexical.dispose()`. */
-    const owned: Array<() => void> = []
-    /* Context values shared down the tree, held apart from the reactive doc (which
-       a child does not inherit): keyed by name, read by the closest ancestor walk. */
-    const shared = new Map<string, unknown>()
-    /* Per-component monotonic index for the async cells constructed under this scope, in
-       declaration order — the local half of a cell's serialization-stable warm-seed key
-       (`${scope.id}:${index}`, see `createAsyncCell`). Per-scope (not global) so a client-only
-       sibling component can't shift another component's cell keys: divergence stays local. Both
-       SSR and client construct a component's cells in the same order, so the indices agree — but
-       ONLY because every cell that CAN become async draws exactly one index per construction,
-       independent of whether it materializes as async on a given render. `computed` gets this from
-       its static `isAsyncFunction` routing; `linked` decides at runtime (it draws in
-       `createAsyncCell` when its seed suspends, else RESERVES the index in its plain-`state`
-       fall-through), so a `linked` whose blocking dep is in flight on the server but warm on the
-       client still occupies its one slot on both sides. Break that "exactly one per construction"
-       rule and every downstream cell keys off-by-one across the handoff. */
-    let cellIndex = 0
-
-    /* `cell` and `nextCellIndex` are not on the public `Scope` type — `cell` is the compiler-only
-       cell-hoisting leaf; `nextCellIndex` is drawn by `createAsyncCell` for its warm-seed key.
-       Both stay on the runtime object but off the documented surface. */
-    const self: Scope & { cell: <T>(path: string) => Cell<T>; nextCellIndex: () => number } = {
-        id,
-        nextCellIndex: () => cellIndex++,
-        parent,
-        read: (path) => data().read(path),
-        /* Consume-once seed adoption: on the client's hydrating build, the FIRST write to each seeded
-           slot is the eager `state(initial)` init — swap in the server value and drop the seed, so a
-           `state(uuid())` keeps the SSR value while its throwaway fresh init is discarded. Every later
-           write (a real reassignment) and every non-seeded path passes straight through. */
-        replace: (path, value) => {
-            if (pendingSeed?.has(path)) {
-                const seeded = pendingSeed.get(path)
-                pendingSeed.delete(path)
-                return data().replace(path, seeded)
-            }
-            return data().replace(path, value)
-        },
-        add: (path, value) => data().add(path, value),
-        remove: (path) => data().remove(path),
-        apply: (patch) => data().apply(patch),
-        cell: (path) => data().cell(path),
-        derive: (path, compute) => data().derive(path, compute),
-        snapshot: () => data().snapshot(),
-        /* The reactive primitives — namespaced under the scope but AMBIENT-bound, not
-           receiver-bound: each binds whatever scope is rendering and the finest ambient
-           build window (branch/row), so the handle is namespacing, not a binding target.
-           Binding to the receiver would leak branch-local cells (see ADR-0012). */
-        state,
-        linked,
-        computed,
-        trackedComputed,
-        effect,
-        own: (dispose) => {
-            owned.push(dispose)
-        },
-        /* Reference store — no tracking, so a lookup never subscribes; reactivity comes
-           from what is shared (a scope, whose doc is reactive), not from the share. */
-        share: (key, value) => {
-            shared.set(key, value)
-        },
-        /* Closest-ancestor resolve: own map first (self can read what it shared), then
-           defer up via each scope's own `shared`. `has` distinguishes a shared
-           `undefined` from "not provided"; undefined at the root means no provider. */
-        shared: <T>(key: string): T | undefined =>
-            shared.has(key) ? (shared.get(key) as T) : parent?.shared<T>(key),
-        dispose: () => {
-            /* Stop the build's reactivity in reverse order — the order the call sites
-               hand-composed as `stop(); lexical.dispose()`. */
-            for (let index = owned.length - 1; index >= 0; index -= 1) {
-                owned[index]?.()
-            }
-            owned.length = 0
-            shared.clear()
-        },
-    }
-    return self
-}

package/src/lib/ui/dom/MATHML_NAMESPACE.ts

@@ -1,6 +0,0 @@
-/*
-The MathML foreign-content namespace — the `<math>` counterpart to `SVG_NAMESPACE`.
-The runtime reads it to namespace MathML children mounted into a `<math>` parent
-dynamically, where no parser-built ancestor namespaces them for free.
-*/
-export const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML'

package/src/lib/ui/dom/SVG_NAMESPACE.ts

@@ -1,8 +0,0 @@
-/*
-The SVG foreign-content namespace. An element created in it (or cloned from a
-parser-built `<svg>` subtree) renders as SVG; the same tag in the HTML namespace
-renders as nothing. The runtime reads it (via `effectiveChildNamespace`) to namespace
-foreign children mounted into a foreign parent dynamically — at a skeleton anchor or in a
-control-flow fragment — where no parser-built `<svg>` ancestor namespaces them for free.
-*/
-export const SVG_NAMESPACE = 'http://www.w3.org/2000/svg'

package/src/lib/ui/dom/adoptRange.ts

@@ -1,27 +0,0 @@
-import { scope } from '../runtime/scope.ts'
-import type { UiProps } from '../runtime/types/UiProps.ts'
-import { disposeRange } from './disposeRange.ts'
-import { openMarker } from './openMarker.ts'
-import { withScope } from './withScope.ts'
-
-/*
-Adopts a component's server range IN PLACE during hydration, given its already-claimed
-`start` marker and the `closeData` of the marker that ends the range. Establishes the
-child's lexical scope + render pass (`withScope`), builds claiming the existing nodes,
-then claims the end marker the build's content stops before — the hydrate half of
-`mountRange`, factored out so `mountChild`'s ADDRESSED adopt (`abide:c:PATH` brackets,
-ADR-0049) and `mountRange`'s anonymous `[`/`]` adopt share ONE implementation and can't
-drift. A build throw is leak-safe: `withScope`/`scope` dispose the partial scope before
-rethrowing, so the caller's `discardAndRebuild` recovery starts clean.
-*/
-export function adoptRange(
-    parent: Node,
-    build: (host: Node, props?: UiProps) => void,
-    props: UiProps | undefined,
-    start: Comment,
-    closeData: string,
-): { start: Comment; end: Comment; dispose: () => void } {
-    const scoped = withScope(() => scope(() => build(parent, props)))
-    const end = openMarker(parent, closeData)
-    return { start, end, dispose: disposeRange(scoped, start, end) }
-}

package/src/lib/ui/dom/anchorCursor.ts

@@ -1,25 +0,0 @@
-import { parkCursor } from '../runtime/parkCursor.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-
-/*
-Positions a skeleton-anchored control-flow block or slot. The anchor (`<!--a-->`) sits
-just before the block's range in BOTH the cloned skeleton and the server DOM, so it marks
-the block's position independently of how wide the surrounding values or earlier blocks
-render — the wall element-count positioning hits once block content varies in element
-count.
-
-Returns the CREATE insertion reference (the node right after the anchor), so the block's
-range lands at the anchor's position rather than the parent's end. On hydrate it also parks
-the parent's claim cursor there, so the block claims its own server range in place (the
-block ignores the returned reference on hydrate). `parentNode` is the located element the
-anchor was cloned into.
-*/
-// @documentation plumbing
-export function anchorCursor(anchor: Node): Node | null {
-    const reference = anchor.nextSibling
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        parkCursor(hydration, anchor.parentNode as Node, reference)
-    }
-    return reference
-}

package/src/lib/ui/dom/anchoredBranch.ts

@@ -1,153 +0,0 @@
-import { scope } from '../runtime/scope.ts'
-import { buildDetachedRange } from './buildDetachedRange.ts'
-import { removeRange } from './removeRange.ts'
-
-/*
-The single-active-branch skeleton shared by `awaitBlock` and `tryBlock`: one
-marker-bounded `[`…`]` range parked before an `anchor`, swapped as a unit when the
-block settles to a different branch. Both blocks previously copy-pasted this skeleton —
-the `active` range record, `detach` (dispose + `removeRange`), the create-path `place`
-(build a detached range and insert it before the anchor), and the hydration `adoptStrand`
-guard — even though their ESSENTIAL orchestration (await's then/catch/finally settlement,
-try's boundary recovery) is genuinely bespoke and stays in each block. This carries only
-the accidental copy-paste, notably its two subtle guards:
-
-  1. the detached-anchor short-circuit in `place` (drop a late swap whose anchor has been
-     pulled from the tree), and
-  2. the adopt-strand-dispose guard in `adoptStrand` (a partial hydration build strands a
-     live sub-scope, so ALWAYS take its disposer and run it on ANY failure before
-     rethrowing, so the caller's cold rebuild starts clean).
-
-`anchor` is a mutable field: each block parks its own anchor text node at create /
-hydrate / rebuild time via `parkAnchor` (WHERE it parks is bespoke — before the boundary
-close, after a discarded boundary, at the create-mode `before`), and `place` reads it. The
-block owns its `scopeGroup`; each built branch's disposer is tracked in it so it disposes
-on owner teardown, not only on a swap.
-*/
-export function anchoredBranch(
-    parent: Node,
-    group: { track: (dispose: () => void) => () => void },
-): {
-    anchor: Node | undefined
-    detach: () => void
-    parkAnchor: (before: Node | null) => void
-    place: (build: (host: Node) => void, wrapBuild?: (run: () => void) => void) => void
-    adoptStrand: (
-        build: (host: Node) => void,
-        afterBuild: () => { start: Comment; end: Comment },
-    ) => void
-} {
-    let active: { start: Comment; end: Comment; dispose: () => void } | undefined
-    let anchor: Node | undefined
-
-    const detach = (): void => {
-        if (active !== undefined) {
-            active.dispose()
-            /* `removeRange` evicts the markers AND everything between them via the end
-               marker's LIVE parent — not the captured `parent`, which (when the block is a
-               bare child of a control-flow branch) is the branch's build fragment, emptied
-               into the document once the enclosing block placed it. */
-            removeRange(active.start, active.end)
-            active = undefined
-        }
-    }
-
-    /* Replace the current content with a freshly-built branch, before the anchor. The branch
-       builds into a detached `[`…`]`-bracketed fragment (so any content — components, text,
-       nested blocks — appends freely), the same create primitive the keyed-list runtimes use,
-       which lands as a marker-bounded range the next swap detaches with `removeRange`.
-       `wrapBuild` (tryBlock only) wraps just the build call so the guarded branch's effects
-       build under the ambient error boundary; detach/insert stay outside it. */
-    const place = (build: (host: Node) => void, wrapBuild?: (run: () => void) => void): void => {
-        /* Backstop for a swap whose anchor has been detached from the tree. The block's own
-           generation guard is the PRIMARY defense — it drops a late settle after the owner
-           tears down — but a gap (e.g. a nested hydration `adopt` that aborts to `rebuildCold`,
-           leaving the inner block's range removed while its guard stays live) can still route a
-           late swap here with `anchor` already pulled out of the DOM. Inserting before a node
-           that is no longer a child of any parent throws `NotFoundError` from `insertBefore` —
-           surfacing as a process-fatal unhandled rejection under Bun. A detached anchor
-           unambiguously means the block is gone, so drop the swap. */
-        if (anchor !== undefined && anchor.parentNode === null) {
-            return
-        }
-        detach()
-        const namespaceParent = anchor?.parentNode ?? parent
-        let built: ReturnType<typeof buildDetachedRange> | undefined
-        const run = (): void => {
-            built = buildDetachedRange(namespaceParent, build)
-        }
-        if (wrapBuild !== undefined) {
-            wrapBuild(run)
-        } else {
-            run()
-        }
-        const range = built as ReturnType<typeof buildDetachedRange>
-        const tracked = group.track(range.dispose)
-        namespaceParent.insertBefore(range.fragment, anchor ?? null)
-        active = { start: range.start, end: range.end, dispose: tracked }
-    }
-
-    /* Adopt an SSR branch in place (its content claims the existing nodes). Adoption is
-       guarded: a build that can't claim the server markup — a resume value that didn't
-       round-trip, a nested-adopt claim desync — throws, and the caller recovers by rebuilding
-       cold. But the partial build may have already created a live sub-scope (an inner `await`'s
-       effect/guard, a subscription) before it threw; letting the throw escape `scope()` would
-       strand that scope's disposer (unreachable → never disposed), leaking the effect AND
-       leaving its guard un-bumped so a late settle stays "live". So capture the build's error,
-       ALWAYS take the returned disposer, and dispose it on ANY failure before rethrowing — the
-       caller's cold rebuild then starts from a clean slate. `afterBuild` (bespoke per block)
-       claims/creates the range markers around the adopted nodes and parks the anchor, returning
-       the range's start/end; it runs only after a clean build. */
-    const adoptStrand = (
-        build: (host: Node) => void,
-        afterBuild: () => { start: Comment; end: Comment },
-    ): void => {
-        let dispose: (() => void) | undefined
-        try {
-            let buildFailed = false
-            let buildError: unknown
-            dispose = group.track(
-                scope(() => {
-                    try {
-                        build(parent)
-                    } catch (error) {
-                        buildFailed = true
-                        buildError = error
-                    }
-                }),
-            )
-            if (buildFailed) {
-                throw buildError
-            }
-            const range = afterBuild()
-            active = { start: range.start, end: range.end, dispose }
-        } catch (error) {
-            /* `dispose` (the group-tracked wrapper) is idempotent; running it here tears the
-               partial branch scope down and drops it from the group so the cold rebuild doesn't
-               inherit a stranded scope, then the caller falls back to a cold build. */
-            dispose?.()
-            throw error
-        }
-    }
-
-    /* Park a fresh empty text node as the branch's swap anchor at `before` (null appends) —
-       the create/hydrate/rebuild triple every block repeated by hand. */
-    const parkAnchor = (before: Node | null): void => {
-        const node = document.createTextNode('')
-        anchor = node
-        parent.insertBefore(node, before)
-    }
-
-    return {
-        get anchor(): Node | undefined {
-            return anchor
-        },
-        set anchor(node: Node | undefined) {
-            anchor = node
-        },
-        detach,
-        parkAnchor,
-        place,
-        adoptStrand,
-    }
-}

package/src/lib/ui/dom/appendSnippet.ts

@@ -1,75 +0,0 @@
-import { snippetPayload } from '../../shared/snippet.ts'
-import { effect } from '../effect.ts'
-import { SNIPPET_CLOSE, SNIPPET_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { scope } from '../runtime/scope.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
-import { fillBefore } from './fillBefore.ts'
-import { openMarker } from './openMarker.ts'
-import { replaceRange } from './replaceRange.ts'
-
-/*
-A `{snippet(args)}` interpolation: mount the branded builder's nodes in a range
-bounded by two comment markers. The content builds straight into `parent` —
-sequential build order places it correctly among siblings — and its effects join
-the surrounding component scope, so the body's reactive reads update fine-grained.
-
-The CALL is reactive in its arguments: an effect re-reads `read()` so a change in
-the argument expression (e.g. `{row(items())}`) tears the range down and rebuilds
-with fresh args. `read()` returns a fresh builder closing over freshly-evaluated
-args each call, so there is nothing to diff — the snippet re-mounts as a unit, the
-same coarse model as `when`/`each` (args behave like props). The body's own reads
-stay fine-grained within a single mount; the outer effect tracks only the args,
-since `fillBefore` wraps the body in its own scope.
-
-On hydrate the builder runs against the server-rendered nodes between the
-`<!--abide:snippet-->`/`<!--/abide:snippet-->` markers — its `skeleton`/`appendText`
-claim them in place — and the effect's first run is a no-op that only subscribes to
-the args; a later argument change rebuilds fresh (the SSR markers stay as the range).
-*/
-// @documentation plumbing
-export function appendSnippet(parent: Node, read: () => unknown): void {
-    const hydration = RENDER.hydration
-    /* Mount scopes register with the owner so they dispose on owner teardown, not
-       only on an argument-driven rebuild via replaceRange. */
-    const group = scopeGroup()
-    let dispose: (() => void) | undefined
-
-    /* The branded builder, or undefined for anything else (a non-snippet value
-       mounts nothing — the range stays empty until the args yield a builder). */
-    const builderOf = (): ((host: Node) => void) | undefined => {
-        const payload = snippetPayload(read())
-        return typeof payload === 'function' ? (payload as (host: Node) => void) : undefined
-    }
-
-    let open: Comment
-    let close: Comment
-    if (hydration !== undefined) {
-        open = openMarker(parent, SNIPPET_OPEN)
-        const builder = builderOf()
-        if (builder !== undefined) {
-            dispose = group.track(scope(() => builder(parent))) // content claims the SSR nodes in place
-        }
-        close = openMarker(parent, SNIPPET_CLOSE)
-    } else {
-        open = openMarker(parent, SNIPPET_OPEN)
-        close = openMarker(parent, SNIPPET_CLOSE)
-        const builder = builderOf()
-        if (builder !== undefined) {
-            dispose = group.track(fillBefore(close, builder))
-        }
-    }
-
-    /* The initial mount is built above (create or hydrate); the first effect run only
-       subscribes to the args via `builderOf`, then later argument changes rebuild. */
-    let first = true
-    effect(() => {
-        const builder = builderOf()
-        if (first) {
-            first = false
-            return
-        }
-        const next = replaceRange(open, close, dispose, builder)
-        dispose = next !== undefined ? group.track(next) : undefined
-    })
-}

package/src/lib/ui/dom/appendStatic.ts

@@ -1,26 +0,0 @@
-import { claimChild } from '../runtime/claimChild.ts'
-import { parkCursor } from '../runtime/parkCursor.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { claimText } from './claimText.ts'
-
-/*
-A static (non-reactive) text node under `parent`: created and appended (create
-mode), or claimed from the server-rendered text (hydrate mode) — the shared
-`claimText` asserts, splits the merged SSR node at this literal's length so the
-next claim lines up, and advances. Nothing is bound since the text never changes.
-A static always renders on the server, so a non-text node at the cursor is a
-tolerated desync: advance past it (assertClaimedText's domain is a text mismatch;
-a structural one is claimExpected's).
-*/
-// @documentation plumbing
-export function appendStatic(parent: Node, value: string, splitAlways = false): void {
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        if (claimText(hydration, parent, value, splitAlways) === undefined) {
-            const node = claimChild(hydration, parent)
-            parkCursor(hydration, parent, node === null ? null : node.nextSibling)
-        }
-        return
-    }
-    parent.appendChild(document.createTextNode(value))
-}