@abide/abide 0.58.0 → 0.100.0

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

@@ -1,40 +0,0 @@
-import { OWNER } from './OWNER.ts'
-
-/*
-A monotonic generation an async block checks before a late continuation touches the DOM. It
-answers one question — "is the work I started still the current work?" — and is bumped on the
-two events that both invalidate in-flight work: a reactive `renew()` (a re-run supersedes the
-prior promise/drain) and the enclosing OWNER's teardown (a settle after disposal must be
-DROPPED, not run `place`/`insertBefore` on a now-detached anchor → NotFoundError). `onTeardown`
-releases extra resources at teardown (e.g. an async iterator's `return()`).
-
-Extracted from the byte-identical guard hand-rolled in `awaitBlock` and `eachAsync`. The
-teardown half is the load-bearing one: a re-run bump alone leaves a promise/drain that settles
-AFTER disposal to still pass the liveness check and crash on the dead anchor — the bug both
-sites independently had to grow.
-*/
-export function generationGuard(onTeardown?: () => void): {
-    renew: () => number
-    token: () => number
-    live: (captured: number) => boolean
-} {
-    let generation = 0
-    /* The teardown bump is load-bearing: without it a promise/drain settling after the owner
-       disposes still passes `live(captured)` and touches a detached anchor. */
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => {
-            generation += 1
-            onTeardown?.()
-        })
-    }
-    return {
-        /* Supersede any in-flight generation; call at the start of each (re-)run. Returns the
-           new token so a runner can capture it in the same statement. */
-        renew: () => (generation += 1),
-        /* The live generation to capture before an await and compare after — for when the
-           renew and the capture happen in different functions (as in awaitBlock's render). */
-        token: () => generation,
-        /* Whether `captured` is still the live generation — safe to touch the DOM. */
-        live: (captured: number) => captured === generation,
-    }
-}

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

