@abide/abide 0.58.0 → 0.100.0

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

@@ -1,253 +0,0 @@
-import { effect } from '../effect.ts'
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { claimChild } from '../runtime/claimChild.ts'
-import { claimMarker } from '../runtime/claimMarker.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { scope } from '../runtime/scope.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
-import type { State } from '../runtime/types/State.ts'
-import { withoutHydration } from '../runtime/withoutHydration.ts'
-import { withPathFrom } from '../runtime/withPathFrom.ts'
-import { state } from '../state.ts'
-import { buildDetachedRange } from './buildDetachedRange.ts'
-import { moveRange } from './moveRange.ts'
-import { removeRange } from './removeRange.ts'
-import type { EachRow } from './types/EachRow.ts'
-import { withSuspense } from './withSuspense.ts'
-
-/*
-Keyed list binding — the runtime for `<template each key=>`. Each row is a content
-RANGE bounded by two comment markers, so a row holds anything — elements,
-components, text, nested control-flow — not just one node. Rows live before a
-trailing anchor so positioning is relative to the each itself. An effect tracks
-`items()` and reconciles by key: a new key builds a row in its own ownership scope,
-a departed key disposes and its range is removed. Keying by identity lets a row
-keep its range and inner effects across a reorder.
-
-Placement walks the desired list *backwards* from the trailing anchor, holding a
-cursor at the node each row should precede; a row already ending there is left
-untouched, so a stable list does zero DOM moves and an append exactly one — only an
-out-of-place row's range is moved. Departed rows are pruned *before* placement.
-
-On hydrate the SSR rows are already in place and in order: each row claims its
-markers and content where they sit (no reordering), the anchor parks after them,
-and the first reconcile is skipped.
-*/
-// @documentation plumbing
-export function each<T>(
-    parent: Node,
-    items: () => Iterable<T>,
-    keyOf: (item: T) => string,
-    /* The row receives its item and its position as reactive cells (not raw snapshots): a
-       re-key with a changed value, or a reorder that shifts the row, sets the matching cell
-       and re-runs the row's effects in place. The compiler binds the `as`/`index` names to
-       read them; a direct caller reads `item.value` / `index.value`. */
-    render: (parent: Node, item: State<T>, index: State<number>) => void,
-    before: Node | null = null,
-    /* Whether the each has an explicit `by` key. A KEYED row takes its stable key as its
-       render-path segment (survives reorders/reloads); a KEYLESS row (no `by`, so `keyOf`
-       returns the raw item identity — unstable) takes its POSITION instead, which is at least
-       deterministic SSR↔client for a single render. Absent → keyless (a direct caller). */
-    keyed = false,
-): void {
-    const rows = new Map<string, EachRow>()
-    /* This each's render-path ancestry, captured at construction; every row builds under
-       `basePath/segment` so a component/cell in a row gets a stable id, re-established on a
-       post-mount reconcile (when the ambient path is gone). */
-    const basePath = CURRENT_PATH.current
-    /* Monotonic reconcile-pass id. Each reconcile stamps every surviving row with the
-       current pass, so prune is a `row.gen !== pass` int compare instead of building a
-       `Set` of present keys every reconcile. */
-    let generation = 0
-    /* Each row's scope, registered with the owner so every live row disposes on owner
-       teardown (the effect's own disposer only unsubscribes it from `items()`). */
-    const group = scopeGroup()
-    /* Persistent reconcile scratch, reused across passes so a steady-state reconcile
-       allocates nothing: `keys` holds each desired key (one `keyOf` call per item), `resolved`
-       its surviving row (or undefined → build). Both are sized to the current list each pass
-       and their stale tail is cleared, so a shrinking list retains no disposed-row refs. */
-    const keys: string[] = []
-    const resolved: (EachRow | undefined)[] = []
-
-    /* Build a row's range. Hydrate mode (only while the claim cursor is active —
-       read fresh, since a row built by a post-hydration reconcile must create, not
-       claim): claim the start marker, build content in place, claim the end marker.
-       Create mode: markers + content in a fragment, held in `pending` until placement
-       inserts it. */
-    /* Reconcile runs inside the effect below; the row build doesn't subscribe it
-       (`scope` builds untracked), so a raw reactive read in the row content — e.g. a
-       nested `<script>` body — can't re-reconcile the whole list. Only `items()` drives
-       the each; each row's own interpolations track through their own effects. */
-    const buildRow = (item: T, position: number): EachRow => {
-        /* Item and position are held in reactive cells the row reads, so a later re-key with
-           a changed value, or a reorder that shifts the row, updates it in place (see the
-           reconcile below) instead of rebuilding it. */
-        const cell = state(item) as State<unknown>
-        const indexCell = state(position)
-        /* Keyed rows key their path on the stable key; keyless on the position. */
-        const segment = keyed ? keyOf(item) : position
-        const hydration = RENDER.hydration
-        if (hydration !== undefined) {
-            const start = claimMarker(hydration, parent, 'each row start marker')
-            const dispose = group.track(
-                scope(() =>
-                    withPathFrom(basePath, segment, () =>
-                        render(parent, cell as State<T>, indexCell),
-                    ),
-                ),
-            )
-            const end = claimMarker(hydration, parent, 'each row end marker')
-            return { start, end, dispose, cell, indexCell }
-        }
-        /* Shared detached-range create primitive: a `[ … ]` fragment built under `parent`'s
-           foreign namespace (so svg/math row children are namespaced, not built as HTML),
-           held in `pending` until placement inserts it. */
-        const { start, end, fragment, dispose } = buildDetachedRange(parent, (host) =>
-            withPathFrom(basePath, segment, () => render(host, cell as State<T>, indexCell)),
-        )
-        return { start, end, dispose: group.track(dispose), cell, indexCell, pending: fragment }
-    }
-
-    /* Place a row so its range ends just before `cursor`: insert a fresh row's
-       fragment, or move an existing range only when it isn't already there. Insert
-       via `cursor`'s LIVE parent, not the captured `parent` — when this `each` is a
-       bare child of a control-flow branch, `parent` is the branch's build fragment,
-       which the enclosing block has since emptied into the document. */
-    const placeBefore = (row: EachRow, cursor: Node): void => {
-        if (row.pending !== undefined) {
-            ;(cursor.parentNode ?? parent).insertBefore(row.pending, cursor)
-            row.pending = undefined
-            return
-        }
-        if (row.end.nextSibling !== cursor) {
-            moveRange(row.start, row.end, cursor)
-        }
-    }
-
-    /* Read the source, tolerating a pending blocking `await` read (a SuspenseSignal): treat a
-       suspend as an empty list — identical to the undefined-while-pending peek (ADR-0032 D3) — so
-       the each renders no rows until the source resolves. The read still tracked its cell, so the
-       driving effect re-runs on settle. */
-    const readSource = (): Iterable<T> | undefined =>
-        withSuspense<Iterable<T> | undefined>(items, undefined)
-
-    let anchor: Node
-    /* When hydrating, the first effect run must NOT reconcile — the rows it would
-       build are already adopted in place below. */
-    let adopting = false
-    const hydration = RENDER.hydration
-    if (hydration !== undefined) {
-        let position = 0
-        /* An undefined source renders an empty list, not a throw — a `{#for x in promise}`
-           whose lifted source peeks undefined while pending (ADR-0032 D3). */
-        for (const item of readSource() ?? []) {
-            const key = keyOf(item)
-            const row = buildRow(item, position) // claims the SSR row where it sits
-            if (rows.has(key)) {
-                /* Duplicate key: this row already claimed its SSR markers, but the map holds
-                   one row per key (create mode keeps the FIRST built row too). Dispose+remove
-                   this later duplicate so it isn't orphaned on screen forever — the reconcile
-                   prune only reaches rows still in the map. */
-                row.dispose()
-                removeRange(row.start, row.end)
-            } else {
-                rows.set(key, row)
-            }
-            position += 1
-        }
-        anchor = document.createTextNode('')
-        parent.insertBefore(anchor, claimChild(hydration, parent))
-        adopting = true
-    } else {
-        anchor = document.createTextNode('')
-        /* `before` (a static node located by the skeleton) places the row anchor among
-           siblings on create, so rows land before a static suffix; null appends (tail). */
-        parent.insertBefore(anchor, before)
-    }
-
-    effect(() => {
-        /* Read (subscribe) every run, including the adopting one. Materialize a
-           non-array iterable to an array so a generator yields fresh each run. */
-        const source = readSource()
-        if (adopting) {
-            adopting = false // rows already adopted in document order; nothing to move
-            return
-        }
-        /* All SSR rows were adopted in the pre-effect loop, so every reconcile build is
-           create mode. Clear the global claim cursor for the duration: a synchronous
-           write that reconciles *mid-hydrate* (RENDER.hydration still active — e.g. a
-           page setting shared state during the hydrate pass) would otherwise make
-           buildRow and its inner row render claim SSR nodes that don't exist for a
-           freshly keyed row. withoutHydration restores the outer cursor after, so the
-           enclosing hydrate pass is untouched (mirrors awaitBlock/tryBlock). */
-        withoutHydration(() => {
-            /* Undefined source → empty list (see the hydration loop, ADR-0032 D3). */
-            const list = source == null ? [] : Array.isArray(source) ? source : [...source]
-            const count = list.length
-            generation += 1
-            const pass = generation
-            /* Fill the reused scratch and resolve each desired key to its surviving row once,
-               here, stamping it with this pass — so prune below is an int compare (no `Set`)
-               and the placement walk reuses the resolved row instead of a second `rows.get`.
-               Halving the map lookups per reconcile is a real win once the harness's O(n)
-               `nextSibling` no longer swamps it. `undefined` marks a key with no surviving row
-               — a build. One `keyOf` call per item, cached in `keys` for the placement walk. */
-            for (let index = 0; index < count; index += 1) {
-                const key = keyOf(list[index] as T)
-                keys[index] = key
-                const row = rows.get(key)
-                if (row !== undefined) {
-                    row.gen = pass
-                }
-                resolved[index] = row
-            }
-            /* Drop the previous pass's longer tail so a shrunk list retains no disposed-row
-               refs and the scratch stays sized to the live list. */
-            if (keys.length > count) {
-                keys.length = count
-                resolved.length = count
-            }
-            /* Prune departed rows first (those the resolve loop didn't reach this pass) so
-               their ranges don't sit between survivors and throw off the in-place sibling
-               checks below. */
-            for (const [key, row] of rows) {
-                if (row.gen !== pass) {
-                    row.dispose()
-                    removeRange(row.start, row.end)
-                    rows.delete(key)
-                }
-            }
-            /* Walk backwards from the anchor: `cursor` is the node the current row must
-               precede. A row already ending there keeps its place; only out-of-order (or
-               freshly built) rows move. */
-            let cursor: Node = anchor
-            for (let index = list.length - 1; index >= 0; index -= 1) {
-                let row = resolved[index]
-                if (row === undefined) {
-                    /* Duplicate key within this list: a row for this key was already built
-                       earlier in this pass. Building another and rows.set-ing it would
-                       overwrite the map entry for the first, orphaning it — the prune loop
-                       only reaches rows still in the map, so it would leak on screen forever.
-                       Collapse to one row (like the hydration path above), skipping this
-                       index rather than inserting an unreachable duplicate. */
-                    const built = rows.get(keys[index] as string)
-                    if (built !== undefined && built.gen === pass) {
-                        continue
-                    }
-                    row = buildRow(list[index] as T, index)
-                    row.gen = pass
-                    rows.set(keys[index] as string, row)
-                } else {
-                    /* Surviving key: push the (possibly new) item and position into the row's
-                       cells. Both write through `Object.is`, so an unchanged item/position is a
-                       no-op and a changed one re-runs only the row's own effects — the row's DOM
-                       is never rebuilt. A reorder thus repaints only the moved rows' `index`. */
-                    row.cell.value = list[index]
-                    row.indexCell.value = index
-                }
-                placeBefore(row, cursor)
-                cursor = row.start
-            }
-        })
-    })
-}

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

