@abide/abide 0.58.0 → 0.101.0

package/src/lib/ui/runtime/toTeardown.ts

@@ -1,38 +0,0 @@
-import { abideLog } from '../../shared/abideLog.ts'
-import type { EffectResult } from './types/EffectResult.ts'
-import type { Teardown } from './types/Teardown.ts'
-
-/*
-Normalises an effect/attachment body's return into a single callable teardown (or
-undefined when it returned nothing). A function is the teardown itself; a promise
-is wrapped so the teardown runs once it settles — chained, never awaited, so a
-dispose mid-setup still tears down without blocking the caller. Shared by
-`createEffectNode` (runs it on re-run + dispose) and `attach` (registers it with
-the owner scope).
-*/
-export function toTeardown(result: EffectResult): Teardown | undefined {
-    if (typeof result === 'function') {
-        return result
-    }
-    if (result instanceof Promise) {
-        return () => {
-            result.then(
-                (teardown) => {
-                    if (typeof teardown === 'function') {
-                        teardown()
-                    }
-                },
-                (error) => {
-                    /* A superseded reactive read aborts its in-flight RPC — expected, stays
-                       quiet. Any OTHER rejection is a real bug in the async effect body;
-                       surface it (the visibility goal) instead of silently discarding it. */
-                    const aborted = (error as { name?: string } | undefined)?.name === 'AbortError'
-                    if (!aborted) {
-                        abideLog.error(error)
-                    }
-                },
-            )
-        }
-    }
-    return undefined
-}

package/src/lib/ui/runtime/track.ts

@@ -1,60 +0,0 @@
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
-import type { ReactiveLink } from './types/ReactiveLink.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Links a node being read to the observer currently running, in both directions, so
-a later write to the node reaches the observer and a recompute can unlink it. A
-no-op outside any tracking scope — reads in plain code (and on the server)
-register nothing, so the same callable works tracked and untracked.
-
-Edge reuse keeps a settled observer allocation-free across runs. `depsTail` is the
-recompute cursor (rewound by `runNode` before compute); the edge just past it is
-what last run captured at this position. If that edge already points at `dep`, the
-observer is reading the same source in the same order as before — advance the
-cursor and reuse the edge, allocating nothing. Otherwise splice a fresh edge in at
-the cursor; `runNode` trims whatever stale edges trail the cursor when compute ends.
-
-On re-runs, an edge whose `dep` matches the next slot in the established list is
-reused in-place (cursor advances, no allocation). New edges are still appended for
-reads that extend the list or find a mismatched slot — including a second consecutive
-read of the same source when no matching edge yet follows the cursor.
-*/
-export function track(dep: ReactiveNode): void {
-    const sub = REACTIVE_CONTEXT.observer
-    if (sub === undefined) {
-        return
-    }
-    /* The edge to reuse: the one after the cursor, or the head when the cursor sits
-       at the start of this run. */
-    const reusable = sub.depsTail === undefined ? sub.depsHead : sub.depsTail.nextDep
-    if (reusable !== undefined && reusable.dep === dep) {
-        sub.depsTail = reusable
-        return
-    }
-    const link: ReactiveLink = {
-        dep,
-        sub,
-        prevDep: sub.depsTail,
-        nextDep: reusable,
-        prevSub: dep.subsTail,
-        nextSub: undefined,
-    }
-    /* Splice into the observer's dependency list at the cursor. */
-    if (sub.depsTail !== undefined) {
-        sub.depsTail.nextDep = link
-    } else {
-        sub.depsHead = link
-    }
-    if (reusable !== undefined) {
-        reusable.prevDep = link
-    }
-    sub.depsTail = link
-    /* Append onto the source's subscriber list (order there is irrelevant). */
-    if (dep.subsTail !== undefined) {
-        dep.subsTail.nextSub = link
-    } else {
-        dep.subsHead = link
-    }
-    dep.subsTail = link
-}

package/src/lib/ui/runtime/trigger.ts

