@abide/abide 0.58.0 → 0.101.0

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

@@ -1,24 +0,0 @@
-/*
-The render-path segment alphabet for control-flow branches — the one place the segment a
-branch's content composes under is decided, read by BOTH sides (the same pattern
-`RANGE_MARKER` uses for the wire markers, so a literal can never drift):
-
-  - the client runtimes (`when` returns THEN/ELSE as its swap key, `switchBlock` its case
-    index) hand the key to `mountSwappableRange`, which pushes `String(key)` as the branch's
-    path segment;
-  - the SSR back-end (`generateSSR`) emits the same segment around a branch's content
-    (`withPathBranch`), so a component/cell inside composes a byte-identical
-    serialization-stable id — the warm-seed key (ADR-0033).
-
-A `when` keys its branches by name; a `switchBlock` (a `{#switch}`, or an `{#if}` chain with
-any `{:elseif}`) keys each case by its index in the `[then, ...branches]` source order —
-the default at its own position.
-*/
-export const THEN_SEGMENT = 'then'
-export const ELSE_SEGMENT = 'else'
-
-/* A switchBlock case's segment: its source-order index, stringified exactly as
-   `mountSwappableRange` stringifies the numeric swap key. */
-export function caseSegment(index: number): string {
-    return String(index)
-}

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

@@ -1,12 +0,0 @@
-import { SEEDS } from '../../shared/SEEDS.ts'
-
-/* The async-cell warm-seed manifest: an SSR-resolved cell value, keyed by the cell's
-   serialization-stable render-path id (`${scope.id}:${index}`), as a ref-json-encoded STRING
-   (decoded lazily at the read site in `createAsyncCell`, so an in-process graph with cycles /
-   shared back-references survives where JSON would drop it — the same codec `RESUME` uses).
-   `startClient` drains `__SSR__.cells` into here before mount; a hydrating cell reads its key to
-   seed its value warm instead of re-running the seed (no refetch, no pending flash).
-
-   The `cells` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS). */
-// @documentation plumbing
-export const CELL_SEED: Record<string, string> = SEEDS.cells

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

@@ -1,8 +0,0 @@
-/*
-A no-op truthiness marker the router (client) and `renderChain` (SSR) set as a layout's
-`$props.children` when a child layer (a nested layout or the page) exists below it. Read
-only by `{#if children}` (→ `$props?.children`); a layout's `{children()}` lowers to the
-`outlet()` boundary the router fills, so this value is never invoked — it exists purely so
-`{#if children}` reads a uniform presence signal on both the client and the server.
-*/
-export const CHILD_PRESENT = (_host: Element): void => {}

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

@@ -1,11 +0,0 @@
-import type { Boundary } from './types/Boundary.ts'
-
-/*
-The ambient reactive error boundary — the `{#try}` mirror of `CURRENT_SCOPE`. A `tryBlock`
-sets `current` to its boundary around the guarded build so every effect created inside
-associates with it (`boundaryFor`), then restores the previous value (boundaries nest, the
-innermost wins). Undefined outside any `{#try}`; a plain mutable holder is enough — the
-value is only read on the cold path where an effect is created inside a boundary, never on
-the reactive hot path.
-*/
-export const CURRENT_BOUNDARY: { current: Boundary | undefined } = { current: undefined }

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

