@abide/abide 0.54.0 → 0.56.0

package/src/lib/server/runtime/SSR_SWAP_SCRIPT.ts

@@ -1,7 +1,8 @@
 /*
 The tiny inline script the abide-ui SSR stream ships in <head>. For each streamed
 `<abide-resolve data-id>` frame it reads the leading `<script type=application/json>`,
-stores its raw ref-json text into `window.__abideResume` (the resume manifest hydration
+stores its raw ref-json text into `window.__abideSeeds.resume` (the resume partition of the
+one seed manifest, ADR-0048 — the store hydration
 reads, decoding each entry at read time) and swaps the resolved markup into the matching
 `<!--abide:await:ID-->…<!--/abide:await:ID-->` boundary — so the pending shell paints
 instantly and each value lands as it arrives, before the client bundle even loads. It
@@ -12,7 +13,7 @@ inlines cheaply ahead of the document body.
 export const SSR_SWAP_SCRIPT =
     "function __abideSwap(){var f=document.querySelector('abide-resolve');while(f){" +
     "var id=f.getAttribute('data-id'),p=f.firstChild,w=document.createTreeWalker(document.body,NodeFilter.SHOW_COMMENT),o=null,c;" +
-    "if(p&&p.nodeName==='SCRIPT'){(window.__abideResume=window.__abideResume||{})[id]=p.textContent||'';p.remove();}" +
+    "if(p&&p.nodeName==='SCRIPT'){var s=window.__abideSeeds=window.__abideSeeds||{};(s.resume=s.resume||{})[id]=p.textContent||'';p.remove();}" +
     "while((c=w.nextNode())){if(c.data==='abide:await:'+id){o=c;break;}}" +
     "if(o){var n=o.nextSibling;while(n&&!(n.nodeType===8&&n.data==='/abide:await:'+id)){var x=n.nextSibling;n.remove();n=x;}" +
     "while(f.firstChild){o.parentNode.insertBefore(f.firstChild,n);}}f.remove();f=document.querySelector('abide-resolve');}}"

package/src/lib/server/runtime/createUiPageRenderer.ts

@@ -1,7 +1,7 @@
 import { appNameSlot } from '../../shared/appNameSlot.ts'
 import { SSR_CACHE_CONTROL } from '../../shared/CACHE_CONTROL_VALUES.ts'
 import { docSnapshotsSlot } from '../../shared/docSnapshotsSlot.ts'
-import { encodeRefJson } from '../../shared/encodeRefJson.ts'
+import { encodeSeedValue } from '../../shared/encodeSeedValue.ts'
 import { formatTraceparent } from '../../shared/formatTraceparent.ts'
 import { hasSeedableRequest } from '../../shared/hasSeedableRequest.ts'
 import { layoutChainForRoute } from '../../shared/layoutChainForRoute.ts'
@@ -116,12 +116,13 @@ export function createUiPageRenderer({
         }
         const cells: Record<string, string> = {}
         for (const { key, value } of entries) {
-            try {
-                cells[key] = encodeRefJson(value)
-            } catch {
-                console.warn(
-                    `[abide] async cell "${key}" resolved to an unserializable value — it will re-run on the client instead of hydrating warm.`,
-                )
+            const encoded = encodeSeedValue(
+                value,
+                `async cell "${key}" resolved value`,
+                'it will re-run on the client instead of hydrating warm',
+            )
+            if (encoded !== undefined) {
+                cells[key] = encoded
             }
         }
         return Object.keys(cells).length > 0 ? cells : undefined
@@ -152,11 +153,13 @@ export function createUiPageRenderer({
             ) {
                 continue
             }
-            try {
-                docs[id] = encodeRefJson(snapshot)
-            } catch {
-                /* Unserializable synchronous state (a function/class instance) — the client re-inits
-                   it cold rather than blanking the payload. */
+            const encoded = encodeSeedValue(
+                snapshot,
+                `scope "${id}" state snapshot`,
+                'the client re-inits its state cold',
+            )
+            if (encoded !== undefined) {
+                docs[id] = encoded
             }
         }
         return Object.keys(docs).length > 0 ? docs : undefined
