@abide/abide 0.57.1 → 0.100.0

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

@@ -1,17 +0,0 @@
-import { foreignWrapperTag } from './foreignWrapperTag.ts'
-
-/*
-Parses a trusted raw-markup string into detached nodes in the SAME foreign namespace
-as `parent`. The HTML fragment parser namespaces by its context element, so markup
-bound inside an <svg>/<math> must parse inside a matching wrapper — otherwise a bare
-`<path>` lands in the HTML namespace and never renders. Mirrors `cloneStatic`'s
-foreign handling, but parses per-call into a throwaway `<template>` rather than the
-skeleton cache: raw values are dynamic, so caching every distinct string would leak.
-*/
-export function parseRawNodes(parent: Node, markup: string): Node[] {
-    const wrapper = foreignWrapperTag(parent)
-    const template = document.createElement('template')
-    template.innerHTML = wrapper === undefined ? markup : `<${wrapper}>${markup}</${wrapper}>`
-    const source = wrapper === undefined ? template.content : (template.content.firstChild as Node)
-    return [...source.childNodes]
-}

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

@@ -1,29 +0,0 @@
-/*
-Guarded method call on a reactive-document read. The doc-access lowering rewrites
-a non-optional method call on a reactive-document read — e.g. `model.draft.trim()` —
-directly to `$$readCall(model.read("draft"), "draft", "trim", [...])` rather than
-the naive `model.read("draft").trim()`, which would throw the engine's opaque
-`undefined is not an object (evaluating '…read("draft").trim()')`, naming only the
-desugared call. This wraps the non-optional call so the throw names the authored
-scope path and member instead —
-the source-mapped stack frame still resolves to the `.abide` line, so message and
-location together read in authored terms. Both opaque engine errors are covered: a
-nullish receiver (`undefined is not an object`) AND a present receiver whose member
-is not callable (`… is not a function`, the misspelled/missing-method case).
-Optional-chained calls are left bare: `?.` means skip-if-absent, not throw, so
-guarding them would change semantics. `.apply(target, …)` preserves the receiver, so
-the method sees the same `this` the bare `target.member(…)` would.
-*/
-// @documentation plumbing
-export function readCall(target: unknown, path: string, member: string, args: unknown[]): unknown {
-    if (target === undefined || target === null) {
-        throw new TypeError(`abide: cannot call .${member}() — scope value "${path}" is ${target}`)
-    }
-    const method = (target 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})`,
-        )
-    }
-    return (method as (...args: unknown[]) => unknown).apply(target, args)
-}

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

@@ -1,55 +0,0 @@
-import { isAsyncCell } from '../../shared/isAsyncCell.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-import { AsyncCellError } from '../runtime/AsyncCellError.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-
-/*
-The one read for a `computed`/`linked` reference the compiler lowers to `$$readCell(NAME)`,
-everywhere — script and template, both sides. An async cell (`AsyncComputed`/`AsyncState`)
-yields its latest retained value, a `derive` reader (a function) is called, and a sync
-`Computed`/`State` yields its `.value`. One read shape lets a `linked`/`computed` binding
-auto-track whichever source it resolved to — a settling promise, a stream, or a plain value —
-with no read-site branching in codegen.
-
-Whether a read PAUSES is a property of the NODE, not the read site (ADR-0042). A pending
-blocking cell (`cell.blocking` — author `await`, the one that joins the SSR barrier) throws
-a `SuspenseSignal`: the reader's branch of the graph pauses until the value resolves, and
-the throwing read subscribed the reader to the cell so it re-runs on settle. A pending
-STREAMING cell peeks `undefined` (composes with `?.`/`??`). So a rendering region withholds,
-a derive over it pauses too, and the SSR barrier awaits it — all off the same node bit,
-with no per-site knowledge threaded through the compiler.
-
-For a settled async cell this stays the value-aware **throwing peek** (ADR-0019 D3.2):
-  - error AND no retained value → throw `AsyncCellError` (carries the cell for keep-the-watch);
-  - error WITH a retained value → the value (a failed background refresh stays visible — SWR);
-  - resolved → the value.
-The throws are codegen behaviour only — `cell.peek()`/`cell.error()` in JS never throw; the
-author handles an error locally via the probes, or lets it reach a `{#try}`.
-*/
-// @documentation plumbing
-export function readCell(cell: unknown): unknown {
-    if (isAsyncCell(cell)) {
-        const asyncCell = cell as AsyncComputed<unknown> & { blocking?: boolean }
-        const value = asyncCell.peek()
-        /* A retained value wins over an error (SWR) and over pending — return it. Only when
-           nothing is retained does the cell's state decide: an error is "nothing to render"
-           (throw to `{#try}`); a pending blocking cell PAUSES (throw suspense); a pending
-           streaming cell — or a blocking cell that legitimately resolved to `undefined` — is
-           the bare `undefined`. `pending()` (in flight, no value) gates the suspend so a
-           resolved-`undefined` blocking cell never suspends forever. */
-        if (value === undefined) {
-            const error = asyncCell.error()
-            if (error !== undefined) {
-                throw new AsyncCellError(asyncCell, error)
-            }
-            if (asyncCell.blocking === true && asyncCell.pending()) {
-                throw new SuspenseSignal(asyncCell)
-            }
-        }
-        return value
-    }
-    if (typeof cell === 'function') {
-        return (cell as () => unknown)()
-    }
-    return (cell as { value: unknown }).value
-}

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

@@ -1,21 +0,0 @@
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-
-/*
-The text a reactive `{expr}` binding writes: the stringified value, or `''` while a blocking
-`await` read is pending — a `SuspenseSignal` (ADR-0042). Nullish stringifies to `''` (never the
-literal `"undefined"`), so a pending streaming read and a suspended blocking read both show nothing.
-A suspending read still tracked its cell before throwing, so the enclosing bind effect re-runs and
-fills in once the value resolves. Rethrows any non-suspense error unchanged.
-*/
-export function readTextOrSuspend(read: () => unknown): string {
-    let next: unknown
-    try {
-        next = read()
-    } catch (signal) {
-        if (!(signal instanceof SuspenseSignal)) {
-            throw signal
-        }
-        return ''
-    }
-    return next == null ? '' : String(next)
-}

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

@@ -1,18 +0,0 @@
-/*
-Removes a contiguous node range — `start` through `end` inclusive — from the DOM.
-Used to evict a departed keyed-`each` row whose content is a range (markers plus
-whatever they bound). Each next sibling is captured before removal.
-*/
-export function removeRange(start: Node, end: Node): void {
-    const parent = 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.removeChild(node)
-        node = next
-    }
-}

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