@@ -1,188 +0,0 @@
-import { effect } from '../effect.ts'
-import { CURRENT_BOUNDARY } from '../runtime/CURRENT_BOUNDARY.ts'
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { claimChild } from '../runtime/claimChild.ts'
-import { generationGuard } from '../runtime/generationGuard.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { scopeGroup } from '../runtime/scopeGroup.ts'
-import type { State } from '../runtime/types/State.ts'
-import { withPathFrom } from '../runtime/withPathFrom.ts'
-import { state } from '../state.ts'
-import { buildDetachedRange } from './buildDetachedRange.ts'
-import { removeRange } from './removeRange.ts'
-import type { EachRow } from './types/EachRow.ts'
-import { withSuspense } from './withSuspense.ts'
-
-/*
-Async keyed list — the runtime for `<template each await key=>`. Like `each`, but
-over an AsyncIterable: rows append and reconcile by key as the iterator yields. Each
-row is a content RANGE bounded by comment markers, so a row holds any content.
-
-SSR renders no rows — async sources are client-time — so hydration just parks the
-anchor before the next sibling (like an empty sync each) and the client drains the
-iterable. A reactive re-run bumps the generation so a prior in-flight drain stops
-appending; departed keys are pruned once a drain completes.
-
-On a mid-stream rejection the already-streamed rows stay and the `<template catch>`
-branch (`renderCatch`) renders after them; absent a catch branch the rejection
-surfaces (re-throws), mirroring `<template await>`.
-*/
-// @documentation plumbing
-export function eachAsync<T>(
-    parent: Node,
-    items: () => AsyncIterable<T>,
-    keyOf: (item: T) => string,
-    /* The row receives its item and position as reactive cells — same contract as sync
-       `each`; the streaming runtime rebuilds the row on a re-yield rather than patching, and
-       the position is the stream arrival ordinal (a stream only appends, never reorders). */
-    render: (parent: Node, item: State<T>, index: State<number>) => void,
-    /* Absent → an iterator rejection routes to the enclosing {#try} boundary captured at build
-       (if any), else surfaces, instead of rendering a catch branch. */
-    renderCatch: ((parent: Node, error: unknown) => void) | undefined,
-    before: Node | null = null,
-    /* Explicit `by` key → the row keys its render-path segment on the stable key; else on the
-       stream arrival ordinal (a stream only appends, so the ordinal is stable). */
-    keyed = false,
-): void {
-    const rows = new Map<string, EachRow>()
-    /* This each's render-path ancestry, captured at build; each row builds under
-       `basePath/segment` so a component/cell in a streamed row gets a stable id even though the
-       row arrives after the ambient path is gone. */
-    const basePath = CURRENT_PATH.current
-    /* The enclosing {#try} boundary ambient at BUILD (see `awaitBlock`). A catch-less rejection
-       arrives LATER from the async drain, after CURRENT_BOUNDARY has been restored, so capture
-       it into this closure now rather than read it at settle time. */
-    const capturedBoundary = CURRENT_BOUNDARY.current
-    /* Each row's (and the error branch's) scope, registered with the owner so they
-       dispose on owner teardown; the block's own teardown only stops the stream. */
-    const group = scopeGroup()
-    const hydration = RENDER.hydration
-    const anchor = document.createTextNode('')
-    if (hydration !== undefined) {
-        parent.insertBefore(anchor, claimChild(hydration, parent)) // no server rows to claim
-    } else {
-        parent.insertBefore(anchor, before) // `before` places rows before a static suffix
-    }
-
-    /* Build a content range (the shared detached-range create primitive) and insert it
-       just before the anchor (arrival order). A bare range (no item cell) — the data-row
-       site adds the cell, the error branch needs none. */
-    const insertRange = (
-        build: (into: Node) => void,
-    ): { start: Node; end: Node; dispose: () => void } => {
-        /* Namespace the build off the anchor's LIVE parent, and insert there too: when this
-           `each` is a bare child of a control-flow branch, the captured `parent` is the
-           branch's build fragment, emptied into the document once the enclosing block
-           placed it. */
-        const host = anchor.parentNode ?? parent
-        const { start, end, fragment, dispose } = buildDetachedRange(host, build)
-        host.insertBefore(fragment, anchor)
-        return { start, end, dispose: group.track(dispose) }
-    }
-
-    /* The mounted `<template catch>` range, disposed when a fresh run re-streams. */
-    let errorRange: { start: Node; end: Node; dispose: () => void } | undefined
-    const clearError = (): void => {
-        if (errorRange !== undefined) {
-            errorRange.dispose()
-            removeRange(errorRange.start, errorRange.end)
-            errorRange = undefined
-        }
-    }
-
-    let iterator: AsyncIterator<T> | undefined
-    /* Bumped each run so a superseded drain stops appending and pruning, and on owner teardown
-       — which also `return()`s the live iterator to release the source (rows and the error
-       branch are disposed by the group, whose scopes were tracked). */
-    const guard = generationGuard(() => {
-        iterator?.return?.(undefined)?.catch(() => undefined)
-        iterator = undefined
-    })
-    effect(() => {
-        const generationAtStart = guard.renew()
-        iterator?.return?.(undefined)?.catch(() => undefined) // close the superseded run's iterator before re-streaming
-        iterator = undefined
-        clearError() // a fresh run drops a prior error branch
-        /* A reseed streams a FRESH source (e.g. `room(newId)`), so the prior run's rows are stale.
-           Drop them now rather than relying on the drain's completion prune below — a never-
-           completing source (a socket) never reaches that prune, so a key the new stream doesn't
-           re-yield would otherwise leak in the DOM and the `rows` map forever (and mix the old
-           source's rows in with the new). Keys the new stream does re-yield rebuild fresh (the
-           block rebuilds on every re-yield regardless), so nothing reusable is lost. */
-        for (const [, row] of rows) {
-            row.dispose()
-            removeRange(row.start, row.end)
-        }
-        rows.clear()
-        /* Read (subscribe) the source synchronously, tolerating a pending blocking `await` read
-           embedded in it (a SuspenseSignal, ADR-0042): withhold — render no rows until it resolves,
-           exactly as sync `each` does. On a cold client render the read runs here at build; the
-           read tracked its cell, so this effect re-runs on settle. */
-        const iterable = withSuspense<AsyncIterable<T> | undefined>(items, undefined)
-        if (iterable === undefined) {
-            return
-        }
-        const present = new Set<string>()
-        let arrivals = 0 // stream arrival ordinal → each row's index
-        const drain = async (): Promise<void> => {
-            const active = iterable[Symbol.asyncIterator]()
-            iterator = active
-            while (true) {
-                const result = await active.next()
-                /* A re-run or teardown bumped the generation while we awaited. */
-                if (!guard.live(generationAtStart)) {
-                    return
-                }
-                if (result.done === true) {
-                    break
-                }
-                const key = keyOf(result.value)
-                present.add(key)
-                /* A re-yielded key rebuilds the row from the new value (arrival order), swapping
-                   the old range out. The item rides in a cell — the row reads it reactively, same
-                   contract as sync `each` — but the streaming runtime rebuilds rather than patches. */
-                const stale = rows.get(key)
-                const cell = state(result.value) as State<unknown>
-                const indexCell = state(arrivals)
-                const segment = keyed ? key : arrivals
-                arrivals += 1
-                rows.set(key, {
-                    ...insertRange((host) =>
-                        withPathFrom(basePath, segment, () =>
-                            render(host, cell as State<T>, indexCell),
-                        ),
-                    ),
-                    cell,
-                    indexCell,
-                })
-                if (stale !== undefined) {
-                    stale.dispose()
-                    removeRange(stale.start, stale.end)
-                }
-            }
-            for (const [key, row] of rows) {
-                if (!present.has(key)) {
-                    row.dispose()
-                    removeRange(row.start, row.end)
-                    rows.delete(key)
-                }
-            }
-        }
-        drain().catch((error: unknown) => {
-            if (!guard.live(generationAtStart)) {
-                return
-            }
-            /* No catch branch → route to the enclosing {#try} boundary captured at build if one
-               was ambient; otherwise surface the rejection (mirrors `<template await>`). */
-            if (renderCatch === undefined) {
-                if (capturedBoundary !== undefined) {
-                    capturedBoundary.handle(error)
-                    return
-                }
-                throw error
-            }
-            /* Keep the streamed rows; render the catch branch after them, at the anchor. */
-            errorRange = insertRange((host) => renderCatch(host, error))
-        })
-    })
-}

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

