@abide/abide 0.57.1 → 0.100.0

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

@@ -1,118 +0,0 @@
-import { isAsyncCell } from '../../shared/isAsyncCell.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-import { createEffectNode } from '../runtime/createEffectNode.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { readCell } from './readCell.ts'
-
-/*
-The subject of an `{#await X}` block, normalised so the block AWAITS an async cell's
-resolution instead of peeking its `undefined`-while-pending value (ADR-0047). `{#await}`
-means "wait", so when its subject is a `computed`/`linked` async cell the block should show
-its pending branch until the cell settles, then `{:then}` with the resolved value — but a
-cell reference otherwise lowers to `$$readCell(cell)`, a PEEK, which reads `undefined` while
-pending and fires `{:then}` with `undefined` (the `{#if}`/`{#switch}` cell subjects avoid this
-with a `cellPending` guard; `{#await}` had no equivalent).
-
-The compiler wraps ONLY a bare cell-reference subject in this (a plain-promise subject like
-`{#await getFoo()}` bypasses it), so `subject` is always some cell the `cellReadNames` set
-named — of two runtime shapes:
-
-  - **an async cell** (`AsyncComputed`/`AsyncState` — a `computed`/`linked` whose seed unwraps a
-    promise/stream). Pending (in flight, no value) → a PROMISE resolving to the cell's value once
-    it settles (rejecting with its error); the `pending()` read subscribes the reading block, so a
-    client reseed/`cache.invalidate` re-runs it and the SSR `renderToStream` awaits the returned
-    promise. Settled (a value, or a held value being refreshed — SWR) → the value now, so `{:then}`
-    shows it with no pending flash; an error with no retained value throws (→ `{:catch}`/`{#try}`).
-  - **a lazy `Computed`/`State`/derive** holding a bare promise (`computed(getFoo())` with no
-    `await` stays an opaque promise-holder, not an async cell) → read through `readCell` to its
-    `.value`, i.e. the promise itself, which `awaitBlock`/`renderToStream` then awaits — exactly the
-    pre-existing `{#await computedPromise}` behaviour, preserved.
-*/
-// @documentation plumbing
-export function awaitSubject(subject: unknown): unknown {
-    if (!isAsyncCell(subject)) {
-        /* A lazy `Computed`/`State`/derive reference: unwrap to its `.value` (the held promise or
-           value), which the await block awaits — never peeked to `undefined`. */
-        return readCell(subject)
-    }
-    const cell = subject as AsyncComputed<unknown> & {
-        settled?: () => Promise<unknown> | undefined
-    }
-    /* `pending()` — in flight AND no value — is the only state that WAITS; a settled or
-       refreshing cell reads its retained value now (SWR). The read subscribes the caller. */
-    if (cell.pending()) {
-        const inFlight = cell.settled?.()
-        if (inFlight !== undefined) {
-            /* Await the in-flight settle, then read the freshly-stored value (a `settled` cell
-               writes its value before this `.then` runs — it registered its handler first); an
-               error there rejects this promise → `{:catch}`. EXCEPT a `SuspenseSignal`
-               rejection, which is a PAUSE, not a failure (an async seed's sync prefix read a
-               pending blocking dep — the cell swallows it and stays pending, reseeding once the
-               dep settles); rejecting would render `{:catch SuspenseSignal}`, so keep waiting
-               for the real settle instead. */
-            return inFlight.then(
-                () => settledValue(cell),
-                (error) => {
-                    if (error instanceof SuspenseSignal) {
-                        return whenSettled(cell)
-                    }
-                    throw error
-                },
-            )
-        }
-        /* Pending with NO in-flight promise — a stream before its first frame, or a
-           `SuspenseSignal`-paused seed (both leave `pending()` true with `settled()` cleared).
-           Resolving now would read `undefined` into `{:then}` — the exact flash ADR-0047 kills;
-           wait for the cell to actually settle. */
-        return whenSettled(cell)
-    }
-    /* Settled: an error with no retained value becomes a REJECTED promise (never a synchronous
-       throw), so `awaitBlock`/`renderToStream` route it to `{:catch}` rather than letting it
-       escape the block; otherwise the retained value now. `settledValue` is the ONE statement
-       of the value-else-error rule for both the settled and the just-settled arms. */
-    try {
-        return settledValue(cell)
-    } catch (error) {
-        return Promise.reject(error)
-    }
-}
-
-/* The value of an in-flight cell once it settles: its retained value, or a throw when it holds
-   only an error — the throw rejects the awaiting promise, routing to `{:catch}`/`{#try}`. */
-function settledValue(cell: AsyncComputed<unknown>): unknown {
-    const value = cell.peek()
-    if (value === undefined) {
-        const error = cell.error()
-        if (error !== undefined) {
-            throw error
-        }
-    }
-    return value
-}
-
-/* A promise for the cell's NEXT settle, driven by the graph: an effect watches `pending()` and
-   resolves with the settled value (or rejects with its error) the moment it flips false — the
-   waiter for the states that hold no in-flight promise to chain on. The write that settles the
-   cell flushes effects synchronously (client and SSR alike), so this needs no polling; the
-   effect disposes itself on a microtask once done. */
-function whenSettled(cell: AsyncComputed<unknown>): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-        let done = false
-        let dispose: (() => void) | undefined
-        const settle = (): void => {
-            if (done || cell.pending()) {
-                return
-            }
-            done = true
-            try {
-                resolve(settledValue(cell))
-            } catch (error) {
-                reject(error)
-            }
-            /* Deferred: disposing mid-run would unlink the node while `runNode` is still
-               tracking it. */
-            queueMicrotask(() => dispose?.())
-        }
-        dispose = createEffectNode(settle)
-    })
-}

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

