@abide/abide 0.43.1 → 0.44.1

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/createPushIterator.ts

@@ -1,5 +1,5 @@
 /*
-Single-slot-mailbox AsyncIterator factory shared by the in-process
+Bounded-queue AsyncIterator factory shared by the in-process
 socket fan-out (defineSocket) and the client-side ws proxy
 (socketProxy). Callers push values, signal end, signal an error, or
 signal a transport disconnect; the iterator drains a queue then awaits

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/decodeResponse.ts

@@ -1,3 +1,4 @@
+import { bodyValueForKind, DEFER } from './bodyValueForKind.ts'
 import { contentBodyKind } from './contentBodyKind.ts'
 import { contentTypeOf } from './contentTypeOf.ts'
 import { httpErrorFor } from './httpErrorFor.ts'
@@ -6,7 +7,7 @@ import { httpErrorFor } from './httpErrorFor.ts'
 Decodes a Response into the natural body value based on Content-Type:
   application/json (or `*\/+json`) → parsed JSON
   text/*                           → string
-  204 No Content / empty body      → undefined
+  204 No Content                   → undefined
   everything else                  → Blob
 
 Non-2xx responses throw HttpError so the happy path never has to check
@@ -39,11 +40,13 @@ export async function decodeResponse(response: Response): Promise<unknown> {
             `[abide] response at ${response.url} is a stream (${contentType}) — use tail(fn.stream(args)) for a reactive view, or fn.stream(args) for per-call iteration, instead of awaiting the bare call or cache()`,
         )
     }
-    if (kind === 'json') {
-        return response.json()
-    }
-    if (kind === 'text') {
-        return response.text()
-    }
-    return response.blob()
+    /* json/text go through the shared mapping warmValueFromSnapshot also uses, so a warm
+       seed reads byte-identically to this live read; binary (the only DEFER kind left,
+       streaming already threw above) blobs. */
+    const value = bodyValueForKind(
+        kind,
+        () => response.json(),
+        () => response.text(),
+    )
+    return value === DEFER ? response.blob() : value
 }

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/hasReplayableRequest.ts

@@ -0,0 +1,17 @@
+import { isReplayableMethod } from './isReplayableMethod.ts'
+import type { CacheEntry } from './types/CacheEntry.ts'
+
+/*
+Whether a cache entry carries a wire request that can be replayed from a warm
+snapshot — a replayable (GET-only) method, so the seed never re-fires a write or
+loses a body. Producer entries (no request) and write methods fail it.
+
+The request half of snapshot shippability, factored out so the two gates that
+need it cannot drift: `snapshotShippable` composes it with `settled` for the
+store-filter sites, and `snapshotEntryFromCache` calls it alone — its
+streaming-drain caller hands it still-pending entries it then awaits, so it can't
+require `settled` up front.
+*/
+export function hasReplayableRequest(entry: CacheEntry): boolean {
+    return entry.request !== undefined && isReplayableMethod(entry.request.method.toUpperCase())
+}

package/src/lib/shared/html.ts

@@ -1,36 +1,17 @@
-const RAW_HTML = Symbol.for('abide.rawHtml')
+/* The registered brand for trusted raw markup. `Symbol.for` resolves through the
+   global registry, so this binding is the same symbol across module/bundle copies;
+   `html` (`abide/ui/html`) imports it to brand, `rawHtmlString` reads it back. */
+export const RAW_HTML = Symbol.for('abide.rawHtml')
 
 /* A value marked as trusted raw markup — a `{expr}` interpolation inserts it
    verbatim (not escaped) on both sides. The brand is a registered Symbol, so it
-   survives across module/bundle copies. */
+   survives across module/bundle copies. Branded by `html` (`abide/ui/html`); read
+   back by `rawHtmlString` here — the isomorphic reader both runtimes consume. */
 export type RawHtml = { readonly [RAW_HTML]: string }
 
