@abide/abide 0.41.0 → 0.41.1

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

@@ -0,0 +1,22 @@
+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/clientPage.ts

@@ -1,7 +1,6 @@
 import type { PageSnapshot } from '../../shared/types/PageSnapshot.ts'
 import { state } from '../state.ts'
-import { flushEffects } from './flushEffects.ts'
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
+import { batch } from './batch.ts'
 import type { State } from './types/State.ts'
 
 /*
@@ -107,15 +106,11 @@ export const clientPage: { value: PageSnapshot } = {
            (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. */
-        REACTIVE_CONTEXT.batchDepth += 1
-        try {
+        batch(() => {
             routeCell.value = next.route
             urlCell.value = next.url
             navigatingCell.value = next.navigating
             reconcileParams(next.params)
-        } finally {
-            REACTIVE_CONTEXT.batchDepth -= 1
-        }
-        flushEffects()
+        })
     },
 }

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

@@ -1,9 +1,8 @@
 import { applyPatchToTree } from './applyPatchToTree.ts'
+import { batch } from './batch.ts'
 import { createComputedNode } from './createComputedNode.ts'
 import { createSignalNode } from './createSignalNode.ts'
-import { flushEffects } from './flushEffects.ts'
 import { PATCH_BUS } from './PATCH_BUS.ts'
-import { REACTIVE_CONTEXT } from './REACTIVE_CONTEXT.ts'
 import { readNode } from './readNode.ts'
 import { trigger } from './trigger.ts'
 import type { Cell } from './types/Cell.ts'
@@ -157,8 +156,7 @@ export function createDoc(initial: unknown): Doc {
         const nonShiftingAdd =
             patch.op === 'add' &&
             (!parentIsArray || leafKey === '-' || Number(leafKey) === arrayLength - 1)
-        REACTIVE_CONTEXT.batchDepth += 1
-        try {
+        batch(() => {
             if (segments.length === 0) {
                 wakeSubtree('', true, true)
             } else if (!structural) {
@@ -178,15 +176,13 @@ export function createDoc(initial: unknown): Doc {
             } else {
                 wakeSubtree(parentPath, true, true)
             }
-        } finally {
-            REACTIVE_CONTEXT.batchDepth -= 1
-        }
-        /* Announce the change before flushing effects, so a patch an effect emits in
-           reaction lands AFTER this one on the bus — the journal stays chronological. */
-        if (PATCH_BUS.active) {
-            PATCH_BUS.emit({ doc: self, patch, inverse: inverseOf(patch, before) })
-        }
-        flushEffects()
+            /* Announce the change before effects flush, so a patch an effect emits in
+               reaction lands AFTER this one on the bus — the journal stays chronological.
+               Emitting inside the batch keeps it ahead of the depth-0 flush on batch exit. */
+            if (PATCH_BUS.active) {
+                PATCH_BUS.emit({ doc: self, patch, inverse: inverseOf(patch, before) })
+            }
+        })
     }
 
     /* The patch that undoes `patch`, from the pre-image `before` (a value the change

package/src/lib/ui/seedResolved.ts

@@ -0,0 +1,28 @@
+import { RESUME } from './runtime/RESUME.ts'
+import { seedStreamedResolution } from './seedStreamedResolution.ts'
+import type { ResolvedFrame } from './types/ResolvedFrame.ts'
+
+/*
+The single client intake seam for SSR warm-state seeding. Both warm-seed channels —
+the cache-snapshot channel (a settled `cache()` value, keyed by cache key) and the
+await-resume channel (an `await`-block resolved value, keyed by boundary id) — answer
+the same "ship a server-settled value so hydration doesn't re-fetch" question, but land
+in two distinct stores: the cache STORE (read by `cache()`) and the RESUME MANIFEST
+(read by `awaitBlock` on adopt). This routes a discriminated `ResolvedFrame` to the
+matching store so every consumer — startClient's boot drain, the live `__abideResolve`,
+applyResolved's stream swap — registers through ONE call instead of poking each store
+inline. The codecs stay split by source: the cache value is an HTTP body capped at plain
+JSON (it must agree with the live `decodeResponse` read), the resume value is an in-process
+graph carried as ref-json text and decoded lazily at the read site.
+*/
+// @documentation plumbing
+export function seedResolved(frame: ResolvedFrame): void {
+    if (frame.kind === 'cache') {
+        seedStreamedResolution(frame.resolution)
+        return
+    }
+    /* The resume value rides as raw ref-json text; store it unparsed so the inline
+       stream-swap script (vanilla, runs before the bundle's codec loads) can register
+       through this same seam. `awaitBlock` decodes it at the read. */
+    RESUME[frame.id] = frame.resume
+}

package/src/lib/ui/startClient.ts

@@ -11,7 +11,7 @@ import { probeNavigation } from './probeNavigation.ts'
 import { router } from './router.ts'
 import { clientPage } from './runtime/clientPage.ts'
 import type { RouteLoader } from './runtime/types/RouteLoader.ts'
-import { seedStreamedResolution } from './seedStreamedResolution.ts'
+import { seedResolved } from './seedResolved.ts'
 
 /* The server's __SSR__ payload this entry consumes. */
 type SsrPayload = { cache?: CacheSnapshotEntry[]; base?: string }
@@ -65,14 +65,16 @@ export function startClient(
     const streamed =
         (globalThis as { __abideResumeCache?: StreamedResolution[] }).__abideResumeCache ?? []
     for (const resolution of [...(ssr.cache ?? []), ...streamed]) {
-        seedStreamedResolution(resolution)
+        seedResolved({ kind: 'cache', resolution })
     }
     /* Keep the cache channel live past boot: replace the head's buffering collector with
        the store-connected sink so a post-load resolution — streaming SPA navigation or a
        socket-delivered SSR frame, both routed through applyResolved — seeds the store
-       directly instead of pushing to a buffer nothing drains again. */
+       directly instead of pushing to a buffer nothing drains again. The inline doc-stream
+       script only ever hands this a cache `StreamedResolution`, so wrap it as a cache frame
+       through the one intake seam. */
     ;(globalThis as { __abideResolve?: (resolution: StreamedResolution) => void }).__abideResolve =
-        seedStreamedResolution
+        (resolution) => seedResolved({ kind: 'cache', resolution })
 
     return router(target, routes, layoutRoutes, probeNavigation)
 }

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

@@ -0,0 +1,15 @@
+import type { StreamedResolution } from '../../shared/types/StreamedResolution.ts'
+
+/*
+A warm-state-seed frame for the single client intake (`seedResolved`), discriminated by
+`kind`. Both kinds ship a server-settled value so hydration adopts without a re-fetch,
+but route to distinct stores:
+  - `cache`  — a `StreamedResolution` for the cache store, read by a warm `cache()` call.
+  - `resume` — an `await`-block boundary id plus its ref-json-encoded value STRING for the
+               RESUME manifest, decoded lazily by `awaitBlock` when it adopts the branch.
+The payloads stay distinct (cache snapshot vs boundary-keyed value); the unified thing is
+the intake seam, not the payload.
+*/
+export type ResolvedFrame =
+    | { kind: 'cache'; resolution: StreamedResolution }
+    | { kind: 'resume'; id: number; resume: string }