@@ -1,151 +0,0 @@
-import type { AbideHistoryState } from './types/AbideHistoryState.ts'
-
-/*
-Per-history-entry scroll buckets for manual scroll restoration. The browser's own
-restoration is disabled (`history.scrollRestoration = 'manual'` after the first build/hydration)
-because the router tears the page down and rebuilds it AFTER the browser would have
-restored scroll — so the offset is lost against a node that no longer exists. Instead
-each history entry carries a monotonic id (stamped into `history.state.abideEntry` by
-`navigate`), and this module buckets that entry's scroll offset: `save()` records the
-outgoing offset before history moves, `restore()` reapplies the destination entry's
-offset after its DOM is rebuilt (or, for an entry seen for the first time — a fresh
-navigation — honours a `#hash` anchor when one resolves, else scrolls to the top). A
-back/forward `adopt`s the entry id read from history.state; a `replace` `discard`s the
-current bucket (its content is superseded). The in-memory `offsets` Map covers the
-same-session back/forward path; `persist()` also mirrors the live scroll into
-`history.state` (on pagehide, when state still reflects the active entry) so a RELOAD
-— where the Map is gone and `scrollRestoration='manual'` keeps the browser from
-restoring — can still recover it via `restore()`'s `persistedOffset` fallback.
-
-Scroll APIs are reached off `globalThis` (guarded) so the module is a no-op on the
-server and in headless tests that never install a window. Shared mutable singleton on
-one object, reached without a barrel — mirrors `reactiveAbortState`/`clientPage`.
-*/
-
-/* The scroll surface: the real `Window` shape, made `Partial` so every member is
-   optional — the module degrades to a no-op on the server / in headless tests that
-   never install a window. */
-const view = globalThis as unknown as Partial<Window>
-
-/* The active entry's offset persisted in `history.state` — survives a reload (the
-   in-memory `offsets` Map does not). Honoured only when the stored id matches `current`,
-   so a foreign history entry's state never restores the wrong scroll. */
-function persistedOffset(): [number, number] | undefined {
-    const state = view.history?.state as AbideHistoryState | null
-    if (state?.abideEntry === current && Array.isArray(state.scroll)) {
-        return state.scroll
-    }
-    return undefined
-}
-
-/* The element a `#hash` addresses, if the document holds one. */
-function anchorFor(hash: string | undefined): HTMLElement | undefined {
-    if (hash === undefined || hash.length <= 1 || view.document === undefined) {
-        return undefined
-    }
-    return view.document.getElementById(hash.slice(1)) ?? undefined
-}
-
-/* The active entry's scroll offset is buckets.get(current); `seq` mints fresh ids. */
-const offsets = new Map<number, [number, number]>()
-let current = 0
-let seq = 0
-
-/* Generation token for an in-flight `restore` retry chain (below); a newer restore
-   bumps it so a stale chain — from a superseded navigation — stops re-applying. */
-let restoreToken = 0
-/* Frame budget for re-applying a saved offset while the page is still filling in.
-   ~half a second at 60fps — long enough for an async page's content to settle, short
-   enough not to fight a user who starts scrolling. */
-const MAX_RESTORE_FRAMES = 30
-
-/* Re-apply a saved offset until it sticks. A restore can land before the page's async
-   content has materialised — `disposeFrom` empties the document, `buildFrom` mounts a
-   page whose blocking `<template await>` is still pending, so the document is momentarily
-   short and the browser clamps the requested offset to its tiny max (an in-page episode
-   swap reset to the top this way). Each frame re-applies; once `scrollTo` is no longer
-   clamped (the content has grown tall enough to honour the offset) the chain stops, so
-   the common case — a page already tall — applies exactly once and schedules no frame. */
-function reapplyOffset(offset: [number, number], token: number): void {
-    const apply = (framesLeft: number): void => {
-        // A newer restore superseded this chain, or the scroll surface vanished.
-        if (token !== restoreToken || typeof view.scrollTo !== 'function') {
-            return
-        }
-        view.scrollTo(offset[0], offset[1])
-        // The browser clamps to the current max; an honoured offset means the page is
-        // tall enough now — stop. Otherwise retry next frame as the content fills in.
-        const reached = (view.scrollY ?? 0) >= offset[1] && (view.scrollX ?? 0) >= offset[0]
-        if (reached || framesLeft <= 0 || typeof view.requestAnimationFrame !== 'function') {
-            return
-        }
-        view.requestAnimationFrame(() => apply(framesLeft - 1))
-    }
-    apply(MAX_RESTORE_FRAMES)
-}
-
-export const historyEntries = {
-    /* The active history entry's id — stamped into history.state by `navigate`. */
-    get current(): number {
-        return current
-    },
-    /* Mint the next entry id for a pushed history entry, making it active. */
-    next(): number {
-        current = seq += 1
-        return current
-    },
-    /* A back/forward landed on an existing entry — make it active so the following
-       save/restore target its bucket. Keeps `seq` ahead of any adopted id. */
-    adopt(entry: number): void {
-        current = entry
-        if (entry > seq) {
-            seq = entry
-        }
-    },
-    /* Bucket the active entry's current scroll offset, before history moves away. */
-    save(): void {
-        if (typeof view.scrollTo === 'function') {
-            offsets.set(current, [view.scrollX ?? 0, view.scrollY ?? 0])
-        }
-    },
-    /* Drop the active entry's bucket — a replace lands fresh content, so the saved
-       scroll no longer applies. (The replace's own `replaceState` overwrites the
-       persisted copy in `history.state`, so the durable fallback clears too.) */
-    discard(): void {
-        offsets.delete(current)
-    },
-    /* Mirror the live scroll into the active entry's `history.state` so it survives a
-       reload (the in-memory Map does not). Called on pagehide — when `history.state`
-       still reflects the active entry — merging to keep its `abideEntry` stamp. */
-    persist(): void {
-        if (typeof view.scrollTo !== 'function' || view.history === undefined) {
-            return
-        }
-        const state = (view.history.state as AbideHistoryState | null) ?? {}
-        view.history.replaceState({ ...state, scroll: [view.scrollX ?? 0, view.scrollY ?? 0] }, '')
-    },
-    /* Reapply the active entry's scroll once its DOM exists. A back/forward to a saved
-       entry returns to its offset (in-memory, else the reload-durable persisted copy);
-       a fresh entry honours a `#hash` anchor when one resolves, else scrolls to the top. */
-    restore(hash?: string): void {
-        if (typeof view.scrollTo !== 'function') {
-            return
-        }
-        /* Any restore supersedes a pending retry chain — including this top/anchor path,
-           so a later navigation to a fresh page can't have an earlier keepScroll swap's
-           re-apply fire its stale offset over it. */
-        restoreToken += 1
-        const token = restoreToken
-        const offset = offsets.get(current) ?? persistedOffset()
-        if (offset !== undefined) {
-            reapplyOffset(offset, token)
-            return
-        }
-        const anchor = anchorFor(hash)
-        if (anchor !== undefined) {
-            anchor.scrollIntoView()
-            return
-        }
-        view.scrollTo(0, 0)
-    },
-}

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