-/*
-Marks a string as trusted raw HTML so a `{expr}` interpolation inserts its nodes
-instead of escaped text — the abide idiom for raw markup (no `{@html}` mustache).
-Works two ways:
-
-  html(trustedString)        // plain call — insert the string verbatim
-  html`<b>${name}</b>`       // tagged — concatenate parts verbatim
-
-Calling `html` is the explicit opt-in to raw insertion; plain `{value}` always
-escapes. The tag does NOT auto-escape interpolations (it's raw by intent), so only
-build markup from values you trust, or escape them yourself.
-*/
-// @documentation templating
-export function html(strings: TemplateStringsArray | string, ...values: unknown[]): RawHtml {
-    if (typeof strings === 'string') {
-        return { [RAW_HTML]: strings }
-    }
-    let markup = strings[0] ?? ''
-    for (let index = 0; index < values.length; index += 1) {
-        markup += String(values[index]) + (strings[index + 1] ?? '')
-    }
-    return { [RAW_HTML]: markup }
-}
-
 /* The raw markup of a `html`-branded value, or undefined for anything else
    (so text bindings can fast-path plain values and only branded ones go raw). */
+// @documentation plumbing
 export function rawHtmlString(value: unknown): string | undefined {
     return value !== null && typeof value === 'object' && RAW_HTML in value
         ? (value as RawHtml)[RAW_HTML]

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/manifestModule.ts

@@ -16,8 +16,8 @@ export function manifestModule(options: {
     manifests whose contents are enumerated once at boot as an aligned table (see
     logExposedSurfaces) — rpc/sockets/pages/layouts — which both avoids the
     redundant list and the double-log of manifests (pages/layouts) loaded by both
-    the server and client bundles. prompts/errors have no table, so they pass a
-    label to keep their build-time line.
+    the server and client bundles. prompts has no table, so it passes a label to
+    keep its build-time line.
     */
     label?: string
 }): { contents: string; loader: 'js' } {

package/src/lib/shared/online.ts

@@ -3,7 +3,7 @@ import { requestScopeSlot } from './requestScopeSlot.ts'
 
 /*
 Reactive network-connectivity probe in the pending()/refreshing() family:
-reading it from a $derived/$effect re-runs that scope when the browser's
+reading it from a scope().computed() / scope().effect() re-runs that scope when the browser's
 online/offline events fire. navigator.onLine's *offline* signal is reliable
 (a true network loss always reports); its online value can false-positive
 behind captive portals — verified backend reachability is a separate,

package/src/lib/shared/outboxProbeSlot.ts

@@ -2,7 +2,7 @@
 Internal slot the browser outbox registry registers its prober into, so the
 shared pending() probe can count parked durable-rpc writes without shared/
 importing browser/. Mirrors tailProbeSlot. The prober reads the doc-backed
-queue entries (reactive inside $derived / $effect) and reports whether any
+queue entries (reactive inside scope().computed() / scope().effect()) and reports whether any
 undelivered entry matches the selector: a durable rpc selector (carries a
 `url`) narrows to its own queue, the bare form spans every registered queue,
 optional args narrow to one parked call by structural compare. Outbox state is

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/pageUrlForFile.ts

@@ -4,7 +4,7 @@ folder-based: every leaf is `page.abide` or `layout.abide`, and the URL
 is the directory path. Pages mount at the directory path; layouts mount at
 the directory prefix. Dynamic segments keep their `[name]` / `[...rest]`
 shape — translation to Bun's `:name` / `*` happens at server registration
-via toBunRoutePattern; consumers see the readable form in `nav.route`.
+via toBunRoutePattern; consumers see the readable form in `page.route`.
 */
 export function pageUrlForFile(relPath: string): string {
     const segments = relPath.split('/')

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/routeParamsShape.ts

@@ -0,0 +1,20 @@
+import { parseRouteSegments } from './parseRouteSegments.ts'
+
+/*
+The TypeScript type literal for a route's path params — `{ "id": string }` for
+`/post/[id]`, `Record<string, never>` for a param-less route. Walks the `[name]` /
+`[...rest]` segments; catch-all segments map to `string` under their declared name
+(the server's toBunRoutePattern renames Bun's `*` key back to that name when
+dispatching, so the page sees `params.rest`, not `params['*']`). The single source of
+truth shared by `writeRoutesDts` (page.params typing) and the `.abide` check shadow
+(page `props()` typing).
+*/
+export function routeParamsShape(routeUrl: string): string {
+    const keys = parseRouteSegments(routeUrl)
+        .filter((segment) => segment.kind === 'param')
+        .map((segment) => segment.name)
+    if (keys.length === 0) {
+        return 'Record<string, never>'
+    }
+    return `{ ${keys.map((key) => `${JSON.stringify(key)}: string`).join('; ')} }`
+}

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