@@ -1,24 +0,0 @@
-import { clearBetween } from './clearBetween.ts'
-import { fillBefore } from './fillBefore.ts'
-
-/*
-The one "replace a marker-bounded region's contents" operation. A control-flow block
-that swaps a branch as a unit (if/else, switch, snippet) clears the live range
-(disposing its scope and removing its nodes via `clearBetween`), then — if the new
-branch has content — builds it fresh into the range before the close marker
-(`fillBefore`). Returns the new content's disposer, or `undefined` for an empty
-branch.
-
-This is the single seam those blocks shared by copy-paste: same `clearBetween` +
-conditional `fillBefore` shape, hand-rolled three times. Routing them through one
-helper makes the region-update strategy a named, testable primitive.
-*/
-export function replaceRange(
-    start: Node,
-    end: Node,
-    dispose: (() => void) | undefined,
-    content: ((into: Node) => void) | undefined,
-): (() => void) | undefined {
-    clearBetween(start, end, dispose)
-    return content !== undefined ? fillBefore(end, content) : undefined
-}

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

@@ -1,32 +0,0 @@
-import type { UiProps } from '../runtime/types/UiProps.ts'
-
-/*
-The rest of a component's props — `const { foo, ...rest } = props()` — as a live
-object of the UNCONSUMED prop values. A child receives prop THUNKS, so `rest.key`
-unwraps them (`$props[key]?.()`), tracking as a reactive dependency; a top-level
-page/layout instead receives its route params as PLAIN values, so a non-function
-value is returned as-is rather than called (which would throw `value is not a
-function`). The explicitly-destructured keys and the `children` slot are excluded.
-Enumerable (`ownKeys`/`for…in`/`Object.keys`), so `{...rest}` can forward the
-remaining props onto a child or a native element. Key membership is live, but a
-consumer that captures the key SET (a `{...rest}` spread) snapshots it at that point.
-*/
-// @documentation plumbing
-export function restProps(props: UiProps, consumed: string[]): Record<string, unknown> {
-    const skip = new Set([...consumed, 'children'])
-    const bag = props as Record<string, unknown>
-    const visible = (key: string | symbol): key is string =>
-        typeof key === 'string' && !skip.has(key) && key in bag
-    const read = (key: string): unknown =>
-        typeof bag[key] === 'function' ? (bag[key] as () => unknown)() : bag[key]
-    return new Proxy(
-        {},
-        {
-            get: (_target, key) => (visible(key) ? read(key) : undefined),
-            has: (_target, key) => visible(key),
-            ownKeys: () => Reflect.ownKeys(bag).filter(visible),
-            getOwnPropertyDescriptor: (_target, key) =>
-                visible(key) ? { enumerable: true, configurable: true } : undefined,
-        },
-    )
-}

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