@@ -1,19 +0,0 @@
-import type { Scope } from '../types/Scope.ts'
-import { CURRENT_SCOPE } from './CURRENT_SCOPE.ts'
-
-/*
-Runs `fn` with `scope` as the ambient current scope, restoring the previous one
-after. Deferred callbacks — an event handler, an effect re-run — fire after the
-build that registered them, when `CURRENT_SCOPE` has moved on; wrapping them in
-the scope captured at registration is what makes `scope()` inside them resolve the
-scope they belong to, not whatever happens to be current when they fire.
-*/
-export function inScope<T>(scope: Scope | undefined, fn: () => T): T {
-    const previous = CURRENT_SCOPE.current
-    CURRENT_SCOPE.current = scope
-    try {
-        return fn()
-    } finally {
-        CURRENT_SCOPE.current = previous
-    }
-}

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

@@ -1,14 +0,0 @@
-/*
-True for an `async () => …` / `async function () {}`. This is the async cell's
-`await` marker at runtime: the `computed`/`linked` transform lowers `computed(await p)`
-to `computed(async () => await p)`, so an async-function seed means "unwrap the
-promise and track it" — as opposed to a plain thunk returning a promise, which is held
-opaque (`Computed<Promise<T>>`). The tag is the reliable signal (`.constructor.name`
-survives minification less reliably; `Symbol.toStringTag` is spec-stable).
-*/
-export function isAsyncFunction(value: unknown): boolean {
-    return (
-        typeof value === 'function' &&
-        (value as { [Symbol.toStringTag]?: unknown })[Symbol.toStringTag] === 'AsyncFunction'
-    )
-}

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

@@ -1,12 +0,0 @@
-import { blockId } from './blockId.ts'
-import { RENDER } from './RENDER.ts'
-
-/* The next block id in the current render pass, namespaced by the ambient render-path
-   (ADR-0037). `await`/`try` blocks draw it in document order WITHIN their path; a page
-   id and a child component's id can never collide because they carry different paths, so
-   ids stay congruent SSR↔client even when the server renders sibling children concurrently.
-   Delegates to the shared `blockId` over the client's per-pass `RENDER.blockCounters` map. */
-// @documentation plumbing
-export function nextBlockId(): string {
-    return blockId(RENDER.blockCounters)
-}

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

@@ -1,10 +0,0 @@
-import type { HydrationCursor } from './types/HydrationCursor.ts'
-
-/* Repositions the parent's claim cursor at `reference` (null = past the last child). The
-   ONE write site of the cursor invariant: every claim must leave the cursor on the next
-   unclaimed sibling, or the following claim grabs the wrong node — a silent desync. The
-   claim verbs advance through here; a block parks explicitly when it skips or discards a
-   region (an anchor's content, a boundary it re-claims later, a discarded range). */
-export function parkCursor(hydration: HydrationCursor, parent: Node, reference: Node | null): void {
-    hydration.next.set(parent, reference)
-}

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

@@ -1,10 +0,0 @@
-import { unescapeKey } from './unescapeKey.ts'
-
-/*
-Splits an escaped JSON-Pointer-style doc path into its REAL key segments
-(each segment unescaped). The path strings (parentPath, node-map keys) stay
-escaped and re-walked through `walkPath`; segments index the live tree.
-*/
-export function pathSegments(path: string): string[] {
-    return path.split('/').map(unescapeKey)
-}

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

