@abide/abide 0.44.0 → 0.44.1

package/src/lib/shared/activePage.ts

@@ -1,25 +1,11 @@
-import { pageSlot } from './pageSlot.ts'
+import { pageResolver } from './pageResolver.ts'
 import type { PageSnapshot } from './types/PageSnapshot.ts'
 
 /*
-Resolves the active page snapshot. The runtime is registered via
-`setPageResolver` from the server entry (request-scoped via ALS) or the
-client entry (module-level singleton). If no resolver is registered, a single
-fallback snapshot is created lazily so isolated tests still work. Mirrors
-activeCacheStore.
+Resolves the active page snapshot: the registered resolver's snapshot, or a
+single lazily-created empty snapshot when none is registered (so isolated tests
+work). The fallback creator guarantees a value, hence the non-null assertion.
 */
 export function activePage(): PageSnapshot {
-    const fromResolver = pageSlot.resolver?.()
-    if (fromResolver) {
-        return fromResolver
-    }
-    if (!pageSlot.fallback) {
-        pageSlot.fallback = {
-            route: '',
-            params: {},
-            url: new URL('http://localhost/'),
-            navigating: false,
-        }
-    }
-    return pageSlot.fallback
+    return pageResolver.get()!
 }

package/src/lib/shared/augmentModule.ts

@@ -0,0 +1,18 @@
+/*
+Emits one `declare module '<module>' { interface <iface> { … } }` block, the
+module-augmentation shape every codegen writer (routes, rpc, publicAssets,
+testRpc, testSockets) shares. `entries` is `[key, type]` pairs already in final
+order; each becomes an 8-space-indented `"key": type` member, the indentation
+the consumer src tsconfig include expects. Returns the block body only — the
+writeDts envelope adds banner + footer.
+*/
+export function augmentModule(module: string, iface: string, entries: [string, string][]): string {
+    const members = entries
+        .map(([key, type]) => `        ${JSON.stringify(key)}: ${type}`)
+        .join('\n')
+    return `declare module '${module}' {
+    interface ${iface} {
+${members}
+    }
+}`
+}

package/src/lib/shared/basePath.ts

@@ -1,10 +1,11 @@
-import { baseSlot } from './baseSlot.ts'
+import { baseResolver } from './baseResolver.ts'
 
 /*
-The current mount base path ('' at root). Resolved per side: the server
-installs an APP_URL-derived resolver at boot, the client one reading
-window.__SSR__.base. url() reads this to prefix rooted internal paths.
+The current mount base path ('' at root). Resolved per side: the server installs
+an APP_URL-derived resolver at boot, the client one reading window.__SSR__.base.
+url() reads this to prefix rooted internal paths. Defaults to '' when no resolver
+or fallback is set.
 */
 export function basePath(): string {
-    return baseSlot.resolver?.() ?? baseSlot.fallback ?? ''
+    return baseResolver.get() ?? ''
 }

package/src/lib/shared/baseResolver.ts

@@ -0,0 +1,10 @@
+import { createResolverSlot } from './createResolverSlot.ts'
+
+/*
+The mount-base slot/resolver/reader bundle. The server entry installs an
+APP_URL-derived resolver at boot; the client entry one reading
+window.__SSR__.base. No lazy fallback creator — `fallback` is a plain string set
+directly by isolated tests, and basePath() supplies the '' default. baseSlot /
+basePath re-export the slot and reader; setBaseResolver the setter.
+*/
+export const baseResolver = createResolverSlot<string>()

package/src/lib/shared/baseSlot.ts

@@ -1,14 +1,8 @@
+import { baseResolver } from './baseResolver.ts'
+
 /*
-Internal slot the runtime entries register their mount-base resolver into.
-The server entry installs an APP_URL-derived resolver at boot; the client
-entry installs one reading window.__SSR__.base. `fallback` is a single value
-used only when no resolver is registered — lets isolated tests set a base
-without spinning up the runtime. Mirrors pageSlot / cacheStoreSlot.
+Internal slot the runtime entries register their mount-base resolver into (see
+baseResolver). Exposed so test helpers snapshot/poke `.resolver` and `.fallback`
+directly.
 */