@@ -1,22 +0,0 @@
-/*
-The parent half of a component `bind:prop={target}`: annotates the prop's value
-thunk with a `set` write-back channel, so the same `() => value` entry every prop
-compiles to ALSO carries a setter. A read-only consumer calls the thunk (`$props[key]?.()`)
-and gets the value exactly as for a plain prop — the `set` simply rides along, invisible
-to code that doesn't look for it (`restProps`/`mergeProps`/`spreadProps` pass the thunk
-through untouched). The child upgrades the prop to a writable cell (`bindableProp`) only
-when it writes or forwards it, and reaches this setter through `.set`.
-
-`read`/`write` are the caller's lowered bind accessors — an lvalue target reads as
-itself and writes by assignment, a `{ get, set }` accessor reads via `get()` and writes
-via `set(next)` — so a component bind accepts the same targets an element bind does.
-*/
-// @documentation plumbing
-export function bindProp<T>(
-    read: () => T,
-    write: (next: T) => void,
-): (() => T) & { set: (next: T) => void } {
-    const thunk = read as (() => T) & { set: (next: T) => void }
-    thunk.set = write
-    return thunk
-}

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

@@ -1,48 +0,0 @@
-import { effect } from '../effect.ts'
-import { on } from './on.ts'
-
-/*
-Two-way `bind:value` for a `<select>`. The bound value drives the selection through
-a reactive effect, and the user's pick writes back on `change`. A plain `bind:value`
-would set `el.value` once, up front — but a `<select>`'s options are frequently
-mounted AFTER the binding runs (a `{#for}` child, an async list), and the browser
-silently drops a `value` assignment naming an option that isn't present yet. So a
-`MutationObserver` re-applies the selection whenever the option set changes (its
-callback runs in a microtask before paint, so no visible flash), disconnected on
-teardown. `multiple` switches single-value (`el.value`) semantics for array
-membership: each option's `selected` is set from the bound array, and the write-back
-collects `selectedOptions` back into an array.
-*/
-// @documentation plumbing
-export function bindSelectValue(
-    element: HTMLSelectElement,
-    read: () => unknown,
-    write: (value: unknown) => void,
-    multiple: boolean,
-): void {
-    /* Push the bound value into the DOM selection. */
-    const apply = (): void => {
-        if (multiple) {
-            const selected = (read() as unknown[]) ?? []
-            for (const option of element.options) {
-                option.selected = selected.includes(option.value)
-            }
-        } else {
-            element.value = read() as string
-        }
-    }
-    /* Read the current DOM selection back out for the write. */
-    const collect = (): unknown =>
-        multiple ? Array.from(element.selectedOptions, (option) => option.value) : element.value
-    /* Re-apply whenever the bound value changes (this effect tracks `read`). */
-    effect(apply)
-    /* Re-apply whenever the option set changes — covers `{#for}`/async options that
-       mount after the first apply. This effect reads nothing reactive, so it runs once
-       and only its teardown (disconnect) fires on dispose. */
-    effect(() => {
-        const observer = new MutationObserver(apply)
-        observer.observe(element, { childList: true, subtree: true })
-        return () => observer.disconnect()
-    })
-    on(element, 'change', () => write(collect()))
-}

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