@@ -1,15 +0,0 @@
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Shared state for scope-bound RPC abort. `controllers` maps a reactive computation
-(effect/computed) to the AbortController of the RPC(s) it fired, kept OFF
-ReactiveNode — like an effect's cleanup closure — so signals and the read/write hot
-path pay nothing. `armed` flips true the first time an RPC binds a controller and
-gates the runNode/unlinkDeps lookups, so an app that never fires a reactive RPC pays
-only one boolean check per compute run. Mirrors REACTIVE_CONTEXT's single-object
-pattern (shared mutable singletons on one object, reached without a barrel).
-*/
-export const reactiveAbortState: {
-    controllers: WeakMap<ReactiveNode, AbortController>
-    armed: boolean
-} = { controllers: new WeakMap(), armed: false }

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

@@ -1,38 +0,0 @@
-import { track } from './track.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-import { updateIfNecessary } from './updateIfNecessary.ts'
-
-/*
-Reads a node's current value and subscribes the running observer to it. A computed
-settles first (the lazy pull — `updateIfNecessary` refreshes only the deps that
-changed, recomputing if any did); a signal has no compute and returns its stored
-value directly. Tracking happens after the settle so the reader links to the
-computed itself, not its transitive deps.
-
-The settle runs in a `try` whose `finally` still links the reader: an edge to a
-node is an edge even when that node is currently PAUSED. A computed whose compute
-throws — the common case being a `SuspenseSignal` from a pending blocking cell it
-reads — must still leave its reader subscribed to it, or the reader would never
-re-run when the paused branch resolves (the compute re-runs on settle via its own
-retained deps, then this reader wakes off its edge to the computed). The signal
-fast-path stays a plain track — it has no compute to throw and is the hot read.
-*/
-export function readNode(node: ReactiveNode): unknown {
-    if (node.compute !== undefined) {
-        try {
-            updateIfNecessary(node)
-            /* Throw memoisation: a paused/erroring compute settled CLEAN with its throw
-               retained (`runNode`'s catch) — rethrow it so EVERY reader observes the
-               pause/error, not just the one whose read ran the compute. Cleared by the
-               next successful run once a dep change re-dirties the node. */
-            if (node.thrown !== undefined) {
-                throw node.thrown
-            }
-        } finally {
-            track(node)
-        }
-        return node.value
-    }
-    track(node)
-    return node.value
-}

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

@@ -1,16 +0,0 @@
-import { CURRENT_PATH } from './CURRENT_PATH.ts'
-import { withPath } from './withPath.ts'
-
-/*
-The render-path a `<Child/>` mounts under — the boundary id of a STREAMED child component (ADR-0039).
-Composes the child's ordinal segment onto the ambient path exactly as the client's dual-mode
-`mountChild` does (`withPath(ordinal, …)`), so the server-written `abide:await:CHILDPATH`
-boundary and the client adopter compute the SAME id with no counter to drift. It carries `/`
-separators and never a `:`, so a child path (`products/0`) can't collide with an await-block id
-(`products:0`). Server-emit-only (the streaming boundary is server codegen), so it tree-shakes out of
-the client bundle like `$$flight`.
-*/
-// @documentation plumbing
-export function renderPath(segment: string | number): string {
-    return withPath(segment, () => CURRENT_PATH.current)
-}

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

@@ -1,30 +0,0 @@
-import { log } from '../../shared/log.ts'
-import type { ChannelLog } from '../../shared/types/ChannelLog.ts'
-import { CURRENT_PATH } from './CURRENT_PATH.ts'
-
-/* The `hydrate` diagnostic channel. `createChannelLog` attaches a live `enabled()` (re-read per
-   call, so toggling `abide-debug` in devtools takes effect without reload) that the public
-   `ChannelLog` type narrows away — reach it here in the one place that needs it. The channel is
-   silent unless DEBUG/`abide-debug` matches `hydrate`. */
-const hydrateChannel = log.channel('hydrate') as ChannelLog & { enabled(): boolean }
-
-/*
-Reports an SSR↔client hydration divergence on the DEBUG-gated `hydrate` channel, tagged with the
-ambient render-path of the enclosing component/branch/row (`CURRENT_PATH` is coarse — it does not
-descend to the individual node/attribute, so the path locates the component, the detail names the
-value). Returns whether the caller should STILL THROW: with the channel off it returns `true`, so
-the caller's hard throw stays the default and a real desync fails loudly; with the channel on it
-warns and returns `false`, so the caller can keep hydrating and one reload surfaces EVERY
-divergence instead of aborting at the first. Structural callers ignore the return (continuing past
-a missing node desyncs the claim cursor) and throw regardless — the warn just names where first.
-*/
-export function reportHydrationDivergence(
-    summary: string,
-    detail: Record<string, unknown>,
-): boolean {
-    if (!hydrateChannel.enabled()) {
-        return true
-    }
-    hydrateChannel.warn(`${summary} at ${CURRENT_PATH.current || '(root)'}`, detail)
-    return false
-}

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

