@abide/abide 0.58.0 → 0.100.0

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

@@ -1,19 +0,0 @@
-import { MATHML_NAMESPACE } from './MATHML_NAMESPACE.ts'
-import { SVG_NAMESPACE } from './SVG_NAMESPACE.ts'
-
-/*
-The foreign namespace that element children of `node` inherit — `SVG_NAMESPACE` under
-an svg, `MATHML_NAMESPACE` under math — or undefined for ordinary HTML. `<foreignObject>`
-is SVG's re-entry point back into HTML, so its children are HTML despite its own SVG
-namespace.
-*/
-export function inheritedNamespace(node: Node): string | undefined {
-    const namespace = (node as Element).namespaceURI
-    if (namespace === SVG_NAMESPACE && (node as Element).localName !== 'foreignObject') {
-        return SVG_NAMESPACE
-    }
-    if (namespace === MATHML_NAMESPACE) {
-        return MATHML_NAMESPACE
-    }
-    return undefined
-}

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

@@ -1,6 +0,0 @@
-/* A comment node carrying exactly `data`. Empty-child check distinguishes the
-   `<!--data-->` marker from an element that happens to expose a `data` property.
-   Shared by the marker-range scanners in appendText. */
-export function isComment(node: Node, data: string): boolean {
-    return (node as { data?: string }).data === data && node.childNodes.length === 0
-}

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

@@ -1,6 +0,0 @@
-/* An element carries `hasAttribute`; comment/text nodes do not. Detected by method (not
-   `nodeType`) so every skeleton walk runs under the test mini-dom too. Shared by the
-   element-hole path resolver (`skeleton`) and both realized-DOM walk adapters. */
-export function isElement(node: Node): node is Element {
-    return typeof (node as Element).hasAttribute === 'function'
-}

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

@@ -1,19 +0,0 @@
-import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-
-/* The block-range nesting rule, the single source both marker-depth scans share
-   (`depthZeroNodes`'s anchor filter and `skeleton`'s `elementChildAt` element walk):
-   `+1` opening a range, `-1` closing one, `0` for any other comment. A control-flow
-   block's rendered content sits between an OPEN and CLOSE comment — `[`…`]` for each
-   rows / if / switch / slot ranges, named `abide:…`…`/abide:…` for await / try /
-   snippet / html / component-mount (`abide:c:`, ADR-0049); the skeleton's own anchor
-   (`a`) sits OUTSIDE any range, so it scores `0`. Keeping the rule here means a new
-   marker family updates one place, so the two scans can never disagree on what nests. */
-export function markerDepthDelta(data: string): number {
-    if (data === RANGE_CLOSE || data.startsWith('/abide:')) {
-        return -1
-    }
-    if (data === RANGE_OPEN || data.startsWith('abide:')) {
-        return 1
-    }
-    return 0
-}

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

@@ -1,29 +0,0 @@
-import { commentData } from './commentData.ts'
-import { markerDepthDelta } from './markerDepthDelta.ts'
-
-/*
-The `]` close marker that balances the `[` range opened by `open`, found by a DEPTH-counting
-scan over the following siblings. A branch's content can hold nested `[`…`]` (if/switch/each)
-and `abide:`…`/abide:` (await/try/snippet) ranges — `markerDepthDelta` scores each open `+1`
-and each close `-1`, so an INNER close is skipped and only the one that returns to depth 0 is
-this range's own. Unlike `discardBoundary`'s named-boundary scan (a unique id-suffixed close
-string), the `[`/`]` alphabet is non-unique, so the depth count is what tells nested closes
-apart. Throws on a desync (no balancing close) rather than over-scan to end-of-parent.
-*/
-export function matchingRangeClose(open: Node): Node {
-    let depth = 1
-    let node = open.nextSibling
-    while (node !== null) {
-        const data = commentData(node)
-        if (data !== undefined) {
-            depth += markerDepthDelta(data)
-            if (depth === 0) {
-                return node
-            }
-        }
-        node = node.nextSibling
-    }
-    throw new Error(
-        '[abide] hydration desync: a control-flow range open marker "[" has no balancing close "]" — the server DOM is truncated or a block diverged.',
-    )
-}

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

