@abide/abide 0.44.0 → 0.44.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # abide
 
+## 0.44.1
+
+### Patch Changes
+
+- 767b415: 02-zod-plugin-memo ([`0e00b21`](https://github.com/briancray/abide/commit/0e00b217f99352a7d3def4841172c5bff287bc5c))
+- 767b415: 06-wakeSubtree-prefix-index ([`23ab920`](https://github.com/briancray/abide/commit/23ab9202fd0cb41e01811e78b76eac2843c9cf8f))
+- 767b415: 09-when-via-switch ([`48f8d50`](https://github.com/briancray/abide/commit/48f8d5063cf74060004ad38691f584abcff0cab2))
+- 767b415: 08-dts-codegen ([`5170542`](https://github.com/briancray/abide/commit/51705426e55a700140cc7bc38f7e21f30759fce3))
+- 767b415: 03-socket-publish-gate ([`56fae49`](https://github.com/briancray/abide/commit/56fae49bf393fdfb3aa35cecc618a39443354ce4))
+- 767b415: 10-cli-tokenizer ([`5e305c1`](https://github.com/briancray/abide/commit/5e305c154efd5f77d0a57e78831b72a30b4d9155))
+- 767b415: 14-resolver-slot-factory-JUDGMENT ([`6e00809`](https://github.com/briancray/abide/commit/6e00809c343e24599d54b2304a50a9cecd90619f))
+- 767b415: catch top-level await in a .abide <script> during abide check ([`76ff64e`](https://github.com/briancray/abide/commit/76ff64e9fb9ffed108ae2fde53f2ded2bf3a0abe))
+- 767b415: 12-warm-clone-PARTIAL ([`8e58e0b`](https://github.com/briancray/abide/commit/8e58e0b2c1891174cc809797f949f01619529b89))
+- 767b415: 05-compiler-double-pass ([`9216dae`](https://github.com/briancray/abide/commit/9216dae4c26e27fce49f39b116bd8b1dcf1dd226))
+- 767b415: 04-lsp-shadow-cache ([`9f9f5fc`](https://github.com/briancray/abide/commit/9f9f5fc84792204259d591fa4aff261b2a19c46d))
+- 767b415: 13-dev-rebuild-scoping-JUDGMENT ([`b5a1d49`](https://github.com/briancray/abide/commit/b5a1d49e6607a8fcf37efe03e9fe6f6b2c31ea45))
+- 767b415: gate skeleton fragment-staging on a connected parent ([`c9380ee`](https://github.com/briancray/abide/commit/c9380eebdd9f6773ccffd446665b1acbc78b1123))
+- 767b415: 07-debug-gate ([`c96466e`](https://github.com/briancray/abide/commit/c96466e73ea1f521d728b11aac44262530c3b09c))
+- 767b415: rename paint's escape var to avoid shadowing the global ([`caf1322`](https://github.com/briancray/abide/commit/caf1322adc6598bc6ea32e0ba9047ba768b6f5e1))
+- 767b415: reflow generateBuild attr-kind union to biome's multiline form ([`f9b3669`](https://github.com/briancray/abide/commit/f9b36690e4add2c955abb8f0127a9af9d513be53))
+- 767b415: 01-bugs-B1-B2 ([`fa8659d`](https://github.com/briancray/abide/commit/fa8659d276265c0fbb4f7ca0740fc74702f00168))
+- 767b415: address code-review findings ([`fb02df5`](https://github.com/briancray/abide/commit/fb02df58c924d7206fce35874cc80309949c9e59))
+- 767b415: 11-server-log-micro ([`fb689bc`](https://github.com/briancray/abide/commit/fb689bc05bee9ba127ddf206e925e3a9e04841fd))
+
 ## 0.44.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.44.0",
+    "version": "0.44.1",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",

package/src/abideResolverPlugin.ts

@@ -257,10 +257,15 @@ export function abideResolverPlugin({
     return {
         name: 'abide-resolver',
         setup(build) {
-            /* Fresh edge graph each build (dev watch reuses the plugin instance).
+            /* Fresh edge graph + resolution cache each build (dev watch reuses the
+               plugin instance). The resolution cache memoises (path → resolved file)
+               within a build; clearing it per build keeps the memo but stops a stale
+               miss — a path resolved before its file existed — surviving into the next
+               build, so a freshly-created file resolves instead of staying "not found".
                onStart is build-time only — absent in the runtime/preload plugin context. */
             build.onStart?.(() => {
                 importerOf.clear()
+                resolveExtensionCache.clear()
             })
 
             /*

package/src/devEntry.ts

@@ -6,6 +6,7 @@ import { DEV_READY_MESSAGE } from './lib/server/runtime/DEV_READY_MESSAGE.ts'
 import { DEV_REBUILD_MESSAGE } from './lib/server/runtime/DEV_REBUILD_MESSAGE.ts'
 import { findOpenPort } from './lib/server/runtime/findOpenPort.ts'
 import { abideLog } from './lib/shared/abideLog.ts'
+import { changeAffectsClient } from './lib/shared/changeAffectsClient.ts'
 
 /*
 Dev orchestrator. Replaces `bun --watch` (which only watches the import graph,
@@ -174,30 +175,51 @@ async function replaceServer(port: number): Promise<void> {
 
 let building = false
 let queued = false
+// True once any change collapsed into the queued run needs the client rebuilt;
+// a client-affecting change can never be downgraded to a server-only restart.
+let queuedNeedsClient = false
 
 /*
-Rebuild the client, then (on success) swap in a fresh server child. Serialized:
-a change arriving mid-build sets `queued` so exactly one more rebuild runs
-after, collapsing any further changes in between. A failed build leaves the
-current child untouched — the error is logged and the last-good server keeps
-serving.
+Apply a change: rebuild the client (unless `skipClientBuild` — a server/MCP-only
+change leaves the client bundle byte-identical), then on success swap in a fresh
+server child. The worker restart always runs: SSR renders through Bun's module
+cache, so a new process is the only reliable way to reflect any source edit,
+client-affecting or not.
+
+Serialized: a change arriving mid-build sets `queued` so exactly one more run
+follows, collapsing further changes in between; `queuedNeedsClient` records
+whether any of them needs the client, so the collapsed run never skips a client
+rebuild a queued change required. A failed build leaves the current child
+untouched — the error is logged and the last-good server keeps serving.
 */
-async function rebuild(port: number): Promise<void> {
+async function rebuild(port: number, skipClientBuild = false): Promise<void> {
     if (building) {
         queued = true
+        queuedNeedsClient ||= !skipClientBuild
         return
     }
     building = true
     try {
-        const succeeded = await build(buildOptions)
+        const succeeded = skipClientBuild ? true : await build(buildOptions)
         if (succeeded) {
             await replaceServer(port)
         }
+        /* A server/MCP-only change reuses the existing client bundle. That's correct for
+           an rpc/socket handler BODY edit, but changing an rpc's method, its export name,
+           or `outbox: true` changes the client proxy stub too — the stale bundle then
+           calls with the old shape (e.g. a 405). Flag the skip so that case isn't silent. */
+        if (skipClientBuild) {
+            abideLog.info(
+                'server-only change — kept the existing client bundle; if you changed an rpc method, export name, or outbox, save a client file (or restart dev) for a full rebuild',
+            )
+        }
     } finally {
         building = false
         if (queued) {
             queued = false
-            void rebuild(port)
+            const needsClient = queuedNeedsClient
+            queuedNeedsClient = false
+            void rebuild(port, !needsClient)
         }
     }
 }
@@ -223,14 +245,26 @@ an agent editing the app's own source — isn't yanked mid-run by a save.
 const manualRebuild = Bun.env.ABIDE_DEV_NO_WATCH === '1'
 
 let debounce: ReturnType<typeof setTimeout> | undefined
+/*
+True only while every change collapsed into the pending debounce is server/MCP-
+only; one client-affecting change in the burst flips it false (latches until the
+debounce fires), so a multi-file save that touches the client never skips the
+client rebuild.
+*/
+let pendingSkipClientBuild = true
 const watcher = manualRebuild
     ? undefined
     : watch(SOURCE_DIR, { recursive: true }, (_event, filename) => {
           if (!filename || isGenerated(filename)) {
               return
           }
+          pendingSkipClientBuild &&= !changeAffectsClient(filename)
           clearTimeout(debounce)
-          debounce = setTimeout(() => void rebuild(port), REBUILD_DEBOUNCE_MS)
+          debounce = setTimeout(() => {
+              const skipClientBuild = pendingSkipClientBuild
+              pendingSkipClientBuild = true
+              void rebuild(port, skipClientBuild)
+          }, REBUILD_DEBOUNCE_MS)
       })
 if (manualRebuild) {
     abideLog.info(

package/src/lib/cli/parseArgvForRpc.ts

@@ -1,3 +1,5 @@
+import { tokenizeArgvFlags } from './tokenizeArgvFlags.ts'
+
 /*
 Parses an argv tail into the JSON args bag for an RPC. The JSON Schema
 on the manifest entry (when present) drives flag typing:
@@ -47,44 +49,39 @@ export async function parseArgvForRpc(
         }
     }
 
-    for (let index = 0; index < argv.length; index++) {
-        const token = argv[index] as string
-        if (token === '--json') {
-            const next = argv[++index]
-            if (!next) {
+    /* The shared tokenizer owns the flag-consumption grammar (boolean / inline /
+       `--json` / `--no-` negation). This loop layers RPC value semantics on each
+       yielded token: JSON-blob merge, Number coercion, array accumulation. */
+    for (const token of tokenizeArgvFlags(argv, jsonSchema)) {
+        if (token.positional !== undefined) {
+            throw new Error(`unexpected positional argument: ${token.positional}`)
+        }
+        if (token.isJson) {
+            if (token.missingValue || token.value === undefined) {
                 throw new Error('--json requires a value')
             }
-            const parsed = JSON.parse(next)
+            const parsed = JSON.parse(token.value)
             if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
                 throw new Error('--json value must be a JSON object')
             }
             Object.assign(args, parsed)
             continue
         }
-        if (!token.startsWith('--')) {
-            throw new Error(`unexpected positional argument: ${token}`)
+        // The tokenizer treats `--help` / `-h` as a help token; in RPC parsing
+        // they are an unrecognised flag, surfaced loudly like any other.
+        if (token.isHelp || token.name === undefined) {
+            throw new Error('unexpected --help flag')
         }
-        const stripped = token.slice('--'.length)
-        const [literalName, eqValue] = stripped.includes('=')
-            ? [stripped.slice(0, stripped.indexOf('=')), stripped.slice(stripped.indexOf('=') + 1)]
-            : [stripped, undefined]
-        /* `--no-x` negates only a known boolean property x; otherwise the literal
-           name wins, so a property legitimately named `no-…` stays reachable. */
-        const negatedName = literalName.startsWith('no-')
-            ? literalName.slice('no-'.length)
-            : undefined
-        const isNegated = negatedName !== undefined && properties[negatedName]?.type === 'boolean'
-        const name = isNegated ? (negatedName as string) : literalName
-        const prop = properties[name]
-        const propType = prop?.type
+        const name = token.name
+        const propType = properties[name]?.type
         if (propType === 'boolean') {
-            args[name] = !isNegated
+            args[name] = !token.negated
             continue
         }
-        const value = eqValue ?? argv[++index]
-        if (value === undefined) {
+        if (token.missingValue || token.value === undefined) {
             throw new Error(`--${name} requires a value`)
         }
+        const value = token.value
         if (propType === 'number' || propType === 'integer') {
             // Reject a blank value explicitly — `Number('')` / `Number('  ')` is 0,
             // not NaN, so the NaN guard alone would silently coerce it to zero.

package/src/lib/cli/runCli.ts

@@ -9,6 +9,7 @@ import { printTrimmed } from './printTrimmed.ts'
 import { resolveCliTarget } from './resolveCliTarget.ts'
 import { runSession } from './runSession.ts'
 import { startLocalInstance } from './startLocalInstance.ts'
+import { tokenizeArgvFlags } from './tokenizeArgvFlags.ts'
 import type { CliManifest } from './types/CliManifest.ts'
 import type { CliTarget } from './types/CliTarget.ts'
 
@@ -16,37 +17,21 @@ const isHelpFlag = (arg: string): boolean => arg === '--help' || arg === '-h'
 
 /*
 Whether a command's argv tail genuinely requests help, i.e. a help flag appears
-at a flag position rather than as the value of a value-expecting flag. Mirrors
-parseArgvForRpc's flag rule: boolean props (and `--name=…`) consume no following
-token, everything else consumes the next token as its value — so `--title --help`
-passes `--help` as the title value, not a help request.
+at a flag position rather than as the value of a value-expecting flag. Shares
+tokenizeArgvFlags' grammar with parseArgvForRpc so the two can't drift: the
+tokenizer applies the flag-consumption rule (boolean / `--name=…` / `--json`
+consume their value), so a `--help` that was a flag's value is already swallowed
+and never surfaces as a help token — `--title --help` passes `--help` as the
+title value, not a help request.
 */
 function commandArgvRequestsHelp(
     argvTail: string[],
     jsonSchema: Record<string, unknown> | undefined,
 ): boolean {
-    const properties =
-        (jsonSchema?.properties as Record<string, { type?: string }> | undefined) ?? {}
-    for (let index = 0; index < argvTail.length; index += 1) {
-        const token = argvTail[index] as string
-        if (isHelpFlag(token)) {
+    for (const token of tokenizeArgvFlags(argvTail, jsonSchema)) {
+        if (token.isHelp) {
             return true
         }
-        if (!token.startsWith('--')) {
-            continue
-        }
-        if (token === '--json') {
-            index += 1 // consumes its value
-            continue
-        }
-        const rawName = token.slice('--'.length)
-        if (rawName.includes('=')) {
-            continue // inline value, consumes no following token
-        }
-        const name = rawName.startsWith('no-') ? rawName.slice('no-'.length) : rawName
-        if (properties[name]?.type !== 'boolean') {
-            index += 1 // a value-expecting flag consumes the next token
-        }
     }
     return false
 }

package/src/lib/cli/tokenizeArgvFlags.ts

@@ -0,0 +1,84 @@
+/*
+The single argv-tail flag grammar shared by help-detection (runCli) and RPC arg
+parsing (parseArgvForRpc) so the two can never drift. Walks the tail and yields
+one token per flag occurrence, honouring the schema-driven consumption rule:
+
+  - `--help` / `-h`               → { isHelp: true }, consumes no following token
+  - `--json <blob>`               → { isJson: true, value }, consumes the next token
+                                     (the value is the verbatim JSON args bag)
+  - boolean props (and `--no-x`)  → { name, value: undefined }, consumes no token
+  - `--name=value`                → { name, value }, inline, consumes no token
+  - everything else               → { name, value }, consumes the next token
+
+`--no-x` negates only a known boolean property x; otherwise the literal `no-…`
+name is kept so a property legitimately named `no-…` stays reachable. Reports
+`negated` and `missingValue` so the parser can apply boolean/coercion semantics
+and throw precise errors. A bare positional (no leading `--`) yields
+{ positional: token } so each consumer rejects or ignores it as it sees fit.
+
+Pure; reads the schema's `properties` only to classify boolean props.
+*/
+export function* tokenizeArgvFlags(
+    argvTail: string[],
+    jsonSchema: Record<string, unknown> | undefined,
+): Generator<{
+    isHelp?: boolean
+    isJson?: boolean
+    positional?: string
+    name?: string
+    value?: string
+    negated?: boolean
+    missingValue?: boolean
+}> {
+    const properties =
+        (jsonSchema?.properties as Record<string, { type?: string }> | undefined) ?? {}
+    for (let index = 0; index < argvTail.length; index += 1) {
+        const token = argvTail[index] as string
+        if (token === '--help' || token === '-h') {
+            yield { isHelp: true }
+            continue
+        }
+        if (!token.startsWith('--')) {
+            yield { positional: token }
+            continue
+        }
+        // `--json <blob>`: the next token is the verbatim JSON args bag.
+        if (token === '--json') {
+            const value = argvTail[index + 1]
+            if (value === undefined) {
+                yield { isJson: true, missingValue: true }
+            } else {
+                index += 1
+                yield { isJson: true, value }
+            }
+            continue
+        }
+        const stripped = token.slice('--'.length)
+        const [literalName, inlineValue] = stripped.includes('=')
+            ? [stripped.slice(0, stripped.indexOf('=')), stripped.slice(stripped.indexOf('=') + 1)]
+            : [stripped, undefined]
+        /* `--no-x` negates only a known boolean property x; otherwise the literal
+           name wins, so a property legitimately named `no-…` stays reachable. */
+        const negatedName = literalName.startsWith('no-')
+            ? literalName.slice('no-'.length)
+            : undefined
+        const negated = negatedName !== undefined && properties[negatedName]?.type === 'boolean'
+        const name = negated ? (negatedName as string) : literalName
+        // Boolean props and inline `--name=value` consume no following token.
+        if (properties[name]?.type === 'boolean') {
+            yield { name, negated }
+            continue
+        }
+        if (inlineValue !== undefined) {
+            yield { name, value: inlineValue }
+            continue
+        }
+        const value = argvTail[index + 1]
+        if (value === undefined) {
+            yield { name, missingValue: true }
+        } else {
+            index += 1
+            yield { name, value }
+        }
+    }
+}

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

@@ -100,7 +100,15 @@ export function defineRpc<Args, Return>(
     function buildRequest(args: Args | undefined): Request {
         const store = requestContext.getStore()
         const baseUrl = store ? store.url.href : 'http://localhost/'
-        const headers = store ? forwardHeaders(store.req.headers) : new Headers()
+        /* The forwarded allowlist is request-invariant — derive it once per scope
+           and clone per call (buildRpcRequest mutates the Headers). */
+        let headers: Headers
+        if (store) {
+            store.forwardedHeaders ??= forwardHeaders(store.req.headers)
+            headers = new Headers(store.forwardedHeaders)
+        } else {
+            headers = new Headers()
+        }
         return buildRpcRequest({ method, url, args, baseUrl, headers })
     }
 

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'
@@ -242,8 +243,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 +366,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 +594,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/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/types/RequestStore.ts

@@ -52,4 +52,20 @@ 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
 }

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/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()!
 }