@abide/abide 0.58.0 → 0.100.0

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

@@ -1,30 +0,0 @@
-import type { PendingAsyncCells } from '../../shared/types/PendingAsyncCells.ts'
-
-/*
-The swappable backing for the PER-RENDER async-cell barrier override (ADR-0037 Phase 2). Mirrors
-`ambientPathBacking`: the default is an inert passthrough (no override — the barrier list resolves
-through the per-request `pendingAsyncCellsSlot` as before), and the server installs an
-AsyncLocalStorage-backed variant (`renderCellBarrierStore`) so a hoisted child render can run its
-async cells under its OWN list.
-
-Why a per-render override at all: sibling child renders that run CONCURRENTLY (the parallel-SSR
-hoist) each register cells on the request-scoped pending list, and `settleAsyncCells` drains it with
-`splice(0)` — so one child's barrier would drain a sibling's cells, letting that sibling's template
-peek a still-pending value. Running each hoisted child under `isolateCellBarrier` gives it a fresh
-list (via `run`), so `activePendingCells()` returns that list for the child's registrations and its
-own barrier drain — isolated from every concurrent sibling and from the page. `current()` returns
-`undefined` outside any isolated render, so the page's own cells fall through to the request list
-unchanged. Kept out of `node:async_hooks` on the client: the default backing is pure JS, and the ALS
-variant is installed only server-side.
-*/
-export const cellBarrierBacking: {
-    active: {
-        current: () => PendingAsyncCells | undefined
-        run: <T>(list: PendingAsyncCells, render: () => T) => T
-    }
-} = {
-    active: {
-        current: () => undefined,
-        run: (_list, render) => render(),
-    },
-}

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

@@ -1,8 +0,0 @@
-import type { HydrationCursor } from './types/HydrationCursor.ts'
-
-/* The next server-rendered node to claim under `parent` during hydration — a PROBE
-   (the cursor doesn't move), defaulting to the first child when the pointer hasn't
-   been set yet. The claim verbs read through this and advance via `parkCursor`. */
-export function claimChild(hydration: HydrationCursor, parent: Node): Node | null {
-    return hydration.next.has(parent) ? (hydration.next.get(parent) ?? null) : parent.firstChild
-}

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

@@ -1,27 +0,0 @@
-import { CURRENT_PATH } from './CURRENT_PATH.ts'
-import { claimChild } from './claimChild.ts'
-import { reportHydrationDivergence } from './reportHydrationDivergence.ts'
-import type { HydrationCursor } from './types/HydrationCursor.ts'
-
-/*
-A hydration claim that MUST succeed. Like `claimChild`, but throws a structural error
-when the cursor has no node to claim. A null here means the SSR markup and the client
-build disagree about the tree at this position — a hydration desync. Cast away unguarded
-(as the claim sites did), that null/undefined derefs several mounts later, far from the
-cause; throwing names what was expected AT the divergence, turning the SSR == client DOM
-invariant from a compile-time-only parity test into a runtime guard. Use only where the
-compiled skeleton GUARANTEES a node — control-flow range markers, keyed-row boundaries —
-never where an end-of-list null is legitimate (e.g. a trailing reactive text binding).
-*/
-export function claimExpected(hydration: HydrationCursor, parent: Node, expected: string): Node {
-    const node = claimChild(hydration, parent)
-    if (node === null) {
-        /* Name where first on the `hydrate` channel (return ignored — a missing structural node
-           desyncs the claim cursor, so unlike a text miss this can't safely continue) then throw. */
-        reportHydrationDivergence('structure desync', { expected })
-        throw new Error(
-            `[abide] hydration desync at ${CURRENT_PATH.current || '(root)'}: expected ${expected} here, but the server DOM had no matching node — SSR markup and the client build disagree on structure at this position.`,
-        )
-    }
-    return node
-}

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

@@ -1,13 +0,0 @@
-import { claimExpected } from './claimExpected.ts'
-import { parkCursor } from './parkCursor.ts'
-import type { HydrationCursor } from './types/HydrationCursor.ts'
-
-/* Claims a compiler-guaranteed marker node (a range bracket, a block/boundary comment,
-   a keyed-row bracket) at the parent's cursor and advances past it. Throws a legible
-   structural desync when no node is there (`claimExpected`) — a missing marker means
-   SSR markup and the client build disagree on structure at this position. */
-export function claimMarker(hydration: HydrationCursor, parent: Node, expected: string): Comment {
-    const node = claimExpected(hydration, parent, expected)
-    parkCursor(hydration, parent, node.nextSibling)
-    return node as Comment
-}

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