@@ -175,12 +178,13 @@ export function createUiPageRenderer({
         }
         const sockets: Record<string, string> = {}
         for (const { name, value } of entries) {
-            try {
-                sockets[name] = encodeRefJson(value)
-            } catch {
-                console.warn(
-                    `[abide] socket "${name}" retained frame is unserializable — its client peek() will read undefined at hydration instead of the server value.`,
-                )
+            const encoded = encodeSeedValue(
+                value,
+                `socket "${name}" retained frame`,
+                'its client peek() reads undefined at hydration instead of the server value',
+            )
+            if (encoded !== undefined) {
+                sockets[name] = encoded
             }
         }
         return Object.keys(sockets).length > 0 ? sockets : undefined
@@ -418,10 +422,12 @@ export function createUiPageRenderer({
                            streamed and the client cold-runs it. An unserializable value emits nothing.
                            Read from `store` directly since the stream body runs outside the request ALS. */
                         for (const { key, value } of store.streamedCells.entries) {
-                            let encoded: string
-                            try {
-                                encoded = encodeRefJson(value)
-                            } catch {
+                            const encoded = encodeSeedValue(
+                                value,
+                                `streaming cell "${key}" settled value`,
+                                'the client cold-runs its seed instead of adopting the streamed value',
+                            )
+                            if (encoded === undefined) {
                                 continue
                             }
                             controller.enqueue(
@@ -436,10 +442,12 @@ export function createUiPageRenderer({
                             if (seededCellKeys.has(key)) {
                                 continue
                             }
-                            let encoded: string
-                            try {
-                                encoded = encodeRefJson(value)
-                            } catch {
+                            const encoded = encodeSeedValue(
+                                value,
+                                `streamed child's async cell "${key}" resolved value`,
+                                'it will re-run on the client instead of hydrating warm',
+                            )
+                            if (encoded === undefined) {
                                 continue
                             }
                             controller.enqueue(

package/src/lib/shared/SEEDS.ts

@@ -0,0 +1,33 @@
+/*
+The ONE hydration seed manifest (ADR-0048): every passive server→client warm-seed
+partition — await resumes, async-cell values, doc snapshots, socket frames — rides a single
+`globalThis.__abideSeeds` global, kind-partitioned. Each partition is a Record of ref-json
+STRINGS decoded lazily at its read site, so the inline pre-bundle scripts (the SSR swap
+script, the resume seed script) can write entries without the codec. The per-kind module
+names (`RESUME`, `CELL_SEED`, `DOC_SEED`, `SOCKET_SEED`) are views onto these partitions,
+so consumers keep their domain name while the wire carries one global.
+
+Each partition initializes with its own `??=` — NOT one whole-object create — because the
+vanilla scripts and the bundle race in either order and a script that ran first may have
+created the root with only its own partition; whoever arrives later must fill the gaps and
+adopt the same references. The live streamed-cell machinery (`STREAMED_CELLS`) and the head
+collector buffer (`__abideResumeCache`) deliberately stay separate: they are apply-timing
+phases (ADR-0040), not passive manifests.
+*/
+type SeedPartitions = {
+    resume: Record<string, string>
+    cells: Record<string, string>
+    docs: Record<string, string>
+    sockets: Record<string, string>
+}
+
+const globalScope = globalThis as { __abideSeeds?: Partial<SeedPartitions> }
+globalScope.__abideSeeds ??= {}
+const root = globalScope.__abideSeeds
+root.resume ??= {}
+root.cells ??= {}
+root.docs ??= {}
+root.sockets ??= {}
+
+// @documentation plumbing
+export const SEEDS: SeedPartitions = root as SeedPartitions

package/src/lib/shared/SOCKET_SEED.ts

@@ -1,13 +1,12 @@
+import { SEEDS } from './SEEDS.ts'
+
 /* The socket warm-seed manifest: a socket's retained latest frame as read via `peek(socket)` during
    SSR, keyed by the socket's name, as a ref-json-encoded STRING (decoded at the read site in
    `socketProxy`). `startClient` drains `__SSR__.sockets` into here before mount; a hydrating
    `socketProxy` reads its key to seed the socket's `lastFrame` WARM, so `peek(socket)` returns the
    SAME retained value the server rendered instead of `undefined` on the not-yet-connected client —
    killing the SSR/hydration divergence that would otherwise discard the server markup and cold-render.
-   Backed by `globalThis.__abideSockets` so an inline pre-bundle script and the framework share one
-   store — whoever runs first creates it, the other adopts the same reference (mirrors CELL_SEED). */
-const globalScope = globalThis as { __abideSockets?: Record<string, string> }
-globalScope.__abideSockets ??= {}
 
+   The `sockets` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS). */
 // @documentation plumbing
-export const SOCKET_SEED: Record<string, string> = globalScope.__abideSockets
+export const SOCKET_SEED: Record<string, string> = SEEDS.sockets

package/src/lib/shared/cache.ts

@@ -176,10 +176,16 @@ its value is kept for display regardless of ttl, and ttl marks a staleness
 deadline (the next read past it revalidates in the background) instead of driving
 eviction. No call-site options (ADR-0020): all policy is read off the endpoint
 (fn.cache). Always a decoded RemoteFunction read (the callable carries .raw), so
-it returns Promise<Return>.
+it returns Promise<Return>. `key` is the caller's already-derived cache key (the
+callable keys its rpc-error registry with it) — threaded through so readThrough
+reuses it instead of re-deriving the identical string; omitted, readThrough derives.
 */
-function smartRead<Args, Return>(fn: RemoteFunction<Args, Return>, args?: Args): Promise<Return> {
-    return readThrough(fn, args, undefined, true) as Promise<Return>
+function smartRead<Args, Return>(
+    fn: RemoteFunction<Args, Return>,
+    args?: Args,
+    key?: string,
+): Promise<Return> {
+    return readThrough(fn, args, undefined, true, key) as Promise<Return>
 }
 cache.read = smartRead
 
@@ -196,6 +202,7 @@ function readThrough<Args, Return>(
     args: Args | undefined,
     options: CacheOptions | undefined,
     smart: boolean,
+    precomputedKey?: string,
 ): Promise<Return | Response> {
     /*
     A remote function carries the REMOTE_FUNCTION brand (set by
@@ -239,13 +246,17 @@ function readThrough<Args, Return>(
     - a read that resolved to the process store WITHOUT `shared` — a server read outside any
       request scope, where activeCacheStore() falls back to the shared store. Nothing bounds
       its lifetime there, so retaining it would leak forever.
-    Both apply on either side and however the call is made.
+    Both apply on either side and however the call is made. An explicit `shared` defeats both:
+    it is a deliberate "memoise this across requests" opt-in (a POST that is a pure function
+    of its args, using the body only to carry a large payload — highlightCode), so it retains
+    in the process store with the default Infinity ttl rather than dropping on settle. An
+    explicit `ttl` already defeats them via the `ttl === undefined` guard above.
     */
     const coalesceOnly =
         isRemote &&
         policy?.ttl === undefined &&
-        (!replayable ||
-            (!policy?.shared && typeof window === 'undefined' && store === sharedCacheStore()))
+        !policy?.shared &&
+        (!replayable || (typeof window === 'undefined' && store === sharedCacheStore()))
     const effectiveOptions = coalesceOnly ? { ...policy, ttl: 0 } : policy
     if (!isRemote) {
         warnAnonymousProducer(fn as Producer<Args, Return>)
@@ -254,7 +265,12 @@ function readThrough<Args, Return>(
         return invokeProducer(store, fn as Producer<Args, Return>, args, effectiveOptions)
     }
     const remote = rawFn as RawRemoteFunction<Args>
-    const key = keyForRemoteCall(remote.method, remote.url, args)
+    /* Reuse the caller's derived key when it threaded one (the smart bare call already
+       computes it for its rpc-error registry, and remote is that callable's .raw — same
+       method/url, so the string is identical). Otherwise derive it — the public cache()
+       and the raw path pass none. Saves a query-encode / canonical-json stringify per read,
+       warm hits included. */
+    const key = precomputedKey ?? keyForRemoteCall(remote.method, remote.url, args)
     if (
         !effectiveOptions?.shared &&
         effectiveOptions?.ttl !== undefined &&
@@ -756,22 +772,100 @@ rather than a first-ever load. An empty or unmatched selector is a no-op on the
 cache; the lifecycle ping still fires but recomputes pending() to the same value.
 */
 function invalidate<Args, Return>(arg?: CacheSelector<Args, Return>, args?: Args): void {
-    /* Resolve the fn-selector prefix once; the matcher and the label both consume it. */
+    /* Resolve the fn-selector prefix once; the matcher, the label, and the exact-key
+       fast path all consume it. */
     const prefix = selectorPrefix(arg, args)
-    invalidateMatching(selectorMatcher(arg, args, prefix), selectorLabel(arg, args, prefix), prefix)
+    invalidateMatching(
+        selectorMatcher(arg, args, prefix),
+        selectorLabel(arg, args, prefix),
+        prefix,
+        exactSelectorKey(arg, args, prefix),
+    )
+}
+
+/*
+The single entry key a `fn + args` selector targets: args narrows the match to one
+call, so the resolved prefix IS the exact key — the apply loops can `Map.get` it
+directly instead of scanning every store. undefined for an all / bare-fn-prefix /
+tag selector (which may match many entries) so those still scan, and for a producer
+never cached (prefix undefined) whose scan matches nothing anyway.
+*/
+function exactSelectorKey<Args, Return>(
+    arg: CacheSelector<Args, Return> | undefined,
+    args: Args | undefined,
+    prefix: string | undefined,
+): string | undefined {
+    return typeof arg === 'function' && args !== undefined ? prefix : undefined
+}
+
+/*
+The ONE per-store selection dispatch every selector-driven verb runs through: an exact
+key (a fn + args selector, from exactSelectorKey) picks its single candidate via a
+direct Map.get instead of scanning; any other selector scans the store against
+`matches`. Shared so the fast path and the scan can't diverge across
+invalidate / refresh / amend (ADR-0041).
+*/
+function applyToMatching(
+    store: CacheStore,
+    exactKey: string | undefined,
+    matches: (entry: CacheEntry) => boolean,
+    apply: (entry: CacheEntry) => void,
+): void {
+    if (exactKey !== undefined) {
+        const entry = store.entries.get(exactKey)
+        if (entry !== undefined) {
+            apply(entry)
+        }
+        return
+    }
+    /* Deleting the current entry mid-iteration is spec-safe on a Map; no snapshot needed. */
+    for (const entry of store.entries.values()) {
+        if (matches(entry)) {
+            apply(entry)
+        }
+    }
+}
+
+/*
+The per-entry drop/refetch decision of invalidate() — the single seam so the full
+scan and the exact-key fast path can't diverge (ADR-0041). A refetch-policy entry is
+kept and its refetch coalesced; every other match is dropped so the next read reloads.
+*/
+function invalidateEntry(
+    store: CacheStore,
+    entry: CacheEntry,
+    matched: string[],
+    affected: string[],
+): void {
+    matched.push(entry.key)
+    if (entry.invalidation) {
+        scheduleInvalidationRefetch(store, entry)
+    } else {
+        store.entries.delete(entry.key)
+        /* Flag the next read a reload (refreshing()) — but only if a reader is
+           holding the value now; with none on screen the next read is a first
+           load, and an ungated add would linger forever on the tab store. */
+        if (store.hasReader(entry.key)) {
+            store.pendingRefresh.add(entry.key)
+        }
+        affected.push(entry.key)
+    }
 }
 
 /*
 The store-loop body of invalidate(), driven by a raw entry predicate rather than a
-selector — the single apply-by-matcher seam so a local invalidate() and a
-wire-driven one (a server broadcast decoded via matcherFromEnvelope) run the EXACT
-same drop loop and can't diverge (ADR-0041). `label` feeds the cycle tripwire;
-`prefix` (undefined for a tag selector) resets recorded rpc errors for the selector.
+selector — a local invalidate() and a wire-driven one (a server broadcast decoded via
+matcherFromEnvelope) share the per-entry `invalidateEntry` seam and can't diverge
+(ADR-0041). `label` feeds the cycle tripwire; `prefix` (undefined for a tag selector)
+resets recorded rpc errors for the selector. `exactKey` (a fn + args selector's one
+key, from exactSelectorKey) picks that entry directly instead of scanning; the
+wire-driven path passes none and scans as before.
 */
 function invalidateMatching(
     matches: (entry: CacheEntry) => boolean,
     label: string,
     prefix: string | undefined,
+    exactKey?: string,
 ): void {
     invalidateTripwire(label)
     /* Reset any recorded rpc errors for this selector too (independent of cache entries — a
@@ -782,25 +876,9 @@ function invalidateMatching(
     for (const store of cacheStores()) {
         const matched: string[] = []
         const affected: string[] = []
-        /* Deleting the current entry mid-iteration is spec-safe on a Map; no snapshot needed. */
-        for (const entry of store.entries.values()) {
-            if (!matches(entry)) {
-                continue
-            }
-            matched.push(entry.key)
-            if (entry.invalidation) {
-                scheduleInvalidationRefetch(store, entry)
-            } else {
-                store.entries.delete(entry.key)
-                /* Flag the next read a reload (refreshing()) — but only if a reader is
-                   holding the value now; with none on screen the next read is a first
-                   load, and an ungated add would linger forever on the tab store. */
-                if (store.hasReader(entry.key)) {
-                    store.pendingRefresh.add(entry.key)
-                }
-                affected.push(entry.key)
-            }
-        }
+        applyToMatching(store, exactKey, matches, (entry) =>
+            invalidateEntry(store, entry, matched, affected),
+        )
         /* Every match changed state (probes re-derive); only the dropped subset
            changed its visible value (readers re-read) — swr matches stay put. */
         notify(store, matched, affected)
@@ -851,18 +929,65 @@ way to re-run, so it drops (the next read reloads) — the invalidate fallback.
 */
 function refresh<Args, Return>(arg?: CacheSelector<Args, Return>, args?: Args): void {
     const prefix = selectorPrefix(arg, args)
-    refreshMatching(selectorMatcher(arg, args, prefix), selectorLabel(arg, args, prefix), prefix)
+    refreshMatching(
+        selectorMatcher(arg, args, prefix),
+        selectorLabel(arg, args, prefix),
+        prefix,
+        exactSelectorKey(arg, args, prefix),
+    )
+}
+
+/*
+The per-entry refetch/drop decision of refresh() — the single seam shared by the full
+scan and the exact-key fast path (ADR-0041). Only a match with a live reader refetches;
+a reader-less match drops so the next read reloads.
+*/
+function refreshEntry(
+    store: CacheStore,
+    entry: CacheEntry,
+    matched: string[],
+    affected: string[],
+): void {
+    matched.push(entry.key)
+    /* No live reader is holding this key — its reactive scope has torn down (or
+       it was never read reactively and already dropped). A refresh has no
+       on-screen value to keep-stale-and-swap, so firing the network now is
+       wasted work that may be stale again before anything shows it. Drop the
+       entry so the next read reloads fresh instead — the same lazy path a
+       reader-less invalidate() takes. */
+    if (!store.hasReader(entry.key)) {
+        store.entries.delete(entry.key)
+        return
+    }
+    /* Arm a refetch on the fly for a policy-less remote entry by replaying its
+       stored Request — so a refresh always refetches-and-swaps, never blanks. */
+    if (entry.invalidation === undefined && entry.request !== undefined) {
+        const request = entry.request
+        entry.invalidation = { refetch: () => fetch(request.clone()) }
+    }
+    if (entry.invalidation !== undefined) {
+        scheduleInvalidationRefetch(store, entry)
+    } else {
+        /* No policy, no request (a producer never cached with a refetch window): drop so the
+           next read reloads. A reader is holding it (checked above), so flag the
+           next read a reload (refreshing()). */
+        store.entries.delete(entry.key)
+        store.pendingRefresh.add(entry.key)
+        affected.push(entry.key)
+    }
 }
 
 /*
 The store-loop body of refresh(), driven by a raw entry predicate — the refetch
-analogue of invalidateMatching, so a local refresh() and a wire-driven one share
-one refetch loop (ADR-0041).
+analogue of invalidateMatching, so a local refresh() and a wire-driven one share the
+per-entry `refreshEntry` seam (ADR-0041). `exactKey` (a fn + args selector's one key)
+picks that entry directly instead of scanning; the wire-driven path passes none.
 */
 function refreshMatching(
     matches: (entry: CacheEntry) => boolean,
     label: string,
     prefix: string | undefined,
+    exactKey?: string,
 ): void {
     invalidateTripwire(label)
     if (prefix !== undefined) {
@@ -871,38 +996,9 @@ function refreshMatching(
     for (const store of cacheStores()) {
         const matched: string[] = []
         const affected: string[] = []
-        for (const entry of store.entries.values()) {
-            if (!matches(entry)) {
-                continue
-            }
-            matched.push(entry.key)
-            /* No live reader is holding this key — its reactive scope has torn down (or
-               it was never read reactively and already dropped). A refresh has no
-               on-screen value to keep-stale-and-swap, so firing the network now is
-               wasted work that may be stale again before anything shows it. Drop the
-               entry so the next read reloads fresh instead — the same lazy path a
-               reader-less invalidate() takes. */
-            if (!store.hasReader(entry.key)) {
-                store.entries.delete(entry.key)
-                continue
-            }
-            /* Arm a refetch on the fly for a policy-less remote entry by replaying its
-               stored Request — so a refresh always refetches-and-swaps, never blanks. */
-            if (entry.invalidation === undefined && entry.request !== undefined) {
-                const request = entry.request
-                entry.invalidation = { refetch: () => fetch(request.clone()) }
-            }
-            if (entry.invalidation !== undefined) {
-                scheduleInvalidationRefetch(store, entry)
-            } else {
-                /* No policy, no request (a producer never cached with a refetch window): drop so the
-                   next read reloads. A reader is holding it (checked above), so flag the
-                   next read a reload (refreshing()). */
-                store.entries.delete(entry.key)
-                store.pendingRefresh.add(entry.key)
-                affected.push(entry.key)
-            }
-        }
+        applyToMatching(store, exactKey, matches, (entry) =>
+            refreshEntry(store, entry, matched, affected),
+        )
         /* Mark the whole match set (probes re-derive); emit only the dropped subset — the
            refetched entries emit when their fresh value lands (fireRefetch). */
         notify(store, matched, affected)
@@ -930,13 +1026,14 @@ function amend<Args, Return>(
     isValue: boolean,
 ): void {
     const prefix = selectorPrefix(arg, args)
+    const exactKey = exactSelectorKey(arg, args, prefix)
     const matches = selectorMatcher(arg, args, prefix)
+    /* The exact-key arm is the optimistic-update / socket-frame path, potentially once
+       per frame — a direct Map.get through the shared dispatch, no scan. */
     for (const store of cacheStores()) {
-        for (const entry of store.entries.values()) {
-            if (matches(entry)) {
-                applyAmend(store, entry, updater as (current: unknown) => unknown, isValue)
-            }
-        }
+        applyToMatching(store, exactKey, matches, (entry) =>
+            applyAmend(store, entry, updater as (current: unknown) => unknown, isValue),
+        )
     }
 }
 
@@ -1378,8 +1475,5 @@ function notify(store: CacheStore, marked: string[], emitted: string[]): void {
 }
 
 function emit(store: CacheStore, keys: string[]): void {
-    if (keys.length === 0) {
-        return
-    }
     store.events.dispatchEvent(invalidateEvent(keys))
 }

package/src/lib/shared/createRemoteFunction.ts

@@ -142,7 +142,10 @@ export function createRemoteFunction<Args, Return>(opts: {
            `raw`. There is no call-site options argument any more — all cache policy is read
            from the endpoint (`callable.cache`); per-call transport options live on `.raw`. */
         const key = keyForRemoteCall(method, url, args)
-        return cache.read(callable as RemoteFunction<Args, Return>, args as Args).then(
+        /* Thread the derived key into the smart read so readThrough reuses it rather than
+           re-deriving the identical string (callable.raw carries the same method/url); the
+           key already tags the rpc-error registry entries in the handlers below. */
+        return cache.read(callable as RemoteFunction<Args, Return>, args as Args, key).then(
             /* Capture the rejection into the rpc error registry (design Part 4) keyed by call
                identity, and clear it on success — the reactive `fn.error()` probe reads it. */
             (value) => {

package/src/lib/shared/encodeSeedValue.ts

@@ -0,0 +1,24 @@
+import { encodeRefJson } from './encodeRefJson.ts'
+
+/*
+The ONE degradation site for every server→client hydration seed (ADR-0048): ref-json-encode
+a value bound for a warm-seed channel (await resume, cell value, doc snapshot, socket frame,
+streamed-cell chunk), or drop JUST that entry with a warn naming what was dropped and what
+the client does instead. encodeRefJson is total for ordinary graphs (cycles become
+back-references, functions fold to undefined), so a throw is pathological — but it must
+never blank the surrounding payload/stream. Funnelling every channel through here keeps the
+serialize-or-degrade policy, the warn shape, and the per-kind consequence in one place
+instead of seven independently-worded (or silent) drop sites.
+*/
+export function encodeSeedValue(
+    value: unknown,
+    label: string,
+    consequence: string,
+): string | undefined {
+    try {
+        return encodeRefJson(value)
+    } catch (cause) {
+        console.warn(`[abide] ${label} is not serializable — ${consequence}.`, cause)
+        return undefined
+    }
+}

package/src/lib/shared/jsonSchemaForType.ts

@@ -85,7 +85,7 @@ function project(
     // A `Set`/`Map` rides the wire as a JSON array (ADR-0029 output encode), so the projected schema
     // MUST agree with those bytes — a `Set<T>` is `T[]`, a `Map<K,V>` is `[K,V][]` entries.
     if (symbolName === 'Set' || symbolName === 'ReadonlySet') {
-        return projectSet(checker, type, seen)
+        return projectArray(checker, type, seen)
     }
     if (symbolName === 'Map' || symbolName === 'ReadonlyMap') {
         return projectMap(checker, type, seen)
@@ -131,7 +131,8 @@ function projectUnion(
     return { anyOf }
 }
 
-/* `T[]`/`readonly T[]` → `{ type: 'array', items: project(T) }`. */
+/* `T[]`/`readonly T[]` → `{ type: 'array', items: project(T) }`. Also serves `Set<T>`, which
+   rides the wire as `[...set]` (ADR-0029) — the same `T[]` shape. */
 function projectArray(
     checker: ts.TypeChecker,
     type: ts.Type,
@@ -144,20 +145,6 @@ function projectArray(
     return { type: 'array', items }
 }
 
-/* `Set<T>`/`readonly Set<T>` → `{ type: 'array', items: project(T) }` — congruent with the
-   `wireJsonReplacer` encode (`[...set]`). */
-function projectSet(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    const element = checker.getTypeArguments(type as ts.TypeReference)[0]
-    seen.add(type)
-    const items = element === undefined ? {} : project(checker, element, seen)
-    seen.delete(type)
-    return { type: 'array', items }
-}
-
 /* `Map<K,V>`/`readonly Map<K,V>` → an array of `[K,V]` entry tuples — congruent with the
    `wireJsonReplacer` encode (`[...map]`). Each entry is a fixed 2-tuple, so the item schema is
    positional `prefixItems` with `items: false` to forbid extras (matching projectTuple). */

package/src/lib/shared/peek.ts

@@ -1,5 +1,6 @@
 import { cache } from './cache.ts'
 import { isAsyncCell } from './isAsyncCell.ts'
+import { isAsyncIterable } from './isAsyncIterable.ts'
 import type { AsyncComputed } from './types/AsyncComputed.ts'
 import type { RemoteFunction } from './types/RemoteFunction.ts'
 import type { Socket } from './types/Socket.ts'
@@ -38,12 +39,8 @@ export function peek(source: unknown, args?: unknown): unknown {
     /* A subscribable (socket/stream) carries its own latest-frame probe; an rpc does not
        have Symbol.asyncIterator, so this cleanly splits the two even though both expose a
        `.peek` method. */
-    if (
-        source !== null &&
-        typeof source === 'object' &&
-        typeof (source as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function'
-    ) {
-        return (source as { peek: () => unknown }).peek()
+    if (isAsyncIterable(source)) {
+        return (source as unknown as { peek: () => unknown }).peek()
     }
     return cache.peek(source as RemoteFunction<unknown, unknown>, args as never)
 }

package/src/lib/ui/amendReaderHook.ts

@@ -57,7 +57,7 @@ export function createAmendReaderHook(
                     /* Transport loss: reconcile the possibly-missed value against server truth,
                        then re-open a fresh LIVE subscription (no replay) and keep going. */
                     if (error instanceof SocketDisconnectedError) {
-                        cache.refreshMatching((entry) => entry.key === key, key, undefined)
+                        cache.refreshMatching((entry) => entry.key === key, key, undefined, key)
                         try {
                             iterator = socket[Symbol.asyncIterator]()
                         } catch (reopenError) {

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

@@ -38,16 +38,12 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: stri
     { name: 'eachAsync', specifier: 'ui/dom/eachAsync', alias: '$$eachAsync' },
     { name: 'when', specifier: 'ui/dom/when', alias: '$$when' },
     { name: 'awaitBlock', specifier: 'ui/dom/awaitBlock', alias: '$$awaitBlock' },
+    { name: 'awaitSubject', specifier: 'ui/dom/awaitSubject', alias: '$$awaitSubject' },
     { name: 'tryBlock', specifier: 'ui/dom/tryBlock', alias: '$$tryBlock' },
     { name: 'switchBlock', specifier: 'ui/dom/switchBlock', alias: '$$switchBlock' },
     { name: 'mountSlot', specifier: 'ui/dom/mountSlot', alias: '$$mountSlot' },
     { name: 'outlet', specifier: 'ui/dom/outlet', alias: '$$outlet' },
     { name: 'mountChild', specifier: 'ui/dom/mountChild', alias: '$$mountChild' },
-    {
-        name: 'mountStreamedChild',
-        specifier: 'ui/dom/mountStreamedChild',
-        alias: '$$mountStreamedChild',
-    },
     { name: 'mergeProps', specifier: 'ui/dom/mergeProps', alias: '$$mergeProps' },
     { name: 'spreadProps', specifier: 'ui/dom/spreadProps', alias: '$$spreadProps' },
     { name: 'restProps', specifier: 'ui/dom/restProps', alias: '$$restProps' },
@@ -56,7 +52,6 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string; alias?: stri
     { name: 'spreadAttrs', specifier: 'ui/dom/spreadAttrs', alias: '$$spreadAttrs' },
     { name: 'readCall', specifier: 'ui/dom/readCall', alias: '$$readCall' },
     { name: 'readCell', specifier: 'ui/dom/readCell', alias: '$$readCell' },
-    { name: 'readCellBlocking', specifier: 'ui/dom/readCellBlocking', alias: '$$readCellBlocking' },
     { name: 'writeCell', specifier: 'ui/dom/writeCell', alias: '$$writeCell' },
     { name: 'cellPending', specifier: 'ui/dom/cellPending', alias: '$$cellPending' },
     { name: 'withPath', specifier: 'ui/runtime/withPath', alias: '$$withPath' },