@@ -1,74 +0,0 @@
-import { flushEffects } from './flushEffects.ts'
-import { NODE_STATE } from './NODE_STATE.ts'
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Raises `node` to at least `status` and propagates the news up its subscriber cone.
-An effect crossing out of CLEAN is queued (whether it became CHECK or DIRTY — the
-flush decides whether it really runs). A computed crossing out of CLEAN propagates
-CHECK to *its* subscribers, so the whole cone learns a dependency *might* have
-changed; it does so exactly once (a later CHECK→DIRTY upgrade re-notifies nobody —
-its subscribers are already CHECK). No compute runs here, so no subscriber list is
-re-linked mid-walk (`track`/`runNode` run inside compute, which only the flush
-reaches). `nextSub` is read before recursing so the walk holds no edge a deeper
-pass could detach.
-*/
-function mark(node: ReactiveNode, status: number): void {
-    /* Tail-iterative down the subscriber cone: a node with a single subscriber (a
-       linear computed chain) advances by reassigning `node` instead of recursing, so a
-       deep chain costs a loop, not a 500-frame call stack. Only a true fan-out (>1
-       subscriber) recurses, and only for the extra branches. */
-    let nextStatus = status
-    for (;;) {
-        if (node.status >= nextStatus) {
-            return
-        }
-        const wasClean = node.status === NODE_STATE.CLEAN
-        node.status = nextStatus
-        if (node.isEffect) {
-            if (wasClean) {
-                REACTIVE_CONTEXT.pendingEffects.push(node)
-            }
-            return
-        }
-        /* A computed propagates CHECK to its subscribers only on its first move out of
-           CLEAN — they are already CHECK on any later upgrade, so re-walking is wasted. */
-        if (!wasClean) {
-            return
-        }
-        const head = node.subsHead
-        if (head === undefined) {
-            return
-        }
-        /* Recurse into every branch but the last; continue the loop on the last, so the
-           common single-subscriber chain never recurses. */
-        let link = head
-        while (link.nextSub !== undefined) {
-            mark(link.sub, NODE_STATE.CHECK)
-            link = link.nextSub
-        }
-        node = link.sub
-        nextStatus = NODE_STATE.CHECK
-    }
-}
-
-/*
-Propagates a change forward from a just-written signal: its direct subscribers read
-a value that actually changed, so they are DIRTY; the rest of their cone is CHECK
-(a transitive dependency *may* have changed — `updateIfNecessary` will verify on
-read). Recompute is lazy. The queued effects flush once, at the outermost trigger
-(or, inside a batch, when the batch owner flushes) — never mid-propagation, so an
-effect never runs against a half-marked graph.
-*/
-export function trigger(node: ReactiveNode): void {
-    let link = node.subsHead
-    while (link !== undefined) {
-        const next = link.nextSub
-        mark(link.sub, NODE_STATE.DIRTY)
-        link = next
-    }
-    if (REACTIVE_CONTEXT.batchDepth === 0) {
-        flushEffects()
-    }
-}

package/src/lib/ui/runtime/types/AbideHistoryState.ts

@@ -1,9 +0,0 @@
-/* The shape abide stamps into `History.state`: a monotonic `abideEntry` id the router
-   buckets scroll by, and the last `scroll` offset persisted for that entry (so a reload
-   can recover it — the in-memory bucket does not survive). Both optional: a foreign or
-   bare entry (one another script pushed, or the first landing before a stamp) carries
-   neither, which the readers treat as "no abide data". */
-export type AbideHistoryState = {
-    abideEntry?: number
-    scroll?: [number, number]
-}

package/src/lib/ui/runtime/types/Boundary.ts

@@ -1,9 +0,0 @@
-/*
-A reactive error boundary — the runtime handle a `{#try}` installs so a LATER re-run
-throw from a guarded effect (an async cell that rejects after mount, read via a throwing
-peek) routes back to it. `handle(error)` swaps the guarded content to the catch branch;
-the scheduler (`flushEffects.drain`) calls it when a node associated with this boundary
-(`boundaryFor`) throws during a flush. Kept minimal so the boundary can install itself as
-the ambient `CURRENT_BOUNDARY` around a guarded build without dragging DOM types here.
-*/
-export type Boundary = { handle(error: unknown): void }

package/src/lib/ui/runtime/types/Cell.ts

@@ -1,7 +0,0 @@
-/* A stable reactive accessor bound to one document path: `get` subscribes the
-   running observer, `set` mutates that path and wakes its readers — all path
-   resolution done once at bind time, so the access itself is string-free. This
-   is the shape the template compiler emits for a `{path}` read / write. `set`
-   returns the written value so a lowered assignment evaluates to that value in
-   expression position (chained `a = b = x`, the postfix `x++` correction). */
-export type Cell<T> = { get: () => T; set: (value: T) => T }

