@abide/abide 0.42.0 → 0.43.0

package/src/lib/shared/createRemoteFunction.ts

@@ -5,7 +5,7 @@ import { REMOTE_FUNCTION } from './REMOTE_FUNCTION.ts'
 import { recordRemoteMeta } from './recordRemoteMeta.ts'
 import { subscribableFromResponse } from './subscribableFromResponse.ts'
 import type { ClientFlags } from './types/ClientFlags.ts'
-import type { HttpVerb } from './types/HttpVerb.ts'
+import type { HttpMethod } from './types/HttpMethod.ts'
 import type { RawRemoteFunction } from './types/RawRemoteFunction.ts'
 import type { RemoteFunction } from './types/RemoteFunction.ts'
 import type { RpcOptions } from './types/RpcOptions.ts'
@@ -13,7 +13,7 @@ import type { Subscribable } from './types/Subscribable.ts'
 
 /*
 Assembles the public RemoteFunction shape used identically by the
-server-side defineVerb (in-process handler invocation) and the
+server-side defineRpc (in-process handler invocation) and the
 client-side remoteProxy (network fetch). Centralising the wiring here
 keeps the call/raw/stream/fetch semantics — including WeakMap meta
 recording, Content-Type decode, and Subscribable derivation — in one
@@ -24,7 +24,7 @@ place so the two halves can't drift.
   base; client uses window.location. The result is memoised inside the
   per-call `getRequest` thunk so the Request is built at most once per
   call regardless of how many readers pull on it.
-- `invoke(args, getRequest)` actually runs the call: server defineVerb
+- `invoke(args, getRequest)` actually runs the call: server defineRpc
   runs the handler and ignores `getRequest`; client remoteProxy calls
   `fetch(getRequest())`. The thunk lets the server skip the Request
   allocation entirely on the SSR hot path — the only consumer that ever
@@ -35,10 +35,10 @@ place so the two halves can't drift.
   forwards the request through invoke().
 */
 export function createRemoteFunction<Args, Return>(opts: {
-    method: HttpVerb
+    method: HttpMethod
     url: string
     clients: ClientFlags
-    /* Server-side only: exempts a mutating verb from the router's same-origin CSRF gate. */
+    /* Server-side only: exempts a mutating rpc from the router's same-origin CSRF gate. */
     crossOrigin?: boolean
     buildRequest: (args: Args | undefined, opts?: RpcOptions) => Request
     invoke: (
@@ -75,7 +75,7 @@ export function createRemoteFunction<Args, Return>(opts: {
     }
 
     /*
-    A body verb may receive a FormData in place of typed Args (the upload
+    A body rpc may receive a FormData in place of typed Args (the upload
     escape hatch). It flows through dispatch only into buildRpcRequest /
     keyForRemoteCall, both of which take it as-is, so the cast to Args is a
     contained type lie — buildRpcRequest's `instanceof FormData` branch handles
@@ -103,6 +103,11 @@ export function createRemoteFunction<Args, Return>(opts: {
             raw(args as Args),
         )
     }
+    /* Uniform runtime guard for every rpc — the per-rpc data typing lives entirely in the
+       RpcErrorGuard<Errors> signature RemoteFunction projects onto it (Errors flows from the
+       rpc helper's declared type, not from here). */
+    callable.isError = (error: unknown, kind: string): boolean =>
+        error instanceof HttpError && error.kind === kind
     Object.defineProperty(callable, REMOTE_FUNCTION, { value: true })
     callable.fetch = parseArgsForFetch
         ? async (request: Request): Promise<Response> => {

package/src/lib/shared/decodeResponse.ts

@@ -1,6 +1,6 @@
 import { contentBodyKind } from './contentBodyKind.ts'
 import { contentTypeOf } from './contentTypeOf.ts'
-import { HttpError } from './HttpError.ts'
+import { httpErrorFor } from './httpErrorFor.ts'
 
 /*
 Decodes a Response into the natural body value based on Content-Type:
@@ -27,7 +27,7 @@ returns the underlying Response untouched.
 */
 export async function decodeResponse(response: Response): Promise<unknown> {
     if (!response.ok) {
-        throw new HttpError(response)
+        throw await httpErrorFor(response)
     }
     if (response.status === 204) {
         return undefined

package/src/lib/shared/detectRpcMethod.ts

@@ -0,0 +1,17 @@
+import type { HttpMethod } from './types/HttpMethod.ts'
+
+/*
+Reads the HTTP method of an $rpc module from its source. Every file under
+src/server/rpc/ follows the convention `export const <name> = GET(fn)` (the
+rpc helper picks the method, possibly with an explicit generic
+`GET<{…}>(fn)`), so the helper name at the export is the method. Returns
+undefined when no rpc export matches — the caller skips the file rather
+than guessing. Used by the rpc.d.ts codegen to type url() against
+query-carrying rpcs; matching the same convention the bundler rewrites
+keeps the two from drifting.
+*/
+const RPC_EXPORT = /export\s+const\s+\w+\s*=\s*(GET|POST|PUT|PATCH|DELETE|HEAD)\s*[<(]/
+
+export function detectRpcMethod(source: string): HttpMethod | undefined {
+    return (source.match(RPC_EXPORT)?.[1] as HttpMethod | undefined) ?? undefined
+}

package/src/lib/shared/emitLogRecord.ts

@@ -77,7 +77,7 @@ function formatClock(ts: number): string {
 
 /*
 Builds the record from the emission's own fields plus the ambient request
-scope (trace, elapsed, verb+path), then renders it through the active
+scope (trace, elapsed, method+path), then renders it through the active
 formatter. The scope is read at emission time so a record emitted from a
 stream-flush callback re-entered into the scope still carries its context.
 Internal seam shared by the public logger and the framework's closing-record
@@ -132,14 +132,14 @@ function consoleFor(level: LogRecord['level']): (...args: unknown[]) => void {
 
 /*
 The unified tsv line (the default format): tab-separated
-`<clock>	<trace8>	<verb path>	[channel] <message>	+0.00ms`. The
+`<clock>	<trace8>	<rpc path>	[channel] <message>	+0.00ms`. The
 wall-clock leads every line (each record carries `ts`); inside a request scope
 the trace column follows and the elapsed-at-emission timing trails; a closing
 record emitted outside one (asset hits sidestep the scope) pads a blank trace
 column and trails its serve duration instead, so request lines stay aligned
 whatever produced them. Every record speaks on a channel
 (the app name, 'abide', or a diagnostic channel), shown as a dim `[name]`
-tag opening the message field. The verb+path pair is one field — it's the
+tag opening the message field. The method+path pair is one field — it's the
 line's anchor unit — and the tag folds into the message field so field
 positions stay stable for cut/awk consumers.
 */

package/src/lib/shared/extraForwardHeaders.ts

@@ -1,7 +1,7 @@
 /*
 App-configured inbound header names to forward onto in-process rpc Requests,
 on top of the built-in FORWARDED_HEADERS. Set once at boot from
-app.forwardHeaders so the SSR in-process path (defineVerb) and the MCP
+app.forwardHeaders so the SSR in-process path (defineRpc) and the MCP
 dispatcher honour the same list without re-reading app config per call. A
 module-level slot rather than threaded config because both call sites are deep
 in the request path and the value is fixed for the process lifetime.

package/src/lib/shared/findExportCallSite.ts

@@ -1,9 +1,14 @@
+import { isAsciiWhitespace } from './isAsciiWhitespace.ts'
+import { isIdentPart } from './isIdentPart.ts'
+import { isIdentStart } from './isIdentStart.ts'
+import { skipNonCode } from './skipNonCode.ts'
+
 /*
 Scans a module source character-by-character — skipping strings,
-templates, comments, and TypeScript generics — for an
-`export const <name> = <IDENT>(...)` binding the caller cares about.
-On a match returns the identifier text, the export name, and the byte
-ranges of the call's open and close parens; the $rpc and $sockets
+templates, comments, regex literals (via skipNonCode), and TypeScript
+generics — for an `export const <name> = <IDENT>(...)` binding the caller
+cares about. On a match returns the identifier text, the export name, and
+the byte ranges of the call's open and close parens; the $rpc and $sockets
 rewriters splice their runtime bindings into those ranges.
 
 The scanner enforces a single matching export per module: a second match
@@ -32,20 +37,12 @@ export function findExportCallSite(
     const len = source.length
     let i = 0
     while (i < len) {
-        const c = source[i]
-        const afterSlash = skipSlashConstruct(source, i)
-        if (afterSlash !== undefined) {
-            i = afterSlash
-            continue
-        }
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
+        const skipped = skipNonCode(source, i)
+        if (skipped !== undefined) {
+            i = skipped
             continue
         }
+        const c = source[i]
         if (isIdentStart(c) && !isIdentPart(source[i - 1])) {
             let j = i + 1
             while (j < len && isIdentPart(source[j])) {
@@ -84,106 +81,9 @@ export function findExportCallSite(
     return found
 }
 
-function skipString(source: string, start: number, quote: string): number {
-    let i = start
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === quote) {
-            return i + 1
-        }
-        if (c === '\n') {
-            return i
-        }
-        i++
-    }
-    return source.length
-}
-
-function skipTemplate(source: string, start: number): number {
-    let i = start
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === '`') {
-            return i + 1
-        }
-        if (c === '$' && source[i + 1] === '{') {
-            i = skipTemplateExpression(source, i + 2)
-            continue
-        }
-        i++
-    }
-    return source.length
-}
-
-function skipTemplateExpression(source: string, start: number): number {
-    let depth = 1
-    let i = start
-    while (i < source.length && depth > 0) {
-        const c = source[i]
-        if (c === '{') {
-            depth++
-            i++
-            continue
-        }
-        if (c === '}') {
-            depth--
-            i++
-            continue
-        }
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
-            continue
-        }
-        const afterSlash = skipSlashConstruct(source, i)
-        if (afterSlash !== undefined) {
-            i = afterSlash
-            continue
-        }
-        i++
-    }
-    return i
-}
-
-/*
-When `i` sits on a `/` introducing a line comment, block comment, or regex
-literal, returns the index immediately after the construct; undefined when
-the `/` is division (or `i` isn't a `/`). One statement of the skip rules
-shared by every scanner loop so they can't drift.
-*/
-function skipSlashConstruct(source: string, i: number): number | undefined {
-    if (source[i] !== '/') {
-        return undefined
-    }
-    const next = source[i + 1]
-    if (next === '/') {
-        const newline = source.indexOf('\n', i + 2)
-        return newline === -1 ? source.length : newline + 1
-    }
-    if (next === '*') {
-        const end = source.indexOf('*/', i + 2)
-        return end === -1 ? source.length : end + 2
-    }
-    if (isRegexContext(source, i)) {
-        return skipRegex(source, i + 1)
-    }
-    return undefined
-}
-
 function matchCallTail(source: string, after: number): number | undefined {
     let j = after
-    while (j < source.length && isWhitespace(source[j])) {
+    while (j < source.length && isAsciiWhitespace(source[j])) {
         j++
     }
     if (source[j] === '<') {
@@ -192,7 +92,7 @@ function matchCallTail(source: string, after: number): number | undefined {
             return undefined
         }
         j = closed
-        while (j < source.length && isWhitespace(source[j])) {
+        while (j < source.length && isAsciiWhitespace(source[j])) {
             j++
         }
     }
@@ -216,15 +116,12 @@ function skipGenerics(source: string, start: number): number | undefined {
     let bracketDepth = 0
     let i = start
     while (i < source.length) {
-        const c = source[i]
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
+        const skipped = skipNonCode(source, i)
+        if (skipped !== undefined) {
+            i = skipped
             continue
         }
+        const c = source[i]
         if (c === '<') {
             angleDepth++
         } else if (c === '>') {
@@ -254,28 +151,20 @@ function skipGenerics(source: string, start: number): number | undefined {
 }
 
 /*
-Walks the call body, skipping strings/templates/comments and respecting
-nested `()` so brackets inside object literals or nested calls don't
-throw the depth count.
+Walks the call body, skipping strings/templates/comments/regex and
+respecting nested `()` so brackets inside object literals or nested calls
+don't throw the depth count.
 */
 function findCallEnd(source: string, parenStart: number): number | undefined {
     let depth = 1
     let i = parenStart + 1
     while (i < source.length) {
-        const c = source[i]
-        if (c === '"' || c === "'") {
-            i = skipString(source, i + 1, c)
-            continue
-        }
-        if (c === '`') {
-            i = skipTemplate(source, i + 1)
-            continue
-        }
-        const afterSlash = skipSlashConstruct(source, i)
-        if (afterSlash !== undefined) {
-            i = afterSlash
+        const skipped = skipNonCode(source, i)
+        if (skipped !== undefined) {
+            i = skipped
             continue
         }
+        const c = source[i]
         if (c === '(') {
             depth++
         } else if (c === ')') {
@@ -297,14 +186,14 @@ isn't the module's declared export.
 */
 function detectExportName(source: string, callStart: number): string | undefined {
     let i = callStart - 1
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     if (source[i] !== '=') {
         return undefined
     }
     i--
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     const nameEnd = i + 1
@@ -316,14 +205,14 @@ function detectExportName(source: string, callStart: number): string | undefined
         return undefined
     }
     const name = source.slice(nameStart, nameEnd)
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     if (!matchesBackwards(source, i, 'const')) {
         return undefined
     }
     i -= 'const'.length
-    while (i >= 0 && isWhitespace(source[i])) {
+    while (i >= 0 && isAsciiWhitespace(source[i])) {
         i--
     }
     if (!matchesBackwards(source, i, 'export')) {
@@ -342,135 +231,3 @@ function matchesBackwards(source: string, end: number, keyword: string): boolean
     }
     return start === 0 || !isIdentPart(source[start - 1])
 }
-
-function isIdentStart(c: string | undefined): boolean {
-    if (c === undefined) {
-        return false
-    }
-    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$'
-}
-
-function isIdentPart(c: string | undefined): boolean {
-    if (c === undefined) {
-        return false
-    }
-    return isIdentStart(c) || (c >= '0' && c <= '9')
-}
-
-function isWhitespace(c: string | undefined): boolean {
-    return c === ' ' || c === '\t' || c === '\n' || c === '\r'
-}
-
-/*
-A `/` starts a regex literal when the prior expression context expects an
-expression rather than a value — after an open delimiter, operator, or
-expression-prefix keyword (return, typeof, instanceof, in, of, delete,
-void, await, yield, new, throw, case, do). Otherwise `/` is division.
-Without this disambiguation a regex like `/^\//` reads as `/` (division),
-then `^`, `\`, `/`, `/` — and the final `//` pair fakes a line comment
-that swallows the rest of the line, eating any `)` that closes the
-enclosing call.
-*/
-const REGEX_PREFIX_KEYWORDS = new Set([
-    'return',
-    'typeof',
-    'instanceof',
-    'in',
-    'of',
-    'delete',
-    'void',
-    'await',
-    'yield',
-    'new',
-    'throw',
-    'case',
-    'do',
-])
-
-const REGEX_PUNCTUATION = new Set([
-    '(',
-    '[',
-    '{',
-    ',',
-    ';',
-    ':',
-    '?',
-    '!',
-    '&',
-    '|',
-    '^',
-    '~',
-    '+',
-    '-',
-    '*',
-    '%',
-    '<',
-    '>',
-    '=',
-    '/',
-])
-
-function isRegexContext(source: string, slashIndex: number): boolean {
-    let i = slashIndex - 1
-    while (i >= 0 && isWhitespace(source[i])) {
-        i--
-    }
-    if (i < 0) {
-        return true
-    }
-    const prev = source[i] as string
-    if (REGEX_PUNCTUATION.has(prev)) {
-        return true
-    }
-    if (isIdentPart(prev)) {
-        let start = i
-        while (start > 0 && isIdentPart(source[start - 1])) {
-            start--
-        }
-        return REGEX_PREFIX_KEYWORDS.has(source.slice(start, i + 1))
-    }
-    return false
-}
-
-/*
-Walks past a regex literal body, respecting character classes (`[...]`
-where `/` is literal) and backslash escapes, then consumes trailing
-flag identifiers. Returns the index immediately after the regex. An
-unterminated regex (newline before closing `/`) returns the newline
-position so the outer scanner can resume normally on the next line.
-*/
-function skipRegex(source: string, start: number): number {
-    let i = start
-    let inClass = false
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === '\n') {
-            return i
-        }
-        if (inClass) {
-            if (c === ']') {
-                inClass = false
-            }
-            i++
-            continue
-        }
-        if (c === '[') {
-            inClass = true
-            i++
-            continue
-        }
-        if (c === '/') {
-            let j = i + 1
-            while (j < source.length && isIdentPart(source[j])) {
-                j++
-            }
-            return j
-        }
-        i++
-    }
-    return source.length
-}

package/src/lib/shared/forwardHeaders.ts

@@ -4,8 +4,8 @@ import { extraForwardHeaders } from './extraForwardHeaders.ts'
 Headers abide forwards from an inbound HTTP/MCP request onto every
 synthesized in-process rpc Request — cookies + bearer auth + the four
 forwarding hints proxies set when terminating TLS in front of the app.
-defineVerb uses this when an SSR pass calls a verb in-process; the MCP
-dispatcher uses it when piping a tool invocation through verb.fetch.
+defineRpc uses this when an SSR pass calls a rpc in-process; the MCP
+dispatcher uses it when piping a tool invocation through rpc.fetch.
 
 WARNING — this is an allowlist: every inbound header NOT named here (and
 not added via app.forwardHeaders) is DROPPED on the in-process path. A

package/src/lib/shared/httpErrorFor.ts

@@ -0,0 +1,26 @@
+import { contentBodyKind } from './contentBodyKind.ts'
+import { contentTypeOf } from './contentTypeOf.ts'
+import { HttpError } from './HttpError.ts'
+
+/*
+Builds the HttpError for a non-2xx response, parsing a typed-error body
+(`{ $abideError, data }`, emitted by `error(errors.x(...))` and validation 422)
+onto `.kind` / `.data`. Reads a clone so the original `response.body` stays
+unread for callers that inspect it. A non-JSON or malformed body leaves
+`.kind` / `.data` undefined (a plain `error(status, text)`). Shared by the
+plain decode path (decodeResponse) and the streaming path (streamResponse) so
+both surface the same typed error on a non-2xx.
+*/
+export async function httpErrorFor(response: Response): Promise<HttpError> {
+    if (contentBodyKind(contentTypeOf(response.headers)) === 'json') {
+        try {
+            const body = await response.clone().json()
+            if (body !== null && typeof body === 'object' && '$abideError' in body) {
+                return new HttpError(response, body.$abideError, body.data)
+            }
+        } catch {
+            /* malformed JSON error body — fall through to a plain HttpError */
+        }
+    }
+    return new HttpError(response)
+}

package/src/lib/shared/isAsciiWhitespace.ts

@@ -0,0 +1,5 @@
+/* True for the source-scanner whitespace set (space, tab, CR, LF). Distinct from
+   isWhitespaceText, which classifies template text nodes. */
+export function isAsciiWhitespace(c: string | undefined): boolean {
+    return c === ' ' || c === '\t' || c === '\n' || c === '\r'
+}

package/src/lib/shared/isIdentPart.ts

@@ -0,0 +1,9 @@
+import { isIdentStart } from './isIdentStart.ts'
+
+/* True when `c` can continue a JavaScript identifier — an identifier-start char or a digit. */
+export function isIdentPart(c: string | undefined): boolean {
+    if (c === undefined) {
+        return false
+    }
+    return isIdentStart(c) || (c >= '0' && c <= '9')
+}

package/src/lib/shared/isIdentStart.ts

@@ -0,0 +1,8 @@
+/* True when `c` can begin a JavaScript identifier (ASCII letters, `_`, `$`). Shared by the
+   source scanners (findExportCallSite, skipNonCode) to find identifiers and regex flags. */
+export function isIdentStart(c: string | undefined): boolean {
+    if (c === undefined) {
+        return false
+    }
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$'
+}

package/src/lib/shared/isReadOnlyMethod.ts

@@ -1,14 +1,14 @@
-import type { HttpVerb } from './types/HttpVerb.ts'
+import type { HttpMethod } from './types/HttpMethod.ts'
 
 /*
 Read-only (safe) HTTP methods — they don't mutate server state. Abide
-uses this to decide which verbs auto-expose to MCP: reads flip MCP on
+uses this to decide which rpcs auto-expose to MCP: reads flip MCP on
 when a schema is present, mutations require an explicit `clients.mcp`
 opt-in so a model can't delete/overwrite data just because the handler
 carries a schema. Also feeds the MCP tool `readOnlyHint` annotation.
 */
-const READ_ONLY_METHODS = new Set<HttpVerb>(['GET', 'HEAD'])
+const READ_ONLY_METHODS = new Set<HttpMethod>(['GET', 'HEAD'])
 
-export function isReadOnlyMethod(method: HttpVerb): boolean {
+export function isReadOnlyMethod(method: HttpMethod): boolean {
     return READ_ONLY_METHODS.has(method)
 }

package/src/lib/shared/keyForRemoteCall.ts

@@ -1,17 +1,17 @@
 import { canonicalJson } from './canonicalJson.ts'
 import { carriesBodyArgs } from './carriesBodyArgs.ts'
 import { queryStringFromArgs } from './queryStringFromArgs.ts'
-import type { HttpVerb } from './types/HttpVerb.ts'
+import type { HttpMethod } from './types/HttpMethod.ts'
 
 /*
-Derives a cache key from a verb-defined remote function and its args. The
+Derives a cache key from a rpc-defined remote function and its args. The
 prefix is `${method} ${url}` where `url` is the route template. GET/DELETE/HEAD
 serialise args onto the URL as `?key=value` (sorted, via queryStringFromArgs —
 the same encoder buildRpcRequest builds its query with, so the key and the
 synthesized Request can't disagree); POST/PUT/PATCH join args after a space as
-canonical JSON. The verb split mirrors buildRpcRequest exactly.
+canonical JSON. The rpc split mirrors buildRpcRequest exactly.
 */
-export function keyForRemoteCall(method: HttpVerb, url: string, args: unknown): string {
+export function keyForRemoteCall(method: HttpMethod, url: string, args: unknown): string {
     const prefix = `${method} ${url}`
     if (!carriesBodyArgs(method)) {
         if (args && typeof args === 'object' && !Array.isArray(args)) {

package/src/lib/shared/log.ts

@@ -5,7 +5,7 @@ import type { Log } from './types/Log.ts'
 
 /*
 The unified logger: every record carries the request-scope context (short
-trace id, +elapsed, verb+path) when one is active, plus a channel — the
+trace id, +elapsed, method+path) when one is active, plus a channel — the
 line's speaker. `log(...)`/`warn`/`error`/`trace` speak on the app's own
 always-on channel (the app name, resolved per emission so boot order doesn't
 matter); `log.channel(name)` returns the same shape on a DEBUG-gated

package/src/lib/shared/outboxProbeSlot.ts

@@ -0,0 +1,20 @@
+/*
+Internal slot the browser outbox registry registers its prober into, so the
+shared pending() probe can count parked durable-rpc writes without shared/
+importing browser/. Mirrors tailProbeSlot. The prober reads the doc-backed
+queue entries (reactive inside $derived / $effect) and reports whether any
+undelivered entry matches the selector: a durable rpc selector (carries a
+`url`) narrows to its own queue, the bare form spans every registered queue,
+optional args narrow to one parked call by structural compare. Outbox state is
+pending-only — a parked write has no value, so it never contributes to
+refreshing(); probeRegistries reads this slot only on its `field === 'pending'`
+branch, which is why the slot mirrors tailProbeSlot but reports a bare boolean
+rather than a { pending, refreshing } pair. When no prober is registered (server
+render, or no durable rpc was ever used) pending() sees no parked writes,
+exactly as on the server where there are no client queues.
+*/
+export const outboxProbeSlot: {
+    probe: ((selector: unknown, args: unknown) => boolean) | undefined
+} = {
+    probe: undefined,
+}

package/src/lib/shared/pending.ts

@@ -15,9 +15,12 @@ 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) live in probeRegistries.
+selector grammar, registry spans, the parked-write term) live in
+probeRegistries.
 */
 // @documentation probes
 export function pending<Args, Return>(