@abide/abide 0.53.0 → 0.55.0

package/src/lib/ui/settleAsyncCells.ts

@@ -10,15 +10,42 @@ earlier settled layer's cells. `Promise.allSettled` never rejects the render: a
 rejected cell settles into its `error()` state, surfaced at the read site (via
 `$$readCell`), not here. On the client the list is always empty (cells register
 server-side only), so the barrier is a no-op await.
+
+It drains to a FIXPOINT — "await until this branch of the graph stops pausing" —
+not a single snapshot. Pending propagates down dependency edges: a blocking cell
+whose seed reads a still-pending blocking dependency stays pending and registers no
+promise (its seed threw a `SuspenseSignal`, caught as pending, not error). When the
+dependency settles inside this await, the reactive flush is synchronous, so the
+dependent's seed re-runs and registers ITS promise before the loop re-checks — the
+whole chain resolves in order. The per-render list isolation (`isolateCellBarrier`)
+keeps the loop draining only this render's cascade, never a concurrent sibling's.
+
+The round cap bounds a pathological feedback edge — a cell whose settle writes a
+signal its own seed reads re-registers a fresh promise every round, and an
+unbounded fixpoint would hang the SSR request forever. Legitimate chains resolve
+one dependency level per round, so the cap is far above any real graph; hitting
+it renders with whatever settled (the old snapshot-drain behavior) and warns.
 */