package/src/lib/ui/runtime/types/Computed.ts

@@ -1,3 +0,0 @@
-/* A read-only reactive cell computed from other cells. Reading `.value`
-   subscribes the running observer and lazily recomputes if a dependency changed. */
-export type Computed<T> = { readonly value: T }

package/src/lib/ui/runtime/types/Doc.ts

@@ -1,24 +0,0 @@
-import type { Cell } from './Cell.ts'
-import type { Patch } from './Patch.ts'
-
-/*
-A reactive document: a single immutable tree addressed by path. `read` subscribes
-the running observer to a path and returns its current value; `apply` (and the
-`replace`/`add`/`remove` sugar) advances the tree by one patch and wakes exactly
-the readers whose paths the patch touched. `snapshot` returns the current root —
-plain, serializable data, which is what makes the document resumable.
-*/
-export type Doc = {
-    read: <T>(path: string) => T
-    cell: <T>(path: string) => Cell<T>
-    /* Registers a computed slot at `path` (a value computed from other paths, never
-       stored/serialized/journalled) and returns a string-free reader bound to it. */
-    derive: <T>(path: string, compute: () => T) => () => T
-    apply: (patch: Patch) => void
-    /* Returns the written value so a lowered assignment/`++` evaluates to it in
-       expression position (mirrored by `Scope.replace` and `Cell.set`). */
-    replace: (path: string, value: unknown) => unknown
-    add: (path: string, value: unknown) => void
-    remove: (path: string) => void
-    snapshot: () => unknown
-}

package/src/lib/ui/runtime/types/EffectResult.ts

@@ -1,10 +0,0 @@
-import type { Teardown } from './Teardown.ts'
-
-/*
-What an effect or attachment body returns: a teardown to run before its next run
-and on dispose, nothing, or — when the body is async — a promise of either. The
-async case tracks only the reads before its first `await`; reads after it are not
-captured by the reactive graph.
-*/
-// biome-ignore lint/suspicious/noConfusingVoidType: an effect body with no return is void; the union is the real contract
-export type EffectResult = void | Teardown | Promise<void | Teardown>

package/src/lib/ui/runtime/types/HydrationCursor.ts

@@ -1,8 +0,0 @@
-/* The active hydration pass's claim cursor: per parent, the next server-rendered child
-   to claim — a node pointer (not an index) so it survives nodes a block inserts (anchors,
-   range brackets) mid-hydration. Read through `claimChild` (probe) / the claim verbs
-   (claim + advance); repositioned through `parkCursor`. The live instance hangs off
-   `RENDER.hydration` (undefined outside a pass). */
-export type HydrationCursor = {
-    next: Map<Node, Node | null>
-}

package/src/lib/ui/runtime/types/NavVerdict.ts

@@ -1,9 +0,0 @@
-/* What the navigation probe decided after running the destination through the
-   server's app.handle: `mount` it client-side (handle() cleared it), `redirect`
-   to where handle() pointed (same-origin — the router re-probes there), or `reload`
-   via a full browser navigation (handle() blocked it, redirected cross-origin, or
-   the probe itself failed) so the server's real response is what the user sees. */
-export type NavVerdict =
-    | { kind: 'mount' }
-    | { kind: 'redirect'; path: string }
-    | { kind: 'reload'; url: string }

package/src/lib/ui/runtime/types/Patch.ts

@@ -1,11 +0,0 @@
-/*
-A serializable change against a document path. `replace` overwrites the value at
-a path; `add` inserts (into an array at an index or `-` to push, or sets an
-object key); `remove` deletes it. The path is `/`-joined segments; `''` is the
-document root. Being plain data is the whole point — a patch is the unit that
-flows from a transition to the DOM, to persistence, and over the wire.
-*/
-export type Patch =
-    | { op: 'replace'; path: string; value: unknown }
-    | { op: 'add'; path: string; value: unknown }
-    | { op: 'remove'; path: string }

package/src/lib/ui/runtime/types/PathWalk.ts

@@ -1,10 +0,0 @@
-/*
-The result of walking a `/`-joined path through a tree: whether the path still
-resolves to an own slot at every segment, and the value it holds. `exists` is
-false when a segment is missing (a deleted key, an out-of-range index); `value`
-is then `undefined`. Separates a missing path from one holding a real `undefined`.
-*/
-export type PathWalk = {
-    exists: boolean
-    value: unknown
-}