@@ -1,47 +0,0 @@
-import { linked } from '../linked.ts'
-import type { State } from '../runtime/types/State.ts'
-import type { UiProps } from '../runtime/types/UiProps.ts'
-
-/*
-The child half of a two-way prop: the writable cell a component gets for a prop it
-WRITES or forwards to another `bind:` target. A prop the child only reads stays a
-read-only derive (unchanged, cheap); this upgrade is emitted only for the props the
-compiler sees written, so the common case pays nothing.
-
-Whether the prop is actually two-way is decided at construction from what the parent
-passed:
-  • Bound (`bind:prop` on the parent) — the value thunk carries a `set` (see `bindProp`),
-    so the cell is a pass-through accessor: reads pull the parent's value (tracking its
-    reactive source), writes go straight upstream. The parent's target is the single
-    source of truth, so no local copy is kept.
-  • Unbound (plain `prop={value}`, or the prop was never passed) — no setter exists, so
-    the cell degrades to a local `linked` cell seeded from the parent value: it reseeds
-    when the parent value changes and holds local writes in between. The component still
-    works standalone; its writes just don't flow anywhere.
-
-`fallback` supplies the destructure's `= default` when the prop is absent/undefined,
-matching the read-only derive's `?? default`.
-*/
-// @documentation plumbing
-export function bindableProp<T>(props: UiProps, key: string, fallback?: () => T): State<T> {
-    const entry = (props as Record<string, unknown>)[key]
-    const read = (): T => {
-        const value = typeof entry === 'function' ? (entry as () => T)() : (entry as T)
-        return (value === undefined ? fallback?.() : value) as T
-    }
-    const setter =
-        typeof entry === 'function' ? (entry as { set?: (next: T) => void }).set : undefined
-    if (setter !== undefined) {
-        /* Bound: a pure pass-through to the parent's target — no local store. */
-        return {
-            get value(): T {
-                return read()
-            },
-            set value(next: T) {
-                setter(next)
-            },
-        }
-    }
-    /* Unbound: a local reseeding cell — writes echo locally, reseed on parent change. */
-    return linked(read) as State<T>
-}

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