@@ -1,29 +0,0 @@
-import { ambientPathBacking } from './ambientPathBacking.ts'
-
-/*
-The ambient RENDER-PATH — a serialization-stable lexical id for "where in the render tree
-am I", composed top-down as the tree builds. Each nesting site pushes a segment for the
-duration of its subtree (route → layout layer → slot → `{#each}` row key → `{#if}`/`{#switch}`
-branch → child-component ordinal), and a lexical scope (`createScope`) snapshots the current
-value as its id (replacing the old process-local `scope-${n}` counter, which restarted every
-run and drifted on any SSR/client divergence). Because the path is built from compiler-stamped
-positions and runtime data keys — NOT a creation-order counter — it is order-independent
-(streaming can't shift it), and it self-handles SSR/client branch divergence: different branches
-compose different paths, so a value keyed by one never mis-adopts under the other.
-
-Segments are joined with `/` and each is `escapeKey`-escaped (RFC 6901), so a segment holding
-a `/` (a URL-shaped row key) stays one segment. `current` is `''` outside any render (a detached
-`scope()` then falls back to the counter for in-run uniqueness).
-
-`current` reads through a SWAPPABLE backing (`ambientPathBacking`) rather than a raw field, and is
-READ-ONLY: a segment is established only by `withPath`/`withPathFrom` calling the backing's `run`
-(ADR-0033 D1), never by assigning `current`. The default backing is a module variable (correct on
-the client, one render tree), but the server installs an AsyncLocalStorage-backed `run` so the
-composed path survives the inline `await`s an SSR render suspends on (the cell barrier, child
-renders) and stays isolated across concurrent requests. Mirrors `CURRENT_SCOPE`/`ambientScopeBacking`.
-*/
-export const CURRENT_PATH: { readonly current: string } = {
-    get current(): string {
-        return ambientPathBacking.active.get()
-    },
-}

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

@@ -1,23 +0,0 @@
-import type { Scope } from '../types/Scope.ts'
-import { ambientScopeBacking } from './ambientScopeBacking.ts'
-
-/*
-The ambient lexical scope. The compiler establishes one per lexical level (a
-component, a control-flow branch) by setting `current` around the build, so the
-bare `scope()` accessor and the scope-bound primitives resolve "where they are"
-with no handle threaded. Undefined outside any scope, where `scope()` mints a
-detached root on first use.
-
-`current` reads/writes through a SWAPPABLE backing (`ambientScopeBacking`) rather
-than a raw field: the default is a module variable, but the server installs an
-AsyncLocalStorage-backed holder so concurrent async SSR renders don't clobber one
-shared global across the inline `await`s they suspend on. See `ambientScopeBacking`.
-*/
-export const CURRENT_SCOPE: { current: Scope | undefined } = {
-    get current(): Scope | undefined {
-        return ambientScopeBacking.active.get()
-    },
-    set current(value: Scope | undefined) {
-        ambientScopeBacking.active.set(value)
-    },
-}

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

@@ -1,10 +0,0 @@
-import { SEEDS } from '../../shared/SEEDS.ts'
-
-/* The doc-state warm-seed manifest: an SSR-captured reactive-document snapshot, keyed by its
-   scope's serialization-stable render-path id, as a ref-json-encoded STRING (decoded at the read
-   site in `createScope`). `startClient` drains `__SSR__.docs` into here before mount; a hydrating
-   scope reads its key to seed a plain `state(initial)` to the SERVER value instead of the fresh
-   init — a uuid/timestamp/random otherwise diverges from the SSR HTML.
-
-   The `docs` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS). */
-export const DOC_SEED: Record<string, string> = SEEDS.docs

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

@@ -1,9 +0,0 @@
-/*
-The marker attribute the client back-end stamps on each hole element in a skeleton
-string — an element carrying reactive attributes/listeners/binds whose live node the
-build must wire up. Its value is the hole's index, so attach code addresses holes by
-number regardless of document order. `skeleton` records each marked node's path,
-strips the attribute, and returns the holes indexed by it. One source of truth so the
-compiler's emit and the runtime's read can't drift.
-*/
-export const HOLE_ATTRIBUTE = 'data-abide-hole'

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

