@abide/abide 0.54.0 → 0.55.0

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)
-}

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

@@ -1,20 +0,0 @@
-import { CELL_SEED } from './CELL_SEED.ts'
-import { DOC_SEED } from './DOC_SEED.ts'
-import { warmSeedBackup } from './warmSeedBackup.ts'
-
-/*
-Re-populate the async-cell and doc-state warm-seed manifests from the pristine SSR copies stashed at
-boot, undoing the consume-once deletes the failed hydration pass made. The router's hydration-desync
-recovery calls this before it rebuilds the page COLD: with the seeds restored, each rebuilt cell
-re-adopts its SSR-resolved value (reads settled, not pending) instead of refetching — so a blocking
-`await` cell can't throw an uncaught SuspenseSignal at mount, and the cold render shows real data with
-no loading flash. A no-op when boot never seeded (a fresh client-only mount).
-*/
-export function restoreWarmSeeds(): void {
-    if (warmSeedBackup.cells !== undefined) {
-        Object.assign(CELL_SEED, warmSeedBackup.cells)
-    }
-    if (warmSeedBackup.docs !== undefined) {
-        Object.assign(DOC_SEED, warmSeedBackup.docs)
-    }
-}

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

@@ -1,10 +0,0 @@
-import type { SsrPayload } from '../../shared/types/SsrPayload.ts'
-
-/* The pristine SSR warm-seed manifests (`__SSR__.cells` / `__SSR__.docs`), stashed by `startClient`
-   before the hydration pass drains their client copies — each adopted seed is DELETED from CELL_SEED /
-   consumed from DOC_SEED as it hydrates. `Object.assign`-ing into those seeds leaves these source
-   records untouched, so they stay a clean re-seed source. The router's discard→cold-rebuild recovery
-   reads them via `restoreWarmSeeds` so the rebuilt cells re-adopt the SSR-resolved values instead of
-   refetching cold — a cold refetch would leave a blocking `await` cell pending and throw an uncaught
-   SuspenseSignal at mount, killing the page. Empty on a fresh client-only mount (nothing seeded). */
-export const warmSeedBackup: { cells?: SsrPayload['cells']; docs?: SsrPayload['docs'] } = {}