@@ -1,28 +0,0 @@
-import { isAsyncIterable } from '../../shared/isAsyncIterable.ts'
-import { isThenable } from '../../shared/isThenable.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-import type { AsyncState } from '../../shared/types/AsyncState.ts'
-import { createAsyncCell } from './createAsyncCell.ts'
-
-/*
-The ONE statement of the ADR-0045 bare-seed contract for `computed`/`linked`: a bare
-seed that reached the runtime literally (a branch-nested `<script>` keeps its
-`state.computed(...)` calls literal, and a direct JS caller never compiles) routes BY
-VALUE exactly as its thunk form would — a promise → a streaming unwrapped value cell, a
-stream → a frame cell. Anything else returns `undefined`: not async, the caller wraps it
-as a constant seed thunk. The classification order (thenable before async-iterable) and
-the streaming flag are load-bearing and shared here so the two primitives cannot drift.
-*/
-export function routeBareSeed(
-    value: unknown,
-    writable: boolean,
-    transform?: (next: unknown, previous: unknown) => unknown,
-): AsyncComputed<unknown> | AsyncState<unknown> | undefined {
-    if (isThenable(value)) {
-        return createAsyncCell(() => value, { writable, transform, streaming: true })
-    }
-    if (isAsyncIterable(value)) {
-        return createAsyncCell(() => value, { writable, transform })
-    }
-    return undefined
-}

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

@@ -1,69 +0,0 @@
-import { hydrationWindow } from '../../shared/hydrationWindow.ts'
-import { enterRenderPass } from './enterRenderPass.ts'
-import { exitRenderPass } from './exitRenderPass.ts'
-import { RENDER } from './RENDER.ts'
-import { SEED_MARKS } from './SEED_MARKS.ts'
-
-/*
-The one owner of a hydration pass's lifecycle. A pass is four lifetimes that must open
-and close together — the claim cursor (`RENDER.hydration`), the cache-withhold window
-(`hydrationWindow`, which `cache.peek` reads), the block-id render pass
-(`enterRenderPass`), and the two-phase seed consume (`SEED_MARKS`/`consumeSeed`,
-ADR-0048): the seeds a pass adopts are only MARKED while it runs, deleted on the
-OUTERMOST clean exit, and left in place on a throw — so the caller's
-discard→cold-rebuild recovery re-adopts the SSR-resolved values instead of refetching
-(a cold refetch would leave blocking `await` cells pending and escape as an uncaught
-SuspenseSignal at mount).
-
-Both entry points (`hydrate`, the router's hydrating first mount) run through here, so
-the bracket order and the throw semantics can't drift between them. Nesting is safe:
-the cursor saves/restores, the window/render-pass are depth-counted, and a nested
-clean exit hands its marks to the enclosing pass rather than committing — if the outer
-pass later throws, the nested pass's seeds are still in place for the recovery rebuild.
-*/
-export function runHydrationPass<T>(run: () => T): T {
-    const previous = RENDER.hydration
-    const previousMarks = SEED_MARKS.current
-    RENDER.hydration = { next: new Map() }
-    SEED_MARKS.current = new Map()
-    try {
-        hydrationWindow.enter()
-        enterRenderPass()
-        try {
-            const result = run()
-            const marks = SEED_MARKS.current
-            if (previousMarks === undefined) {
-                /* Outermost clean pass: spend the adopted seeds, preserving the one-shot
-                   contract (a later mount at the same render-path re-inits fresh, never a
-                   stale snapshot). */
-                for (const [store, keys] of marks) {
-                    for (const key of keys) {
-                        delete store[key]
-                    }
-                }
-            } else {
-                /* Nested clean pass: merge the marks upward — only the outermost owner
-                   commits, so an outer throw still leaves every value in place. */
-                for (const [store, keys] of marks) {
-                    let outerKeys = previousMarks.get(store)
-                    if (outerKeys === undefined) {
-                        outerKeys = new Set()
-                        previousMarks.set(store, outerKeys)
-                    }
-                    for (const key of keys) {
-                        outerKeys.add(key)
-                    }
-                }
-            }
-            return result
-        } finally {
-            exitRenderPass()
-            RENDER.hydration = previous
-            /* Outermost exit clears the window and wakes the peeks this pass withheld for
-               SSR congruence, now that the warm value is congruent to show. */
-            hydrationWindow.exit()
-        }
-    } finally {
-        SEED_MARKS.current = previousMarks
-    }
-}

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