@@ -1,22 +0,0 @@
-/*
-The three settle-states a reactive node moves through, for value-memoised
-(push-pull) propagation. CLEAN: the value is current. CHECK: a *transitive*
-dependency may have changed — the value can't be trusted until the direct deps are
-refreshed. DIRTY: a *direct* dependency changed — recompute.
-
-A signal write marks its direct subscribers DIRTY and the rest of their cone
-CHECK; a read then settles a node by refreshing only the deps that the check walk
-finds actually changed. A computed that recomputes to an `Object.is`-equal value
-leaves its subscribers untouched, so an unchanged value never wakes downstream —
-the memoisation a single bare boolean `dirty` flag (no CHECK tier, no value
-compare) couldn't express.
-*/
-/* Typed as `number` (not `as const` literals) so a `node.status === CHECK` guard
-   doesn't narrow the field to the literal `1` — the recursive `updateIfNecessary`
-   call mutates `status` out of band, which TS can't see, and a literal narrowing
-   would make the following `=== DIRTY` check a "no overlap" error. */
-export const NODE_STATE: {
-    readonly CLEAN: number
-    readonly CHECK: number
-    readonly DIRTY: number
-} = { CLEAN: 0, CHECK: 1, DIRTY: 2 }

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

@@ -1,10 +0,0 @@
-/* The comment-marker boundary a layout's `<slot/>` outlet lowers to — replacing the old
-   `<abide-outlet>` ELEMENT, so the next chain layer the router fills in lays out as a true
-   direct child of the slot's parent (no wrapper box breaking the layout's flex/grid/`:first-child`).
-
-   `abide:outlet` / `/abide:outlet` deliberately match `markerDepthDelta`'s `startsWith('abide:')` /
-   `startsWith('/abide:')` rule (the `abide:` / `/abide:` convention), so a layout's own hole-scanning treats the outlet's
-   future child content as a balanced range and skips it — exactly like an `await`/`try` boundary.
-   The router fills the boundary with the next layer (see `outlet`/`fillBoundary`). */
-export const OUTLET_OPEN = 'abide:outlet'
-export const OUTLET_CLOSE = '/abide:outlet'

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

@@ -1,7 +0,0 @@
-/* The compile-time AST tag a layout's `<slot/>` is rewritten to (`asOutlet`). It is a
-   sentinel only — never a rendered element: both compiler back-ends lower it to an empty
-   `<!--abide:outlet-->`…`<!--/abide:outlet-->` comment boundary (`outlet` on the client,
-   the marker string in SSR) the router fills with the next chain layer. Shared by both
-   back-ends and `skeletonContext` so they all agree which node is the outlet. */
-// @documentation plumbing
-export const OUTLET_TAG = 'abide-outlet'

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

@@ -1,8 +0,0 @@
-/*
-The ownership scope currently collecting teardown callbacks. While a component
-(or a list row) builds, `scope()` points this at an array; every effect and event
-listener created during the build pushes its disposer here, so the whole instance
-tears down together. undefined outside any build — effects in plain code own
-their own lifecycle via the disposer they return.
-*/
-export const OWNER: { current: Array<() => void> | undefined } = { current: undefined }

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

@@ -1,8 +0,0 @@
-/* The outlet boundary the most recent `outlet()` call established (a layout's `<slot/>`
-   fill point, or the router's root boundary in `#app`). The router reads it right after
-   building/claiming a layer — synchronously, so it is exactly that layer's single slot —
-   to learn where the NEXT chain layer mounts, without scanning the DOM. A layer with no
-   slot (the leaf page) leaves it whatever the router reset it to. */
-export const PENDING_OUTLET: { current: { open: Comment; close: Comment } | undefined } = {
-    current: undefined,
-}

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

@@ -1,18 +0,0 @@
-/* The comment-marker "wire alphabet" — the single source of truth for the sentinel
-   strings the SSR emit (`generateSSR`) writes into HTML comments and the hydrate scan
-   (`skeleton`) + every range-mount runtime (`when`/`switchBlock`/`each`/`mountRange`/
-   `mountSlot`/`appendSnippet`) creates as `document.createComment` nodes. Both sides
-   reference THESE constants, so a marker the server writes and the marker the client
-   looks for can never drift on a literal.
-
-   A control-flow block's rendered content sits between an OPEN (`[`) and CLOSE (`]`)
-   comment; a snippet interpolation between `abide:snippet` / `/abide:snippet` (matching
-   `skeleton`'s `abide:` / `/abide:` named-boundary convention, like `OUTLET_MARKER`); a
-   component mount between the ADDRESSED pair `abide:c:PATH` / `/abide:c:PATH` (PATH the
-   child's render-path — ADR-0049 — so a desync inside recovers at that one boundary).
-   The skeleton's own positioning anchor (`a`) sits OUTSIDE any such range. */
-export const RANGE_OPEN = '['
-export const RANGE_CLOSE = ']'
-export const ANCHOR = 'a'
-export const SNIPPET_OPEN = 'abide:snippet'
-export const SNIPPET_CLOSE = '/abide:snippet'

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