+const MAX_SETTLE_ROUNDS = 1000
+
 // @documentation plumbing
 export async function settleAsyncCells(): Promise<void> {
     const pending = activePendingCells()
     if (pending === undefined) {
         return
     }
-    const promises = pending.promises.splice(0)
-    if (promises.length > 0) {
-        await Promise.allSettled(promises)
+    let rounds = 0
+    while (pending.promises.length > 0) {
+        if (rounds >= MAX_SETTLE_ROUNDS) {
+            console.warn(
+                '[abide] settleAsyncCells did not reach a fixpoint after ' +
+                    `${MAX_SETTLE_ROUNDS} rounds — an async cell is re-registering ` +
+                    'a promise on every settle (a seed that reads state its own ' +
+                    'resolution writes). Rendering with the values settled so far.',
+            )
+            break
+        }
+        rounds += 1
+        await Promise.allSettled(pending.promises.splice(0))
     }
 }

package/src/lib/ui/socketProxy.ts

@@ -1,4 +1,6 @@
 import { buildSocketOverChannel } from '../shared/buildSocketOverChannel.ts'
+import { decodeRefJson } from '../shared/decodeRefJson.ts'
+import { SOCKET_SEED } from '../shared/SOCKET_SEED.ts'
 import type { Socket } from '../shared/types/Socket.ts'
 import { getSocketChannel } from './socketChannel.ts'
 import { watch } from './watch.ts'
@@ -22,7 +24,21 @@ socketProxy API, not the wire layer.
 */
 // @documentation plumbing
 export function socketProxy<T>(name: string): Socket<T> {
-    const socket = buildSocketOverChannel<T>(name, getSocketChannel)
+    /* Warm-seed from the server's retained frame (shipped in `__SSR__.sockets`, drained into
+       SOCKET_SEED by startClient before mount) so `peek(socket)` returns the SAME value the SSR
+       render committed to instead of undefined on this not-yet-connected client — otherwise the two
+       disagree and hydration discards the server markup. A frame that failed to serialize server-side
+       simply isn't present, and the socket falls back to a cold peek. */
+    const seeded = SOCKET_SEED[name]
+    let initialFrame: T | undefined
+    if (seeded !== undefined) {
+        try {
+            initialFrame = decodeRefJson(seeded) as T
+        } catch {
+            initialFrame = undefined
+        }
+    }
+    const socket = buildSocketOverChannel<T>(name, getSocketChannel, initialFrame)
     /* Overwrite the shared builder's inert `.watch` with the real reaction sugar
        (`socket.watch(handler)` ≡ `watch(socket, handler)`). Attached here so the ui-only
        `watch` primitive never rides into a server bundle. */

package/src/lib/ui/startClient.ts

@@ -1,11 +1,16 @@
+import { amendBroadcastSlot } from '../shared/amendBroadcastSlot.ts'
+import { applyAmendLocally } from '../shared/applyAmendLocally.ts'
 import { applyCacheStalenessLocally } from '../shared/applyCacheStalenessLocally.ts'
+import { cacheReaderSocketSlot } from '../shared/cacheReaderSocketSlot.ts'
 import { cacheStalenessSlot } from '../shared/cacheStalenessSlot.ts'
 import { cacheStoreSlot } from '../shared/cacheStoreSlot.ts'
 import { createCacheStore } from '../shared/createCacheStore.ts'
 import { pageSlot } from '../shared/pageSlot.ts'
+import { SOCKET_SEED } from '../shared/SOCKET_SEED.ts'
 import { sharedCacheStoreSlot } from '../shared/sharedCacheStoreSlot.ts'
 import type { SsrPayload } from '../shared/types/SsrPayload.ts'
 import type { StreamedResolution } from '../shared/types/StreamedResolution.ts'
+import { createAmendReaderHook } from './amendReaderHook.ts'
 import { probeNavigation } from './probeNavigation.ts'
 import { router } from './router.ts'
 import { CELL_SEED } from './runtime/CELL_SEED.ts'
@@ -57,6 +62,13 @@ export function startClient(
        broadcaster instead — the ADR-0041 side-swap). Same function as the slot fallback so
        the local-apply path can't diverge. */
     cacheStalenessSlot.resolver = () => applyCacheStalenessLocally
+    /* amend(args, value) applies to THIS tab's cache too — the server entry broadcasts instead
+       (the ADR-0043 side-swap). Same function as the slot fallback for the same reason. */
+    amendBroadcastSlot.resolver = () => applyAmendLocally
+    /* Open/close a per-call amend value subscription as reactive readers of a key come and go
+       (ADR-0043), so a server amend(args, value) push lands on keys this tab is reading. */
+    const amendReader = createAmendReaderHook()
+    cacheReaderSocketSlot.resolver = () => amendReader.hook
     /* Seed both SSR cache partitions through the one streamed-resolution sink: `ssr.cache`
        (inline — reads settled at render-return, in __SSR__) and `__abideResumeCache` (pending
        {#await} reads whose `__abideResolve(...)` chunks the stream pushed during parse, before
@@ -80,6 +92,12 @@ export function startClient(
     if (ssr.docs !== undefined) {
         Object.assign(DOC_SEED, ssr.docs)
     }
+    /* Seed the socket warm partition into SOCKET_SEED before mount: a hydrating `socketProxy` reads
+       its name key to seed `lastFrame`, so `peek(socket)` returns the server's retained frame instead
+       of undefined on the not-yet-connected client — congruent with the SSR HTML. */
+    if (ssr.sockets !== undefined) {
+        Object.assign(SOCKET_SEED, ssr.sockets)
+    }
     /* Keep the cache channel live past boot: replace the head's buffering collector with
        the store-connected sink so a post-boot resolution — the inline doc-stream cache
        script — seeds the store through `seedStreamedResolution` directly instead of pushing
@@ -94,6 +112,11 @@ export function startClient(
     const disposeRouter = router(target, routes, layoutRoutes, probeNavigation)
     return () => {
         disposeStaleness()
+        amendReader.dispose()
+        /* Clear the reader hook so a post-teardown cache read doesn't re-open amend subscriptions
+           — unlike the staleness/store slots (whose leaked resolver stays benign), a live hook on
+           the read path must not outlive the client it belongs to. */
+        cacheReaderSocketSlot.resolver = undefined
         disposeRouter()
     }
 }

package/src/lib/ui/tryEncodeResume.ts

@@ -1,20 +1,11 @@
-import { encodeRefJson } from '../shared/encodeRefJson.ts'
+import { encodeSeedValue } from '../shared/encodeSeedValue.ts'
 import type { ResumeEntry } from './runtime/RESUME.ts'
 
-/* ref-json-encode an await-resume entry, or `undefined` if it can't be serialized.
-   encodeRefJson is total (cycles become back-references, functions fold to undefined),
-   but a pathological throw must not blank the surrounding seed/stream — drop just this
-   entry and warn, so the client re-runs that one branch's promise while every other
+/* ref-json-encode an await-resume entry, or `undefined` if it can't be serialized — the
+   await-resume arm of the shared serialize-or-degrade policy (`encodeSeedValue`): drop
+   just this entry, so the client re-runs that one branch's promise while every other
    branch stays seeded. Shared by the streaming (`renderToStream`) and buffered/seed
-   (`resumeSeedScript`) paths so the serialize-or-refetch policy lives in one place. */
+   (`resumeSeedScript`) paths. */
 export function tryEncodeResume(entry: ResumeEntry, id: number | string): string | undefined {
-    try {
-        return encodeRefJson(entry)
-    } catch (cause) {
-        console.warn(
-            `[abide] resume for await ${id} is not serializable; client will refetch it`,
-            cause,
-        )
-        return undefined
-    }
+    return encodeSeedValue(entry, `resume for await ${id}`, 'the client will refetch it')
 }