@@ -1,75 +0,0 @@
-import { abortNode } from './abortNode.ts'
-import { endTracking } from './endTracking.ts'
-import { NODE_STATE } from './NODE_STATE.ts'
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
-import { reactiveAbortState } from './reactiveAbortState.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Runs a compute node (computed or effect) with dependency capture. Rewinds the
-recompute cursor (`depsTail`) to the start of the dependency list, installs itself
-as the current observer so reads inside `compute` re-link via `track`, runs, then
-trims every edge `track` didn't reuse — last run's dependencies that weren't read
-this time. Re-capturing every run is what makes dependencies dynamic: a branch not
-taken this run leaves its edges past the cursor, so they are dropped here. Returns
-the fresh value (used by lazy computed reads).
-*/
-export function runNode(node: ReactiveNode): unknown {
-    /* This run supersedes the prior one — abort any RPC it left in flight before
-       re-tracking, so a stale request never lands after a newer one started. The
-       `armed` gate inlines here so an app that never fires a reactive RPC pays one
-       property read on this hot path, not a call. */
-    if (reactiveAbortState.armed) {
-        abortNode(node)
-    }
-    /* Rewind: track() walks forward from here, reusing matching edges in order. */
-    node.depsTail = undefined
-    const previous = REACTIVE_CONTEXT.observer
-    REACTIVE_CONTEXT.observer = node
-    try {
-        const next = node.compute?.()
-        /* Value memoisation: only a computed whose result actually changed marks its
-           subscribers DIRTY, so the in-progress check walk recomputes them. An
-           Object.is-equal recompute leaves them at CHECK — they settle back to CLEAN
-           on read without re-running, never waking downstream. An effect has no value
-           worth comparing and no subscribers, so this is a no-op for it (its body ran
-           inside compute above). The subscriber list isn't re-linked here — only its
-           members' `status` is bumped — so walking it live is safe.
-
-           This bumps status directly, bypassing `mark` — it neither enqueues effects nor
-           propagates CHECK onward, yet nothing is missed: this recompute only happens
-           while settling a subscriber that was itself reached from the originating
-           write's `mark` propagation, which already CHECK-marked (and so enqueued) every
-           effect in this cone on their CLEAN→CHECK edge. So every subscriber here is
-           already CHECK/queued; the direct write only UPGRADES it CHECK→DIRTY so its own
-           settle recomputes instead of memoising back to CLEAN. */
-        if (!Object.is(node.value, next)) {
-            node.value = next
-            let link = node.subsHead
-            while (link !== undefined) {
-                link.sub.status = NODE_STATE.DIRTY
-                link = link.nextSub
-            }
-        }
-        node.status = NODE_STATE.CLEAN
-        node.thrown = undefined
-        return node.value
-    } catch (error) {
-        /* The compute threw — commonly a `SuspenseSignal` from a pending blocking cell it read,
-           propagating the pause down this edge. Settle the node CLEAN anyway (its value is left
-           stale) so a later change to the deps it DID track before throwing re-marks it DIRTY and
-           re-propagates to its subscribers; left DIRTY, `mark`'s status gate would take the
-           settle's CLEAN→DIRTY edge as already-dirty and leave the node permanently inert — the
-           same reset `flushEffects` applies to a thrown effect. The throw is also RETAINED on the
-           node: a CLEAN settle memoises, so without it only this first reader would observe the
-           pause/error and every later reader would silently get the stale value — `readNode`
-           rethrows the retained throw until the next successful run clears it. */
-        node.status = NODE_STATE.CLEAN
-        node.thrown = error
-        throw error
-    } finally {
-        REACTIVE_CONTEXT.observer = previous
-        /* Drop the edges `track` didn't reuse — last run's now-stale dependencies. */
-        endTracking(node)
-    }
-}

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