@@ -1,22 +0,0 @@
-import { claimChild } from './claimChild.ts'
-import { parkCursor } from './parkCursor.ts'
-import type { HydrationCursor } from './types/HydrationCursor.ts'
-
-/* Claims a run of `count` top-level server-rendered siblings at the parent's cursor and
-   parks it past them (a short run — the server DOM ending early — parks on null). The
-   static-clone paths advance through this: the markup is byte-identical to the server's,
-   so nothing inside needs claiming individually. `into` collects the claimed nodes when
-   the caller resolves holes against them (`skeleton`); omitted, the run is only skipped. */
-export function claimRun(
-    hydration: HydrationCursor,
-    parent: Node,
-    count: number,
-    into?: Node[],
-): void {
-    let node = claimChild(hydration, parent)
-    for (let index = 0; index < count && node !== null; index += 1) {
-        into?.push(node)
-        node = node.nextSibling
-    }
-    parkCursor(hydration, parent, node)
-}

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

@@ -1,116 +0,0 @@
-import type { PageSnapshot } from '../../shared/types/PageSnapshot.ts'
-import { state } from '../state.ts'
-import { batch } from './batch.ts'
-import type { State } from './types/State.ts'
-
-/*
-The client-side page snapshot the `page` proxy reads (startClient registers
-`() => clientPage.value` as the page resolver). Server renders never touch this —
-there the resolver reads the per-request store instead.
-
-GRANULAR by field: rather than one signal holding the whole snapshot (which woke
-every `page.*` reader on any navigation), each field is its own cell and each param
-key its own lazily-created cell. So a reader of `page.params.id` subscribes to the id
-cell alone and is NOT woken when `page.params.rest` changes (stepping between episodes
-on one detail page) — no manual `computed` memo needed at the call site.
-
-The `.value` get/set API is unchanged, so the router and tests still read
-`clientPage.value.url` and write `clientPage.value = {…}`: the getter returns a STABLE
-snapshot whose field accessors do the granular reads (returning a stable object is what
-stops `clientPage.value` itself from subscribing to everything — a subscription happens
-only when a field is read), and the setter reconciles each field cell (an Object.is-equal
-write is a no-op, so an unchanged id never fires).
-*/
-
-const routeCell = state<string>('')
-const navigatingCell = state<boolean>(false)
-const urlCell = state<URL>(
-    typeof location === 'undefined' ? new URL('http://localhost/') : new URL(location.href),
-)
-
-/* Per-param-key cells, created on first read/write of a key. A page that reads
-   `page.params.id` mints the id cell and subscribes to it alone. Keys persist across
-   navigations (the Map is bounded by the app's param vocabulary); a route that drops a
-   key sets its cell to undefined so its readers wake to the absence. */
-const paramCells = new Map<string, State<string | undefined>>()
-function paramCell(key: string): State<string | undefined> {
-    let cell = paramCells.get(key)
-    if (cell === undefined) {
-        cell = state<string>()
-        paramCells.set(key, cell)
-    }
-    return cell
-}
-
-/* The surface `page.params` exposes: each key access is a granular cell read, so it
-   tracks per-key like the underlying object would, but reactively. */
-const paramsProxy = new Proxy({} as Record<string, string>, {
-    get: (_target, key) => (typeof key === 'string' ? paramCell(key).value : undefined),
-    has: (_target, key) => typeof key === 'string' && paramCell(key).value !== undefined,
-    ownKeys: () =>
-        [...paramCells].filter(([, cell]) => cell.value !== undefined).map(([key]) => key),
-    getOwnPropertyDescriptor: (_target, key) => {
-        if (typeof key !== 'string') {
-            return undefined
-        }
-        const value = paramCell(key).value
-        if (value === undefined) {
-            return undefined
-        }
-        return { enumerable: true, configurable: true, value }
-    },
-})
-
-/* The stable snapshot `clientPage.value` returns — reading a field does the granular
-   cell read, so a reader subscribes to that field alone. */
-const snapshot: PageSnapshot = {
-    get route(): string {
-        return routeCell.value
-    },
-    get params(): Record<string, string> {
-        return paramsProxy
-    },
-    get url(): URL {
-        return urlCell.value
-    },
-    get navigating(): boolean {
-        return navigatingCell.value
-    },
-}
-
-/* Reconcile the param cells to `next`: write each key (Object.is in the cell skips a
-   no-op, so an unchanged id stays asleep), clear any key the new route dropped. The
-   spread-and-rewrite paths (`{ ...clientPage.value, navigating }`) hand our own proxy
-   straight back — a no-op, recognised by identity. */
-function reconcileParams(next: Record<string, string>): void {
-    if (next === paramsProxy) {
-        return
-    }
-    for (const key of Object.keys(next)) {
-        paramCell(key).value = next[key]
-    }
-    for (const [key, cell] of paramCells) {
-        if (!(key in next)) {
-            cell.value = undefined
-        }
-    }
-}
-
-export const clientPage: { value: PageSnapshot } = {
-    get value(): PageSnapshot {
-        return snapshot
-    },
-    set value(next: PageSnapshot) {
-        /* Batch the field writes so a navigation publishes the whole snapshot atomically:
-           without it each cell write flushes effects separately, so a reader of two fields
-           (e.g. `page.url` + `page.params.id`) re-runs once per field and transiently
-           observes a half-updated snapshot (new url, stale id). Same batch idiom as
-           `createDoc` — flush once, after every cell is reconciled. */
-        batch(() => {
-            routeCell.value = next.route
-            urlCell.value = next.url
-            navigatingCell.value = next.navigating
-            reconcileParams(next.params)
-        })
-    },
-}

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