@@ -1,20 +0,0 @@
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Mutable singletons shared by every reactive primitive: the observer currently
-running (so a read can register itself as that observer's dependency), the queue
-of effects dirtied since the last flush, and the batch depth (writes inside a
-batch queue effects and flush once on exit). Held on one object so signal,
-computed, and effect all reference the same graph state without a barrel.
-
-`pendingEffects` is a plain array, not a `Set`: an effect is enqueued only on its
-CLEAN→dirty transition (`mark`'s `wasClean` gate), so it can be pushed at most once
-per flush cycle — the status machine already guarantees the dedup a `Set` would,
-without hashing every enqueue. The flush double-buffers (swaps in a fresh array) so
-effects re-dirtied mid-flush queue for the next pass.
-*/
-export const REACTIVE_CONTEXT: {
-    observer: ReactiveNode | undefined
-    pendingEffects: ReactiveNode[]
-    batchDepth: number
-} = { observer: undefined, pendingEffects: [], batchDepth: 0 }

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

@@ -1,35 +0,0 @@
-import type { HydrationCursor } from './types/HydrationCursor.ts'
-
-/*
-Render mode shared by the dom helpers. In the default (create) mode `hydration`
-is undefined and helpers build fresh nodes. During `hydrate` it holds the pass's
-claim cursor (see `HydrationCursor`): helpers claim in build order, which matches
-the SSR order, advancing through the claim verbs (`claimMarker`/`claimRun`/
-`claimText`) or parking explicitly (`parkCursor`).
-
-`blockCounters`/`depth` drive the render-pass block-id counters: every `await`/`try`
-block draws a path-namespaced id via `nextBlockId` (ADR-0037) — `blockCounters` maps
-each render-path to its own 0,1,2… sequence, counted in document order within that
-path. Namespacing by path (not one flat counter shared across a component and the
-children it inlines) is what keeps ids congruent SSR↔client even when sibling child
-renders run concurrently on the server; the client mounts each child synchronously
-under the same path, so both sides compose the same ids (`RESUME` is keyed by them).
-`depth` tracks nesting so the OUTERMOST render/mount clears the map and a child render/
-mount continues it. See `enterRenderPass`/`nextBlockId`.
-
-`namespace` is the ambient foreign-content namespace (SVG/MathML) a control-flow block
-sets from its insertion parent while building into a detached fragment, so foreign
-elements built there get the right namespace — the fragment itself carries none. It is
-undefined outside foreign content. See `enterNamespace`/`effectiveChildNamespace`.
-*/
-export const RENDER: {
-    hydration: HydrationCursor | undefined
-    blockCounters: Map<string, number>
-    depth: number
-    namespace: string | undefined
-} = {
-    hydration: undefined,
-    blockCounters: new Map(),
-    depth: 0,
-    namespace: undefined,
-}

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

@@ -1,8 +0,0 @@
-/*
-The abort reason used to cancel an RPC bound to a reactive computation when that
-computation re-runs (its result is superseded) or its scope disposes. A unique
-symbol so remoteProxy can distinguish OUR cancellation — which it swallows into a
-never-settling promise, never a rejection — from a genuine network fault or a
-caller's own abort.
-*/
-export const REQUEST_SUPERSEDED: unique symbol = Symbol('abide.request.superseded')

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

@@ -1,21 +0,0 @@
-import { SEEDS } from '../../shared/SEEDS.ts'
-
-/* The await-resume manifest: the resolved value (or error) of each streamed
-   `await` block, keyed by its boundary id. The SSR stream serializes each entry
-   alongside its fragment; the client registers it (via the inline swap script),
-   and hydration reads it so an `await` block adopts the
-   resolved branch with the real value instead of re-running the promise.
-
-   Each value is the ref-json-encoded ResumeEntry STRING, not the decoded object:
-   the entry is encoded with the ref-json codec (so a resolved value carrying cycles
-   or shared back-references survives, where JSON would drop it) and decoded lazily
-   at the read site in `awaitBlock`. Storing the raw string keeps the inline
-   stream-swap script — vanilla, running before the bundle and the codec load — able
-   to register an entry without the decoder.
-
-   The `resume` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS) —
-   the inline scripts and the framework share the same reference. */
-export type ResumeEntry = { ok: true; value: unknown } | { ok: false; error: unknown }
-
-// @documentation plumbing
-export const RESUME: Record<string, string> = SEEDS.resume

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

@@ -1,14 +0,0 @@
-/* The active hydration pass's consumed-seed marks (ADR-0048 two-phase consume): each seed a
-   pass adopts is MARKED here rather than deleted, so a THROWING pass leaves every value in
-   place for the cold rebuild to re-adopt (no shadow backup), while the OUTERMOST clean pass
-   exit deletes the marked keys — preserving the one-shot contract (an SPA re-nav to the same
-   render-path re-inits fresh). Keyed per store so a mark is an O(1) Set add on the hydrate
-   hot path. Owned by `runHydrationPass`: save/restore for nesting, and a nested clean exit
-   hands its marks to the enclosing pass instead of committing — only the outermost owner
-   spends seeds, so an outer-pass throw can still hand every value to the recovery rebuild.
-   undefined outside a pass, where `consumeSeed` falls back to delete-on-read. Deliberately
-   NOT cleared by `withoutHydration` — a fresh build inside a live pass (a block's cold
-   rebuild) still marks and re-adopts. */
-export const SEED_MARKS: {
-    current: Map<Record<string, string>, Set<string>> | undefined
-} = { current: undefined }

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

@@ -1,57 +0,0 @@
-/*
-Post-mount sink for STREAMING-cell resolutions (ADR-0035). Unlike `CELL_SEED` — the pre-mount
-warm-seed a blocking cell reads at construction — a streaming cell ships pending and its value
-arrives LATER (streamed after the shell, `__abideResolve({ cellKey, value })` →
-`seedStreamedResolution`). So a mounted streaming cell registers an `apply` fn keyed by its
-render-path id, and the streamed value is routed to it — the render-path analogue of the cache
-path's `markLifecycle` wake. A value that arrives before its cell registers is buffered and applied
-on registration (the two orderings race as the shell hydrates while chunks stream in).
-
-Backed by `globalThis.__abideStreamedCells` so an inline pre-bundle script and the framework share
-one store, mirroring `CELL_SEED`/`RESUME`.
-*/
-const globalScope = globalThis as {
-    __abideStreamedCells?: {
-        apply: Map<string, (value: unknown) => void>
-        buffer: Map<string, unknown>
-    }
-}
-globalScope.__abideStreamedCells ??= { apply: new Map(), buffer: new Map() }
-
-const store = globalScope.__abideStreamedCells
-
-/* Apply a streamed value to its cell as a POST-hydration reactive update. Deferred to a microtask
-   so it can NEVER run inside the synchronous hydration mount: the streamed `__abideResolve` chunk
-   parses (buffering the value) BEFORE the client mounts, so a synchronous apply at registration
-   would set the cell to the resolved value while the SSR DOM still shows the pending text — an
-   `assertClaimedText` desync (ADR-0033). The microtask runs after the whole synchronous mount
-   tree unwinds, so hydration claims the pending markup first and the value lands as a plain
-   reactive update (pending → resolved), congruent with a fresh mount. */
-function deferApply(apply: (value: unknown) => void, value: unknown): void {
-    queueMicrotask(() => apply(value))
-}
-
-/* A mounted streaming cell offers where to deliver its streamed value. If the value already
-   arrived (buffered), schedule it; otherwise hold the apply fn for when it streams in. */
-export function registerStreamedCell(key: string, apply: (value: unknown) => void): void {
-    if (store.buffer.has(key)) {
-        const value = store.buffer.get(key)
-        store.buffer.delete(key)
-        deferApply(apply, value)
-        return
-    }
-    store.apply.set(key, apply)
-}
-
-/* A streamed value landed for `key`. Deliver it to the registered cell (scheduled post-mount), or
-   buffer it until the cell registers. One-shot: the apply fn is consumed (a cell adopts a streamed
-   value once; later reactivity is its own reseed). */
-export function receiveStreamedCell(key: string, value: unknown): void {
-    const apply = store.apply.get(key)
-    if (apply !== undefined) {
-        store.apply.delete(key)
-        deferApply(apply, value)
-        return
-    }
-    store.buffer.set(key, value)
-}

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

@@ -1,24 +0,0 @@
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-
-/*
-The sentinel `readCell` raises when a BLOCKING cell (`cell.blocking` — an `await`-marked cell)
-has no value *yet* — "not resolved," not an error (ADR-0042 D3). It is a sibling
-of `AsyncCellError` but a DISTINCT class so the two are told apart by `instanceof`: a suspend is
-caught LOCALLY by the reading region — each DOM primitive (`appendText`, `attr`, `each`,
-`spreadAttrs`, `watch`, and the `when`/`switchBlock` condition) swallows it and withholds to an
-empty fallback, re-running on settle because the throwing read already subscribed the region's
-effect to the cell. It must never be handled as an error: `flushEffects` refuses to route a
-`SuspenseSignal` to a reactive `{#try}` (that would flash the author's `{:catch}` during loading),
-while an `AsyncCellError` still passes through. It carries the originating cell for diagnostics.
-Extends `Error` only to satisfy throw-an-Error lint and match `AsyncCellError`; it carries no
-`cause` — there is nothing wrong, the value is simply pending.
-*/
-export class SuspenseSignal extends Error {
-    readonly cell: AsyncComputed<unknown>
-
-    constructor(cell: AsyncComputed<unknown>) {
-        super('abide: suspense (value pending)')
-        this.name = 'SuspenseSignal'
-        this.cell = cell
-    }
-}

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

@@ -1,22 +0,0 @@
-import { REQUEST_SUPERSEDED } from './REQUEST_SUPERSEDED.ts'
-import { reactiveAbortState } from './reactiveAbortState.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Aborts the RPC(s) a reactive computation left in flight — called when the node
-re-runs (the prior run's result is superseded) and when its scope disposes (the
-result would land in a torn-down tree). The `armed` gate keeps this a single
-boolean check until some reactive RPC has actually bound a controller. The abort
-reason is REQUEST_SUPERSEDED so remoteProxy can tell our cancellation from a real
-fault and swallow it rather than surface a rejection.
-*/
-export function abortNode(node: ReactiveNode): void {
-    if (!reactiveAbortState.armed) {
-        return
-    }
-    const controller = reactiveAbortState.controllers.get(node)
-    if (controller !== undefined) {
-        reactiveAbortState.controllers.delete(node)
-        controller.abort(REQUEST_SUPERSEDED)
-    }
-}

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

@@ -1,32 +0,0 @@
-/*
-The swappable backing behind `CURRENT_PATH.current` — the render-path sibling of
-`ambientScopeBacking`. The default is a module variable with a synchronous save/restore `run`
-(correct on the client, whose mount is synchronous — the whole subtree builds and restores before
-control returns, so a slot never has to survive an `await`). The server swaps in an
-AsyncLocalStorage-backed `run` at boot (`installAmbientScopeStore`, ADR-0033 D1), because SSR
-composes the path while `await`ing inline (the Tier-2 cell barrier, child renders) and the pushed
-segment must be inherited by the render's own post-await continuation — a synchronously-restored slot
-cannot follow an async continuation. `run(composed, build)` establishes the composed path for
-`build`; `get()` reads the active path (`''` outside any push). Mirrors `ambientScopeBacking`.
-*/
-type PathBacking = {
-    run: <T>(composedPath: string, build: () => T) => T
-    get: () => string
-}
-
-let modulePath = ''
-
-export const ambientPathBacking: { active: PathBacking } = {
-    active: {
-        run: <T>(composedPath: string, build: () => T): T => {
-            const previous = modulePath
-            modulePath = composedPath
-            try {
-                return build()
-            } finally {
-                modulePath = previous
-            }
-        },
-        get: () => modulePath,
-    },
-}

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

@@ -1,26 +0,0 @@
-import type { Scope } from '../types/Scope.ts'
-
-/*
-The swappable backing behind `CURRENT_SCOPE.current`. The default is a module
-variable — correct on the client (one render tree) and on the server outside any
-request. The server swaps in an AsyncLocalStorage-backed holder at boot
-(`installAmbientScopeStore`), because SSR is partly async: a render brackets itself
-with `enterScope`/`exitScope` and `await`s inline between them (blocking `{#await}`,
-child renders, slots, a top-level `await`). A module global held across those awaits
-interleaves across concurrent requests — one render resumes to read another's scope.
-Keying the ambient off the per-request store (which the async context propagates
-correctly) isolates it. Mirrors `requestScopeSlot`'s server-installed slot; the
-indirection cost lands at build/effect-creation time, never on the signal hot path.
-*/
-type ScopeBacking = { get(): Scope | undefined; set(value: Scope | undefined): void }
-
-let moduleCurrent: Scope | undefined
-
-export const ambientScopeBacking: { active: ScopeBacking } = {
-    active: {
-        get: () => moduleCurrent,
-        set: (value) => {
-            moduleCurrent = value
-        },
-    },
-}

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

@@ -1,54 +0,0 @@
-import { setOwnProperty } from '../../shared/setOwnProperty.ts'
-import type { Patch } from './types/Patch.ts'
-
-/*
-Applies `patch` to `tree` by mutating in place and returns the root (a fresh
-value only when the root itself is replaced). In-place is the deliberate choice:
-the patch path already names exactly what changed, so we never need copy-on-write
-to *detect* a change — and cloning the spine made every leaf write O(width) of
-the widest ancestor (a 5k-item list copied 50k times in the bench). Mutating is
-O(depth). Change detection is served by announcing patches (the change is a value),
-not by retaining old roots — which is cheaper anyway. The wake step in createDoc
-force-notifies ancestor readers from the path, since their container keeps its
-identity now.
-
-`segments` is the patch path pre-split by the caller (createDoc also needs it),
-threaded in so the path is split once per patch rather than here and there.
-*/
-export function applyPatchToTree(tree: unknown, patch: Patch, segments: string[]): unknown {
-    /* Replacing the root can't mutate in place — hand back the new value. */
-    if (segments.length === 0) {
-        return patch.op === 'remove' ? undefined : patch.value
-    }
-    let parent = tree as Record<string, unknown>
-    for (const segment of segments.slice(0, -1)) {
-        /* Only descend into an OWN property. A segment of `__proto__`/`constructor`/
-           `prototype` is not own on a plain data object/array, so this refuses to walk
-           into a shared prototype (or the constructor function) that a later write would
-           then pollute — the real vector, since `apply` is reachable from `sync()` with
-           unvalidated peer-controlled patch paths. A legit document key that happens to be
-           named `constructor` is an own data property, so `hasOwn` still traverses it. */
-        const next = Object.hasOwn(parent, segment) ? parent[segment] : undefined
-        if (next === null || typeof next !== 'object') {
-            throw new TypeError(
-                `abide: patch path segment "${segment}" does not address a container`,
-            )
-        }
-        parent = next as Record<string, unknown>
-    }
-    const key = segments[segments.length - 1] as string
-    if (patch.op === 'replace') {
-        setOwnProperty(parent, key, patch.value)
-    } else if (patch.op === 'add') {
-        if (Array.isArray(parent)) {
-            parent.splice(key === '-' ? parent.length : Number(key), 0, patch.value)
-        } else {
-            setOwnProperty(parent, key, patch.value)
-        }
-    } else if (Array.isArray(parent)) {
-        parent.splice(Number(key), 1)
-    } else {
-        delete parent[key]
-    }
-    return tree
-}

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

@@ -1,22 +0,0 @@
-import { flushEffects } from './flushEffects.ts'
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
-
-/*
-Runs `fn` with reactive writes coalesced: effects dirtied inside queue once and
-flush a single time when the outermost batch exits, so a burst of writes (e.g. an
-event handler setting several signals) re-runs each dependent effect once instead
-of once per write. Nests safely — only the depth-0 exit flushes — so a batched
-write that calls into another batched write (a handler invoking a doc patch) still
-flushes once, at the top. Same idiom `createDoc`/`clientPage` inline, factored out.
-*/
-export function batch<T>(fn: () => T): T {
-    REACTIVE_CONTEXT.batchDepth += 1
-    try {
-        return fn()
-    } finally {
-        REACTIVE_CONTEXT.batchDepth -= 1
-        if (REACTIVE_CONTEXT.batchDepth === 0) {
-            flushEffects()
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-import { CURRENT_PATH } from './CURRENT_PATH.ts'
-
-/*
-Allocates an await/try block id NAMESPACED by the ambient render-path (ADR-0037). The id is
-`${CURRENT_PATH.current}:${n}` where `n` is a per-path counter incremented in document order —
-so blocks WITHIN one component/branch/row (one path) number 0,1,2… deterministically, while a
-child component (its own path segment) gets its own independent sequence. This replaces the old
-flat monotonic counter shared across a component and the children it inlines.
-
-Path-namespacing is what lets sibling child renders run CONCURRENTLY during SSR: their ids no
-longer depend on a globally-sequential draw order (which parallel renders would interleave), only
-on document order within each child's own path — and the server render-path is ALS-backed
-(pathStore), so each child's continuations keep their own path across awaits. The client mounts
-each child synchronously under the same path (mountChild → withPath), so both sides compose
-byte-identical ids and the resume manifest stays keyed congruently.
-
-`counters` is the per-render-pass map: the request-local `$ctx` threaded through the SSR render
-tree, or `RENDER.blockCounters` on the client (see nextBlockId). Concurrent sibling renders write
-DIFFERENT path keys, so a shared map needs no locking — each get/set is atomic and per-path.
-*/
-// @documentation plumbing
-export function blockId(counters: Map<string, number>): string {
-    const path = CURRENT_PATH.current
-    const next = counters.get(path) ?? 0
-    counters.set(path, next + 1)
-    /* Bare (pathless) render — a top-level page whose route key is `''`, or a component rendered
-       outside any route in a test — keeps the plain `0,1,2…` form; only a non-empty path qualifies
-       the id. Both sides compute the same path, so the branch is congruent, and the common bare case
-       stays identical to the pre-ADR-0037 flat counter. */
-    return path === '' ? String(next) : `${path}:${next}`
-}

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

@@ -1,11 +0,0 @@
-import type { Boundary } from './types/Boundary.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/*
-Associates an effect node with the reactive `{#try}` boundary it was created inside. Kept
-OFF the `ReactiveNode` shape — a WeakMap populated only for effects built while
-`CURRENT_BOUNDARY.current` is set — so the node stays monomorphic for signals/computeds/
-effects on the read/write hot path, and this map is consulted only on the cold throw path
-(`flushEffects.drain`'s catch), to route a guarded effect's later-run throw to its boundary.
-*/
-export const boundaryFor = new WeakMap<ReactiveNode, Boundary>()