@@ -1,9 +0,0 @@
-import { state } from '../state.ts'
-import type { State } from './types/State.ts'
-
-/* The current route as a reactive signal — read by `router` to pick the page,
-   written by `navigate`/`popstate`. Defaults to `/` where there is no location
-   (the server, which routes by request URL instead). */
-export const runtimePath: State<string> = state(
-    typeof location !== 'undefined' ? location.pathname + location.search + location.hash : '/',
-)

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

@@ -1,46 +0,0 @@
-import { OWNER } from './OWNER.ts'
-import { untrack } from './untrack.ts'
-
-/*
-Runs `build` under a fresh ownership scope so every effect and listener created
-inside is collected, and returns a disposer that tears them all down in reverse
-order (children before parents). Save/restore of the previous owner makes scopes
-nest — a list row's scope sits inside its component's scope.
-
-The build runs UNTRACKED. A detached subtree is built synchronously, and when that
-build happens inside a swap effect (a control-flow block re-running `each`/`when`/
-`switch`/`await`) its top-level reads would otherwise subscribe THAT effect, so any
-in-content state change would re-run the block and rebuild the whole subtree. The
-content's own interpolations still track normally — each wraps its read in its own
-effect, which re-installs itself as the observer. Untracking here is the framework's
-invariant (a build never subscribes its builder) stated once, so no control-flow
-block has to remember it; it's a harmless no-op for top-level builds (mount/hydrate),
-where there is no surrounding observer to leak into.
-*/
-export function scope(build: () => void): () => void {
-    const previous = OWNER.current
-    const disposers: Array<() => void> = []
-    OWNER.current = disposers
-    try {
-        untrack(build)
-    } catch (error) {
-        /* A build that throws partway (e.g. a hydration desync deep in a subtree) has
-           already created and subscribed some effects/listeners. The caller never
-           receives this scope's disposer on the throw path, so tear down what was built —
-           in reverse, children before parents — before rethrowing; otherwise those effects
-           stay subscribed forever with no owner able to dispose them. */
-        for (let index = disposers.length - 1; index >= 0; index -= 1) {
-            disposers[index]?.()
-        }
-        disposers.length = 0
-        throw error
-    } finally {
-        OWNER.current = previous
-    }
-    return () => {
-        for (let index = disposers.length - 1; index >= 0; index -= 1) {
-            disposers[index]?.()
-        }
-        disposers.length = 0
-    }
-}

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

@@ -1,40 +0,0 @@
-import { OWNER } from './OWNER.ts'
-
-/*
-A set of child-scope disposers that composes with the enclosing owner. `scope()`
-returns a disposer but does NOT self-register, so a control-flow block's live
-children — a branch, a list row — would outlive an owner teardown (a navigation):
-the leak every block otherwise hand-wires against, several incorrectly. A block
-creates one group, then `track`s each child it builds:
-
-  `track(dispose)` adopts a child's disposer and returns a wrapper that disposes it
-  AND drops it from the group — call the wrapper on a flip/prune (it's idempotent, so
-  a second call is a no-op). Whatever stays tracked is disposed once, when the
-  enclosing owner tears down. A swapped-out child is already dropped, so owner
-  teardown only ever runs the children still live.
-
-This is the single mechanism `when`/`switch`/`await`/`try`/`each`/`eachAsync` share
-in place of each re-deriving owner composition (where the divergence bred the leaks).
-*/
-export function scopeGroup(): { track: (dispose: () => void) => () => void } {
-    const live = new Set<() => void>()
-    const track = (dispose: () => void): (() => void) => {
-        live.add(dispose)
-        return () => {
-            if (live.delete(dispose)) {
-                dispose()
-            }
-        }
-    }
-    /* One teardown for the whole group; disposes whatever children are still live when
-       the owner goes. Outside any scope (a standalone block) the group owns nothing. */
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => {
-            for (const dispose of live) {
-                dispose()
-            }
-            live.clear()
-        })
-    }
-    return { track }
-}