@@ -1,38 +0,0 @@
-import { SEED_MARKS } from './SEED_MARKS.ts'
-
-/*
-Reads a warm-seed entry (`CELL_SEED` / `DOC_SEED`) under the one-shot contract: a seed
-hydrates exactly one pass, so a LATER fresh mount at the same render-path can't
-warm-adopt a stale boot-time snapshot (an SPA navigation recomputes the identical key).
-
-Two-phase (ADR-0048): during a hydration pass the read MARKS the entry instead of deleting
-it — a clean pass exit deletes the marked keys, and a THROWING pass leaves every value in
-place, so the 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). WITHIN a pass the read is idempotent — a repeat read
-re-adopts the still-present value, because the repeat is a block-level cold rebuild
-reconstructing the same render-path inside the live pass (its first construction marked
-the key, then the adopt desynced); the one-shot half is enforced at pass exit, not per
-read. Outside a pass — the recovery rebuild itself, a manual client-only mount — the
-read deletes immediately, the plain one-shot.
-*/
-export function consumeSeed(store: Record<string, string>, key: string): string | undefined {
-    const marks = SEED_MARKS.current
-    if (marks === undefined) {
-        const value = store[key]
-        if (value !== undefined) {
-            delete store[key]
-        }
-        return value
-    }
-    const value = store[key]
-    if (value !== undefined) {
-        let keys = marks.get(store)
-        if (keys === undefined) {
-            keys = new Set()
-            marks.set(store, keys)
-        }
-        keys.add(key)
-    }
-    return value
-}

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