@@ -1,31 +0,0 @@
-import { RANGE_CLOSE, RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { scope } from '../runtime/scope.ts'
-import { enterNamespace } from './enterNamespace.ts'
-
-/*
-Builds a `[ … ]`-bounded content range into a DETACHED fragment under a fresh reactive
-scope, then returns the markers, the fragment, and the scope disposer — leaving
-INSERTION to the caller. The create-path range builder for the keyed list runtimes
-(`each` / `eachAsync`) and `awaitBlock` (branch swaps): `each` holds the fragment in
-`pending` for deferred placement (its reconcile reorders rows), `eachAsync` inserts it
-immediately at the stream anchor (arrival order). All need the same bracketed-fragment
-build, so it lives here once.
-
-Unlike `openMarker`, this never touches a live parent or the hydrate claim cursor — the
-markers are created fresh and parked in a fragment — so it is a pure CREATE primitive;
-the hydrate paths claim their server markers directly. `namespaceParent` sets the
-ambient foreign namespace for the build (a row's svg/math children read it off the
-fragment's eventual parent), matching `fillBefore`/`enterNamespace`.
-*/
-export function buildDetachedRange(
-    namespaceParent: Node,
-    build: (into: Node) => void,
-): { start: Comment; end: Comment; fragment: DocumentFragment; dispose: () => void } {
-    const start = document.createComment(RANGE_OPEN)
-    const end = document.createComment(RANGE_CLOSE)
-    const fragment = document.createDocumentFragment()
-    fragment.appendChild(start)
-    const dispose = enterNamespace(namespaceParent, () => scope(() => build(fragment)))
-    fragment.appendChild(end)
-    return { start, end, fragment, dispose }
-}

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

@@ -1,24 +0,0 @@
-import { isAsyncCell } from '../../shared/isAsyncCell.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-
-/*
-Whether a control-flow subject (`{#if}`/`{#switch}`) is a still-loading async cell — no
-value yet, no error (`AsyncComputed.pending()`). The compiler pairs it with the value read
-for a bare async subject: while `cellPending(cell)` is true the block renders NO branch, so
-"still loading" never collapses into the falsy branch (`{#if getProfile()}` does not flash
-its `{:else}` before the promise settles). A settled falsy value (or a held value being
-refreshed) is NOT pending, so it still routes to its branch. Non-async subjects (a plain
-value, a sync `computed`) are never pending — the block reads them directly.
-
-Reading `pending()` subscribes the block's effect to the cell's in-flight/has-value facets,
-so the block re-renders when the value arrives. An errored cell is NOT pending: the paired
-value read (`$$readCell`) then throws its `AsyncCellError`, routing the error to the nearest
-`{#try}` exactly as a bare read does.
-*/
-// @documentation plumbing
-export function cellPending(cell: unknown): boolean {
-    if (isAsyncCell(cell)) {
-        return (cell as AsyncComputed<unknown>).pending()
-    }
-    return false
-}

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

@@ -1,38 +0,0 @@
-import { claimChild } from '../runtime/claimChild.ts'
-import { parkCursor } from '../runtime/parkCursor.ts'
-import type { HydrationCursor } from '../runtime/types/HydrationCursor.ts'
-import { assertClaimedText } from './assertClaimedText.ts'
-
-/*
-Claims one text consumer's portion of the merged SSR text node at the parent's cursor:
-assert the node begins with `value` (or the split below misaligns and orphans the tail),
-split the node at the value's length so the remainder stays claimable, and advance past
-the claimed portion. `splitAlways` splits even on an exact-length consume — a non-final
-consumer in a run must leave a node behind for its sibling (an interpolation rendering
-empty otherwise has no node and the next claim grabs the wrong sibling); the final
-consumer keeps the cheaper split-only-when-shorter path.
-
-Returns undefined WITHOUT moving the cursor when the cursor doesn't hold a text node —
-a value that rendered empty on the server emitted no text node, so the cursor sits on
-the following element/comment or past the end. The caller owns that miss policy (bind a
-synthesized node, or skip); a text node is detected by `splitText`, not `nodeType`, so
-the test mini-dom is covered too.
-*/
-export function claimText(
-    hydration: HydrationCursor,
-    parent: Node,
-    value: string,
-    splitAlways: boolean,
-): Text | undefined {
-    const claimed = claimChild(hydration, parent)
-    if (claimed === null || typeof (claimed as Text).splitText !== 'function') {
-        return undefined
-    }
-    const node = claimed as Text
-    assertClaimedText(node, value)
-    if (splitAlways ? value.length <= node.data.length : value.length < node.data.length) {
-        node.splitText(value.length)
-    }
-    parkCursor(hydration, parent, node.nextSibling)
-    return node
-}

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

@@ -1,16 +0,0 @@
-/*
-Tears down a control-flow range: disposes its reactive scope, then removes every
-node between the `start` and `end` markers (exclusive). Walking between the markers
-at clear time — rather than tracking a captured node list — is what lets a branch
-hold dynamic nested blocks: nodes a nested block inserted after the initial build
-still sit between the markers, so they're removed too.
-*/
-export function clearBetween(start: Node, end: Node, dispose?: () => void): void {
-    dispose?.()
-    let node = start.nextSibling
-    while (node !== null && node !== end) {
-        const next = node.nextSibling
-        end.parentNode?.removeChild(node)
-        node = next
-    }
-}

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

@@ -1,38 +0,0 @@
-import { claimRun } from '../runtime/claimRun.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { foreignWrapperTag } from './foreignWrapperTag.ts'
-import { templateFor } from './templateFor.ts'
-
-/*
-Appends a fully-static subtree (one or more top-level nodes) under `parent` — what
-the compiler emits for an element subtree that carries no bindings, control flow, or
-listeners (its bound sibling, `skeleton`, carries the same clone plus located holes).
-The skeleton string is generated by the same rules as the SSR back-end, so it is
-byte-identical to the server markup.
-
-Create mode: clone the cached template once per mount — a single deep clone (native
-in the browser) instead of N create/append calls. Hydrate mode: nothing is built;
-the server already rendered this exact markup, so it only advances the parent's
-claim cursor past the run's top-level nodes (nothing inside binds, so none need
-claiming individually). The node count comes from the parsed template, which has
-the same top-level node count as the server markup.
-*/
-// @documentation plumbing
-export function cloneStatic(parent: Node, html: string): void {
-    /* When `parent` is a foreign element built dynamically (not part of this static
-       run's own parser-built subtree), the run's markup has no foreign ancestor of
-       its own, so a bare `<path>` would parse into the HTML
-       namespace. Parse it inside a matching `<svg>`/`<math>` wrapper and clone the
-       wrapper's children — the parser namespaces them correctly. */
-    const wrapper = foreignWrapperTag(parent)
-    const template = templateFor(wrapper === undefined ? html : `<${wrapper}>${html}</${wrapper}>`)
-    const source = wrapper === undefined ? template.content : (template.content.firstChild as Node)
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        claimRun(hydration, parent, source.childNodes.length)
-        return
-    }
-    for (const child of source.childNodes) {
-        parent.appendChild(child.cloneNode(true))
-    }
-}

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