package/src/lib/ui/runtime/types/ReactiveLink.ts

@@ -1,21 +0,0 @@
-import type { ReactiveNode } from './ReactiveNode.ts'
-
-/*
-One dependency edge in the reactive graph: `sub` (the observer) reads `dep` (the
-source). The edge is threaded into two intrusive doubly-linked lists at once — the
-source's list of subscribers (the `*Sub` pointers, walked forward on a write) and
-the observer's list of dependencies (the `*Dep` pointers, walked on recompute to
-reuse or drop edges). Replacing the former `Set` on each side makes link/unlink
-O(1) with no per-edge allocation once a node settles, and propagation a sequential
-pointer walk instead of a hashed-set iteration.
-*/
-export type ReactiveLink = {
-    dep: ReactiveNode
-    sub: ReactiveNode
-    /* Siblings in `sub`'s dependency list (the edges `sub` captured, in read order). */
-    prevDep: ReactiveLink | undefined
-    nextDep: ReactiveLink | undefined
-    /* Siblings in `dep`'s subscriber list (every observer reading `dep`). */
-    prevSub: ReactiveLink | undefined
-    nextSub: ReactiveLink | undefined
-}

package/src/lib/ui/runtime/types/ReactiveNode.ts

@@ -1,33 +0,0 @@
-import type { ReactiveLink } from './ReactiveLink.ts'
-
-/*
-A node in the reactive graph. A signal has a value and no compute; a computed has
-both; an effect has a compute and runs for its side effects. Dependencies (the
-nodes this node read on its last run) and subscribers (the nodes that read this
-one) are each held as an intrusive doubly-linked list of `ReactiveLink` edges
-rather than a `Set` — a write walks `subsHead → nextSub` forward to dependents, a
-recompute walks `depsHead → nextDep` to reuse still-live edges and drop stale
-back-links, both O(1) per edge with no allocation once the node settles.
-
-`depsTail` doubles as the recompute cursor: `runNode` rewinds it before compute
-and `track` advances it past each reused edge, so whatever trails it afterward is
-this run's stale dependencies, trimmed in one pass.
-*/
-export type ReactiveNode = {
-    value: unknown
-    compute: (() => unknown) | undefined
-    depsHead: ReactiveLink | undefined
-    depsTail: ReactiveLink | undefined
-    subsHead: ReactiveLink | undefined
-    subsTail: ReactiveLink | undefined
-    /* The node's settle-state for push-pull propagation: CLEAN / CHECK / DIRTY (see
-       NODE_STATE). A signal is always CLEAN (no compute); a computed is born DIRTY and
-       cycles CLEAN→CHECK/DIRTY→CLEAN as deps change and reads settle it. */
-    status: number
-    /* Throw memoisation: what the last compute threw (commonly a `SuspenseSignal`
-       pause), retained while the node sits CLEAN so EVERY reader observes the pause or
-       error — not just the one whose read ran the compute. Cleared by the next
-       successful run; undefined on a signal (no compute to throw). */
-    thrown: unknown
-    isEffect: boolean
-}

package/src/lib/ui/runtime/types/RenderContext.ts

@@ -1,10 +0,0 @@
-/* The per-request SSR render context, threaded through a layout chain and every
-   child component a page inlines. It is the block-id counter MAP (ADR-0037): each
-   `await`/`try` block draws a path-namespaced id via `blockId(ctx)` — keyed by the
-   ambient render-path, counting 0,1,2… in document order WITHIN each path. Both sides
-   compose the same ids (the client mounts each child under the same path), so the
-   streamed fragments and the `RESUME` manifest line up. Request-local (not a module
-   global) because SSR render is async and concurrent — but sibling child renders write
-   different path keys, so the shared map needs no locking and survives parallel renders
-   (which a single flat counter could not). */
-export type RenderContext = Map<string, number>

package/src/lib/ui/runtime/types/Route.ts

@@ -1,9 +0,0 @@
-/* A routable page/layout. Callable to mount directly into a host (the direct-mount
-   API), but the router instead uses `build` — the bare client build — to fill the
-   layer into its outlet boundary as a marker range (no `<abide-outlet>` wrapper; see
-   `fillBoundary`/`outlet`). `hydratable` (always true for compiled components; undefined on manually-constructed
-   Route objects) tells the router whether the first paint adopts the SSR DOM in place. */
-export type Route = ((host: Element, props?: unknown) => (() => void) | undefined) & {
-    build: (host: Node, props?: unknown) => void
-    hydratable?: boolean
-}