@@ -1,153 +0,0 @@
-import { walkAnchorOrder } from '../compile/walkAnchorOrder.ts'
-import { walkElementOrder } from '../compile/walkElementOrder.ts'
-import { claimRun } from '../runtime/claimRun.ts'
-import { HOLE_ATTRIBUTE } from '../runtime/HOLE_ATTRIBUTE.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import { commentData } from './commentData.ts'
-import { depthZeroNodes } from './depthZeroNodes.ts'
-import { domAnchorAdapter } from './domAnchorAdapter.ts'
-import { domElementAdapter } from './domElementAdapter.ts'
-import { foreignWrapperTag } from './foreignWrapperTag.ts'
-import { isElement } from './isElement.ts'
-import { markerDepthDelta } from './markerDepthDelta.ts'
-import type { SkeletonHoles } from './types/SkeletonHoles.ts'
-
-type CompiledSkeleton = {
-    /* The node whose children are the skeleton's top-level run — the template content,
-       or a foreign wrapper element (`<svg>`/`<math>`) the run was parsed inside. */
-    source: Node
-    /* Element holes, in pre-order — each an element-only-index path from a top-level
-       node. Element-only indexing keeps a path stable: a reactive text value is a text
-       node, so its width never shifts an element hole between the empty client skeleton
-       and the value-filled server DOM. */
-    elementPaths: number[][]
-    topLevelCount: number
-}
-
-/* Parsed-once skeleton per unique string, keyed by the owning document (see
-   `templateFor` for the per-document rationale). */
-const CACHES = new WeakMap<object, Map<string, CompiledSkeleton>>()
-
-/* The `index`-th depth-0 ELEMENT among `children` — skipping text/comment nodes AND any
-   element nested inside a block's rendered range (between `[`…`]` / `abide:…` boundaries),
-   which belongs to that block's own skeleton. The compiler indexes element holes over the
-   SHALLOW template (block positions are `<!--a-->` anchors, no content), so on hydrate the
-   expanded tree must skip that inline content or a hole positioned after a block shifts. In
-   create mode the clone is shallow (no markers), so depth stays 0 — a plain element count. */
-function elementChildAt(children: ArrayLike<Node>, index: number): Element | undefined {
-    let seen = 0
-    let depth = 0
-    for (let cursor = 0; cursor < children.length; cursor += 1) {
-        const child = children[cursor] as Node
-        const data = commentData(child)
-        if (data === undefined) {
-            if (isElement(child) && depth === 0) {
-                if (seen === index) {
-                    return child
-                }
-                seen += 1
-            }
-            continue
-        }
-        depth += markerDepthDelta(data)
-    }
-    return undefined
-}
-
-/* Walks an element-only path from the top-level node list to the target element. A step
-   that resolves to nothing means the claimed server run is missing an element the skeleton
-   expects here — a hydration desync; throw AT it (naming the path) rather than returning
-   the undefined that derefs in the downstream `mountChild`/`attr`, far from the cause. */
-function resolveElementHole(topLevel: ArrayLike<Node>, path: number[]): Element {
-    let node = elementChildAt(topLevel, path[0] as number)
-    for (let depth = 1; depth < path.length && node !== undefined; depth += 1) {
-        node = elementChildAt(node.childNodes, path[depth] as number)
-    }
-    if (node === undefined) {
-        throw new Error(
-            `[abide] hydration desync: skeleton element hole [${path.join(',')}] resolved to no node — the server DOM is missing an element the client build expects here.`,
-        )
-    }
-    return node
-}
-
-/* When `parent` is foreign (or a control-flow fragment inside foreign content), the
-   skeleton's own markup carries no foreign ancestor, so a bare `<circle>` would parse
-   into the HTML namespace. Parse it inside the matching wrapper so the parser
-   namespaces the run; key the cache by wrapper too, since one string can be realized
-   in either context. */
-function compile(html: string, wrapper: string | undefined): CompiledSkeleton {
-    let cache = CACHES.get(document)
-    if (cache === undefined) {
-        cache = new Map()
-        CACHES.set(document, cache)
-    }
-    const key = wrapper === undefined ? html : `${wrapper} ${html}`
-    let compiled = cache.get(key)
-    if (compiled === undefined) {
-        const template = document.createElement('template')
-        template.innerHTML = wrapper === undefined ? html : `<${wrapper}>${html}</${wrapper}>`
-        const source =
-            wrapper === undefined ? template.content : (template.content.firstChild as Node)
-        /* Element holes via the ONE shared rule (`walkElementOrder`) — the same element-only
-           pre-order the compiler numbers `elIndex` with. Record each `HOLE_ATTRIBUTE`
-           element's path and strip the marker so a clone never carries it into the live DOM. */
-        const elementPaths: number[][] = []
-        walkElementOrder(Array.from(source.childNodes), domElementAdapter, (node, path) => {
-            elementPaths.push(path)
-            ;(node as Element).removeAttribute(HOLE_ATTRIBUTE)
-        })
-        compiled = { source, elementPaths, topLevelCount: source.childNodes.length }
-        cache.set(key, compiled)
-    }
-    return compiled
-}
-
-/*
-Realizes a compiled skeleton under `parent` and returns its holes: `el` the element
-holes (attribute/listener/bind), in pre-order; `an` the anchor holes (reactive text,
-control flow, components), in document order. The browser's parser is the sole
-tree-builder here, so foreign content (SVG/MathML) lands in the correct namespace and
-`cloneNode` preserves it — a hand-rolled `createElement` tree-builder could not.
-
-Element holes resolve by element-only path (stable against text-value width, computed
-client-side — no server marker). Anchor holes resolve by scanning for their `a` comment
-markers (present in both clone and server DOM). Create mode clones the parsed top-level
-nodes; hydrate mode claims the matching server run.
-*/
-// @documentation plumbing
-export function skeleton(parent: Node, html: string): SkeletonHoles {
-    const { source, elementPaths, topLevelCount } = compile(html, foreignWrapperTag(parent))
-    const hydration = RENDER.hydration
-    const topLevel: Node[] = []
-    if (hydration !== undefined) {
-        claimRun(hydration, parent, topLevelCount, topLevel)
-    } else {
-        const children = source.childNodes
-        /* Stage clones in a fragment ONLY for a live (connected) parent, where one
-           append reflows once instead of per clone. A detached parent triggers no
-           reflow on append, so the fragment is pure overhead there — skip it and
-           append direct. `topLevel` collects each clone either way for anchor/
-           element-hole resolution. */
-        const target: Node = parent.isConnected ? document.createDocumentFragment() : parent
-        for (let index = 0; index < children.length; index += 1) {
-            const clone = (children[index] as Node).cloneNode(true)
-            topLevel.push(clone)
-            target.appendChild(clone)
-        }
-        if (target !== parent) {
-            parent.appendChild(target)
-        }
-    }
-    /* Anchor holes via the ONE shared ordering rule (`walkAnchorOrder`) — the same traversal
-       the compiler numbers `anIndex` with. The top-level list is depth-0-filtered up front (a
-       nested range can sit among the top-level run); the adapter filters each deeper level. */
-    const an: Node[] = []
-    walkAnchorOrder(depthZeroNodes(topLevel), domAnchorAdapter, (anchor) => {
-        an.push(anchor as Node)
-    })
-    return {
-        el: elementPaths.map((path) => resolveElementHole(topLevel, path)),
-        an,
-    }
-}

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