package/src/lib/ui/types/Scope.ts

@@ -25,7 +25,7 @@ export type Scope = {
     readonly parent: Scope | undefined
     /* data — mirrors Doc */
     read: <T>(path: string) => T
-    replace: (path: string, value: unknown) => void
+    replace: (path: string, value: unknown) => unknown
     add: (path: string, value: unknown) => void
     remove: (path: string) => void
     apply: (patch: Patch) => void

package/src/lib/ui/watch.ts

@@ -1,4 +1,5 @@
 import { cache } from '../shared/cache.ts'
+import { isAsyncIterable } from '../shared/isAsyncIterable.ts'
 import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
 import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
 import type { NamedAsyncIterable } from '../shared/types/NamedAsyncIterable.ts'
@@ -8,6 +9,7 @@ import { effect } from './effect.ts'
 import { generationGuard } from './runtime/generationGuard.ts'
 import type { EffectResult } from './runtime/types/EffectResult.ts'
 import type { State } from './runtime/types/State.ts'
+import { untrack } from './runtime/untrack.ts'
 
 /*
 The single reaction primitive: `watch(source, handler)` names its trigger and runs
@@ -25,6 +27,14 @@ into a server bundle; server-side it is an inert no-op. Unlike bare `watch(…)`
 the SSR back-end strips — a `.watch(…)` member call survives to the server and relies on
 that inert stub.
 
+Tracking contract (ADR-0044): the named source(s) are the sole triggers — the handler
+is a sink, run untracked, so a reactive read in its body never becomes an accidental
+extra trigger. Only the bare `watch(thunk)` form auto-tracks everything it reads (that
+IS its job — it is the compiler binding). This makes all explicit-source forms uniform:
+the subscribable (cache.on, per-frame) and rpc (handler in a .then microtask) branches
+already ran their handlers out of the tracking window; the two synchronous cell branches
+now match by wrapping the handler in `untrack`.
+
 Sources (discriminated at runtime, monomorphic per branch):
   watch(thunk)                       // compiler binding form — auto-tracked, == effect(thunk)
   watch(count, n => …)               // a state cell → handler(newValue)
@@ -77,7 +87,7 @@ export function watch(
     const handler = argsOrHandler as (value: unknown, context?: CacheOnContext) => void
     /* A subscribable (socket / stream): per-frame delivery with reconnect-replay — the
        existing cache.on loop is the single implementation this branch delegates to. */
-    if (isSubscribable(source)) {
+    if (isAsyncIterable(source)) {
         return cache.on(
             source as NamedAsyncIterable<unknown>,
             handler as (frame: unknown, context: CacheOnContext) => void | Promise<void>,
@@ -85,7 +95,7 @@ export function watch(
     }
     /* An rpc without args → run the smart read reactively, pipe its value to the handler. A
        RemoteFunction is a callable, so accept `function` too — a state cell is a branded-free
-       object and never matches, and a streaming rpc was already caught by isSubscribable above. */
+       object and never matches, and a streaming rpc was already caught by isAsyncIterable above. */
     if (
         source !== null &&
         (typeof source === 'object' || typeof source === 'function') &&
@@ -93,34 +103,29 @@ export function watch(
     ) {
         return reactToRpc(source, undefined, handler)
     }
-    /* Multiple cells → fire on any change; hand the handler the current values. */
+    /* Multiple cells → fire on any change; hand the handler the current values. Read every
+       cell (the tracked triggers), then run the handler untracked so a reactive read in its
+       body is not captured as an extra trigger (ADR-0044). */
     if (Array.isArray(source)) {
         const cells = source as ReadonlyArray<State<unknown>>
         return effect(() => {
             const values = cells.map((cell) => cell.value)
-            handler(values)
+            untrack(() => handler(values))
         })
     }
-    /* A single state cell → handler(newValue) on change. */
+    /* A single state cell → handler(newValue) on change. The cell read is the tracked
+       trigger; the handler is a sink, run untracked (ADR-0044). */
     const cell = source as State<unknown>
     return effect(() => {
-        handler(cell.value)
+        const value = cell.value
+        untrack(() => handler(value))
     })
 }
 
-/* True for a socket / rpc stream — anything async-iterable. */
-function isSubscribable(source: unknown): boolean {
-    return (
-        source !== null &&
-        (typeof source === 'object' || typeof source === 'function') &&
-        typeof (source as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function'
-    )
-}
-
 /*
 Reacts to an rpc's cached value: an effect that runs the smart read (subscribing
 its key synchronously, so the effect re-runs when the value changes — a refresh,
-a patch, an invalidate) and pipes the resolved value to the handler. Triggers the
+an amend, an invalidate) and pipes the resolved value to the handler. Triggers the
 read, unlike peek: `watch` observes a live query, so it keeps it flowing.
 */
 function reactToRpc(fn: unknown, args: unknown, handler: (value: unknown) => void): () => void {

package/src/serverEntry.ts

@@ -26,10 +26,12 @@ import { shell } from './_virtual/shell.ts'
 import { sockets } from './_virtual/sockets.ts'
 import { exitWithParent } from './lib/bundle/exitWithParent.ts'
 import { loadEnvFromBinaryDir } from './lib/cli/loadEnvFromBinaryDir.ts'
+import { broadcastAmend } from './lib/server/runtime/amendBroadcaster.ts'
 import { broadcastCacheStaleness } from './lib/server/runtime/cacheStalenessBroadcaster.ts'
 import { createServer } from './lib/server/runtime/createServer.ts'
 import { requestContext } from './lib/server/runtime/requestContext.ts'
 import { resolvePageSnapshot } from './lib/server/runtime/resolvePageSnapshot.ts'
+import { amendBroadcastSlot } from './lib/shared/amendBroadcastSlot.ts'
 import { cacheStalenessSlot } from './lib/shared/cacheStalenessSlot.ts'
 import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
 import { createCacheStore } from './lib/shared/createCacheStore.ts'
@@ -40,6 +42,7 @@ import { pendingAsyncCellsSlot } from './lib/shared/pendingAsyncCellsSlot.ts'
 import { resolvedCellsSlot } from './lib/shared/resolvedCellsSlot.ts'
 import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
 import { sharedCacheStoreSlot } from './lib/shared/sharedCacheStoreSlot.ts'
+import { socketTailsSlot } from './lib/shared/socketTailsSlot.ts'
 import { streamedCellsSlot } from './lib/shared/streamedCellsSlot.ts'
 
 /*
@@ -89,6 +92,14 @@ so its server socket code never enters the client reachability graph.
 */
 cacheStalenessSlot.resolver = () => broadcastCacheStaleness
 
+/*
+Server-side amend(args, value) broadcasts the keyed value to every authorized reader
+instead of mutating a throwaway request store (ADR-0043). Imported ONLY here so the
+broadcaster's socket code never enters the client reachability graph — the same import
+discipline as the staleness broadcaster above.
+*/
+amendBroadcastSlot.resolver = () => broadcastAmend
+
 /* One process-wide fallback list for reads with no request in flight (boot/cron/socket) —
    real requests each carry their own `pendingAsyncCells`, so the SSR barrier drains a
    per-request list and concurrent renders never cross-contaminate. */
@@ -99,6 +110,10 @@ const sharedResolvedCells = { entries: [] }
 resolvedCellsSlot.resolver = () => requestContext.getStore()?.resolvedCells ?? sharedResolvedCells
 const sharedStreamedCells = { entries: [] }
 streamedCellsSlot.resolver = () => requestContext.getStore()?.streamedCells ?? sharedStreamedCells
+/* No shared fallback: `defineSocket.peek` records into this on every retained-frame read, including
+   reads outside any request (ws handlers, boot) — a fallback list would accumulate entries no render
+   ever drains. Off-request this resolves undefined and the record is skipped (see socketTailsSlot). */
+socketTailsSlot.resolver = () => requestContext.getStore()?.socketTails
 const sharedDocSnapshots = { entries: [] }
 docSnapshotsSlot.resolver = () => requestContext.getStore()?.docSnapshots ?? sharedDocSnapshots
 

package/src/lib/shared/patch.ts

@@ -1,41 +0,0 @@
-import { cache } from './cache.ts'
-import type { CacheOptions } from './types/CacheOptions.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-import type { RemoteFunction } from './types/RemoteFunction.ts'
-
-/*
-Mutate the retained value of the matching cached read(s) in place — reactive
-(readers re-render), no network. The optimistic-update / real-time primitive:
-patch a cached list from a socket frame (`on(chat, m => getList.patch(l => [...l,
-m]))`) or apply an optimistic edit before a write lands. The updater receives the
-current decoded value and returns the next.
-
-  patch(getFoo, args, updater)   → that exact call
-  patch(getFoo, updater)         → every args-variant of that rpc
-  patch({ tags }, updater)       → every entry sharing a tag
-
-Instance sugar `getFoo.patch(args?, updater)` ≡ `patch(getFoo, args, updater)`.
-The updater is always the last argument; a not-yet-read key has nothing to patch.
-*/
-// @documentation cache
-export function patch<Args, Return>(
-    fn: RemoteFunction<Args, Return> | ((args?: Args) => Promise<Return>),
-    args: Args | undefined,
-    updater: (current: Return) => Return,
-): void
-export function patch<Args, Return>(
-    fn: RemoteFunction<Args, Return> | ((args?: Args) => Promise<Return>),
-    updater: (current: Return) => Return,
-): void
-export function patch<Return>(
-    selector: Pick<CacheOptions, 'tags'>,
-    updater: (current: Return) => Return,
-): void
-export function patch(selector: unknown, argsOrUpdater: unknown, maybeUpdater?: unknown): void {
-    /* Updater is always last: 3 args → (selector, args, updater); 2 args → (selector, updater). */
-    const updater = (maybeUpdater !== undefined ? maybeUpdater : argsOrUpdater) as (
-        current: unknown,
-    ) => unknown
-    const args = maybeUpdater !== undefined ? argsOrUpdater : undefined
-    cache.patch(selector as CacheSelector<unknown, unknown>, args, updater)
-}

package/src/lib/ui/compile/COMPOUND_ASSIGNMENT_OPERATORS.ts

@@ -1,19 +0,0 @@
-import ts from 'typescript'
-
-/*
-Maps a compound-assignment operator to its plain binary counterpart, for lowering
-`x += y` into an unconditional read-combine-write. Logical assignments
-(`||=`/`&&=`/`??=`) lower the same way — the patch/cell write always fires,
-consistent with how `+=` lowers. Shared by lowerDocAccess (the `$$model` write path)
-and renameSignalRefs (the `$$writeCell` linked-cell path) so the two lowerings can't
-drift.
-*/
-export const COMPOUND_ASSIGNMENT_OPERATORS = new Map<ts.SyntaxKind, ts.BinaryOperator>([
-    [ts.SyntaxKind.PlusEqualsToken, ts.SyntaxKind.PlusToken],
-    [ts.SyntaxKind.MinusEqualsToken, ts.SyntaxKind.MinusToken],
-    [ts.SyntaxKind.AsteriskEqualsToken, ts.SyntaxKind.AsteriskToken],
-    [ts.SyntaxKind.SlashEqualsToken, ts.SyntaxKind.SlashToken],
-    [ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.BarBarToken],
-    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, ts.SyntaxKind.AmpersandAmpersandToken],
-    [ts.SyntaxKind.QuestionQuestionEqualsToken, ts.SyntaxKind.QuestionQuestionToken],
-])

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

@@ -1,84 +0,0 @@
-import { CURRENT_PATH } from '../runtime/CURRENT_PATH.ts'
-import { claimChild } from '../runtime/claimChild.ts'
-import { OWNER } from '../runtime/OWNER.ts'
-import { RANGE_OPEN } from '../runtime/RANGE_MARKER.ts'
-import { RENDER } from '../runtime/RENDER.ts'
-import type { UiComponent } from '../runtime/types/UiComponent.ts'
-import { withOptionalPath } from '../runtime/withOptionalPath.ts'
-import { withoutHydration } from '../runtime/withoutHydration.ts'
-import { discardBoundary } from './discardBoundary.ts'
-import { mountRange } from './mountRange.ts'
-import { openMarker } from './openMarker.ts'
-
-/*
-The client mount for a HOISTABLE child (ADR-0039) — a DUAL-MODE adopter. The server decides per
-render whether a hoistable child inlined (fast/settled) or streamed (still-pending), and the client
-build can't know which, so this probes the hydration cursor:
-
-  - `<!--[-->` (RANGE_OPEN) next → the server INLINED the child; adopt its range exactly as
-    `mountChild` does (byte-identical to the pre-ADR-0039 path).
-  - `<!--abide:await:CHILDPATH-->` next → the server STREAMED it; `__abideSwap` has already spliced
-    the child's `<!--[-->…<!--]-->` between the boundary markers before the bundle ran, so claim the
-    boundary open, adopt the inner range in place, claim the boundary close.
-  - no hydration (a client-side navigation) → a plain create-mode mount, like `mountChild`.
-
-CHILDPATH is the child's render-path — `withPath(ordinal, () => CURRENT_PATH.current)` — computed the
-same way the server's `renderPath(ordinal)` wrote the boundary id, so the two agree with no counter.
-A streamed child re-mounts (no RESUME value of its own — the boundary is html-only); nested `{#await}`
-blocks and async cells inside it adopt through their own existing channels.
-*/
-// @documentation plumbing
-export function mountStreamedChild(
-    parent: Node,
-    factory: UiComponent,
-    props: Parameters<UiComponent>[1],
-    before: Node | null = null,
-    ordinal?: number,
-): void {
-    const run = <T>(build: () => T): T => withOptionalPath(ordinal, build)
-    const mount = (): { dispose: () => void } =>
-        run(() => mountRange(parent, factory.build, props, before))
-
-    const hydration = RENDER.hydration
-    if (hydration === undefined) {
-        /* Call mount() first, THEN register its dispose — `OWNER.current?.push(mount())` would
-           short-circuit the whole expression (never mounting) when there is no owner. */
-        const handle = mount()
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-
-    /* Probe the cursor without consuming it. Streamed iff the next node is this child's boundary. */
-    const childPath = run(() => CURRENT_PATH.current)
-    const cursor = claimChild(hydration, parent)
-    const streamed =
-        cursor !== null &&
-        cursor.nodeType === 8 &&
-        (cursor as Comment).data === `abide:await:${childPath}`
-
-    if (!streamed) {
-        /* INLINE — the server inlined a settled child; adopt its `[ … ]` range in place. */
-        const handle = mount()
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-
-    /* STREAMED — claim the boundary open (advances the cursor to the swapped-in `[`). */
-    const open = openMarker(parent, `abide:await:${childPath}`)
-    const inner = claimChild(hydration, parent)
-    const warm = inner !== null && inner.nodeType === 8 && (inner as Comment).data === RANGE_OPEN
-    if (warm) {
-        const handle = mount()
-        openMarker(parent, `/abide:await:${childPath}`)
-        OWNER.current?.push(handle.dispose)
-        return
-    }
-    /* COLD (defensive — renderToStream drains every await before closing, so a warm boundary is the
-       deterministic path). The fragment never arrived: discard the empty boundary and create-mount
-       the child fresh at that position; its streamed cells resolve post-mount via receiveStreamedCell. */
-    const after = discardBoundary(parent, open, `/abide:await:${childPath}`, hydration)
-    const handle = withoutHydration(() =>
-        run(() => mountRange(parent, factory.build, props, after)),
-    )
-    OWNER.current?.push(handle.dispose)
-}

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

@@ -1,29 +0,0 @@
-import { isAsyncCell } from '../../shared/isAsyncCell.ts'
-import type { AsyncComputed } from '../../shared/types/AsyncComputed.ts'
-import { SuspenseSignal } from '../runtime/SuspenseSignal.ts'
-import { readCell } from './readCell.ts'
-
-/*
-The blocking-cell read the compiler lowers to `$$readCellBlocking(NAME)` for an `await`-marked
-cell (ADR-0042 D5.3). Exactly `readCell`, with one added rule ahead of it: a cell with no value
-*yet* throws a `SuspenseSignal` so the enclosing region SUSPENDS until the value resolves rather
-than rendering against `undefined`. This is what makes an `await` binding read as a resolved `T`
-(never `undefined`-while-pending) on both sides — the client mirrors the server flush barrier.
-
-The suspend is keyed on `cell.pending()` (in-flight AND no value), NOT `peek() === undefined`:
-  - a blocking cell that legitimately resolves to `undefined` is not pending, so it does not
-    suspend forever;
-  - a warm-seeded cell on hydrate is `refreshing()` (has value, in flight), not `pending()`, so it
-    reads its held value and adopts the SSR markup with no suspend and no flash (ADR-0042 D4).
-Everything past the pending gate — the throwing peek (error-with-no-retained-value → `AsyncCellError`
-to `{#try}`, a retained value winning over pending/error via SWR), a function call, or a `.value`
-read — is `readCell` verbatim, so the two reads can never drift.
-*/
-// @documentation plumbing
-export function readCellBlocking(cell: unknown): unknown {
-    /* No value yet → suspend the reading region (distinct from an error, which `readCell` routes). */
-    if (isAsyncCell(cell) && (cell as AsyncComputed<unknown>).pending()) {
-        throw new SuspenseSignal(cell as AsyncComputed<unknown>)
-    }
-    return readCell(cell)
-}