package/src/lib/ui/runtime/types/RouteLoader.ts

@@ -1,7 +0,0 @@
-import type { Route } from './Route.ts'
-
-/* A code-split page entry: imports the page chunk on demand, yielding its default
-   Route. The router resolves a loader on first match and caches the result, so
-   each page's chunk downloads only when its route is first visited — not all of
-   them up front at boot. Mirrors the `_virtual/pages` manifest shape. */
-export type RouteLoader = () => Promise<{ default: Route }>

package/src/lib/ui/runtime/types/SsrRender.ts

@@ -1,34 +0,0 @@
-import type { ResumeEntry } from '../RESUME.ts'
-
-/* One STREAMING await block captured during SSR (no `then` on the `await` tag): its
-   boundary id, the promise to await, and the async string-renderers for the resolved
-   value / error. `renderToStream` flushes each resolved fragment out of order. The
-   renderers are async so a nested `await` block inside the branch composes. `catch`
-   is absent when the block has no catch branch — a rejection then surfaces to the
-   stream/error path instead of rendering an empty branch. (Blocking awaits — a `then`
-   on the tag — never land here: they render inline during the async render pass and
-   seed `SsrRender.resume`.) */
-export type SsrAwait = {
-    id: string
-    promise: () => unknown
-    then: (value: unknown) => Promise<string>
-    catch?: (error: unknown) => Promise<string>
-    /* ADR-0039 (spike): a STANDALONE-UNIT boundary — a streamed child COMPONENT — carries no
-       resume value of its own (its `then` returns the child's rendered html and merges the child's
-       own awaits/resume for nested composition; the child re-mounts client-side rather than
-       adopting a RESUME[id] value). Marks `settle` to emit an html-only fragment with no resume seed
-       script, so the client never tries to decode a whole SsrRender as an await value. Absent for a
-       normal await block (which seeds its resolved value). */
-    htmlOnly?: boolean
-}
-
-/* The result of a component's server `render()`: the pending-shell HTML, the
-   serializable document snapshot for client resume, the STREAMING await blocks to
-   flush out of order, and `resume` — the inline-rendered BLOCKING await values keyed
-   by boundary id, seeded into the manifest so hydration adopts them without a refetch. */
-export type SsrRender = {
-    html: string
-    state: unknown
-    awaits: SsrAwait[]
-    resume: Record<string, ResumeEntry>
-}

package/src/lib/ui/runtime/types/State.ts

@@ -1,3 +0,0 @@
-/* A writable reactive cell. Reading `.value` subscribes the running observer;
-   assigning it notifies subscribers (an `Object.is`-equal write is a no-op). */
-export type State<T> = { value: T }

package/src/lib/ui/runtime/types/Teardown.ts

@@ -1,5 +0,0 @@
-/*
-The cleanup an effect or attachment body may return. Optionally async — abide runs
-it but never awaits it, so teardown never blocks the reactive flush.
-*/
-export type Teardown = () => void | Promise<void>

package/src/lib/ui/runtime/types/UiComponent.ts

@@ -1,24 +0,0 @@
-import type { RenderContext } from './RenderContext.ts'
-import type { SsrRender } from './SsrRender.ts'
-import type { UiProps } from './UiProps.ts'
-
-/*
-A compiled abide-ui component's default export: the client mounter, plus `render`
-for SSR and the hydration hooks. This is the shape `compileModule` emits and the
-page/route registries carry — abide-ui's compiled-component shape.
-*/
-export type UiComponent = ((host: Element, props?: UiProps) => () => void) & {
-    /* `ctx` is the request-local block-id counter, threaded so a child's ids share the
-       page's depth-first numbering; omitted at the top level (a fresh counter defaults
-       in). Returns a Promise when the component contains an inline `await` — a blocking
-       `{#await … then}` block, a child-component render, a `<slot>` read, or a
-       top-level `await` in the author script; otherwise renders synchronously. Callers `await`
-       it either way (awaiting a sync value just returns it). */
-    render: (props?: UiProps, ctx?: RenderContext) => SsrRender | Promise<SsrRender>
-    hydrate?: (host: Element, props?: UiProps) => () => void
-    /* The bare client build (`(host, props) => void`) — appends the component's nodes
-       to `host`. A nested child mounts it into a marker range (`mountRange`/`mountChild`)
-       instead of the wrapped `mount`. */
-    build: (host: Node, props?: UiProps) => void
-    hydratable?: boolean
-}

