@abide/abide 0.49.0 → 0.50.1

package/src/lib/shared/loadProjectTsConfig.ts

@@ -0,0 +1,28 @@
+import ts from 'typescript'
+
+/*
+Loads the project's tsconfig (for lib/paths/baseUrl/moduleResolution — so the
+server graph resolves imports the same way the app does) and forces type-check-only
+overrides: `noEmit` (never write) and `skipLibCheck` (the warm server program only
+queries handler return types, never reports diagnostics, so lib checking is dead
+cost). Falls back to permissive defaults when no tsconfig is found. Distinct from
+`loadShadowTsConfig` (the UI shadow's loader) so the server side carries no ui import.
+*/
+export function loadProjectTsConfig(cwd: string): ts.ParsedCommandLine {
+    const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, 'tsconfig.json')
+    const base = configPath
+        ? ts.parseJsonConfigFileContent(
+              ts.readConfigFile(configPath, ts.sys.readFile).config,
+              ts.sys,
+              cwd,
+          )
+        : { options: {}, fileNames: [], errors: [] }
+    return {
+        ...base,
+        options: {
+            ...base.options,
+            noEmit: true,
+            skipLibCheck: true,
+        },
+    }
+}

package/src/lib/shared/markFrameworkSourcesIgnored.ts

@@ -36,7 +36,7 @@ the widest debugger support. Mutates and returns the same map.
 */
 export function markFrameworkSourcesIgnored(map: SourceMap): SourceMap {
     const ignored = (map.sources ?? []).reduce<number[]>((indices, source, index) => {
-        if (source !== null && source.includes(FRAMEWORK_LIB_PATH)) {
+        if (source?.includes(FRAMEWORK_LIB_PATH)) {
             indices.push(index)
         }
         return indices

package/src/lib/shared/matchRoute.ts

@@ -1,3 +1,4 @@
+import { lenientDecode } from './lenientDecode.ts'
 import { normalizePathname } from './normalizePathname.ts'
 import type { RouteSegment } from './parseRouteSegments.ts'
 import { parseRouteSegments } from './parseRouteSegments.ts'
@@ -83,17 +84,6 @@ export function matchRoute(
     return best === undefined ? undefined : { route: best.route, params: best.params }
 }
 
-/* Percent-decodes a captured value. Lenient — a malformed sequence (`/%E0%A4%A`)
-   keeps the raw text rather than throwing, so a bad escape in a navigation or
-   request can't crash matching; the downstream lookup just misses naturally. */
-function decodeParam(value: string): string {
-    try {
-        return decodeURIComponent(value)
-    } catch {
-        return value
-    }
-}
-
 /* Matches one parsed pattern against the path's segments, capturing decoded
    params; undefined on mismatch. */
 function matchSegments(
@@ -129,7 +119,7 @@ function matchFrom(
         return false
     }
     if (segment.kind === 'param' && segment.catchAll) {
-        params[segment.name] = pathSegments.slice(pathIndex).map(decodeParam).join('/')
+        params[segment.name] = pathSegments.slice(pathIndex).map(lenientDecode).join('/')
         return true
     }
     const value = pathSegments[pathIndex]
@@ -145,7 +135,7 @@ function matchFrom(
            optional never captures an empty segment. */
         if (value !== undefined && value !== '') {
             const previous = params[segment.name]
-            params[segment.name] = decodeParam(value)
+            params[segment.name] = lenientDecode(value)
             if (matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex + 1, params)) {
                 return true
             }
@@ -170,6 +160,6 @@ function matchFrom(
     if (value === undefined || value === '') {
         return false
     }
-    params[segment.name] = decodeParam(value)
+    params[segment.name] = lenientDecode(value)
     return matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex + 1, params)
 }

package/src/lib/shared/peek.ts

@@ -1,4 +1,6 @@
 import { cache } from './cache.ts'
+import { isAsyncCell } from './isAsyncCell.ts'
+import type { AsyncComputed } from './types/AsyncComputed.ts'
 import type { RemoteFunction } from './types/RemoteFunction.ts'
 import type { Socket } from './types/Socket.ts'
 
@@ -20,7 +22,19 @@ export function peek<Args, Return>(
     args?: Args,
 ): Return | undefined
 export function peek<T>(source: Socket<T>): T | undefined
+export function peek<T>(cell: AsyncComputed<T>): T | undefined
 export function peek(source: unknown, args?: unknown): unknown {
+    /* Null-tolerant: a promise/iterable subexpression peek-lifts to `undefined` while
+       pending (ADR-0032), so `peek(getFeed())` in a template hands us `undefined` on the
+       first pass — return `undefined` rather than routing a missing source into the cache. */
+    if (source == null) {
+        return undefined
+    }
+    /* An async cell carries its own probe surface — route to its method (`peek(cell)` ≡
+       `cell.peek()`), the same instance/standalone equivalence as an rpc or socket. */
+    if (isAsyncCell(source)) {
+        return source.peek()
+    }
     /* 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. */

package/src/lib/shared/pending.ts

@@ -1,7 +1,9 @@
+import { isAsyncCell } from './isAsyncCell.ts'
 import { probeRegistries } from './probeRegistries.ts'
+import type { AsyncComputed } from './types/AsyncComputed.ts'
 import type { CacheEntry } from './types/CacheEntry.ts'
 import type { CacheSelector } from './types/CacheSelector.ts'
-import type { Subscribable } from './types/Subscribable.ts'
+import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
 
 /*
 Reactive in-flight probe over both registries — the cache (calls) and the
@@ -15,18 +17,19 @@ tail registry (streams). Pending means "no value yet":
   pending(subscribable)  → that stream awaiting its first frame
                            (tail.status === 'pending'; true when nothing
                            is reading yet — there is no value either way)
-  pending(durableRpc)    → that durable rpc's parked writes (a parked write
-                           has no value yet); the bare form counts them too
 Probes report, never act: reading one opens no fetch and no stream. SSR
 loading state is driven by {#await}, not this. Scan semantics (tap order,
-selector grammar, registry spans, the parked-write term) live in
-probeRegistries.
+selector grammar, registry spans) live in probeRegistries.
 */
 // @documentation probes
 export function pending<Args, Return>(
-    arg?: CacheSelector<Args, Return> | Subscribable<unknown>,
+    arg?: CacheSelector<Args, Return> | NamedAsyncIterable<unknown> | AsyncComputed<unknown>,
     args?: Args,
 ): boolean {
+    /* An async cell answers from its own facet (`pending(cell)` ≡ `cell.pending()`). */
+    if (isAsyncCell(arg)) {
+        return arg.pending()
+    }
     return probeRegistries(arg, args, 'pending', unsettled, true)
 }
 

package/src/lib/shared/pendingAsyncCellsSlot.ts

@@ -0,0 +1,13 @@
+import { createResolverSlot } from './createResolverSlot.ts'
+import type { PendingAsyncCells } from './types/PendingAsyncCells.ts'
+
+/*
+The active pending-async-cells slot — mirrors `cacheStoreSlot`. The server entry
+installs an ALS-backed resolver (a fresh list per request, so concurrent SSR
+renders never share the drain); with no resolver registered a single fallback
+list is created lazily so isolated tests work without booting the runtime. Read
+through `pendingAsyncCellsSlot.get()`; the SSR barrier (`settleAsyncCells`) drains it.
+*/
+export const pendingAsyncCellsSlot = createResolverSlot<PendingAsyncCells>(() => ({
+    promises: [],
+}))

package/src/lib/shared/prepareRpcModule.ts

@@ -1,9 +1,11 @@
-import { isReadOnlyMethod } from './isReadOnlyMethod.ts'
+import { HTTP_METHODS } from './HTTP_METHODS.ts'
 import { prepareRemoteExport } from './prepareRemoteExport.ts'
+import { DEFINE_RPC_GLOBAL, REMOTE_PROXY_GLOBAL } from './RPC_SHIM_GLOBALS.ts'
 import { skipNonCode } from './skipNonCode.ts'
 import type { HttpMethod } from './types/HttpMethod.ts'
+import type { RpcBuildStamps } from './types/RpcBuildStamps.ts'
 
-const RPC_NAMES = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'] as const
+const RPC_NAMES = HTTP_METHODS
 const RPC_SET = new Set<string>(RPC_NAMES)
 
 const SINGLE_EXPORT_ERROR =
@@ -11,21 +13,14 @@ const SINGLE_EXPORT_ERROR =
 
 export type PreparedRpcModule = {
     method: HttpMethod
-    /* `outbox: true` in the opts — the client proxy is emitted durable. */
-    durable: boolean
     /* The handler calls jsonl()/sse() — the client proxy is emitted streaming (bare call
-       returns the Subscribable). Congruent with the RemoteCallable conditional by construction. */
+       returns the NamedAsyncIterable). Congruent with the RemoteCallable conditional by construction. */
     streaming: boolean
     exportName: string
     rewriteForServer: (url: string) => string
+    rewriteForClient: (url: string) => string
 }
 
-/* The `outbox` opts key plus its value's leading token (up to the next comma / whitespace /
-   closing brace). `outbox` is a BUILD-TIME flag: the client bundle is rewritten durable or
-   not from this scan, before any handler runs — so the value must be a literal the scan can
-   read, not a computed expression. */
-const OUTBOX_OPT = /\boutbox\s*:\s*([^,\s}]+)/
-
 /*
 Scans an `$rpc/**` module once and returns its declared method + export
 name plus a closure that, given the route URL, emits the server-side
@@ -37,19 +32,11 @@ character-by-character once.
 A regex pass would be tidier but it can't tell a `GET` mention inside a
 docstring or template literal from the real call, and it can't follow
 nested generics like `GET<Map<K, V>>(`.
-
-The two build-time `outbox` invariants live here, not at runtime, because the
-client bundle's durability is decided here — making this the single source of
-truth (the server-side defineRpc guard stays as a cheap backstop):
-  - `outbox` must be a literal `true`/`false`; a computed value can't be read at
-    bundle time, so it's rejected loudly instead of silently shipping a
-    non-durable client proxy.
-  - `outbox: true` is mutating-only — a read RPC (GET/HEAD) has nothing to
-    durably deliver.
 */
 export function prepareRpcModule(
     source: string,
     importName: string,
+    stamps: RpcBuildStamps = {},
 ): PreparedRpcModule | undefined {
     /*
     The "no barrels" surface places each method at its own path
@@ -69,60 +56,99 @@ export function prepareRpcModule(
     }
     const { stripped, site } = prepared
     const method = site.ident as HttpMethod
-    const durable = detectDurable(stripped, site.parenStart, site.parenEnd, method)
-    const streaming = detectStreaming(stripped, site.parenStart, site.parenEnd)
+    /* Streaming is decided by the warm server program's return-type query when it resolved a
+       verdict (ADR-0025 D2 — it sees the wrapper-indirection case the scan misses); undefined
+       (no warm program / unresolvable node) falls open to the char-scan, byte-identical to before. */
+    const streaming = stamps.streaming ?? detectStreaming(stripped, site.parenStart, site.parenEnd)
+    /* The call's top-level args (handler + optional opts), dropping a trailing-comma empty
+       part. The handler is elided on the client; `opts` (schemas/cache/stream) rides through as
+       a LIVE expression in the kept module (ADR-0022 D2) — evaluated in its real scope, so it can
+       reference imported constants, composed values, and separate modules. */
+    const argParts = splitTopLevelArgs(stripped, site.parenStart, site.parenEnd)
     return {
         method,
-        durable,
         streaming,
         exportName: site.exportName,
         rewriteForServer(url: string): string {
-            const binding = `__abideDefineRpc__(${JSON.stringify(method)}, ${JSON.stringify(url)}, `
+            const binding = `${DEFINE_RPC_GLOBAL}(${JSON.stringify(method)}, ${JSON.stringify(url)}, `
             const head = stripped.slice(0, site.callStart) + binding
-            if (!streaming) {
+            /* Build-injected server opts: `streaming` (from the handler body / return type), the
+               `coerce` plan (numeric/boolean query fields → typed, ADR-0028), `inputJsonSchema` (the
+               handler's input args projected to JSON Schema, ADR-0030 input side), `outputJsonSchema`
+               (the handler return type projected to JSON Schema, ADR-0030 D2), and `errorJsonSchemas`
+               (the handler's typed-error branches as a status-keyed schema map, ADR-0030). All are
+               stamped into a fresh opts object that spreads the author's opts, so policy stays live.
+               With none present the original args pass through untouched. */
+            const injected: string[] = []
+            if (streaming) {
+                injected.push('streaming: true')
+            }
+            if (stamps.coercion !== undefined) {
+                injected.push(`coerce: ${JSON.stringify(stamps.coercion)}`)
+            }
+            if (stamps.inputSchema !== undefined) {
+                injected.push(`inputJsonSchema: ${JSON.stringify(stamps.inputSchema)}`)
+            }
+            if (stamps.outputSchema !== undefined) {
+                injected.push(`outputJsonSchema: ${JSON.stringify(stamps.outputSchema)}`)
+            }
+            if (stamps.errorSchemas !== undefined) {
+                injected.push(`errorJsonSchemas: ${JSON.stringify(stamps.errorSchemas)}`)
+            }
+            if (injected.length === 0) {
                 return head + stripped.slice(site.parenStart + 1)
             }
-            /* Inject the build-time streaming flag into the handler's opts, preserving any author
-               opts by spread. Split the call's top-level args (handler + optional opts) — dropping
-               a trailing-comma empty part — so a trailing comma or absent opts can't produce
-               `...()`. `head` ends after the METHOD( paren; keep everything from `)` onward. */
-            const parts = splitTopLevelArgs(stripped, site.parenStart, site.parenEnd)
-            const [handler, opts] = parts
-            const injected = opts ? `{ streaming: true, ...(${opts}) }` : '{ streaming: true }'
-            return `${head}${handler}, ${injected}${stripped.slice(site.parenEnd)}`
+            /* Reuse the top-level arg split (handler + optional opts) so a trailing comma or absent
+               opts can't produce `...()`. `head` ends after the METHOD( paren; keep everything from
+               `)` onward. */
+            const [handler, opts] = argParts
+            const optsObject = opts
+                ? `{ ${injected.join(', ')}, ...(${opts}) }`
+                : `{ ${injected.join(', ')} }`
+            return `${head}${handler}, ${optsObject}${stripped.slice(site.parenEnd)}`
+        },
+        /*
+        Client rewrite, symmetric with rewriteForServer: keep the real module, swap the
+        METHOD( call for a remoteProxy( call, and ELIDE the handler argument. The handler and
+        the imports only it used become dead code the bundler tree-shakes out of the client
+        bundle (proven safe by the D3 reachability guard). `method`/`url` are the build-time
+        scalars; `opts` is left VERBATIM as a live expression, so endpoint policy (cache/stream)
+        can reference imports; `streaming` is the only genuinely build-injected flag — it's
+        derived from the elided handler body (returns jsonl()/sse()), so it can't ride `opts`.
+        remoteProxy reads only streaming/cache/stream off the opts and ignores the rest.
+        */
+        rewriteForClient(url: string): string {
+            const callHead = `${stripped.slice(0, site.callStart)}${REMOTE_PROXY_GLOBAL}(${JSON.stringify(method)}, ${JSON.stringify(url)}`
+            const opts = argParts[1]
+            /* Build-injected CLIENT opts: `streaming` (build-derived from the elided handler body)
+               and the `outputWirePlan` (the handler's structured success fields → the client revives
+               a `Set`/`Map`/`bigint`/`Date` off the decoded response, ADR-0029). Both are stamped
+               into a fresh opts object that spreads the author's live `opts`, so endpoint policy
+               (cache/stream/schemas) still rides through verbatim. */
+            const injected: string[] = []
+            if (streaming) {
+                injected.push('streaming: true')
+            }
+            if (stamps.outputWirePlan !== undefined) {
+                injected.push(`outputWirePlan: ${JSON.stringify(stamps.outputWirePlan)}`)
+            }
+            let argsText: string
+            if (injected.length === 0) {
+                argsText = opts === undefined ? '' : `, ${opts}`
+            } else {
+                const injectedText = injected.join(', ')
+                argsText =
+                    opts === undefined
+                        ? `, { ${injectedText} }`
+                        : `, { ${injectedText}, ...(${opts}) }`
+            }
+            /* Keep everything from the call's closing paren onward (same slicing discipline as
+               rewriteForServer) so any trailing content after the call survives. */
+            return `${callHead}${argsText}${stripped.slice(site.parenEnd)}`
         },
     }
 }
 
-/* Reads the `outbox` flag off the call's opts object (the trailing argument), enforcing the
-   two build-time invariants. Scoping to the opts object keeps the scan off the handler body,
-   so a handler that mentions `outbox:` doesn't misfire. */
-function detectDurable(
-    source: string,
-    parenStart: number,
-    parenEnd: number,
-    method: HttpMethod,
-): boolean {
-    const opts = lastArgText(source, parenStart, parenEnd)
-    const match = opts === undefined ? null : OUTBOX_OPT.exec(opts)
-    if (match === null) {
-        return false
-    }
-    const value = match[1]
-    if (value !== 'true' && value !== 'false') {
-        throw new Error(
-            `[abide] \`outbox\` must be a literal \`true\` or \`false\` (got \`${value}\`) — it's a build-time flag the client bundle reads, so it can't be a computed expression`,
-        )
-    }
-    const durable = value === 'true'
-    if (durable && isReadOnlyMethod(method)) {
-        throw new Error(
-            `[abide] outbox: true is only valid on mutating RPCs (POST/PUT/PATCH/DELETE), not ${method}`,
-        )
-    }
-    return durable
-}
-
 const STREAM_HELPERS = new Set(['jsonl', 'sse'])
 const IDENT_START = /[A-Za-z_$]/
 const IDENT_PART = /[A-Za-z0-9_$]/
@@ -131,8 +157,9 @@ const IDENT_PART = /[A-Za-z0-9_$]/
    constructors of a `TypedResponse<AsyncIterable<Frame>>`. Congruent by construction with the
    RemoteCallable conditional (Return is an AsyncIterable iff the handler calls jsonl/sse). Scans
    the whole call-arg region depth-blind (the opts never mention jsonl/sse), skipping
-   strings/comments/regex via skipNonCode so a mention in a literal can't misfire. Same
-   literal-only limit as `outbox`: an indirection through a wrapper function isn't seen. */
+   strings/comments/regex via skipNonCode so a mention in a literal can't misfire. A
+   literal-only limit: an indirection through a wrapper function isn't seen (the warm server
+   program's return-type query covers that case). */
 function detectStreaming(source: string, parenStart: number, parenEnd: number): boolean {
     let i = parenStart + 1
     while (i < parenEnd) {
@@ -192,32 +219,3 @@ function splitTopLevelArgs(source: string, parenStart: number, parenEnd: number)
     parts.push(source.slice(start, parenEnd).trim())
     return parts.filter((part) => part.length > 0)
 }
-
-/*
-The text of the call's final argument — the opts object for a `METHOD(handler, opts)` call.
-Walks the arg list depth-aware, skipping strings / templates / comments / regex (skipNonCode)
-so their commas and braces don't miscount, and returns the slice after the last top-level
-comma. undefined when the call has a single argument (a bare handler, no opts).
-*/
-function lastArgText(source: string, parenStart: number, parenEnd: number): string | undefined {
-    let depth = 0
-    let lastComma = -1
-    let i = parenStart + 1
-    while (i < parenEnd) {
-        const skipped = skipNonCode(source, i)
-        if (skipped !== undefined) {
-            i = skipped
-            continue
-        }
-        const c = source[i]
-        if (c === '(' || c === '{' || c === '[') {
-            depth++
-        } else if (c === ')' || c === '}' || c === ']') {
-            depth--
-        } else if (c === ',' && depth === 0) {
-            lastComma = i
-        }
-        i++
-    }
-    return lastComma === -1 ? undefined : source.slice(lastComma + 1, parenEnd)
-}

package/src/lib/shared/prepareSocketModule.ts

@@ -1,4 +1,5 @@
 import { prepareRemoteExport } from './prepareRemoteExport.ts'
+import { DEFINE_SOCKET_GLOBAL } from './RPC_SHIM_GLOBALS.ts'
 
 const SINGLE_EXPORT_ERROR =
     '[abide] $sockets module contains more than one `socket(...)` export — each file must declare exactly one socket'
@@ -37,8 +38,8 @@ export function prepareSocketModule(
             const inner = stripped.slice(site.parenStart + 1, site.parenEnd).trim()
             const binding =
                 inner.length === 0
-                    ? `__abideDefineSocket__(${JSON.stringify(name)})`
-                    : `__abideDefineSocket__(${JSON.stringify(name)}, ${stripped.slice(site.parenStart + 1, site.parenEnd)})`
+                    ? `${DEFINE_SOCKET_GLOBAL}(${JSON.stringify(name)})`
+                    : `${DEFINE_SOCKET_GLOBAL}(${JSON.stringify(name)}, ${stripped.slice(site.parenStart + 1, site.parenEnd)})`
             return stripped.slice(0, site.callStart) + binding + stripped.slice(site.parenEnd + 1)
         },
     }

package/src/lib/shared/probeRegistries.ts

@@ -1,13 +1,12 @@
 import { cacheStores } from './cacheStores.ts'
 import { isSubscribable } from './isSubscribable.ts'
-import { outboxProbeSlot } from './outboxProbeSlot.ts'
 import { selectorMatcher } from './selectorMatcher.ts'
 import { selectorPrefix } from './selectorPrefix.ts'
 import { tailProbeSlot } from './tailProbeSlot.ts'
 import type { CacheEntry } from './types/CacheEntry.ts'
 import type { CacheSelector } from './types/CacheSelector.ts'
 import type { CacheStore } from './types/CacheStore.ts'
-import type { Subscribable } from './types/Subscribable.ts'
+import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
 
 /*
 Shared scan behind the pending() / refreshing() probes: one selector
@@ -24,22 +23,11 @@ re-tracks narrowed. `matchesEntry` is the probe's cache-side question;
 `field` selects the stream-side answer; `unprobed` is the answer for a
 stream no prober can see (server, or tail never imported) — matching what
 tail() itself reports there. The bare form (no selector) spans every
-registry; fn/tag selectors are cache identities only (plus the parked-write
-queue a durable rpc selector narrows to). Outside a tracking scope the taps
-are no-ops and the current value returns.
-
-A parked durable (`outbox`) write has no value yet, so it counts as pending —
-but never refreshing (it's holding nothing to supersede), hence the term is
-guarded to `field === 'pending'`. The outbox prober (registered into
-outboxProbeSlot by browser/, empty on the server) reads its doc-backed queue,
-which is the term's own reactive tap. It sits last under `||`: when a matching
-cache call or stream already answers true the queue isn't read, but that's
-monotonic-safe — the parked write can't flip a true result, and the moment the
-cache/stream term falls back to false its lifecycle tap re-derives and the
-queue is read then.
+registry; fn/tag selectors are cache identities only. Outside a tracking scope
+the taps are no-ops and the current value returns.
 */
 export function probeRegistries<Args, Return>(
-    arg: CacheSelector<Args, Return> | Subscribable<unknown> | undefined,
+    arg: CacheSelector<Args, Return> | NamedAsyncIterable<unknown> | undefined,
     args: Args | undefined,
     field: 'pending' | 'refreshing',
     matchesEntry: (entry: CacheEntry) => boolean,
@@ -58,8 +46,7 @@ export function probeRegistries<Args, Return>(
     const matches = selectorMatcher(arg, args, prefix)
     return (
         stores.some((store) => anyEntryMatches(store, matchesEntry, matches)) ||
-        streams?.[field] === true ||
-        (field === 'pending' && (outboxProbeSlot.probe?.(arg, args) ?? false))
+        streams?.[field] === true
     )
 }
 

package/src/lib/shared/reachable.ts

@@ -4,10 +4,10 @@ import { parseBoundedEnvInt } from './parseBoundedEnvInt.ts'
 /*
 Isomorphic outbound reachability. `await reachable(host)` HEADs the host's
 origin: the first call awaits a real probe (faithful — a down host costs the
-full timeout, an up host one handshake) and starts a background poll that
-re-probes every TTL, so every later call resolves instantly off the warm
-value, fresh within one TTL. A host going down is caught within ~failureLimit
-polls; recovery flips it back automatically.
+full timeout, an up host one handshake) and caches the verdict for one TTL, so
+every later call within the TTL resolves instantly off the cached value. The
+first call after the TTL expires re-probes; a host going down (or recovering) is
+noticed on the next read past its cached verdict, not continuously.
 
   if (!(await reachable('api.example.com'))) return error(503)
 
@@ -27,10 +27,10 @@ this is the honest way to fail a doomed outbound call fast — see online() for
 the inbound/client-reported counterpart. The browser probes no-cors (a
 completed opaque response proves connectivity without the host's CORS
 blessing) and composes navigator.onLine in at read time, so a lost network
-reports false instantly instead of waiting out the warm value — except for
+reports false instantly instead of waiting out the cached value — except for
 loopback hosts, which need no network.
 
-ABIDE_REACHABLE_TTL (poll cadence / freshness, ms) and ABIDE_REACHABLE_TIMEOUT
+ABIDE_REACHABLE_TTL (cache freshness, ms) and ABIDE_REACHABLE_TIMEOUT
 (per-HEAD bound, ms) tune the server defaults; the browser has no env, so it
 runs the defaults. The timeout is deliberately generous so a healthy-but-
 distant host over a slow link is not mis-read as down.
@@ -38,8 +38,6 @@ distant host over a slow link is not mis-read as down.
 const env = typeof process === 'undefined' ? undefined : process.env
 const TTL_MS = parseBoundedEnvInt(env?.ABIDE_REACHABLE_TTL, 1_000, 600_000) ?? 30_000
 const TIMEOUT_MS = parseBoundedEnvInt(env?.ABIDE_REACHABLE_TIMEOUT, 100, 60_000) ?? 3_000
-/* Stop polling a host nobody has read in a few TTLs; the next read restarts it cold. */
-const IDLE_MS = TTL_MS * 3
 
 /* Status-agnostic HEAD: a completed response proves connectivity; reject/timeout does not.
    The browser probes no-cors — an opaque response still completes, so a foreign origin
@@ -59,8 +57,7 @@ async function probeOrigin(origin: string): Promise<boolean> {
 
 const registry = createReachable({
     probe: probeOrigin,
-    intervalMs: TTL_MS,
-    idleMs: IDLE_MS,
+    ttlMs: TTL_MS,
 })
 
 /* Loopback = this machine: no network between, so no probe and no offline gate. */

package/src/lib/shared/refresh.ts

@@ -1,4 +1,6 @@
 import { cache } from './cache.ts'
+import { isAsyncCell } from './isAsyncCell.ts'
+import type { AsyncComputed } from './types/AsyncComputed.ts'
 import type { CacheSelector } from './types/CacheSelector.ts'
 
 /*
@@ -17,6 +19,14 @@ Instance sugar `getFoo.refresh(args?)` ≡ `refresh(getFoo, args?)`. Reports, ne
 retains a spinner — pair with `refreshing()` to surface the in-flight reload.
 */
 // @documentation cache
-export function refresh<Args, Return>(arg?: CacheSelector<Args, Return>, args?: Args): void {
-    cache.refresh(arg, args)
+export function refresh<Args, Return>(
+    arg?: CacheSelector<Args, Return> | AsyncComputed<unknown>,
+    args?: Args,
+): void {
+    /* An async cell re-invokes its own seed (`refresh(cell)` ≡ `cell.refresh()`). */
+    if (isAsyncCell(arg)) {
+        arg.refresh()
+        return
+    }
+    cache.refresh(arg as CacheSelector<Args, Return>, args)
 }

package/src/lib/shared/refreshing.ts

@@ -1,7 +1,9 @@
+import { isAsyncCell } from './isAsyncCell.ts'
 import { probeRegistries } from './probeRegistries.ts'
+import type { AsyncComputed } from './types/AsyncComputed.ts'
 import type { CacheEntry } from './types/CacheEntry.ts'
 import type { CacheSelector } from './types/CacheSelector.ts'
-import type { Subscribable } from './types/Subscribable.ts'
+import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
 
 /*
 Reactive revalidation probe over both registries. Refreshing means "holding a
@@ -22,9 +24,13 @@ registry spans) live in probeRegistries.
 */
 // @documentation probes
 export function refreshing<Args, Return>(
-    arg?: CacheSelector<Args, Return> | Subscribable<unknown>,
+    arg?: CacheSelector<Args, Return> | NamedAsyncIterable<unknown> | AsyncComputed<unknown>,
     args?: Args,
 ): boolean {
+    /* An async cell answers from its own facet (`refreshing(cell)` ≡ `cell.refreshing()`). */
+    if (isAsyncCell(arg)) {
+        return arg.refreshing()
+    }
     return probeRegistries(arg, args, 'refreshing', reloading, false)
 }
 

package/src/lib/shared/resolvedCellsSlot.ts

@@ -0,0 +1,13 @@
+import { createResolverSlot } from './createResolverSlot.ts'
+import type { ResolvedCells } from './types/ResolvedCells.ts'
+
+/*
+The active resolved-async-cells slot — mirrors `pendingAsyncCellsSlot`. The server entry installs
+an ALS-backed resolver (a fresh list per request, so concurrent SSR renders never mix their warm
+seeds); with no resolver registered a single fallback list is created lazily so isolated tests
+work without booting the runtime. `createAsyncCell` pushes a `{key, value}` when a seed settles
+server-side; the page renderer reads it at render-return to stamp `__SSR__.cells`.
+*/
+export const resolvedCellsSlot = createResolverSlot<ResolvedCells>(() => ({
+    entries: [],
+}))

package/src/lib/shared/reviveWireField.ts

@@ -0,0 +1,49 @@
+import type { WireKind } from './types/WireKind.ts'
+
+/*
+One field's honest-JSON wire value → its declared runtime type, fail-open — the decode core
+shared by the rpc RESPONSE revival (`reviveWireOutput`) and the INPUT revival (`parseArgs`), so
+the two ends can't drift on how a wire form decodes (ADR-0029). A `Set`/`Map` already carried by
+an abide ref-json body passes through; a wire array becomes the `Set`/`Map`; an ISO string becomes
+a `Date`; a digit string becomes a `bigint`. An already-typed or non-matching value is returned
+untouched so the codec never throws.
+
+Callers layer their own-side extras on top: the input side additionally accepts a plain object as
+`Map` entries and coerces query/form STRINGS to number/boolean (see `parseArgs`). Top-level fields
+only — a structured value nested deeper is not descended into (deferred, ADR-0029).
+*/
+export function reviveWireField(value: unknown, kind: WireKind): unknown {
+    if (kind === 'set') {
+        if (value instanceof Set) {
+            return value
+        }
+        return Array.isArray(value) ? new Set(value) : value
+    }
+    if (kind === 'map') {
+        if (value instanceof Map) {
+            return value
+        }
+        return Array.isArray(value) ? new Map(value as [unknown, unknown][]) : value
+    }
+    if (kind === 'date') {
+        if (typeof value !== 'string') {
+            return value
+        }
+        const date = new Date(value)
+        return Number.isNaN(date.getTime()) ? value : date
+    }
+    if (kind === 'bigint') {
+        if (typeof value !== 'string' || value.trim() === '') {
+            return value
+        }
+        try {
+            return BigInt(value)
+        } catch {
+            /* A non-integer literal throws — keep the string rather than crash the decode. */
+            return value
+        }
+    }
+    /* number/boolean ride as their JSON type on the wire; nothing to revive here (the input side
+       coerces them from query/form strings separately). */
+    return value
+}