@@ -1,13 +0,0 @@
-import { RENDER } from '../runtime/RENDER.ts'
-import { inheritedNamespace } from './inheritedNamespace.ts'
-
-/*
-The foreign namespace a child built under `parent` belongs to. A real element dictates
-it from its own namespace (`inheritedNamespace`); a detached `DocumentFragment` — a
-control-flow block's build buffer — carries none, so it inherits the ambient context
-the enclosing block set via `enterNamespace`. `foreignWrapperTag` reads this so a
-`skeleton` parsed into a block's fragment wraps its markup in the right namespace.
-*/
-export function effectiveChildNamespace(parent: Node): string | undefined {
-    return (parent as Element).namespaceURI == null ? RENDER.namespace : inheritedNamespace(parent)
-}

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

@@ -1,20 +0,0 @@
-import { RENDER } from '../runtime/RENDER.ts'
-import { effectiveChildNamespace } from './effectiveChildNamespace.ts'
-
-/*
-Runs a control-flow block's fragment build with the ambient foreign namespace set from
-its insertion `parent`, then restores it. Foreign elements (svg/math children) the
-block builds into its detached fragment read this context (the fragment carries no
-namespace of its own). A foreign `parent` establishes the context; a fragment parent
-keeps the current one, so a block nested inside foreign content stays foreign; a real
-HTML parent (e.g. `<foreignObject>`'s content) resets it.
-*/
-export function enterNamespace<T>(parent: Node, build: () => T): T {
-    const previous = RENDER.namespace
-    RENDER.namespace = effectiveChildNamespace(parent)
-    try {
-        return build()
-    } finally {
-        RENDER.namespace = previous
-    }
-}

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