@@ -1,14 +0,0 @@
-/* A comment node's data, or undefined for elements/text. A comment is a node that is
-   neither an element (`hasAttribute`) nor a text node (`splitText`); the mini-dom
-   exposes no `nodeType`, so detect by method. Shared by every marker-range scan
-   (`skeleton`'s anchor walk, `outlet`'s close-marker skip) so the convention is probed
-   one way everywhere. */
-export function commentData(node: Node): string | undefined {
-    if (
-        typeof (node as Element).hasAttribute === 'function' ||
-        typeof (node as Text).splitText === 'function'
-    ) {
-        return undefined
-    }
-    return (node as Comment).data
-}

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

@@ -1,34 +0,0 @@
-import { commentData } from './commentData.ts'
-import { markerDepthDelta } from './markerDepthDelta.ts'
-
-/*
-A sibling list's DEPTH-0 nodes — those belonging to THIS skeleton's own structure, excluding
-any node inside a block/component's `[`…`]` / `abide:` range (depth > 0), whose anchors belong
-to that range's OWN skeleton. The realized-DOM analogue of the compiler's fresh-context
-boundary: the shared anchor walk (`walkAnchorOrder`) classifies one node at a time and so can't
-skip a sibling RUN, so the marker-depth skip lives here, feeding the walk only own-skeleton
-nodes. In create mode the clone is shallow (no markers built yet), so depth stays 0 and every
-node is returned — a plain document scan.
-*/
-export function depthZeroNodes(nodes: ArrayLike<Node>): Node[] {
-    const own: Node[] = []
-    let depth = 0
-    for (let index = 0; index < nodes.length; index += 1) {
-        const node = nodes[index] as Node
-        const data = commentData(node)
-        if (data === undefined) {
-            if (depth === 0) {
-                own.push(node)
-            }
-            continue
-        }
-        const delta = markerDepthDelta(data)
-        if (delta !== 0) {
-            depth += delta
-        } else if (depth === 0) {
-            /* A non-marker comment (this skeleton's own `a` anchor) at depth 0. */
-            own.push(node)
-        }
-    }
-    return own
-}

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

@@ -1,23 +0,0 @@
-import type { HydrationCursor } from '../runtime/types/HydrationCursor.ts'
-import { withoutHydration } from '../runtime/withoutHydration.ts'
-import { discardBoundary } from './discardBoundary.ts'
-
-/*
-The shared divergence-recovery mechanics of every named-boundary block: remove the SSR
-boundary (open marker through `closeData`, parking the cursor after it) and run a FRESH
-build at the freed position with the claim cursor cleared — so the build's helpers create
-nodes instead of claiming the discarded ones. `build` receives the node after the removed
-boundary (its insertion reference; null = parent's end). Each block keeps its own POLICY —
-when to give up on adoption (a resume value that didn't round-trip, a rejected guarded
-build, a boundary whose streamed fragment never arrived) — and delegates the dance here.
-*/
-export function discardAndRebuild<T>(
-    hydration: HydrationCursor,
-    parent: Node,
-    open: Node | null,
-    closeData: string,
-    build: (after: Node | null) => T,
-): T {
-    const after = discardBoundary(parent, open, closeData, hydration)
-    return withoutHydration(() => build(after))
-}

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

@@ -1,46 +0,0 @@
-import { parkCursor } from '../runtime/parkCursor.ts'
-import type { HydrationCursor } from '../runtime/types/HydrationCursor.ts'
-
-/* Remove an SSR boundary — open marker through close marker (inclusive) — and park
-   the hydration cursor on the node after it, returning that node. A fresh run then
-   replaces the boundary in place without duplicating the server's pending shell.
-   Shared by the await and try blocks (await ignores the return). */
-export function discardBoundary(
-    parent: Node,
-    open: Node | null,
-    closeData: string,
-    hydration: HydrationCursor,
-): Node | null {
-    /* Nothing to discard (no open marker) — park the cursor and return, as before. */
-    if (open === null) {
-        parkCursor(hydration, parent, null)
-        return null
-    }
-    /* Locate the close marker WITHOUT mutating first. Removing as we walk would, on a
-       marker/id desync (the await/try block-id counter drifting between server and
-       client), delete every remaining sibling before discovering there is no match —
-       silently wiping unrelated later content. Throw AT the divergence like `outlet`
-       instead, rather than over-clear to end-of-parent. */
-    let close: Node | null = open
-    while (close !== null && (close as { data?: string }).data !== closeData) {
-        close = close.nextSibling
-    }
-    if (close === null) {
-        throw new Error(
-            `[abide] hydration desync: boundary open marker has no matching close "${closeData}" — the server DOM is truncated or the block id drifted.`,
-        )
-    }
-    const after = close.nextSibling
-    /* Remove open..close inclusive now that the range is known-bounded. */
-    let node: Node | null = open
-    while (node !== null) {
-        const next: Node | null = node.nextSibling
-        parent.removeChild(node)
-        if (node === close) {
-            break
-        }
-        node = next
-    }
-    parkCursor(hydration, parent, after)
-    return after
-}

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