@@ -1,358 +0,0 @@
-import { ASYNC_CELL } from '../../shared/ASYNC_CELL.ts'
-import { decodeRefJson } from '../../shared/decodeRefJson.ts'
-import { isAsyncIterable } from '../../shared/isAsyncIterable.ts'
-import { isThenable } from '../../shared/isThenable.ts'
-import { resolvedCellsSlot } from '../../shared/resolvedCellsSlot.ts'
-import { streamedCellsSlot } from '../../shared/streamedCellsSlot.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-import type { AsyncState } from '../../shared/types/AsyncState.ts'
-import type { NamedAsyncIterable } from '../../shared/types/NamedAsyncIterable.ts'
-import { warmSeedKey } from '../../shared/warmSeedKey.ts'
-import { activePendingCells } from '../activePendingCells.ts'
-import type { Scope } from '../types/Scope.ts'
-import { CELL_SEED } from './CELL_SEED.ts'
-import { CURRENT_SCOPE } from './CURRENT_SCOPE.ts'
-import { consumeSeed } from './consumeSeed.ts'
-import { createEffectNode } from './createEffectNode.ts'
-import { createSignalNode } from './createSignalNode.ts'
-import { readNode } from './readNode.ts'
-import { registerStreamedCell } from './STREAMED_CELLS.ts'
-import { SuspenseSignal } from './SuspenseSignal.ts'
-import { writeNode } from './writeNode.ts'
-
-/* The seed's transform gate (mirrors `state`/`linked`): coerces every value entering
-   the store, whether from a settling promise, a frame, or a `set()`. */
-type Transform = (next: unknown, previous: unknown) => unknown
-
-type AsyncCellOptions = {
-    writable: boolean
-    transform?: Transform
-    /* ADR-0032: a STREAMING cell must NOT join the SSR blocking barrier. A no-`await` async
-       value/content position lowers to a cell that ships pending-`undefined` in the shell and
-       resolves on the client, rather than blocking the first flush inline (that is the `await`
-       tier). Absent/false → today's blocking registration (`await` tier / a keyed bare read).
-       A stream (`isAsyncIterable`) never registers regardless — this only gates a promise seed. */
-    streaming?: boolean
-}
-
-/*
-The source-agnostic async cell — the runtime behind `computed`/`linked` when the seed
-tracks a promise or a NamedAsyncIterable (ADR-0019 D1). It is **eager**: a reactive
-effect runs the seed once at construction (capturing its synchronous dependencies) and
-re-runs — a *reseed* — whenever they change, so independent cells load in parallel and a
-dependent cell re-loads when its dependency settles. The seed's result drives the cell:
-
-  - a **promise** (an `async () => await …` thunk) → unwrap; resolve → value, reject → error;
-  - a **NamedAsyncIterable** (socket / streaming rpc) → `for await` its frames, each frame
-    updating the value; the terminal error/close land on `error()` / clear in-flight;
-  - a **synchronous value** (a seed that produced one directly) → settle immediately.
-
-Read through the probe family only — there is no `.value`. `pending()` is "no value yet",
-`refreshing()` is "a held value while a fresher source is in flight" (a reseed or a
-`refresh()`), `peek()` is the retained value/latest frame (stale-while-revalidate),
-`error()` the last rejection. Every out-of-order settle is guarded by a run id, so a slow
-prior flight never overwrites a newer one. `refresh()` re-invokes the seed keeping the
-value visible; a writable cell adds `set()`, which latches until the next reseed.
-*/
-export function createAsyncCell(
-    seed: () => unknown,
-    options: AsyncCellOptions,
-): AsyncComputed<unknown> | AsyncState<unknown> {
-    const transform = options.transform
-    /* Reactive state, each its own signal so a reader subscribes only to the facets it
-       touches (peeking the value does not re-run on a pending flip, and vice versa). */
-    const valueNode = createSignalNode(undefined)
-    const errorNode = createSignalNode(undefined)
-    const inFlightNode = createSignalNode(true)
-    const hasValueNode = createSignalNode(false)
-
-    /* This cell's serialization-stable warm-seed key: its scope's render-path id + a per-scope
-       index, drawn at construction (in declaration order) so SSR and client agree on it. Minted
-       through the shared `warmSeedKey` so BOTH sides of the handoff (this same isomorphic call,
-       server-side keying `resolvedCells`/`streamedCells` and client-side reading `CELL_SEED`) form
-       the identical string from one definition. Undefined for a detached cell (no scope) — such a
-       cell never crosses SSR→client, so never warm-seeds. */
-    const scope = CURRENT_SCOPE.current as (Scope & { nextCellIndex: () => number }) | undefined
-    const warmKey = scope !== undefined ? warmSeedKey(scope.id, scope.nextCellIndex()) : undefined
-
-    /* `linked` write latch: a local `set()` holds the cell until the next reseed, so an
-       arriving frame / settling promise never clobbers an in-progress edit. Cleared on reseed. */
-    let written = false
-    /* Supersedes out-of-order settles: only the latest run's promise/stream may write. */
-    let runId = 0
-    /* The current run's in-flight promise (undefined once settled, or for a stream/sync seed).
-       Surfaced through `settled()` for the SSR barrier's structural read; a stream never sets it. */
-    let inFlight: Promise<unknown> | undefined
-    /* Cancels the active stream subscription (a reseed, refresh, or dispose supersedes it). */
-    let cancelStream: (() => void) | undefined
-    /* Whether a pending read of this cell PAUSES its reader (ADR-0046). True only for a
-       BLOCKING source — a settling PROMISE the cell would join the SSR barrier for (author
-       `await`, or a fail-open bare-call that registers): `streaming !== true` AND the seed
-       produced a thenable. A STREAM (`isAsyncIterable`) never settles and always peeks, so it
-       is NOT blocking even though it carries the same default `streaming` flag; `run` clears
-       this when it sees a stream. Resolved from the produced source, not the flag alone, so
-       `streaming: false` cannot conflate "author `await`" with "stream". */
-    let blockingSource = false
-
-    /* Store a produced value, honouring the write latch and the transform gate. */
-    const acceptValue = (value: unknown): void => {
-        if (written) {
-            return
-        }
-        writeNode(valueNode, transform === undefined ? value : transform(value, valueNode.value))
-        writeNode(hasValueNode, true)
-    }
-
-    const settleValue = (myRun: number, value: unknown): void => {
-        if (myRun !== runId) {
-            return
-        }
-        inFlight = undefined
-        acceptValue(value)
-        writeNode(errorNode, undefined)
-        writeNode(inFlightNode, false)
-        /* Server-only: record the resolved value keyed by this cell's render-path id (the `window`
-           guard keeps client settles from ever recording). BLOCKING cells → `resolvedCells`: the
-           barrier awaits them before the template peeks, so the value bakes into the SSR HTML and
-           the page renderer stamps it into the PRE-mount `__SSR__.cells` warm-seed — a warm client
-           value MATCHES it (no flash, no duplication). STREAMING cells → `streamedCells` (ADR-0035):
-           they ship pending in the shell, so their value can't ride the pre-mount seed (it would
-           diverge from the pending markup); it's streamed AFTER the shell as an `__abideResolve`
-           chunk the client adopts POST-hydration. Recording a VALUE (not awaiting a promise) means a
-           cell that never settles this request is simply never recorded — no hang. */
-        if (warmKey !== undefined && typeof window === 'undefined') {
-            if (options.streaming === true) {
-                streamedCellsSlot.get()?.entries.push({ key: warmKey, value })
-            } else {
-                resolvedCellsSlot.get()?.entries.push({ key: warmKey, value })
-            }
-        }
-    }
-
-    /* An error retains the value (SWR): a failed background refresh keeps the stale value
-       visible and surfaces the rejection through `error()` — the read decides what to do. */
-    const settleError = (myRun: number, error: unknown): void => {
-        if (myRun !== runId) {
-            return
-        }
-        inFlight = undefined
-        /* A `SuspenseSignal` is a PAUSE, not a failure — the same as the synchronous case in
-           `run`, but arriving through a REJECTION: an async seed (`computed(await f(dep))`) reads a
-           pending blocking `dep` in its synchronous prefix, and the throw becomes the thunk's
-           rejection rather than a sync throw. Stay pending (leave `inFlightNode` true, hold no
-           error); the throwing read subscribed this seed's effect to `dep` during that prefix, so
-           it re-runs and produces the real source once `dep` settles. */
-        if (error instanceof SuspenseSignal) {
-            writeNode(errorNode, undefined)
-            return
-        }
-        writeNode(errorNode, error)
-        writeNode(inFlightNode, false)
-    }
-
-    /* Drive a NamedAsyncIterable: first frame clears pending, each later frame updates the
-       value (unless written), a throw lands in `error()`, and completion clears in-flight. */
-    const consumeStream = (myRun: number, source: NamedAsyncIterable<unknown>): void => {
-        const iterator = source[Symbol.asyncIterator]()
-        let live = true
-        cancelStream = (): void => {
-            live = false
-            void iterator.return?.(undefined)
-        }
-        const pump = async (): Promise<void> => {
-            try {
-                while (live && myRun === runId) {
-                    const step = await iterator.next()
-                    if (!live || myRun !== runId) {
-                        return
-                    }
-                    if (step.done === true) {
-                        writeNode(inFlightNode, false)
-                        return
-                    }
-                    acceptValue(step.value)
-                    writeNode(errorNode, undefined)
-                    writeNode(inFlightNode, false)
-                }
-            } catch (error) {
-                settleError(myRun, error)
-            }
-        }
-        /* The pump never rejects (its body is fully try/caught), so the kickoff is contained
-           — no unhandled rejection, never Bun-fatal. */
-        void pump()
-    }
-
-    /* Run (or re-run) the seed. `reseed` marks a dependency-driven new source, which clears
-       the write latch; a `refresh()` passes false so a held write and value survive. */
-    const run = (reseed: boolean): void => {
-        runId += 1
-        const myRun = runId
-        if (cancelStream !== undefined) {
-            cancelStream()
-            cancelStream = undefined
-        }
-        if (reseed) {
-            written = false
-        }
-        writeNode(inFlightNode, true)
-
-        let produced: unknown
-        try {
-            produced = seed()
-        } catch (error) {
-            /* A `SuspenseSignal` is a PAUSE, not a failure: this seed read a blocking
-               dependency that has no value yet, so this cell's branch pauses too. Stay
-               pending — leave `inFlightNode` true, hold no value, carry no error — rather
-               than latching the pause into `error()`. The throwing read already subscribed
-               this seed's effect to the pending dependency, so when it settles the effect
-               re-runs the seed, which now reads a value and produces the real source. No
-               promise is registered (there is none), so the SSR barrier's fixpoint drain
-               picks this cell up on that re-run instead. */
-            if (error instanceof SuspenseSignal) {
-                /* This cell's pending reads must PAUSE too — the seed derives from a blocking
-                   source, so a reader peeking `undefined` (the streaming default) would race the
-                   dependency instead of waiting for it. Mark blocking from the SUSPEND itself,
-                   since a synchronously-suspending seed produces no promise for the `isThenable`
-                   branch to read it from; honour a `streaming` opt-out for symmetry with that
-                   branch. Once the seed re-runs and settles a value this flag is moot (a retained
-                   value is returned before `blocking` is ever consulted). */
-                if (options.streaming !== true) {
-                    blockingSource = true
-                }
-                if (myRun === runId) {
-                    inFlight = undefined
-                    writeNode(errorNode, undefined)
-                }
-                return
-            }
-            settleError(myRun, error)
-            return
-        }
-
-        if (isAsyncIterable(produced)) {
-            /* A stream never settles — it PEEKS `undefined` until its first frame, never pauses. */
-            blockingSource = false
-            consumeStream(myRun, produced as NamedAsyncIterable<unknown>)
-            return
-        }
-        if (isThenable(produced)) {
-            /* A settling promise the cell would join the SSR barrier for (author `await`, or a
-               fail-open bare-call) PAUSES a pending read; a `streaming` promise peeks. */
-            blockingSource = options.streaming !== true
-            inFlight = produced as Promise<unknown>
-            /* Server-only: register the in-flight promise on the request-scoped pending list so
-               the SSR barrier (`$$settleAsyncCells`) awaits it before the template peeks the
-               cell — baking the resolved value into the first-pass HTML (ADR-0019 Tier-2). A
-               stream (the `isAsyncIterable` branch above) never registers: it never settles. The
-               `window` guard keeps client construction from ever registering. A `streaming`
-               cell (ADR-0032, a no-`await` position) opts OUT: it ships pending and resolves on
-               the client instead of blocking the flush. */
-            if (typeof window === 'undefined' && options.streaming !== true) {
-                activePendingCells()?.promises.push(inFlight)
-            }
-            /* `.then(onValue, onError)` handles the rejection inline — contained in `error()`,
-               never an unhandled rejection. A STREAMING cell's resolved value is recorded in
-               `settleValue` (ADR-0035), not here — awaiting the promise could hang if it never
-               settles this request. */
-            ;(produced as PromiseLike<unknown>).then(
-                (value) => settleValue(myRun, value),
-                (error) => settleError(myRun, error),
-            )
-            return
-        }
-        settleValue(myRun, produced)
-    }
-
-    /* Warm hydrate: if the server shipped this cell's resolved value (keyed by its render-path
-       id), adopt it NOW — before the eager run — so `hasValue` is already true. The cell then reads
-       as REFRESHING (not pending) through the eager run below, so the value shows instantly with no
-       flash and matches the SSR-rendered branch. The run still fires (revalidate + subscribe the
-       seed's deps for reactivity, SWR), and its settle supersedes via the `runId` guard. Client-
-       only in effect (the store is only ever populated by `startClient`, so it's empty on the
-       server — no `window` sniff needed); a decode failure falls through to a cold run. */
-    if (warmKey !== undefined) {
-        /* One-shot via `consumeSeed` (two-phase, ADR-0048): a LATER fresh mount at the same
-           render-path can't warm-adopt this boot-time snapshot. `scope.id` is the route PATTERN
-           (params-independent), so an SPA navigation `/products/42`→`/products/99` — or a
-           back-nav that rebuilds the SSR page — recomputes the identical warmKey; unconsumed,
-           the new cell would render `/products/42`'s stale value until revalidation. During a
-           hydration pass the consume only MARKS, so a desync throw hands the seed to the cold
-           rebuild instead of losing it. */
-        const seeded = consumeSeed(CELL_SEED, warmKey)
-        if (seeded !== undefined) {
-            try {
-                acceptValue(decodeRefJson(seeded))
-            } catch {
-                /* Unserializable/corrupt seed → cold run renders it. */
-            }
-        }
-    }
-
-    /* The eager first-run + reactive reseed: the effect tracks the seed's synchronous reads,
-       so a dependency change re-runs it. Its cleanup cancels any live stream on reseed/dispose. */
-    createEffectNode(() => {
-        run(true)
-        return (): void => {
-            if (cancelStream !== undefined) {
-                cancelStream()
-                cancelStream = undefined
-            }
-        }
-    })
-
-    /* Client-only, STREAMING cells (ADR-0035): a streaming cell ships pending and its value streams
-       in AFTER the shell. Register — AFTER the eager run above, so its `inFlight = true` is already
-       set — to receive that value by render-path id; when it lands, adopt it as a reactive update:
-       the value shows immediately (no `loading…` flash) and the in-flight cold seed run re-settles
-       the same value, superseded by the write latch. The streamed value only ever seeds the initial
-       render; a later dep-driven reseed is authoritative and runs the seed as usual. */
-    if (warmKey !== undefined && options.streaming === true && typeof window !== 'undefined') {
-        registerStreamedCell(warmKey, (value) => {
-            acceptValue(value)
-            writeNode(errorNode, undefined)
-            writeNode(inFlightNode, false)
-        })
-    }
-
-    /* The shared read surface, identical for read-only and writable cells. */
-    const readOnly: AsyncComputed<unknown> = {
-        [ASYNC_CELL]: true,
-        peek: () => readNode(valueNode),
-        /* No value yet: in flight and nothing retained. */
-        pending: () => readNode(inFlightNode) === true && readNode(hasValueNode) !== true,
-        /* A held value being superseded: in flight but a value is retained. */
-        refreshing: () => readNode(inFlightNode) === true && readNode(hasValueNode) === true,
-        error: () => readNode(errorNode),
-        /* Re-invoke the seed keeping the value visible (SWR); not a reseed, so a write holds. */
-        refresh: () => run(false),
-        /* The current in-flight promise (undefined once settled / not-a-promise) — an internal
-           runtime affordance the SSR barrier reads structurally; not on the public cell types. */
-        settled: () => inFlight,
-        /* Whether a pending read of this cell PAUSES its reader (ADR-0046) — true only for a
-           blocking source (a barrier-joining settling promise), resolved from what the seed
-           produced (`blockingSource`) so a stream (which shares the default `streaming` flag)
-           is correctly NON-blocking. A getter, since the seed's eager run sets it. `readCell`
-           consults it; an internal affordance, not on the public cell type. */
-        get blocking(): boolean {
-            return blockingSource
-        },
-    } as AsyncComputed<unknown>
-    if (!options.writable) {
-        return readOnly
-    }
-    /* A writable cell adds `set()`: latches until the next reseed. `settled` rides along from
-       the `readOnly` spread (a runtime affordance not on the public type). */
-    const writable: AsyncState<unknown> = {
-        ...readOnly,
-        set: (value: unknown): void => {
-            written = true
-            writeNode(
-                valueNode,
-                transform === undefined ? value : transform(value, valueNode.value),
-            )
-            writeNode(hasValueNode, true)
-        },
-    }
-    return writable
-}

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

@@ -1,19 +0,0 @@
-import { NODE_STATE } from './NODE_STATE.ts'
-import type { ReactiveNode } from './types/ReactiveNode.ts'
-
-/* Creates a lazy computed node. Born DIRTY so its first read computes; thereafter a
-   read settles it — recomputing only when the check walk finds a dependency whose
-   value actually changed. */
-export function createComputedNode(compute: () => unknown): ReactiveNode {
-    return {
-        value: undefined,
-        compute,
-        depsHead: undefined,
-        depsTail: undefined,
-        subsHead: undefined,
-        subsTail: undefined,
-        status: NODE_STATE.DIRTY,
-        thrown: undefined,
-        isEffect: false,
-    }
-}