@@ -1,42 +0,0 @@
-import { scope } from '../runtime/scope.ts'
-import { withoutHydration } from '../runtime/withoutHydration.ts'
-import { enterNamespace } from './enterNamespace.ts'
-
-/*
-Builds `content` into a fragment under a fresh reactive scope, then inserts it just
-before the `end` marker; returns the scope disposer. Building into a fragment lets
-the content append freely (elements, components, nested blocks all use the normal
-append path) before it lands as a unit. Inserting via the marker's LIVE parent
-(`end.parentNode`) keeps placement correct even after an enclosing block has moved
-the markers from a build-time fragment into the document.
-
-`fillBefore` is exclusively the *create* path — control-flow blocks adopt SSR nodes
-in place (a direct `scope(render)`) and route only fresh builds here. So neutralize
-the global claim cursor for the build: a rebuild that runs while the hydrate pass is
-still active (e.g. a synchronous write that flips a `when`/`switch` mid-hydrate)
-would otherwise make the build helpers claim SSR nodes that don't exist for fresh
-content. The same cursor is restored after (mirrors awaitBlock/tryBlock/each).
-*/
-export function fillBefore(end: Node, content: (into: Node) => void): () => void {
-    /* A control-flow effect can fire one final time after its block was already
-       detached — e.g. an enclosing await/each block tears the branch down in the same
-       microtask flush that re-ran this effect, before the owner scope disposes it. The
-       end marker then has no live parent, so there is nowhere to build into; inserting
-       a fragment before a parentless comment throws HierarchyRequestError ("would yield
-       an incorrect node tree"). Skip the rebuild — owner teardown disposes this dead
-       block anyway. */
-    if (!end.parentNode) {
-        return () => {}
-    }
-    const fragment = document.createDocumentFragment()
-    /* `fillBefore` is exclusively the CREATE path, so build with the claim cursor
-       cleared (see withoutHydration): a rebuild that runs mid-hydrate must not claim
-       SSR nodes that don't exist for this fresh content. */
-    return withoutHydration(() => {
-        /* Build under the insertion parent's foreign namespace (if any), so foreign
-           elements built into the fragment are namespaced off `end`'s live parent. */
-        const dispose = enterNamespace(end.parentNode ?? end, () => scope(() => content(fragment)))
-        ;(end.parentNode ?? end).insertBefore(fragment, end)
-        return dispose
-    })
-}

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