@@ -1,18 +0,0 @@
-import type { Scope } from '../types/Scope.ts'
-import { clearBetween } from './clearBetween.ts'
-
-/*
-The standard teardown for a marker-bounded range (component, layout/page boundary,
-slot): dispose its lexical scope (which stops the content's reactivity first, then its
-nested children and capabilities), and clear the nodes between the markers — leaving the
-markers in place so a later rebuild (navigation, control-flow re-fill) refills the range.
-Shared by every range mount
-(`fillRange`, `mountRange`, `fillBoundary`) so the one disposer contract lives in a
-single place.
-*/
-export function disposeRange(scoped: { lexical: Scope }, start: Comment, end: Comment): () => void {
-    return () => {
-        scoped.lexical.dispose()
-        clearBetween(start, end)
-    }
-}

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

@@ -1,29 +0,0 @@
-import type { AnchorRole, AnchorWalkAdapter } from '../compile/walkAnchorOrder.ts'
-import { ANCHOR } from '../runtime/RANGE_MARKER.ts'
-import { commentData } from './commentData.ts'
-import { depthZeroNodes } from './depthZeroNodes.ts'
-import { isElement } from './isElement.ts'
-
-/*
-The realized-DOM side of the shared anchor-ordering rule (`walkAnchorOrder`). Classifies each
-recovered node by the SAME positions the template-AST side numbered (`templateAnchorAdapter`),
-so `scanAnchors`'s collection lines up with the compiler's `anIndex`.
-
-An `a` comment is this skeleton's own anchor (one position); an element is an own-skeleton
-container to descend; anything else contributes nothing. `childrenOf` returns only depth-0
-nodes — a nested block/component's marker-bracketed content is skipped exactly as the compiler
-stops at a fresh-context boundary.
-*/
-export const domAnchorAdapter: AnchorWalkAdapter<Node> = {
-    classify: (node: Node): AnchorRole => {
-        const data = commentData(node)
-        if (data === ANCHOR) {
-            return { kind: 'anchor', positions: [node] }
-        }
-        if (data === undefined && isElement(node)) {
-            return { kind: 'recurse' }
-        }
-        return { kind: 'skip' }
-    },
-    childrenOf: (node: Node): readonly Node[] => depthZeroNodes(node.childNodes),
-}

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

@@ -1,20 +0,0 @@
-import type { ElementRole, ElementWalkAdapter } from '../compile/walkElementOrder.ts'
-import { HOLE_ATTRIBUTE } from '../runtime/HOLE_ATTRIBUTE.ts'
-import { isElement } from './isElement.ts'
-
-/*
-The parsed-DOM side of the shared element-hole numbering rule (`walkElementOrder`). Classifies
-each node of the parsed skeleton by the SAME holes the template-AST side numbered
-(`templateElementAdapter`), so the runtime's collected element paths line up with the compiler's
-`elIndex`. Runs over the SHALLOW parsed skeleton (blocks/components/slots are already `<!--a-->`
-anchors, not elements), so a `HOLE_ATTRIBUTE` element is a hole and every element is descended;
-everything else skips. The collected paths resolve against the expanded server DOM separately
-(`resolveElementHole`, which skips nested ranges there).
-*/
-export const domElementAdapter: ElementWalkAdapter<Node> = {
-    classify: (node: Node): ElementRole =>
-        isElement(node)
-            ? { kind: 'element', isHole: node.hasAttribute(HOLE_ATTRIBUTE) }
-            : { kind: 'skip' },
-    childrenOf: (node: Node): readonly Node[] => Array.from(node.childNodes),
-}