package/src/lib/ui/runtime/types/UiProps.ts

@@ -1,12 +0,0 @@
-/*
-What a component is invoked with. A top-level page/layout is called by the router
-(client) and `renderChain` (SSR) with its route params as reactive thunks, shaped
-identically to the thunk map `mountChild` passes a nested child — so `props()` reads
-(`$props[name]?.()`) work uniformly on both. `children` is an ordinary prop thunk like
-any other: on a component it returns the parent's `Snippet`; on a layout with a child
-layer below it, the router/SSR set it to `() => CHILD_PRESENT` (a presence sentinel, not
-a slot builder) so `{#if children}` reads truthy.
-*/
-export type UiProps = Record<string, () => unknown> & {
-    children?: () => unknown
-}

package/src/lib/ui/runtime/unescapeKey.ts

@@ -1,12 +0,0 @@
-/*
-Reverses `escapeKey` for one path segment (JSON Pointer RFC 6901): `~1`→`/`,
-`~0`→`~`, in that order so a literal `~1` in the original key (escaped to `~01`)
-round-trips. A segment with no `~` can't carry an escape, so it returns untouched
-— the fast path for every plain-identifier segment on the hot read/split path.
-*/
-export function unescapeKey(segment: string): string {
-    if (!segment.includes('~')) {
-        return segment
-    }
-    return segment.replace(/~1/g, '/').replace(/~0/g, '~')
-}

package/src/lib/ui/runtime/unlinkDeps.ts

@@ -1,28 +0,0 @@
-import { abortNode } from './abortNode.ts'
-import { detachLink } from './detachLink.ts'
-import { reactiveAbortState } from './reactiveAbortState.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Detaches a node from every source it reads — the dispose path for a computed or
-effect torn down with its scope. Walks the node's dependency list once, removing
-each edge from its source's subscriber list so no source keeps a back-link to a
-dead observer, then empties the node's own list. The `Set`-era equivalent was
-`for (dep of node.deps) dep.observers.delete(node); node.deps.clear()`.
-*/
-export function unlinkDeps(node: ReactiveNode): void {
-    /* Disposing tears this computation out of the graph — abort any RPC it left in
-       flight, its result would land in a scope that no longer exists. Gated inline so
-       the common disarmed dispose pays one property read, not a call. */
-    if (reactiveAbortState.armed) {
-        abortNode(node)
-    }
-    let link = node.depsHead
-    while (link !== undefined) {
-        const next = link.nextDep
-        detachLink(link)
-        link = next
-    }
-    node.depsHead = undefined
-    node.depsTail = undefined
-}

package/src/lib/ui/runtime/untrack.ts

@@ -1,20 +0,0 @@
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
-
-/*
-Runs `fn` with dependency tracking suspended: reads inside register no
-subscription on the surrounding observer. The inverse of `track` — for a
-reactive computation that must read or build without capturing those reads as
-its own dependencies. The router mounts a page inside an effect, so without this
-the page's build-time reads (every interpolation reads its value once before
-wrapping it in its own effect) would subscribe the router effect to the page's
-state — any in-page change would then re-run the router and re-mount the page.
-*/
-export function untrack<T>(fn: () => T): T {
-    const previous = REACTIVE_CONTEXT.observer
-    REACTIVE_CONTEXT.observer = undefined
-    try {
-        return fn()
-    } finally {
-        REACTIVE_CONTEXT.observer = previous
-    }
-}

package/src/lib/ui/runtime/updateIfNecessary.ts