@@ -1,38 +0,0 @@
-import { parkCursor } from '../runtime/parkCursor.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { scope } from '../runtime/scope.ts'
-import type { UiProps } from '../runtime/types/UiProps.ts'
-import { disposeRange } from './disposeRange.ts'
-import { fillRange } from './fillRange.ts'
-import { withScope } from './withScope.ts'
-
-/*
-Mounts a chain layer (layout or page) into an EXISTING outlet boundary — the markers
-a parent layout's `<slot/>` left (`outlet`), or the router's root boundary in `#app`.
-The router fills these boundaries instead of mounting into a host element, so the whole
-page/layout chain composes through one range model (no `<abide-outlet>` wrapper).
-
-Create: build the layer's content into a fragment that lands just before `close`
-(`fillRange`). Hydrate: claim the server content in place — park the parent cursor at
-`open.nextSibling` and let the build adopt the existing nodes (the outlet markers
-themselves are located via `PENDING_OUTLET`, not claimed through the cursor). The disposer
-stops the layer's reactivity and clears the boundary — the router calls it to tear a
-divergent layer down before rebuilding the same boundary.
-*/
-// @documentation plumbing
-export function fillBoundary(
-    open: Comment,
-    close: Comment,
-    build: (host: Node, props?: UiProps) => void,
-    props: UiProps | undefined,
-): { dispose: () => void } {
-    const hydration = RENDER.hydration
-    if (hydration === undefined) {
-        return fillRange(open, close, build, props)
-    }
-    /* Hydrate: adopt the server content between the markers in place. */
-    const parent = open.parentNode as Node
-    parkCursor(hydration, parent, open.nextSibling)
-    const scoped = withScope(() => scope(() => build(parent, props)))
-    return { dispose: disposeRange(scoped, open, close) }
-}

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