@@ -1,95 +0,0 @@
-import { effect } from '../effect.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { attr } from './attr.ts'
-import { on } from './on.ts'
-
-/*
-Spreads an object's keys onto a native element — the `<div {...rest}>` runtime. `source`
-is a thunk over the spread expression; its keys are enumerated ONCE (so the attribute set
-is fixed at build, not reactively added/removed), but each value stays live: an `on<event>`
-key holding a function attaches as that event listener (mirroring `onclick={…}` on an
-element), and every other key binds as a reactive attribute (`attr`, re-reading the source
-per change, with the same present/absent semantics — `false`/`null`/`undefined` removes it,
-`true` sets it bare). A function under a non-`on` key is skipped (no attribute for it). A key
-in `exclude` is skipped — the element names it explicitly, and an explicit attribute wins
-over a spread key (the same set SSR's `$spread` skips, keeping the two sides congruent).
-*/
-// @documentation plumbing
-export function spreadAttrs(
-    element: Element,
-    source: () => Record<string, unknown>,
-    exclude: string[] = [],
-): void {
-    const skip = new Set(exclude)
-    let object: Record<string, unknown>
-    try {
-        object = source()
-    } catch (signal) {
-        /* A spread over a PENDING blocking `await` read throws a `SuspenseSignal` here (ADR-0042):
-           its keys can't be enumerated yet. Binding the empty object now would create no `attr`/`on`
-           effects, so the attributes would never appear after the cell resolves — instead defer the
-           enumeration into a one-shot effect that re-runs on settle (the read tracked its cell). The
-           effect is pinned to this build's scope, so the `attr` binds it creates own their lifetime
-           correctly; a `spread` flag makes the enumeration fire exactly once (later value changes
-           re-read per key via `attr`, never re-enumerate). */
-        if (!(signal instanceof SuspenseSignal)) {
-            throw signal
-        }
-        let spread = false
-        effect(() => {
-            let resolved: Record<string, unknown>
-            try {
-                resolved = source()
-            } catch (retry) {
-                if (!(retry instanceof SuspenseSignal)) {
-                    throw retry
-                }
-                return
-            }
-            if (spread) {
-                return
-            }
-            spread = true
-            bindKeys(element, source, resolved, skip)
-        })
-        return
-    }
-    bindKeys(element, source, object, skip)
-}
-
-/* Binds each own key of `object` onto `element`: an `on<event>` function attaches as a listener,
-   any other non-function value binds as a reactive attribute re-reading `source()[key]` per change.
-   A key in `skip` is left to its explicit binding. */
-function bindKeys(
-    element: Element,
-    source: () => Record<string, unknown>,
-    object: Record<string, unknown>,
-    skip: Set<string>,
-): void {
-    for (const key in object) {
-        if (skip.has(key)) {
-            continue
-        }
-        /* Reading the value can itself throw a `SuspenseSignal`: when `source()` is a
-           restProps proxy (the `<Button {...rest}>` case), its `get` invokes the underlying
-           prop thunk, so a key whose expression reads a still-pending blocking `await` suspends
-           HERE — after the `source()` enumeration guard already passed. Classify it as an
-           attribute; `attr`'s own effect swallows the suspend and fills the value in on settle.
-           An event handler never suspends — its thunk returns a function without reading a cell. */
-        let value: unknown
-        try {
-            value = object[key]
-        } catch (signal) {
-            if (!(signal instanceof SuspenseSignal)) {
-                throw signal
-            }
-            attr(element, key, () => source()[key])
-            continue
-        }
-        if (key.startsWith('on') && typeof value === 'function') {
-            on(element, key.slice(2), value as EventListener)
-        } else if (typeof value !== 'function') {
-            attr(element, key, () => source()[key])
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-/*
-Wraps a `{...source}` spread layer so every key resolves to a live value thunk —
-the same `() => value` shape an explicit `name={expr}` prop compiles to, so a child
-reads a spread key exactly like an authored one (`$props[key]?.()`). `source` is a
-THUNK over the spread expression (not its value), re-evaluated on each key read and
-membership test, so a reactive source stays live both when its keys mutate and when
-the whole object is replaced — and the read registers as the reader's dependency. A
-nullish source spreads nothing. The reserved `children` slot key is never surfaced —
-a source happening to carry one must not masquerade as slot content.
-*/
-// @documentation plumbing
-export function spreadProps(
-    source: () => Record<string, unknown> | null | undefined,
-): Record<string, () => unknown> {
-    /* A spread key the merged bag exposes — present on the current source and not the
-       reserved `children` slot key (a source carrying one must not become slot content). */
-    const carries = (key: string | symbol): boolean => key !== 'children' && key in (source() ?? {})
-    return new Proxy(
-        {},
-        {
-            /* Each read returns a fresh thunk that re-evaluates the source for the key. */
-            get: (_target, key) => () => source()?.[key as string],
-            /* Live membership: whether the current source object carries the key. */
-            has: (_target, key) => carries(key),
-            /* Enumerable over the current source, so a merged bag reports spread keys. */
-            ownKeys: () => Reflect.ownKeys(source() ?? {}).filter(carries),
-            getOwnPropertyDescriptor: (_target, key) =>
-                carries(key) ? { enumerable: true, configurable: true } : undefined,
-        },
-    ) as Record<string, () => unknown>
-}

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

@@ -1,80 +0,0 @@
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { mountSwappableRange } from './mountSwappableRange.ts'
-import type { SwitchCase } from './types/SwitchCase.ts'
-
-/*
-Multi-branch binding — the runtime for `{#switch}` blocks and for `{#if}` chains that
-include `{:elseif}` branches (compiled as a switch over `true` with Boolean-coerced
-match thunks so the first truthy branch wins). A swappable range evaluates the
-subject, picks the first case whose `match` equals it (strict `===`), falling back
-to the default (`match` undefined); the chosen case's content lives in a RANGE
-bounded by two comment markers, so a case holds any content. Staying on the same
-case across a subject change leaves it mounted; switching clears the range and
-builds the new case fresh. See `mountSwappableRange` for the shared
-hydrate/swap/teardown semantics — the case index is the swap key, which doubles as
-the case's render-path segment (`caseSegment` — the alphabet SSR also emits).
-*/
-// @documentation plumbing
-export function switchBlock(
-    parent: Node,
-    subject: () => unknown,
-    cases: SwitchCase[],
-    before: Node | null = null,
-    isPending?: () => boolean,
-): void {
-    /* Walk the cases in source order (the same order a `{#if}`/`{:elseif}` chain reads): the
-       first whose own async condition is still `pending()` HOLDS the chain — returns -1, so no
-       later branch renders on a not-yet-known earlier condition; the first whose `match() ===`
-       the subject wins; a match-less `default` is the fallback once every case settled without a
-       match. A plain `{#switch}` (no per-case `pending`) reduces to first-match-else-default. */
-    const select = (value: unknown): number => {
-        let fallback = -1
-        for (let index = 0; index < cases.length; index++) {
-            const entry = cases[index]
-            if (entry === undefined) {
-                continue
-            }
-            if (entry.pending?.()) {
-                return -1
-            }
-            if (entry.match === undefined) {
-                fallback = index
-            } else if (entry.match() === value) {
-                return index
-            }
-        }
-        return fallback
-    }
-    mountSwappableRange(
-        parent,
-        /* A pending bare async subject (compiler-supplied `isPending`) selects no case — not
-           even the default — so the block renders nothing until the cell settles, rather than
-           conflating "still loading" with a subject that matched the default. A blocking `await`
-           cell embedded in the subject or a `match` (a member access / compound the `isPending`
-           gate doesn't cover) throws a `SuspenseSignal` while pending (ADR-0042); select no case
-           until it settles, exactly as a bare async subject holds — the read tracked its cell, so
-           the swap effect re-runs on resolve. */
-        () => {
-            if (isPending?.() === true) {
-                return -1
-            }
-            try {
-                return select(subject())
-            } catch (signal) {
-                if (!(signal instanceof SuspenseSignal)) {
-                    throw signal
-                }
-                return -1
-            }
-        },
-        (index) => {
-            const chosen = index === -1 ? undefined : cases[index]
-            return chosen && ((p) => chosen.render(p))
-        },
-        before,
-        /* Any async subject/branch (a bare async subject, or an async `{:else if}` in a cond-chain)
-           can select a different branch on the server than the pending client, so hydration must
-           discard the SSR range rather than adopt it in place. */
-        isPending !== undefined || cases.some((entry) => entry.pending !== undefined),
-    )
-}

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

@@ -1,28 +0,0 @@
-/*
-Parsed-once `<template>` per unique static-skeleton string, reused across every
-mount. A `<template>` (not a detached `<div>`) so table/select content parses by
-the real content model, exactly as the browser parsed the server markup. Backs
-`cloneStatic`'s skeleton-string→template cache.
-
-The cache is keyed by the owning `document`: a template belongs to the document
-that created it, and its clones must land in that same document. In production there
-is one document, so this is one inner map; under the test harness, which installs a
-fresh `document` per file, it keeps each file's templates (and their node class)
-from leaking into the next.
-*/
-const CACHES = new WeakMap<object, Map<string, HTMLTemplateElement>>()
-
-export function templateFor(html: string): HTMLTemplateElement {
-    let cache = CACHES.get(document)
-    if (cache === undefined) {
-        cache = new Map()
-        CACHES.set(document, cache)
-    }
-    let template = cache.get(html)
-    if (template === undefined) {
-        template = document.createElement('template')
-        template.innerHTML = html
-        cache.set(html, template)
-    }
-    return template
-}