@@ -1,32 +0,0 @@
-import type { UiProps } from '../runtime/types/UiProps.ts'
-
-/*
-Composes a child's props from ordered layers — explicit prop runs (`{ name: () =>
-value }` thunk maps), `{...spread}` layers (`spreadProps`), and a trailing slot
-layer (`children`) — into one prop bag, last layer wins per key (source order, like
-JSX). A key resolves by scanning layers in reverse for the first that carries it, so
-an explicit prop after a spread overrides it and vice-versa. Emitted only when a
-component carries a spread; the plain object literal stays the path otherwise.
-*/
-// @documentation plumbing
-export function mergeProps(layers: Record<string | symbol, unknown>[]): UiProps {
-    return new Proxy(Object.create(null), {
-        get(_target, key) {
-            for (let index = layers.length - 1; index >= 0; index -= 1) {
-                const layer = layers[index]
-                if (layer !== undefined && key in layer) {
-                    return layer[key]
-                }
-            }
-            return undefined
-        },
-        has: (_target, key) => layers.some((layer) => key in layer),
-        /* Enumerable across every layer (deduped), so `restProps` can collect a
-           parent-spread bag's keys. */
-        ownKeys: () => [...new Set(layers.flatMap((layer) => Reflect.ownKeys(layer)))],
-        getOwnPropertyDescriptor: (_target, key) =>
-            layers.some((layer) => key in layer)
-                ? { enumerable: true, configurable: true }
-                : undefined,
-    }) as UiProps
-}

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

@@ -1,30 +0,0 @@
-import { scope } from '../runtime/scope.ts'
-import { withScope } from './withScope.ts'
-
-/*
-Mounts a top-level page/layout into `host` (the router's outlet/root element): runs
-`build(host, props)` under an ownership scope so every binding it creates is
-collected, and returns a disposer that stops all reactivity and clears the host.
-`build` appends its nodes to `host` (via the dom bindings below). This is the runtime
-entry the router calls; a NESTED child instead mounts as a marker range (see
-`mountRange`), so it leaves no wrapper element.
-
-Brackets a render pass so the outermost mount resets the block-id counter and an
-inlined child component's mount continues it — keeping await/try ids aligned with
-the SSR stream (see `enterRenderPass`).
-*/
-// @documentation plumbing
-export function mount(
-    host: Element,
-    build: (host: Element, props: unknown) => void,
-    props?: unknown,
-): () => void {
-    /* Establish this component's lexical scope (nested, `awaiting` so it adopts the model
-       doc the build's first `doc()` creates) and render pass, run the build under it, and
-       restore the previous scope — the shared mount core (see `withScope`). */
-    const { lexical } = withScope(() => scope(() => build(host, props)))
-    return () => {
-        lexical.dispose()
-        host.textContent = ''
-    }
-}

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