@@ -1,30 +0,0 @@
-import type { UiProps } from '../runtime/types/UiProps.ts'
-import { disposeRange } from './disposeRange.ts'
-import { fillBefore } from './fillBefore.ts'
-import { withScope } from './withScope.ts'
-
-/*
-Builds a component's content fresh between two existing range markers (the create
-path), under the component's own lexical scope and render pass — the range analog of
-`mount` for a nested child. `build` appends into a fragment (via `fillBefore`) that
-lands just before `end`, so the content sits in the `[ … ]` range the child mounts
-into rather than at the parent's tail; that range is what makes a component
-selector-transparent (a true direct child of its parent, no `<abide-name>` wrapper).
-
-Brackets a render pass (a nested child continues the parent's block-id counter) and
-establishes the child's lexical scope in `awaiting` mode so it adopts the model doc
-its first `doc()` creates. The disposer stops the content's reactivity, disposes the
-lexical scope, and clears the range — leaving the markers, so a later rebuild
-(navigation, control-flow re-fill) fills in place. Shared by `mountRange` (create
-branch) and `fillBoundary` (a page/layout outlet boundary).
-*/
-// @documentation plumbing
-export function fillRange(
-    start: Comment,
-    end: Comment,
-    build: (host: Node, props?: UiProps) => void,
-    props: UiProps | undefined,
-): { start: Comment; end: Comment; dispose: () => void } {
-    const scoped = withScope(() => fillBefore(end, (fragment) => build(fragment, props)))
-    return { start, end, dispose: disposeRange(scoped, start, end) }
-}

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