@@ -1,40 +0,0 @@
-import { NODE_STATE } from './NODE_STATE.ts'
-import { runNode } from './runNode.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Settles a node so its value is current before it is read (or, for an effect, before
-it runs at flush). CLEAN: nothing to do. CHECK: a transitive dependency *might* have
-changed — refresh each direct dependency in turn; refreshing one that truly changed
-marks this node DIRTY (`runNode` does the marking), so stop the moment that happens.
-DIRTY (set directly by a write, or by the check walk): recompute.
-
-A CHECK node whose dependencies all recompute to equal values ends CLEAN without
-recomputing — the value memoisation that stops an unchanged computed from waking its
-readers. Refreshing deps top-down *before* a recompute reads them is what keeps the
-pull glitch-free: a reader never observes a stale intermediate, because by the time
-it recomputes, every dependency it reads has already settled this pass.
-*/
-export function updateIfNecessary(node: ReactiveNode): void {
-    if (node.status === NODE_STATE.CLEAN) {
-        return
-    }
-    if (node.status === NODE_STATE.CHECK) {
-        let link = node.depsHead
-        while (link !== undefined) {
-            updateIfNecessary(link.dep)
-            /* A dep recomputed to a changed value and marked us DIRTY — no need to
-               check the rest, we already know we must recompute. */
-            if (node.status === NODE_STATE.DIRTY) {
-                break
-            }
-            link = link.nextDep
-        }
-    }
-    if (node.status === NODE_STATE.DIRTY) {
-        runNode(node)
-    } else {
-        /* CHECK with no changed dependency — the cached value still holds. */
-        node.status = NODE_STATE.CLEAN
-    }
-}

package/src/lib/ui/runtime/walkPath.ts

@@ -1,41 +0,0 @@
-import type { PathWalk } from './types/PathWalk.ts'
-import { unescapeKey } from './unescapeKey.ts'
-
-/*
-Walks a `/`-joined path through a plain tree in one pass, returning both whether
-the path still resolves (`exists`) and the value it holds (`value`). `''` is the
-root. Arrays index by their numeric segment as a string — JS array access coerces
-the key, and `in` covers an own index in range or `length`.
-
-The two answers are inseparable on the eviction path (`createDoc`'s descend),
-which must distinguish a path the tree no longer has (a deleted key, an
-out-of-range index after a shrink) from one holding a genuine `undefined` — a
-distinction the value alone can't make. Returning both walks the path once where
-a separate value-read + existence-check would walk it twice.
-*/
-export function walkPath(tree: unknown, path: string): PathWalk {
-    if (path === '') {
-        return { exists: tree !== undefined, value: tree }
-    }
-    /* A path with no `~` carries no escape in any segment, so the per-segment
-       unescape is skipped wholesale — the case for every plain-identifier path. */
-    const escaped = path.includes('~')
-    let current: unknown = tree
-    /* Scan `/`-separated segments by index, no `split` array allocated — this runs
-       once per candidate on the structural descend scan, the hot path's hot loop. */
-    let start = 0
-    for (;;) {
-        const slash = path.indexOf('/', start)
-        const end = slash === -1 ? path.length : slash
-        const raw = path.slice(start, end)
-        const segment = escaped ? unescapeKey(raw) : raw
-        if (current === null || typeof current !== 'object' || !(segment in current)) {
-            return { exists: false, value: undefined }
-        }
-        current = (current as Record<string, unknown>)[segment]
-        if (slash === -1) {
-            return { exists: true, value: current }
-        }
-        start = slash + 1
-    }
-}

package/src/lib/ui/runtime/withOptionalPath.ts

@@ -1,8 +0,0 @@
-import { withPath } from './withPath.ts'
-
-/* Runs `build` under the render-path segment for a compiler `ordinal`, or plainly when `ordinal`
-   is undefined (a non-compiled caller that supplied no site id). Shared by the child-mount paths so
-   the "push a path segment iff an ordinal is present" convention lives in one place. */
-export function withOptionalPath<T>(ordinal: number | undefined, build: () => T): T {
-    return ordinal === undefined ? build() : withPath(ordinal, build)
-}

package/src/lib/ui/runtime/withPath.ts

@@ -1,16 +0,0 @@
-import { CURRENT_PATH } from './CURRENT_PATH.ts'
-import { withPathFrom } from './withPathFrom.ts'
-
-/*
-Pushes one render-path segment for the duration of `build`, RELATIVE to the live ambient path,
-restoring after (synchronous build, so the save/restore is exact and nesting is a strict stack —
-the same shape `withScope`/`enterRenderPass` use). The segment is `escapeKey`-escaped and joined
-with `/`, so a segment carrying a `/` (a URL-shaped `{#each}` key) survives as one element. Used
-at sites that run DURING the initial render walk (a layout layer, a `<Child/>` mount) where the
-ambient path is the correct base. A control-flow block that rebuilds reactively after mount uses
-`withPathFrom` with a captured base instead.
-*/
-// @documentation plumbing
-export function withPath<T>(segment: string | number, build: () => T): T {
-    return withPathFrom(CURRENT_PATH.current, segment, build)
-}