@abide/abide 0.44.0 → 0.45.0

package/src/lib/server/rpc/types/RpcHelper.ts

@@ -2,7 +2,61 @@ import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
 import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
 import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
 import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
-import type { RemoteHandler } from './RemoteHandler.ts'
+import type { TypedError } from './TypedError.ts'
+import type { TypedResponse } from './TypedResponse.ts'
+
+/*
+The success body carried by a handler's return type `R`. Error branches
+(`TypedError`, checked first since they're also Responses) drop to `never` and
+union away, so `Return` is the body of the success `TypedResponse` members alone
+— an untagged `Response` falls back to `unknown`, matching hand-built responses.
+*/
+type SuccessBody<R> =
+    R extends TypedError<string, ErrorSpec[string]>
+        ? never
+        : R extends TypedResponse<infer Body>
+          ? Body
+          : unknown
+
+/*
+The error spec a handler's return type `R` declares — rebuilt name→entry from the
+`TypedError` brands among its branches (distributes over the union; no error
+branches → `{}`). This is what gives `rpc.isError` its typed surface with no
+`errors:` option: the errors a handler RETURNS are the errors it can raise.
+*/
+type ErrorBrand<R> =
+    R extends TypedError<infer Name, infer Entry> ? { name: Name; entry: Entry } : never
+type InferredErrors<R> = { [Brand in ErrorBrand<R> as Brand['name']]: Brand['entry'] }
+
+/*
+The handler every bare (schemaless) overload accepts: any args in, a Response (or a
+Promise of one) out. Collapsing the old `<Args, R>` pair into this single inferred
+function type is deliberate. TypeScript has no partial type-argument inference, so
+`GET<Args>(fn)` used to drop `R` to its `Response` default and silently erase the body
+to `unknown`. With one generic constrained to `RpcFn`, that same call is instead a loud
+`does not satisfy the constraint 'RpcFn'`, and `Args`/`Return`/`Errors` all read
+structurally off the handler — args from its parameter, body + errors from its return —
+which is where a normal TS function declares them anyway (no mainstream rpc framework
+parameterises the call with generics). `any` is load-bearing: `never`/`unknown` in the
+parameter position break return inference by contextually widening the handler's body.
+*/
+type RpcFn = (args: any) => Response | Promise<Response>
+
+/* The handler's declared args: its first parameter, or `undefined` for a nullary handler. */
+type RpcArgs<F extends RpcFn> = Parameters<F> extends [infer Args, ...unknown[]] ? Args : undefined
+
+/*
+The RemoteFunction a bare overload produces from handler `F`. `SuccessBody`/`InferredErrors`
+run over `Awaited<ReturnType<F>>` INLINE (not via an intermediate `extends RpcFn`-constrained
+alias) — such an alias resolves `ReturnType` against the constraint bound and degrades the
+body to `any`. `Durable` threads the outbox bit through for the durable overloads.
+*/
+type RpcOf<F extends RpcFn, Durable extends boolean = false> = RemoteFunction<
+    RpcArgs<F>,
+    SuccessBody<Awaited<ReturnType<F>>>,
+    InferredErrors<Awaited<ReturnType<F>>>,
+    Durable
+>
 
 /*
 Options every rpc overload accepts: the OpenAPI 200 `outputSchema`, the
@@ -34,14 +88,17 @@ type MutatingRpcOpts = RpcBaseOpts & {
 }
 
 /*
-Shared signature for every rpc helper (GET / POST / …). Four overloads:
+Shared signature for every rpc helper (GET / POST / …). The handler's return
+type is inferred whole (`Awaited<ReturnType<F>>`), then split: `SuccessBody`
+becomes the caller's `Return`, `InferredErrors` becomes the rpc's `Errors`
+(driving `isError`). Typed errors are raised by returning an
+`error.typed(name, status, schema?)` constructor — there is no `errors:` opt.
+Four overloads by argument source:
 
   - `Rpc(fn, { inputSchema, outputSchema?, clients? })` — `Args` infers
     from `InferInput<InputSchema>`, the handler receives
-    `InferOutput<InputSchema>`. Generic order is `<Return, InputSchema>` so
-    users can override `Return` while letting `InputSchema` infer from
-    `opts.inputSchema`. `outputSchema` is an optional Standard Schema for
-    the success body — it feeds the OpenAPI 200 response and the MCP tool
+    `InferOutput<InputSchema>`. `outputSchema` is an optional Standard Schema
+    for the success body — it feeds the OpenAPI 200 response and the MCP tool
     `outputSchema`. JSON Schema is projected from each schema's own
     `toJSONSchema()` (wrap with withJsonSchema if the library lacks one).
     `clients` controls which surfaces (browser / mcp / cli) expose this rpc.
@@ -57,9 +114,13 @@ Shared signature for every rpc helper (GET / POST / …). Four overloads:
     just abandoned.
   - `Rpc(fn, { clients })` — schemaless but with explicit client
     targeting (e.g. server-internal RPC with `clients: { browser: false }`).
-  - `Rpc(fn)` — bare handler. `Args` and `Return` come from the handler
-    type; `Return` is usually inferred via the `TypedResponse<T>` brand on
-    `json`/`error`/`redirect`/`jsonl`/`sse`.
+  - `Rpc(fn)` — bare handler, a single `F extends RpcFn` generic. Everything
+    is read off the handler: `Args` from its parameter (annotate it —
+    `POST((a: { id: string }) => …)` — or leave it nullary for `undefined`),
+    `Return` from the `TypedResponse<T>` brand on
+    `json`/`error`/`redirect`/`jsonl`/`sse`, `Errors` from any
+    `error.typed(...)` branches. You never pass `<Args, Return>` generics; a
+    stray one is a loud constraint error, not a silent `unknown` body.
 */
 type RpcHelperOf<Opts> = {
     /*
@@ -72,47 +133,76 @@ type RpcHelperOf<Opts> = {
     jsonSchemaForSchema) — so only inputSchema feeds MCP/CLI/OpenAPI.
     */
     <
-        Return = unknown,
+        R extends Response,
         InputSchema extends StandardSchemaV1 = StandardSchemaV1,
         FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
-        Errors extends ErrorSpec = Record<string, never>,
     >(
-        fn: RemoteHandler<
-            StandardSchemaV1.InferOutput<InputSchema> & StandardSchemaV1.InferOutput<FilesSchema>,
-            Return,
-            Errors
-        >,
+        fn: (
+            args: StandardSchemaV1.InferOutput<InputSchema> &
+                StandardSchemaV1.InferOutput<FilesSchema>,
+        ) => R | Promise<R>,
         opts: Opts & {
             inputSchema: InputSchema
             filesSchema: FilesSchema
-            errors?: Errors
         },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, Return, Errors>
-    <
-        Return = unknown,
-        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
-        Errors extends ErrorSpec = Record<string, never>,
-    >(
-        fn: RemoteHandler<StandardSchemaV1.InferOutput<InputSchema>, Return, Errors>,
-        opts: Opts & { inputSchema: InputSchema; errors?: Errors },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, Return, Errors>
-    <Args = undefined, Return = unknown, Errors extends ErrorSpec = Record<never, never>>(
-        fn: RemoteHandler<Args, Return, Errors>,
-        opts: Opts & { errors?: Errors },
-    ): RemoteFunction<Args, Return, Errors>
-    <Args = undefined, Return = unknown>(
-        fn: RemoteHandler<Args, Return>,
-    ): RemoteFunction<Args, Return>
+    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
+    <R extends Response, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
+        fn: (args: StandardSchemaV1.InferOutput<InputSchema>) => R | Promise<R>,
+        opts: Opts & { inputSchema: InputSchema },
+    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
+    <F extends RpcFn>(fn: F, opts: Opts): RpcOf<F>
+    <F extends RpcFn>(fn: F): RpcOf<F>
 }
 
 /* The read helpers (GET/HEAD): no `outbox` — a read has nothing to durably deliver. */
 export type RpcHelper = RpcHelperOf<RpcBaseOpts>
 
+/*
+Durable-call overloads: an `outbox: true` opt returns a RemoteFunction whose `Durable` bit
+is set, so `rpc.outbox` is the queue face rather than optionally-undefined. Mirrors the
+opts-bearing base overloads (multipart-upload, schema'd, schemaless); the bare `Rpc(fn)`
+form has no opts to carry `outbox`, so it stays non-durable. Intersected AHEAD of the base
+set in MutatingRpcHelper so an `outbox: true` literal resolves here first.
+*/
+type DurableMutatingRpcHelper = {
+    <
+        R extends Response,
+        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
+        FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
+    >(
+        fn: (
+            args: StandardSchemaV1.InferOutput<InputSchema> &
+                StandardSchemaV1.InferOutput<FilesSchema>,
+        ) => R | Promise<R>,
+        opts: MutatingRpcOpts & {
+            inputSchema: InputSchema
+            filesSchema: FilesSchema
+            outbox: true
+        },
+    ): RemoteFunction<
+        StandardSchemaV1.InferInput<InputSchema>,
+        SuccessBody<R>,
+        InferredErrors<R>,
+        true
+    >
+    <R extends Response, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
+        fn: (args: StandardSchemaV1.InferOutput<InputSchema>) => R | Promise<R>,
+        opts: MutatingRpcOpts & { inputSchema: InputSchema; outbox: true },
+    ): RemoteFunction<
+        StandardSchemaV1.InferInput<InputSchema>,
+        SuccessBody<R>,
+        InferredErrors<R>,
+        true
+    >
+    <F extends RpcFn>(fn: F, opts: MutatingRpcOpts & { outbox: true }): RpcOf<F, true>
+}
+
 /*
 The mutating helpers (POST/PUT/PATCH/DELETE). A durable (`outbox`) call is a normal
 RemoteFunction — it throws exactly like a non-durable one and only parks the request as a
 side-effect on an unreachable server — so there is no separate return shape; `outbox` rides
 MutatingRpcOpts and `rpc.outbox` exposes the queue. The distinct opts base is what makes
-`outbox` legal here and a compile error on the read helpers.
+`outbox` legal here and a compile error on the read helpers; the durable overloads then set
+the return type's `Durable` bit so `rpc.outbox` is present without an optional chain.
 */
-export type MutatingRpcHelper = RpcHelperOf<MutatingRpcOpts>
+export type MutatingRpcHelper = DurableMutatingRpcHelper & RpcHelperOf<MutatingRpcOpts>

package/src/lib/server/rpc/types/TypedError.ts

@@ -0,0 +1,18 @@
+import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
+
+/*
+A `Response` branded with the typed error a handler RETURNED — the name it
+travels as (`$abideError`) plus its spec entry (`{ status, data? }`). The rpc
+helper reads this brand off the handler's inferred return union to build the
+function's `Errors` surface, so `rpc.isError(e, 'name')` narrows `.kind` / `.data`
+with no `errors:` option to declare.
+
+Unlike `TypedResponse`'s `__body?` (optional, so a bare `new Response()` stays
+assignable), the brand here is REQUIRED: it's the discriminant that tells the
+helper an error branch from a success branch (the success body is extracted from
+the non-error members, the error spec from these). The runtime value is a plain
+serialized Response cast to this type — the brand is phantom, never assigned.
+*/
+export type TypedError<Name extends string, Entry extends ErrorSpec[string]> = Response & {
+    readonly __abideError: { name: Name; entry: Entry }
+}

package/src/lib/server/rpc/validationError.ts

@@ -1,17 +1,17 @@
 import type { StandardSchemaV1 } from '../../shared/types/StandardSchemaV1.ts'
 import type { ValidationErrorData } from '../../shared/types/ValidationErrorData.ts'
-import { error } from '../error.ts'
+import { typedErrorResponse } from '../runtime/typedErrorResponse.ts'
 import { fieldErrorsFromIssues } from './fieldErrorsFromIssues.ts'
 
 /*
 The framework-reserved `validation` typed error a 422 carries: the raw Standard
 Schema `issues` plus the form-friendly field → first-message map. Routed through
-the single `error()` funnel (descriptor form) so it serializes as the same
+the shared `typedErrorResponse` serializer so it emits the same
 `{ $abideError, data }` body every typed error uses, and so the 422's reason
 phrase reaches `HttpError.statusText`. The client parses it back onto
 `HttpError.kind = 'validation'` / `.data: ValidationErrorData`.
 */
 export function validationError(issues: readonly StandardSchemaV1.Issue[]): Response {
     const data: ValidationErrorData = { issues, fields: fieldErrorsFromIssues(issues) }
-    return error({ $abideError: 'validation', status: 422, data })
+    return typedErrorResponse('validation', 422, data)
 }

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

@@ -0,0 +1,22 @@
+/*
+Standard reason phrases for the statuses abide sets explicitly. Bun's `Response`
+does not populate `statusText` from the status code, so there's no platform table
+to read. Unlisted codes fall back to `HTTP <status>` at the call site.
+*/
+export const STATUS_TEXT: Record<number, string> = {
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    409: 'Conflict',
+    410: 'Gone',
+    413: 'Content Too Large',
+    422: 'Unprocessable Content',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+}

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

@@ -17,6 +17,7 @@ import { isDebugNegated } from '../../shared/isDebugNegated.ts'
 import { logClosingRecord } from '../../shared/logClosingRecord.ts'
 import { OFFLINE_HEADER } from '../../shared/OFFLINE_HEADER.ts'
 import { parseBoundedEnvInt } from '../../shared/parseBoundedEnvInt.ts'
+import { responseBodyKind } from '../../shared/responseBodyKind.ts'
 import { SOCKETS_PATH } from '../../shared/SOCKETS_PATH.ts'
 import { setAppName } from '../../shared/setAppName.ts'
 import { setBaseResolver } from '../../shared/setBaseResolver.ts'
@@ -49,6 +50,7 @@ import { devHotModuleResponse } from './devHotModuleResponse.ts'
 import { devReloadResponse } from './devReloadResponse.ts'
 import { disableIdleTimeoutForStream } from './disableIdleTimeoutForStream.ts'
 import { gzipResponse } from './gzipResponse.ts'
+import { installAmbientScopeStore } from './installAmbientScopeStore.ts'
 import { internalErrorResponse } from './internalErrorResponse.ts'
 import { listenOnOpenPort } from './listenOnOpenPort.ts'
 import { logExposedSurfaces } from './logExposedSurfaces.ts'
@@ -158,6 +160,12 @@ export async function createServer({
     HTTP test harness gets the same behaviour as a real boot. elapsedMs is
     computed at read time so every log line carries a current value.
     */
+    /*
+    Key the ambient lexical scope off the per-request ALS store, so concurrent
+    async SSR renders don't clobber one shared module global across the inline
+    `await`s they suspend on (see installAmbientScopeStore / CURRENT_SCOPE).
+    */
+    installAmbientScopeStore()
     setRequestScopeResolver(() => {
         const store = requestContext.getStore()
         if (!store) {
@@ -242,8 +250,11 @@ export async function createServer({
     isn't installed. Resolved at boot so the fetch route below can branch on it.
     */
     const inspectorHandler = await maybeMountInspector({ name: appName, version: appVersion })
-    /* Built on first request, then reused — the rpc registry is frozen after load. */
-    let openApiSpec: ReturnType<typeof buildOpenApiSpec> | undefined
+    /* Built on first request, then reused — the rpc registry is frozen after load.
+       Memoised as a promise so two concurrent cold requests share one build instead
+       of both building (the second otherwise clobbering the first). A rejected build
+       clears the memo so the next request retries rather than caching the failure. */
+    let openApiSpec: Promise<ReturnType<typeof buildOpenApiSpec>> | undefined
     const cliCwd = process.cwd()
 
     /* Request closing records are on by default — DEBUG=-abide is the off switch (negation, like the abide channel itself). */
@@ -362,12 +373,19 @@ export async function createServer({
             const response = app?.handle
                 ? await app.handle(req, (next) => handler(next, pathParams, store))
                 : await handler(req, pathParams, store)
+            /* Classify the body once (S2) and thread it into both downstream
+               steps — gzip + the closing-record stream monitor — instead of
+               each re-deriving from the Content-Type. */
+            const kind = responseBodyKind(response)
+            store.responseStreaming = kind === 'streaming'
+            // Streaming bodies (sse/jsonl, socket tail) opt out of the idle timeout.
+            if (kind === 'streaming') {
+                server.timeout(req, 0)
+            }
             /* Gzip compressible dynamic bodies (SSR HTML, rpc/json, 404) when the
                client accepts it; streaming frame protocols and static assets are
                passed through untouched (see gzipResponse). */
-            const encoded = gzipResponse(req, response)
-            // Streaming bodies (sse/jsonl, socket tail) opt out of the idle timeout.
-            return disableIdleTimeoutForStream(server, req, encoded)
+            return gzipResponse(req, response, kind)
         })
     }
 
@@ -583,14 +601,20 @@ export async function createServer({
                         req,
                         {},
                         async () => {
-                            if (!openApiSpec) {
-                                await ensureRegistriesLoaded()
-                                openApiSpec = buildOpenApiSpec({
-                                    title: appName,
-                                    version: appVersion,
+                            openApiSpec ??= ensureRegistriesLoaded()
+                                .then(() =>
+                                    buildOpenApiSpec({
+                                        title: appName,
+                                        version: appVersion,
+                                    }),
+                                )
+                                .catch((error) => {
+                                    // Don't cache a failed build — clear the memo so a
+                                    // later request retries instead of 500-ing forever.
+                                    openApiSpec = undefined
+                                    throw error
                                 })
-                            }
-                            return Response.json(openApiSpec, {
+                            return Response.json(await openApiSpec, {
                                 headers: { 'Cache-Control': NO_STORE },
                             })
                         },

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

@@ -26,7 +26,7 @@ export async function devHotModuleResponse(moduleId: string): Promise<Response>
     if (source === undefined) {
         return new Response('not found', { status: 404 })
     }
-    const code = compileModule(source, {
+    const { code } = compileModule(source, {
         isLayout: moduleId.endsWith('layout.abide'),
         moduleId,
         hot: true,

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

@@ -1,17 +1,9 @@
-import { contentTypeOf } from '../../shared/contentTypeOf.ts'
-import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
+import type { ResponseBodyKind } from '../../shared/responseBodyKind.ts'
+import { responseBodyKind } from '../../shared/responseBodyKind.ts'
 import { acceptsGzip } from './acceptsGzip.ts'
 import { flushingGzipStream } from './flushingGzipStream.ts'
 import { STREAMED_HTML_HEADER } from './STREAMED_HTML_HEADER.ts'
 
-/*
-Compressible Content-Types — text and structured-text payloads. Binary or
-already-compressed bodies (images, fonts, archives, zstd/gzip blobs) gain
-nothing from a second pass and only burn CPU.
-*/
-const COMPRESSIBLE_TYPE =
-    /^(?:text\/|application\/(?:json|javascript|xml|[\w.-]+\+(?:json|xml))|image\/svg)/
-
 /*
 Gzips a dynamic response (SSR HTML, rpc/json replies, the plain 404) when the
 client accepts it. Static assets never reach here — they already carry a
@@ -23,6 +15,12 @@ expose a string body's length before send, and measuring would mean buffering th
 body — the framing overhead on the rare tiny body is negligible against
 compressing every page and rpc payload.
 
+`kind` is the body class the dispatch pipeline already computed (S2: classify
+once, thread it in) — only `compressible` bodies gzip; `streaming` and `opaque`
+pass through. Standalone callers (the health probe) omit it and it's derived
+here. The streamed-HTML marker is handled independent of `kind` since it's
+stripped even on a skip path.
+
 Buffered bodies take the web CompressionStream (best ratio, one flush at close).
 The streamed SSR document self-marks (STREAMED_HTML_HEADER) and takes a
 per-chunk-flushing gzip instead: the plain CompressionStream buffers the head
@@ -30,7 +28,7 @@ until its deflate window fills, which defeats streaming (the browser can't
 preload-scan the head or paint the pending shell until the stream nearly closes).
 The marker is stripped so it never reaches the client.
 */
-export function gzipResponse(req: Request, response: Response): Response {
+export function gzipResponse(req: Request, response: Response, kind?: ResponseBodyKind): Response {
     const streamedHtml = response.headers.has(STREAMED_HTML_HEADER)
     if (streamedHtml) {
         response.headers.delete(STREAMED_HTML_HEADER)
@@ -38,11 +36,11 @@ export function gzipResponse(req: Request, response: Response): Response {
     if (!response.body || response.headers.has('Content-Encoding')) {
         return response
     }
-    if (!acceptsGzip(req) || isStreamingResponse(response)) {
-        return response
-    }
-    const contentType = contentTypeOf(response.headers)
-    if (!COMPRESSIBLE_TYPE.test(contentType)) {
+    /* A streamed-HTML document classifies as `compressible` (text/html) but the
+       marker was already stripped above, so re-derive after the strip when the
+       pipeline didn't hand a kind in. */
+    const bodyKind = kind ?? responseBodyKind(response)
+    if (!acceptsGzip(req) || bodyKind !== 'compressible') {
         return response
     }
     const headers = new Headers(response.headers)

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

@@ -0,0 +1,33 @@
+import { ambientScopeBacking } from '../../ui/runtime/ambientScopeBacking.ts'
+import type { Scope } from '../../ui/types/Scope.ts'
+import { requestContext } from './requestContext.ts'
+
+/* Ambient scope when no request is in flight (server boot, a standalone render). */
+let outsideRequest: Scope | undefined
+
+/*
+Swaps the ambient-scope backing to one keyed off the per-request AsyncLocalStorage
+store, so `CURRENT_SCOPE.current` isolates per request instead of living in one
+module global (see CURRENT_SCOPE). SSR is partly async — a render `await`s inline
+between its `enterScope`/`exitScope` bracket — and the async context propagates the
+right store across those awaits, so a resumed render reads ITS OWN scope even while
+another request renders concurrently. Called once at server boot (createServer),
+alongside the request-scope resolver install. Reads/writes outside any request fall
+back to a module variable (unchanged behaviour for standalone renders).
+*/
+export function installAmbientScopeStore(): void {
+    ambientScopeBacking.active = {
+        get: () => {
+            const store = requestContext.getStore()
+            return store ? store.currentScope : outsideRequest
+        },
+        set: (value) => {
+            const store = requestContext.getStore()
+            if (store) {
+                store.currentScope = value
+            } else {
+                outsideRequest = value
+            }
+        },
+    }
+}

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

@@ -120,7 +120,10 @@ export function runWithRequestScope(
                 })
             })
         }
-        if (response.body && isStreamingResponse(response)) {
+        /* Reuse the dispatch pipeline's single S2 classification when it stashed
+           one; callers that don't (mcp, the fetch fallback, tests) classify here. */
+        const streaming = store.responseStreaming ?? isStreamingResponse(response)
+        if (response.body && streaming) {
             /*
             A hand-pumped wrap rather than a TransformStream: streams typically
             end by client disconnect (an SSE tab closing), which cancels the

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

@@ -74,6 +74,8 @@ export async function snapshotEntryFromCache(
         statusText: response.statusText,
         headers: Array.from(response.headers.entries()),
         body,
+        /* Deferred by the SSR resume path → seed the shipped body lazily (no hydration decode). */
+        lazy: entry.deferred === true ? true : undefined,
     }
 }
 

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

@@ -0,0 +1,26 @@
+import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
+import type { TypedResponse } from '../rpc/types/TypedResponse.ts'
+import { STATUS_TEXT } from './STATUS_TEXT.ts'
+import { withResponseDefaults } from './withResponseDefaults.ts'
+
+/*
+Serializes a typed error as a `{ $abideError, data }` JSON body at `status`, with
+the status reason phrase as statusText so it reaches `HttpError.statusText` on the
+client (which parses the body back onto `HttpError.kind` / `.data`). `data` of
+`undefined` drops the key (nullary errors). The single serializer shared by the
+`error.typed(...)` constructors and the framework-reserved `validation` error.
+*/
+export function typedErrorResponse(
+    name: string,
+    status: number,
+    data: unknown,
+): TypedResponse<never> {
+    return new Response(
+        JSON.stringify({ $abideError: name, data }),
+        withResponseDefaults(
+            { statusText: STATUS_TEXT[status] ?? `HTTP ${status}` },
+            { 'Content-Type': 'application/json', 'Cache-Control': NO_STORE },
+            status,
+        ),
+    ) as TypedResponse<never>
+}

package/src/lib/server/runtime/types/RequestStore.ts

@@ -1,5 +1,6 @@
 import type { CacheStore } from '../../../shared/types/CacheStore.ts'
 import type { TraceContext } from '../../../shared/types/TraceContext.ts'
+import type { Scope } from '../../../ui/types/Scope.ts'
 
 /*
 Per-request state propagated through AsyncLocalStorage. Every field is
@@ -52,4 +53,28 @@ export type RequestStore = {
     carried no file parts.
     */
     files?: Record<string, File[]>
+    /*
+    The allowlisted headers forwarded onto in-process rpc Requests during this
+    request's SSR pass — derived once from the inbound headers (which don't change
+    within the scope) and reused by every defineRpc call. Each call clones it,
+    since buildRpcRequest mutates the Headers (content-type/ref-json) before
+    constructing the Request. Undefined until the first in-process rpc.
+    */
+    forwardedHeaders?: Headers
+    /*
+    The body class of the response the dispatch pipeline produced, stashed so
+    runWithRequestScope's closing-record stream monitor reuses the single S2
+    classification instead of re-deriving from the Content-Type. Undefined for
+    callers that don't classify (mcp, the fetch fallback, tests) — those fall
+    back to classifying the response themselves.
+    */
+    responseStreaming?: boolean
+    /*
+    The request's ambient lexical scope during its SSR pass — the backing for
+    `CURRENT_SCOPE.current` under the server's ALS-backed holder
+    (installAmbientScopeStore). Keeping it per-request isolates the ambient across
+    the inline `await`s a render suspends on, so concurrent renders don't clobber
+    one shared module global. Undefined until the render enters its first scope.
+    */
+    currentScope?: Scope
 }

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

@@ -17,8 +17,13 @@ export function withResponseDefaults(
     status?: number,
 ): ResponseInit {
     const headers = new Headers(defaultHeaders)
-    new Headers(init?.headers).forEach((value, key) => {
-        headers.set(key, value)
-    })
+    /* The dominant case carries no overrides — skip the second Headers
+       allocation + per-key copy and ship the defaults alone. Only merge when
+       the caller actually supplied headers. */
+    if (init?.headers !== undefined) {
+        new Headers(init.headers).forEach((value, key) => {
+            headers.set(key, value)
+        })
+    }
     return { ...init, headers, ...(status !== undefined && { status }) }
 }

package/src/lib/server/sockets/defineSocket.ts

@@ -119,7 +119,11 @@ export function defineSocket<T>(name: string, opts: SocketOptions = {}): Socket<
             cachedServer = getActiveServer()
         }
         const server = cachedServer
-        if (server) {
+        /* Remote fan-out is the only consumer of the encoded frame: in-process iterators
+           already received the live object via notify() above. Skip the full message-graph
+           walk (encodeRefJson) + native publish when zero ws clients are subscribed to the
+           topic — subscriberCount is a cheap C-side check, encodeRefJson is not. */
+        if (server && server.subscriberCount(topic) > 0) {
             /* Typed against the shared wire contract so a `SocketServerFrame` change can't
                silently drift from this construction site (the dispatcher's `send` is already
                typed; this was the last `msg` frame built through an unchecked JSON.stringify). */

package/src/lib/server/sse.ts

@@ -5,7 +5,7 @@ Server-Sent Events (text/event-stream) — each frame becomes one
 generator over plain HTTP so EventSource (or `tail(fn.stream(args))`
 on the client) can consume it frame-by-frame.
 
-  export const orderFeed = GET<Args>((args) =>
+  export const orderFeed = GET((args: Args) =>
       sse(async function* () {
           for await (const order of db.watchOrders(args)) yield order
       }())

package/src/lib/shared/HttpError.ts

@@ -9,7 +9,7 @@ export class HttpError extends Error {
     readonly status: number
     readonly statusText: string
     readonly response: Response
-    /* Set when the handler returned a typed error (`error(errors.x(...))`) or a
+    /* Set when the handler returned a typed error (`error.typed(...)` constructor) or a
        validation 422: `kind` is the declared error name (or 'validation'), `data` the
        payload it carried — parsed off the `{ $abideError, data }` body by decodeResponse.
        `data` is typed `unknown` (a throw can't carry the rpc's per-kind type to the

package/src/lib/shared/RPC_ARGS_TYPE.ts

@@ -0,0 +1,7 @@
+/*
+The `RpcArgs<Fn>` type alias both rpc d.ts writers emit verbatim: it lifts the
+args type out of a RemoteFunction, dropping the FormData upload variant so a
+url()/test-client call types against the rpc's plain args.
+*/
+export const RPC_ARGS_TYPE =
+    'type RpcArgs<Fn> = Fn extends (args: infer Args) => unknown ? Exclude<Args, FormData> : never'

package/src/lib/shared/activeCacheStore.ts

@@ -1,20 +1,11 @@
-import { cacheStoreSlot } from './cacheStoreSlot.ts'
-import { createCacheStore } from './createCacheStore.ts'
+import { cacheStoreResolver } from './cacheStoreResolver.ts'
 import type { CacheStore } from './types/CacheStore.ts'
 
 /*
-Resolves the active CacheStore. The runtime is registered via
-`setCacheStoreResolver` from the server entry (request-scoped via ALS)
-or the client entry (module-level singleton). If no resolver is registered,
-a single fallback store is created lazily so isolated tests still work.
+Resolves the active CacheStore: the registered resolver's store, or a single
+lazily-created fallback when none is registered (so isolated tests work). The
+fallback creator guarantees a value, hence the non-null assertion.
 */
 export function activeCacheStore(): CacheStore {
-    const fromResolver = cacheStoreSlot.resolver?.()
-    if (fromResolver) {
-        return fromResolver
-    }
-    if (!cacheStoreSlot.fallback) {
-        cacheStoreSlot.fallback = createCacheStore()
-    }
-    return cacheStoreSlot.fallback
+    return cacheStoreResolver.get()!
 }