@@ -1,22 +0,0 @@
-import { effectiveChildNamespace } from './effectiveChildNamespace.ts'
-import { MATHML_NAMESPACE } from './MATHML_NAMESPACE.ts'
-import { SVG_NAMESPACE } from './SVG_NAMESPACE.ts'
-
-/*
-The wrapper tag a static run must be parsed inside so its children land in `parent`'s
-foreign namespace — `svg`/`math`, or undefined for HTML. A bare `<path>` fragment
-parses into the HTML namespace; wrapping it in `<svg>` lets the parser namespace it.
-`cloneStatic` uses this for a static run coalesced under a foreign parent built
-dynamically, or under a control-flow block's fragment inside foreign content
-(where `parent`'s effective namespace comes from the ambient context).
-*/
-export function foreignWrapperTag(parent: Node): string | undefined {
-    const namespace = effectiveChildNamespace(parent)
-    if (namespace === SVG_NAMESPACE) {
-        return 'svg'
-    }
-    if (namespace === MATHML_NAMESPACE) {
-        return 'math'
-    }
-    return undefined
-}

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

@@ -1,34 +0,0 @@
-import { runHydrationPass } from '../runtime/runHydrationPass.ts'
-import { scope } from '../runtime/scope.ts'
-import { withScope } from './withScope.ts'
-
-/*
-Adopts existing server-rendered DOM instead of rebuilding it. Runs `build(host)`
-with a claim cursor active, so the dom helpers (skeleton/appendText/appendStatic)
-take the existing nodes rather than creating new ones — attaching event listeners
-and reactive effects to the server's markup in place (no re-render, preserved
-focus/scroll). Returns a disposer.
-
-Adopts the server DOM in place across the framework: static structure (elements
-+ text + bindings), `if`/`else`, keyed `each`, `switch`, `try`, and child
-components (with slots) — they hydrate automatically because a child's marker range
-is claimed while hydration is still active (see `mountRange`). `await` adopts too when it can resume
-the value (a streamed `RESUME[id]` or a warm-sync/cache read); only a genuinely-
-pending `await` — no resume, not cache-warm — discards its boundary and builds
-the pending branch fresh (see `awaitBlock`).
-*/
-// @documentation plumbing
-export function hydrate(
-    host: Element,
-    build: (host: Element, props: unknown) => void,
-    props?: unknown,
-): () => void {
-    /* The pass lifecycle (claim cursor, withhold window, render pass, restore-on-throw)
-       is owned by `runHydrationPass` — the same bracket the router's hydrating mount runs. */
-    return runHydrationPass(() => {
-        /* Same shared mount core as `mount` (see `withScope`) — a hydrated component owns a
-           scope too, adopting the model its build adopts — run with the claim cursor active. */
-        const { lexical } = withScope(() => scope(() => build(host, props)))
-        return () => lexical.dispose()
-    })
-}