@@ -1,129 +0,0 @@
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { claimChild } from '../runtime/claimChild.ts'
-import { OWNER } from '../runtime/OWNER.ts'
-import { RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { reportHydrationDivergence } from '../runtime/reportHydrationDivergence.ts'
-import type { UiComponent } from '../runtime/types/UiComponent.ts'
-import { withOptionalPath } from '../runtime/withOptionalPath.ts'
-import { adoptRange } from './adoptRange.ts'
-import { commentData } from './commentData.ts'
-import { discardAndRebuild } from './discardAndRebuild.ts'
-import { mountRange } from './mountRange.ts'
-import { openMarker } from './openMarker.ts'
-
-/*
-The client mount for a child component — a DUAL-MODE adopter, and the ONLY child mount the
-compiler emits. A child mounts as a marker-bounded range at `before` in `parent` (no wrapper
-element, so the child's root is a true direct child — see `mountRange`), its dispose filed
-with the mounting owner so scope and DOM leave together on teardown.
-
-The server decides per render whether a HOISTABLE child (ADR-0039) inlined (fast/settled) or
-streamed (still-pending), and the client build can't know which — nor whether this child was
-hoistable at all — so hydrate mode probes the cursor:
-
-  - `<!--abide:c:CHILDPATH-->` next → the server INLINED the child in its ADDRESSED boundary
-    (ADR-0049 — every non-streamed child); claim the boundary open, adopt the range in place,
-    claim the close. A structural desync INSIDE the child (a client-true / server-false `{#if}`
-    gating an element's presence) throws through the build — recover by discarding just this
-    boundary and remounting the child fresh (`discardAndRebuild`), so the desync costs one
-    component instead of reaching the router and discarding the whole page.
-  - `<!--abide:await:CHILDPATH-->` next → the server STREAMED it; `__abideSwap` has already
-    spliced the child's `<!--[-->…<!--]-->` between the boundary markers before the bundle
-    ran, so claim the boundary open, adopt the inner range in place, claim the boundary close.
-  - no hydration (a client-side navigation) → a plain create-mode mount.
-
-CHILDPATH is the child's render-path — `withPath(ordinal, () => CURRENT_PATH.current)` —
-computed the same way the server's `renderPath(ordinal)` wrote the boundary id, so the two
-agree with no counter. A streamed child re-mounts (no RESUME value of its own — the boundary
-is html-only); nested `{#await}` blocks and async cells inside it adopt through their own
-existing channels.
-*/
-// @documentation plumbing
-export function mountChild(
-    parent: Node,
-    factory: UiComponent,
-    props: Parameters<UiComponent>[1],
-    before: Node | null = null,
-    /* The compiler's source-order ordinal for this `<Child/>` mount site — pushed onto the render
-       path so the child's scope (and its cells) get a serialization-stable id under this parent
-       (two same-type siblings differ by ordinal; the same site across `{#each}` rows differs by the
-       row key the each block already pushed). Absent (a non-compiled caller) → no path segment. */
-    ordinal?: number,
-): void {
-    const run = <T>(build: () => T): T => withOptionalPath(ordinal, build)
-    /* Both boundary ids are the child's render-path, computed here exactly as the server wrote it
-       (`renderPath(ordinal)`), so SSR and client agree with no counter. */
-    const childPath = run(() => CURRENT_PATH.current)
-    const addressed = { open: `abide:c:${childPath}`, close: `/abide:c:${childPath}` }
-    /* Mount the child's range in its ADDRESSED boundary (ADR-0049) — the create path and the
-       inline-recovery rebuild, so a client-only mount is byte-congruent with the SSR markup and a
-       desync has a named close to discard to. */
-    const mountAddressed = (where: Node | null): { dispose: () => void } =>
-        run(() => mountRange(parent, factory.build, props, where, addressed))
-    /* Mount into an anonymous `[ … ]` range — the swapped-in inner range of a STREAMED child, whose
-       own address is the outer `abide:await` pair. */
-    const mountAnon = (where: Node | null): { dispose: () => void } =>
-        run(() => mountRange(parent, factory.build, props, where))
-
-    const hydration = RENDER.hydration
-    if (hydration === undefined) {
-        /* Call mountAddressed() first, THEN register its dispose — pushing the call result inline
-           would short-circuit (never mounting) when there is no owner. */
-        const handle = mountAddressed(before)
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-
-    /* Probe the cursor without consuming it, and classify what the server emitted here by the
-       marker data. */
-    const cursor = claimChild(hydration, parent)
-    const marker = cursor !== null ? commentData(cursor) : undefined
-
-    if (marker !== `abide:await:${childPath}`) {
-        /* INLINE (ADR-0049) — claim the addressed open, adopt the child's range in place. A
-           structural desync inside the child throws through the build; recover by discarding just
-           THIS boundary and remounting fresh, so the desync costs one component, not the page. The
-           partial scope a throwing build stranded is already disposed (`withScope`/`scope`), so the
-           cold rebuild starts clean. */
-        const open = openMarker(parent, addressed.open)
-        try {
-            const handle = run(() =>
-                adoptRange(parent, factory.build, props, open, addressed.close),
-            )
-            OWNER.current?.push(handle.dispose)
-        } catch (error) {
-            reportHydrationDivergence('component boundary recovered — remounting', {
-                path: childPath,
-                error,
-            })
-            const handle = discardAndRebuild(hydration, parent, open, addressed.close, (after) =>
-                mountAddressed(after),
-            )
-            OWNER.current?.push(handle.dispose)
-        }
-        return
-    }
-
-    /* STREAMED — claim the boundary open (advances the cursor to the swapped-in `[`). */
-    const open = openMarker(parent, `abide:await:${childPath}`)
-    const inner = claimChild(hydration, parent)
-    const warm = inner !== null && commentData(inner) === RANGE_OPEN
-    if (warm) {
-        const handle = mountAnon(before)
-        openMarker(parent, `/abide:await:${childPath}`)
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-    /* COLD (defensive — renderToStream drains every await before closing, so a warm boundary is the
-       deterministic path). The fragment never arrived: discard the empty boundary and create-mount
-       the child fresh at that position; its streamed cells resolve post-mount via receiveStreamedCell. */
-    const handle = discardAndRebuild(
-        hydration,
-        parent,
-        open,
-        `/abide:await:${childPath}`,
-        (after) => mountAnon(after),
-    )
-    OWNER.current?.push(handle.dispose)
-}

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

@@ -1,48 +0,0 @@
-import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import type { UiProps } from '../runtime/types/UiProps.ts'
-import { adoptRange } from './adoptRange.ts'
-import { fillRange } from './fillRange.ts'
-import { openMarker } from './openMarker.ts'
-
-/*
-Mounts a nested child component as a marker-bounded range — the wrapper-free
-replacement for the old `<abide-name display:contents>` host. A component positions
-and hydrates exactly like a control-flow block: its content lives in a `[ … ]` range,
-so the child's real root is a TRUE direct child of the parent and structural CSS
-(`>`, `:first-child`, `space-x`, grid placement) reaches it with no indirection —
-which `display:contents` could never give, since it hides the wrapper from layout but
-not from the selector tree.
-
-Create fills the range before the end marker (`fillRange`); hydrate claims the server
-range in place (claim the start marker, build claims the content, claim the end
-marker — mirrors `mountSlot`/`when`). `before` (a skeleton-located node, the block's
-`anchorCursor`) places the range among static siblings on create; hydrate ignores it
-(the claim cursor drives placement). Returns the markers + a disposer so the hot path
-can rebuild in place.
-
-`bracket` names the range's boundary markers. It defaults to the anonymous `[`/`]` a
-control-flow re-fill and the swapped-in inner range of a streamed child use; `mountChild`
-passes the ADDRESSED `abide:c:PATH` pair (ADR-0049) so a component's range carries its own
-render-path — the same markers on create and SSR (congruent) and a named close a desync can
-discard to.
-*/
-// @documentation plumbing
-export function mountRange(
-    parent: Node,
-    build: (host: Node, props?: UiProps) => void,
-    props: UiProps | undefined,
-    before: Node | null = null,
-    bracket: { open: string; close: string } = DEFAULT_BRACKET,
-): { start: Comment; end: Comment; dispose: () => void } {
-    const hydration = RENDER.hydration
-    const start = openMarker(parent, bracket.open, before)
-    if (hydration === undefined) {
-        const end = openMarker(parent, bracket.close, before)
-        return fillRange(start, end, build, props)
-    }
-    /* Hydrate: adopt the server range in place, claiming `bracket.close` as the end marker. */
-    return adoptRange(parent, build, props, start, bracket.close)
-}
-
-const DEFAULT_BRACKET = { open: RANGE_OPEN, close: RANGE_CLOSE }

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

@@ -1,38 +0,0 @@
-import { RANGE_CLOSE, RANGE_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'
-
-/*
-Mounts a component's `<slot>` content as a marker-bounded range, so a slot positions among
-static siblings exactly like a control-flow block — by `before` (create) or the claim
-cursor (hydrate). `render` appends the parent-supplied `children`, or the slot's own
-fallback when none was passed; it runs once (a slot never toggles), so there is no effect or
-re-render — the markers exist only to delimit the range for create insertion and hydrate
-claiming.
-
-Create fills the range before the end marker; hydrate adopts the server range in place
-(claiming from the parked cursor). Mirrors `when` without the conditional swap.
-*/
-// @documentation plumbing
-export function mountSlot(
-    parent: Node,
-    render: (host: Node) => void,
-    before: Node | null = null,
-): void {
-    const hydration = RENDER.hydration
-    /* The slot content's scope, registered with the owner so its effects/listeners
-       dispose on owner teardown (a navigation) — the slot never toggles, so the
-       group only ever tracks this one child. */
-    const group = scopeGroup()
-    openMarker(parent, RANGE_OPEN, before)
-    if (hydration !== undefined) {
-        group.track(scope(() => render(parent))) // content claims the SSR range in place
-        openMarker(parent, RANGE_CLOSE)
-    } else {
-        const end = openMarker(parent, RANGE_CLOSE, before)
-        group.track(fillBefore(end, render))
-    }
-}

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

@@ -1,122 +0,0 @@
-import { effect } from '../effect.ts'
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { parkCursor } from '../runtime/parkCursor.ts'
-import { RANGE_CLOSE, RANGE_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 { withPathFrom } from '../runtime/withPathFrom.ts'
-import { clearBetween } from './clearBetween.ts'
-import { fillBefore } from './fillBefore.ts'
-import { matchingRangeClose } from './matchingRangeClose.ts'
-import { openMarker } from './openMarker.ts'
-import { replaceRange } from './replaceRange.ts'
-
-/*
-The shared lifecycle of every single-slot control-flow block (`when`, `switchBlock`):
-a marker-bounded RANGE that holds at most one piece of content at a time, swapped as a
-unit when a `key` changes. The block supplies a `key()` thunk (the identity of the
-chosen branch — `'then'|'else'` for `when`, the case index for `switchBlock`) and a
-`contentFor(key)` resolver returning that branch's builder, or `undefined` for an
-empty branch. This module owns the marker setup, the hydrate-vs-create fork, and the
-swap effect with its reentrancy/teardown dance — the structure both blocks copy-pasted.
-
-The chosen branch builds through `scope` (directly on hydrate, via `fillBefore` on a
-swap), which builds untracked — so a raw reactive read in the branch content doesn't
-subscribe the swap effect; only `key()` (which reads the block's source) drives the
-toggle. The branch's own interpolations still track, each through its own effect.
-
-On hydrate it adopts the server-rendered range: claim the start marker, run the chosen
-branch in place (its content claims the existing nodes), then claim the end marker. The
-effect's first run sees the same key and is a no-op; later changes clear the range and
-build fresh into a fragment.
-
-`before` (a static node located by the skeleton) places the range among siblings on
-create, so the block sits before a static suffix rather than at the parent's end.
-Hydrate ignores it — the claim cursor (positioned past the prefix) drives placement.
-*/
-export function mountSwappableRange<Key>(
-    parent: Node,
-    key: () => Key,
-    contentFor: (key: Key) => ((parent: Node) => void) | undefined,
-    before: Node | null = null,
-    /* The chosen branch MAY differ between SSR and the client's first render — set only for an
-       ASYNC subject (a bare async `{#if}`/`{#switch}`, or an async cond-chain branch), whose cell
-       can be settled on the server (a barrier-baked value) yet pending on the client, so each side
-       selects a different branch. Adopting SSR nodes in place then orphans them (they are neither
-       claimed nor cleared) and the next swap duplicates. When set, hydration DISCARDS the SSR range
-       content and builds the client's branch fresh instead — correct regardless of what the server
-       rendered. Left false for a sync range, where SSR and client always agree and in-place
-       adoption (node reuse, preserved focus/scroll) is safe. */
-    mayDiverge = false,
-): void {
-    const hydration = RENDER.hydration
-    /* The live branch's scope, registered with the owner so it disposes on owner
-       teardown — not only on a branch swap via replaceRange. */
-    const group = scopeGroup()
-    let dispose: (() => void) | undefined
-    let activeKey: Key
-    let end: Comment
-
-    /* Capture the render path at construction (this block's ancestry), and wrap each chosen
-       branch's builder so its content builds under `basePath/branchKey` — the key is the swap
-       discriminator (`'then'`/`'else'` or a case index), so a component/cell in one branch gets a
-       distinct, stable id from the other, re-established on every reactive swap (when the ambient
-       path is gone). An empty branch (`undefined`) needs no wrap. */
-    const basePath = CURRENT_PATH.current
-    const chosenFor = (branchKey: Key): ((parent: Node) => void) | undefined => {
-        const content = contentFor(branchKey)
-        if (content === undefined) {
-            return undefined
-        }
-        return (host) => withPathFrom(basePath, String(branchKey), () => content(host))
-    }
-
-    const start = openMarker(parent, RANGE_OPEN, before)
-    if (hydration !== undefined && mayDiverge) {
-        /* Async range: don't trust the SSR content to match the client's branch. Discard the
-           server's rendered range (balanced `[`…`]`), park the cursor on the real close so it
-           claims correctly, then build the client's chosen branch FRESH (`fillBefore` clears the
-           claim cursor for the build). Usually the client is pending here → nothing built → an
-           empty range the later reactive swap fills, matching a clean create. */
-        activeKey = key()
-        const chosen = chosenFor(activeKey)
-        const matchedEnd = matchingRangeClose(start)
-        clearBetween(start, matchedEnd)
-        parkCursor(hydration, parent, matchedEnd)
-        end = openMarker(parent, RANGE_CLOSE)
-        if (chosen !== undefined) {
-            dispose = group.track(fillBefore(end, chosen))
-        }
-    } else if (hydration !== undefined) {
-        activeKey = key()
-        const chosen = chosenFor(activeKey)
-        if (chosen !== undefined) {
-            dispose = group.track(scope(() => chosen(parent))) // content claims the SSR nodes in place
-        }
-        end = openMarker(parent, RANGE_CLOSE)
-    } else {
-        end = openMarker(parent, RANGE_CLOSE, before)
-        activeKey = key()
-        const chosen = chosenFor(activeKey)
-        if (chosen !== undefined) {
-            dispose = group.track(fillBefore(end, chosen))
-        }
-    }
-
-    effect(() => {
-        const next = key()
-        if (next === activeKey) {
-            return
-        }
-        activeKey = next
-        const chosen = chosenFor(next)
-        /* Null `dispose` before `replaceRange` builds the new branch: a reentrant swap
-           during that build (an effect in the new content writing the source) would
-           otherwise re-enter with the already-disposed disposer and clear it twice. */
-        const prior = dispose
-        dispose = undefined
-        const built = replaceRange(start, end, prior, chosen)
-        dispose = built !== undefined ? group.track(built) : undefined
-    })
-}

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

@@ -1,19 +0,0 @@
-/*
-Moves a contiguous node range — `start` through `end` inclusive — to sit just
-before `ref`, preserving order. Each node's next sibling is captured before the
-move (insertBefore relocates it, changing `nextSibling`). Used by the keyed `each`
-to reposition a row whose content is a range rather than a single node.
-*/
-export function moveRange(start: Node, end: Node, ref: Node | null): void {
-    const parent = ref?.parentNode ?? end.parentNode
-    if (parent === null) {
-        return
-    }
-    let node: Node | null = start
-    const stop: Node | null = end.nextSibling
-    while (node !== null && node !== stop) {
-        const next: Node | null = node.nextSibling
-        parent.insertBefore(node, ref)
-        node = next
-    }
-}

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

@@ -1,65 +0,0 @@
-import type { Doc } from '../runtime/types/Doc.ts'
-import { readCall } from './readCall.ts'
-
-/*
-An in-place-mutating container method lowered on a reactive-document value. The
-doc-access lowering rewrites e.g. `model.items.splice(i, 1)` to
-`$$mutateDocContainer(model, "items", "splice", [i, 1])` rather than the bare
-`$$readCall(model.read("items"), …)` it emits for non-mutating calls. The reason:
-`read` returns the live tree value by reference, so a bare `.splice()`/`.sort()`/
-`.add()`/`.set()`/… would mutate the document in place while never emitting a
-patch — so no reader would re-render (`.push` is the one already-handled exception,
-lowered to `add` patches). Cloning the container, applying the mutation to the copy,
-and writing it back through `replace` emits a real patch: readers wake.
-
-Covers the three mutable containers the doc codec serializes (encodeRefJson):
-Array (cloned by `slice`), Map (`new Map`) and Set (`new Set`) — the mutating
-method names are disjoint across the three (`pop`/`splice`/… vs `add`/`set`/…), so
-the caller routes them all here and the actual kind is decided at runtime by the
-value's type, no compile-time check needed. Element identity is preserved for
-untouched entries (a shallow copy), so a keyed `{#for}` reconciles instead of
-rebuilding. The native method's return value (spliced-out elements, the new
-length, the deleted flag, …) is returned unchanged.
-*/
-// @documentation plumbing
-export function mutateDocContainer(
-    doc: Doc,
-    path: string,
-    member: string,
-    args: unknown[],
-): unknown {
-    const current = doc.read<unknown>(path)
-    const copy = cloneContainer(current)
-    /* Not a container we clone (array/Map/Set) — fall back to the guarded in-place call so
-       the author still gets readCall's authored-scope error message (a plain doc object has
-       no methods, so this is the same throw the bare call would raise). */
-    if (copy === undefined) {
-        return readCall(current, path, member, args)
-    }
-    const method = (copy as unknown as Record<string, unknown>)[member]
-    if (typeof method !== 'function') {
-        throw new TypeError(
-            `abide: cannot call .${member}() — "${path}".${member} is not a function (got ${typeof method})`,
-        )
-    }
-    const returned = (method as (...callArgs: unknown[]) => unknown).apply(copy, args)
-    doc.replace(path, copy)
-    return returned
-}
-
-/* A shallow clone of a mutable doc container, or undefined when the value is not one — the
-   shallow copy preserves element/entry identity so keyed reconciliation survives the patch. */
-function cloneContainer(
-    current: unknown,
-): unknown[] | Map<unknown, unknown> | Set<unknown> | undefined {
-    if (Array.isArray(current)) {
-        return current.slice()
-    }
-    if (current instanceof Map) {
-        return new Map(current)
-    }
-    if (current instanceof Set) {
-        return new Set(current)
-    }
-    return undefined
-}

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

@@ -1,33 +0,0 @@
-import { batch } from '../runtime/batch.ts'
-import { CURRENT_SCOPE } from '../runtime/CURRENT_SCOPE.ts'
-import { inScope } from '../runtime/inScope.ts'
-import { OWNER } from '../runtime/OWNER.ts'
-
-/*
-Attaches an event listener and registers its removal with the current ownership
-scope, so a component's listeners detach when it disposes. This is the runtime
-target for an `onclick={…}` binding; the handler body is where the compiler's
-lowered patches (`model.replace(...)`) run. The handler is pinned to the scope it
-was attached under, so an ambient `scope()` inside it resolves the component, not
-whatever is current when the event fires.
-*/
-// @documentation plumbing
-export function on(element: Element, type: string, handler: EventListener): void {
-    /* A caller that omits an optional `on*` prop forwards it as undefined, yet the
-       compiler still emits this on() call — so skip attaching a non-function rather
-       than invoke undefined when the event fires (e.g. input/keydown on a search box,
-       which would throw "handler is not a function" on every keystroke). */
-    if (typeof handler !== 'function') {
-        return
-    }
-    const captured = CURRENT_SCOPE.current
-    /* Coalesce the handler's writes: a handler setting several signals re-runs each
-       dependent effect once on batch exit, not once per write (the unbatched default
-       flushed eagerly per `trigger`). Stays synchronous — flush runs at handler-end
-       before it returns, so the causal stack (dispatch → handler → effects) is intact. */
-    const wrapped: EventListener = (event) => inScope(captured, () => batch(() => handler(event)))
-    element.addEventListener(type, wrapped)
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => element.removeEventListener(type, wrapped))
-    }
-}

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

@@ -1,22 +0,0 @@
-import { claimMarker } from '../runtime/claimMarker.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-
-/*
-Opens a control-flow range boundary: a comment marker. Create mode appends a fresh
-comment to `parent`; hydrate mode claims the server-rendered marker at the parent's
-cursor and advances it. Markers are real comment nodes so they survive in the SSR
-HTML and the block can claim them positionally on hydrate — the boundary that lets
-a branch hold ANY content (components, text, nested blocks, snippets) as a range,
-rather than a list of single nodes.
-*/
-export function openMarker(parent: Node, data: string, before: Node | null = null): Comment {
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        return claimMarker(hydration, parent, `control-flow marker "${data}"`)
-    }
-    const node = document.createComment(data)
-    /* `before` (a node already in `parent`) places the block among static siblings —
-       its content lands at that position; without it the marker appends (block at tail). */
-    parent.insertBefore(node, before)
-    return node
-}