-export const baseSlot: {
-    resolver: (() => string) | undefined
-    fallback: string | undefined
-} = {
-    resolver: undefined,
-    fallback: undefined,
-}
+export const baseSlot = baseResolver.slot

package/src/lib/shared/cache.ts

@@ -199,7 +199,7 @@ export function cache<Args, Return>(
         fetch hands each reader a fresh object; cloning keeps warm reads the same.
         */
         if (!isRaw && existing?.value !== undefined) {
-            return Promise.resolve(structuredClone(existing.value)) as Promise<Return>
+            return Promise.resolve(cloneWarmValue(existing.value)) as Promise<Return>
         }
         const responsePromise = invokeRemote(
             store,
@@ -216,6 +216,26 @@ export function cache<Args, Return>(
     return read
 }
 
+/*
+Deep-copies a warm value so each reader gets its own mutable object — the
+no-shared-mutation invariant the warm path turns on (a live fetch hands every
+reader a fresh object; a warm read must match). A warm value only ever comes
+from the json or text body kinds (bodyValueForKind): json yields JSON.parse
+output and text yields a string, so the whole population is JSON-round-trippable
+by construction — no Date/Map/Blob/cycle a structuredClone would be needed for.
+A primitive (string/number/boolean from a text or scalar-json body) is immutable,
+so it is returned as-is with no copy. An object/array goes through a JSON
+round-trip, ~2x faster than structuredClone for this exact shape (measured:
+773µs→516µs on a 149KB list, 3.4ms→1.7ms on 474KB) while producing the same
+fresh, mutable, isomorphic-with-a-cold-read copy.
+*/
+function cloneWarmValue(value: unknown): unknown {
+    if (typeof value !== 'object' || value === null) {
+        return value
+    }
+    return JSON.parse(JSON.stringify(value))
+}
+
 /*
 Normalises the `swr` option to its window, or undefined when off. `true` (or
 `{}`) is stale-while-revalidate with no window — refetch immediately on every

package/src/lib/shared/cacheStoreResolver.ts

@@ -0,0 +1,12 @@
+import { createCacheStore } from './createCacheStore.ts'
+import { createResolverSlot } from './createResolverSlot.ts'
+import type { CacheStore } from './types/CacheStore.ts'
+
+/*
+The active-CacheStore slot/resolver/reader bundle. The server entry installs an
+ALS-backed resolver (request-scoped); the client entry a module-singleton one.
+With no resolver registered, a single fallback store is created lazily so
+isolated tests work without booting the runtime. cacheStoreSlot / activeCacheStore
+re-export the slot and reader; setCacheStoreResolver the setter.
+*/
+export const cacheStoreResolver = createResolverSlot<CacheStore>(createCacheStore)

package/src/lib/shared/cacheStoreSlot.ts

@@ -1,16 +1,8 @@
-import type { CacheStore } from './types/CacheStore.ts'
+import { cacheStoreResolver } from './cacheStoreResolver.ts'
 
 /*
-Internal slot the runtime entries register their resolver into. The
-server entry installs an ALS-backed resolver (request-scoped); the
-client entry installs a module-singleton resolver. `fallback` is a
-single lazy store used only when no resolver is registered — keeps
-isolated tests working without forcing them to spin up the runtime.
+Internal slot the runtime entries register their resolver into (see
+cacheStoreResolver). Exposed so test helpers snapshot/poke `.resolver` and
+`.fallback` directly.
 */
-export const cacheStoreSlot: {
-    resolver: (() => CacheStore | undefined) | undefined
-    fallback: CacheStore | undefined
-} = {
-    resolver: undefined,
-    fallback: undefined,
-}
+export const cacheStoreSlot = cacheStoreResolver.slot

package/src/lib/shared/changeAffectsClient.ts

@@ -0,0 +1,35 @@
+/*
+Classifies a watcher change (a path relative to the project's `src/`, with
+either OS separator) by whether it can alter the client bundle. The dev
+orchestrator uses this to skip the full client `Bun.build` for changes that
+only reach the server or MCP runtimes, while still restarting the SSR worker.
+
+Server/MCP-only — client unaffected, skip the client rebuild:
+- `server/rpc/**`     — the client only ships proxy stubs derived from the file
+                        path (rpc url) and the `<METHOD>(...)` wrapper, not the
+                        handler body; the rpc manifest is server-only. A body
+                        edit produces an identical stub. (Risk: changing the
+                        method, the export name, or `outbox: true` does change
+                        the stub — those need a manual full rebuild.)
+- `server/sockets/**` — name-only `socketProxy` stubs derived from the file
+                        path; socket opts are server-side. Body edits don't
+                        change the stub.
+- `mcp/**`            — prompts/resources are MCP-only; the client bundle never
+                        imports them (it emits empty stubs defensively).
+- `server/config.ts`  — server boot-time env validation (`abide:config`); never
+                        reaches the client.
+
+Everything else (`.abide` templates, `ui/**`, `shared/**`, `app.ts`, state
+files, the rest of `server/`) is treated as client-affecting. Conservative by
+default: an unrecognised path returns true so an ambiguous change still pays the
+full rebuild rather than risking a stale client.
+*/
+export function changeAffectsClient(relativePath: string): boolean {
+    const path = relativePath.split('\\').join('/')
+    const serverOnly =
+        path.startsWith('server/rpc/') ||
+        path.startsWith('server/sockets/') ||
+        path.startsWith('mcp/') ||
+        path === 'server/config.ts'
+    return !serverOnly
+}

package/src/lib/shared/createResolverSlot.ts

@@ -0,0 +1,37 @@
+import type { ResolverSlot } from './types/ResolverSlot.ts'
+
+/*
+The slot/resolver/reader triple the runtime entries share for cache store,
+page, and mount-base state. A runtime entry registers a side-specific resolver
+via `set` (ALS-backed on the server, a module singleton on the client); `get`
+returns the resolved value, falling back to a single lazily-created fallback
+when no resolver is registered so isolated tests work without booting the
+runtime. `slot` stays exposed so test helpers can snapshot/poke `.resolver` and
+`.fallback` directly. Pass `createFallback` for a lazily-built, cached fallback
+(cache store, page); omit it for a slot whose fallback is a plain value set
+directly (mount base) — `get` then returns `T | undefined`.
+*/
+export function createResolverSlot<T>(createFallback?: () => T): {
+    slot: ResolverSlot<T>
+    set: (fn: () => T | undefined) => void
+    get: () => T | undefined
+} {
+    const slot: ResolverSlot<T> = { resolver: undefined, fallback: undefined }
+
+    function set(fn: () => T | undefined): void {
+        slot.resolver = fn
+    }
+
+    function get(): T | undefined {
+        const fromResolver = slot.resolver?.()
+        if (fromResolver !== undefined) {
+            return fromResolver
+        }
+        if (createFallback && slot.fallback === undefined) {
+            slot.fallback = createFallback()
+        }
+        return slot.fallback
+    }
+
+    return { slot, set, get }
+}

package/src/lib/shared/debugGate.ts

@@ -0,0 +1,90 @@
+import type { DebugGate } from './types/DebugGate.ts'
+
+/*
+The DEBUG-gate core: one memoized decision-maker per distinct DEBUG string,
+npm-debug conventions. `enabled(name)` answers "is gated channel X on?",
+`negated(name)` answers "did a `-X` pattern explicitly shut it off?" — the two
+questions isDebugEnabled / isDebugNegated expose. Both were re-deriving the same
+parse + filter work on every emission; here the include/exclude partition is
+computed once per env value (a single pass, not two throwaway-array filters) and
+each per-name boolean is cached, since the server's DEBUG is stable and channel
+names are a tiny fixed set.
+
+A new env string (the browser's abide-debug localStorage toggle, or tests
+mutating process.env.DEBUG) misses the single-slot memo and rebuilds — so a
+runtime DEBUG change takes effect on its next read.
+*/
+
+// One DEBUG pattern (already `-`-stripped) against one channel name: `*` matches
+// everything, `abide:*` matches 'abide' and every 'abide:…' sub-channel, else exact.
+function matches(name: string, pattern: string): boolean {
+    if (pattern === '*') {
+        return true
+    }
+    if (pattern.endsWith(':*')) {
+        const prefix = pattern.slice(0, -2)
+        return name === prefix || name.startsWith(`${prefix}:`)
+    }
+    return pattern === name
+}
+
+// Builds a gate for one env value: partitions the comma list into include/exclude
+// patterns in a single pass, then memoizes each per-name decision in a map.
+function buildGate(env: string | undefined): DebugGate {
+    const includes: string[] = []
+    const excludes: string[] = []
+    if (env) {
+        for (const raw of env.split(',')) {
+            const pattern = raw.trim()
+            if (pattern === '') {
+                continue
+            }
+            if (pattern.startsWith('-')) {
+                excludes.push(pattern.slice(1))
+            } else {
+                includes.push(pattern)
+            }
+        }
+    }
+    /* Cache-hit fast path: a Map keyed on channel name, since names are a tiny
+       fixed set and the gate runs on every log emission. Negated and enabled
+       cache separately — a channel can be queried through either question. */
+    const negatedCache = new Map<string, boolean>()
+    const enabledCache = new Map<string, boolean>()
+    return {
+        negated(name: string): boolean {
+            const cached = negatedCache.get(name)
+            if (cached !== undefined) {
+                return cached
+            }
+            const result = excludes.some((pattern) => matches(name, pattern))
+            negatedCache.set(name, result)
+            return result
+        },
+        enabled(name: string): boolean {
+            const cached = enabledCache.get(name)
+            if (cached !== undefined) {
+                return cached
+            }
+            // Exclusions win over inclusions (npm-debug negation precedence).
+            const result =
+                !excludes.some((pattern) => matches(name, pattern)) &&
+                includes.some((pattern) => matches(name, pattern))
+            enabledCache.set(name, result)
+            return result
+        },
+    }
+}
+
+/* Single-slot memo on the env string: the gate (partition + decision caches) is
+   rebuilt only when DEBUG changes. */
+let lastEnv: string | undefined
+let lastGate: DebugGate = buildGate(undefined)
+
+export function debugGate(env: string | undefined): DebugGate {
+    if (env !== lastEnv) {
+        lastEnv = env
+        lastGate = buildGate(env)
+    }
+    return lastGate
+}

package/src/lib/shared/emitLogRecord.ts

@@ -8,12 +8,21 @@ const useColor = hasBun && Bun.enableANSIColors
 const RESET = '\x1b[0m'
 const DIM = '\x1b[2m'
 
-// Wraps `text` in a Bun-resolved ANSI color escape; no-op when colors are disabled or unavailable (browser).
+/* The finite color set the log fragments paint with. Resolve each ANSI-256
+   escape once at module load — `Bun.color` was otherwise called per colored
+   fragment per line. Empty when colors are off so `paint` short-circuits. */
+const COLOR_NAMES = ['red', 'yellow', 'cyan', 'green', 'blue', 'white'] as const
+const COLOR_ESCAPES: Record<string, string> = useColor
+    ? Object.fromEntries(COLOR_NAMES.map((name) => [name, Bun.color(name, 'ansi-256') ?? '']))
+    : {}
+
+// Wraps `text` in a precomputed ANSI color escape; no-op when colors are disabled or unavailable (browser).
 function paint(color: string, text: string): string {
-    if (!useColor) {
+    const ansiEscape = COLOR_ESCAPES[color]
+    if (ansiEscape === undefined) {
         return text
     }
-    return `${Bun.color(color, 'ansi-256')}${text}${RESET}`
+    return `${ansiEscape}${text}${RESET}`
 }
 
 // Applies the ANSI dim attribute; no-op when colors are disabled.
@@ -66,12 +75,17 @@ function formatElapsed(ms: number): string {
     return `+${ms.toFixed(2)}ms`
 }
 
+/* Left-pads a clock component to a fixed width. Module-scoped so it isn't
+   re-allocated per log line. */
+function pad(value: number, width = 2): string {
+    return String(value).padStart(width, '0')
+}
+
 /* `14:23:01.072` — local wall-clock to the ms. Every record carries `ts`, so the
    tsv line always leads with one; `+elapsedMs` still trails as the request-relative
    timing — the two are different axes (when it happened vs how long it took). */
 function formatClock(ts: number): string {
     const date = new Date(ts)
-    const pad = (value: number, width = 2): string => String(value).padStart(width, '0')
     return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
 }
 

package/src/lib/shared/globalCacheStoreResolver.ts

@@ -0,0 +1,12 @@
+import { createResolverSlot } from './createResolverSlot.ts'
+import type { CacheStore } from './types/CacheStore.ts'
+
+/*
+Slot + setter for the process-level cache store resolver used by cache() entries
+opting into `global: true`. The server entry registers a module-singleton store
+outliving any one request; the client entry points it at its single tab store so
+`global` is a no-op there. No fallback creator — when unset, globalCacheStore()
+falls through to the active store rather than minting an isolated one.
+globalCacheStoreSlot / setGlobalCacheStoreResolver re-export the slot and setter.
+*/
+export const globalCacheStoreResolver = createResolverSlot<CacheStore>()

package/src/lib/shared/globalCacheStoreSlot.ts

@@ -1,14 +1,9 @@
-import type { CacheStore } from './types/CacheStore.ts'
+import { globalCacheStoreResolver } from './globalCacheStoreResolver.ts'
 
 /*
-Slot for the process-level cache store resolver used by cache() entries opting
-into `global: true`. The server entry registers a module-singleton store that
-outlives any one request; the client entry points it at its single tab store so
-`global` is a no-op there. Unset means no global store is registered, in which
-case globalCacheStore() falls back to the active (request/tab) store.
+Slot for the process-level cache store resolver (see globalCacheStoreResolver).
+Exposed so test helpers snapshot/poke `.resolver` directly. Unset means no global
+store is registered, in which case globalCacheStore() falls back to the active
+(request/tab) store.
 */
-export const globalCacheStoreSlot: {
-    resolver: (() => CacheStore | undefined) | undefined
-} = {
-    resolver: undefined,
-}
+export const globalCacheStoreSlot = globalCacheStoreResolver.slot

package/src/lib/shared/isDebugEnabled.ts

@@ -1,6 +1,4 @@
-import { isDebugNegated } from './isDebugNegated.ts'
-import { matchesDebugPattern } from './matchesDebugPattern.ts'
-import { parseDebugPatterns } from './parseDebugPatterns.ts'
+import { debugGate } from './debugGate.ts'
 
 /*
 Whether a DEBUG-gated channel is enabled, npm-debug conventions:
@@ -11,16 +9,11 @@ DEBUG="a,abide"         → comma-separated list
 DEBUG="abide:*,-abide:cache" → negation: exclusions win over inclusions
 Always-on channels don't consult this — they check isDebugNegated only.
 The default is guarded: this runs in the browser bundle, where `process`
-doesn't exist.
+doesn't exist. Decision routed through debugGate, memoized per DEBUG value.
 */
 export function isDebugEnabled(
     name: string,
     env: string | undefined = typeof process === 'undefined' ? undefined : process.env.DEBUG,
 ): boolean {
-    if (isDebugNegated(name, env)) {
-        return false
-    }
-    return parseDebugPatterns(env)
-        .filter((pattern) => !pattern.startsWith('-'))
-        .some((pattern) => matchesDebugPattern(name, pattern))
+    return debugGate(env).enabled(name)
 }

package/src/lib/shared/isDebugNegated.ts

@@ -1,5 +1,4 @@
-import { matchesDebugPattern } from './matchesDebugPattern.ts'
-import { parseDebugPatterns } from './parseDebugPatterns.ts'
+import { debugGate } from './debugGate.ts'
 
 /*
 Whether a `-` pattern in DEBUG explicitly shuts a channel off — the off
@@ -7,13 +6,12 @@ switch for the always-on channels (the app's name, 'abide'): DEBUG="-abide"
 silences framework lines including the per-request closing records,
 DEBUG="-myapp" the app's own. Silencing a channel silences all its levels —
 levels never gate, in either direction. The default is guarded: this runs in
-the browser bundle, where `process` doesn't exist.
+the browser bundle, where `process` doesn't exist. Decision routed through
+debugGate, memoized per DEBUG value.
 */
 export function isDebugNegated(
     name: string,
     env: string | undefined = typeof process === 'undefined' ? undefined : process.env.DEBUG,
 ): boolean {
-    return parseDebugPatterns(env)
-        .filter((pattern) => pattern.startsWith('-'))
-        .some((pattern) => matchesDebugPattern(name, pattern.slice(1)))
+    return debugGate(env).negated(name)
 }

package/src/lib/shared/pageResolver.ts

@@ -0,0 +1,16 @@
+import { createResolverSlot } from './createResolverSlot.ts'
+import type { PageSnapshot } from './types/PageSnapshot.ts'
+
+/*
+The active-page slot/resolver/reader bundle. The server entry installs an
+ALS-backed resolver (request-scoped, so concurrent and streaming renders never
+share state); the client entry a module-singleton one. With no resolver
+registered, a single empty snapshot is created lazily so isolated tests work.
+pageSlot / activePage re-export the slot and reader; setPageResolver the setter.
+*/
+export const pageResolver = createResolverSlot<PageSnapshot>(() => ({
+    route: '',
+    params: {},
+    url: new URL('http://localhost/'),
+    navigating: false,
+}))

package/src/lib/shared/pageSlot.ts

@@ -1,17 +1,8 @@
-import type { PageSnapshot } from './types/PageSnapshot.ts'
+import { pageResolver } from './pageResolver.ts'
 
 /*
-Internal slot the runtime entries register their page resolver into. The
-server entry installs an ALS-backed resolver (request-scoped, so concurrent
-and streaming renders never share state); the client entry installs a
-module-singleton resolver. `fallback` is a single lazy snapshot used only
-when no resolver is registered — keeps isolated tests working without forcing
-them to spin up the runtime. Mirrors cacheStoreSlot.
+Internal slot the runtime entries register their page resolver into (see
+pageResolver). Exposed so test helpers snapshot/poke `.resolver` and
+`.fallback` directly.
 */
-export const pageSlot: {
-    resolver: (() => PageSnapshot | undefined) | undefined
-    fallback: PageSnapshot | undefined
-} = {
-    resolver: undefined,
-    fallback: undefined,
-}
+export const pageSlot = pageResolver.slot

package/src/lib/shared/requestScopeResolver.ts

@@ -0,0 +1,12 @@
+import { createResolverSlot } from './createResolverSlot.ts'
+import type { RequestScopeInfo } from './types/RequestScopeInfo.ts'
+
+/*
+Slot + setter for the request-scope resolver. The server installs an ALS-backed
+resolver (createServer, reading the RequestStore); the client a module-singleton
+seeded from __SSR__ (startClient). No fallback creator — an unset resolver (or one
+returning undefined outside any request) means "no scope": callers read
+`.resolver?.()` and treat undefined as absent. requestScopeSlot /
+setRequestScopeResolver re-export the slot and setter.
+*/
+export const requestScopeResolver = createResolverSlot<RequestScopeInfo>()

package/src/lib/shared/requestScopeSlot.ts

@@ -1,15 +1,10 @@
-import type { RequestScopeInfo } from './types/RequestScopeInfo.ts'
+import { requestScopeResolver } from './requestScopeResolver.ts'
 
 /*
-Internal slot the runtime entries register their request-scope resolver into.
-The server installs an ALS-backed resolver (createServer, reading the
-RequestStore); the client installs a module-singleton resolver seeded from
-__SSR__ (startClient). Undefined resolver — or a resolver returning undefined
-outside any request — means "no scope": trace() returns undefined and log
-lines print without the context prefix. Mirrors pageSlot / cacheStoreSlot.
+Internal slot the runtime entries register their request-scope resolver into (see
+requestScopeResolver). Exposed so callers read `.resolver?.()` and test helpers
+snapshot/poke `.resolver` directly. Undefined resolver — or one returning
+undefined outside any request — means "no scope": trace() returns undefined and
+log lines print without the context prefix.
 */
-export const requestScopeSlot: {
-    resolver: (() => RequestScopeInfo | undefined) | undefined
-} = {
-    resolver: undefined,
-}
+export const requestScopeSlot = requestScopeResolver.slot

package/src/lib/shared/responseBodyKind.ts

@@ -0,0 +1,35 @@
+import { contentBodyKind } from './contentBodyKind.ts'
+import { contentTypeOf } from './contentTypeOf.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)/
+
+/*
+The post-handler body class that decides a dynamic response's wire handling:
+`streaming` (SSE / JSONL — drained frame-by-frame, never gzip-buffered, opted
+out of the idle timeout), `compressible` (text/structured-text — gzipped when
+the client accepts it), or `opaque` (binary/already-encoded — passed through).
+
+One header read + classify per response, threaded through the dispatch pipeline
+so `gzipResponse` and the idle-timeout opt-out don't each re-derive it from the
+Content-Type (the S2 finding: the same body was classified 3-4×). Mirrors the
+shared `contentBodyKind` streaming bucket so the wire path and the decode path
+can't disagree on what's a stream.
+*/
+export type ResponseBodyKind = 'streaming' | 'compressible' | 'opaque'
+
+export function responseBodyKind(response: Response): ResponseBodyKind {
+    const contentType = contentTypeOf(response.headers)
+    if (contentBodyKind(contentType) === 'streaming') {
+        return 'streaming'
+    }
+    if (COMPRESSIBLE_TYPE.test(contentType)) {
+        return 'compressible'
+    }
+    return 'opaque'
+}

package/src/lib/shared/setBaseResolver.ts

@@ -1,6 +1,4 @@
-import { baseSlot } from './baseSlot.ts'
+import { baseResolver } from './baseResolver.ts'
 
 // Registers the runtime's mount-base resolver. Called once per side at boot.
-export function setBaseResolver(fn: () => string): void {
-    baseSlot.resolver = fn
-}
+export const setBaseResolver = baseResolver.set

package/src/lib/shared/setCacheStoreResolver.ts

@@ -1,6 +1,4 @@
-import { cacheStoreSlot } from './cacheStoreSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
+import { cacheStoreResolver } from './cacheStoreResolver.ts'
 
-export function setCacheStoreResolver(fn: () => CacheStore | undefined): void {
-    cacheStoreSlot.resolver = fn
-}
+// Registers the runtime's active-CacheStore resolver. Called once per side at boot.
+export const setCacheStoreResolver = cacheStoreResolver.set

package/src/lib/shared/setGlobalCacheStoreResolver.ts

@@ -1,6 +1,4 @@
-import { globalCacheStoreSlot } from './globalCacheStoreSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
+import { globalCacheStoreResolver } from './globalCacheStoreResolver.ts'
 
-export function setGlobalCacheStoreResolver(fn: () => CacheStore | undefined): void {
-    globalCacheStoreSlot.resolver = fn
-}
+// Registers the process-level cache store resolver. Called once per side at boot.
+export const setGlobalCacheStoreResolver = globalCacheStoreResolver.set

package/src/lib/shared/setPageResolver.ts

@@ -1,7 +1,4 @@
-import { pageSlot } from './pageSlot.ts'
-import type { PageSnapshot } from './types/PageSnapshot.ts'
+import { pageResolver } from './pageResolver.ts'
 
 // Registers the runtime's page resolver. Called once per side at boot.
-export function setPageResolver(fn: () => PageSnapshot | undefined): void {
-    pageSlot.resolver = fn
-}
+export const setPageResolver = pageResolver.set