@abide/abide 0.44.0 → 0.45.0

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

@@ -12,6 +12,7 @@ import { keyForRemoteCall } from './keyForRemoteCall.ts'
 import { producerKey } from './producerKey.ts'
 import { REMOTE_FUNCTION } from './REMOTE_FUNCTION.ts'
 import { REPLAYABLE_METHODS } from './REPLAYABLE_METHODS.ts'
+import { recordCacheKey } from './recordCacheKey.ts'
 import { SocketDisconnectedError } from './SocketDisconnectedError.ts'
 import { selectorMatcher } from './selectorMatcher.ts'
 import { selectorPrefix } from './selectorPrefix.ts'
@@ -198,8 +199,22 @@ export function cache<Args, Return>(
         reader of the key, so one mutating it would corrupt the others. A live
         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>
+        if (
+            !isRaw &&
+            existing !== undefined &&
+            (existing.value !== undefined || existing.warm !== undefined)
+        ) {
+            /* A deferred seed carries a lazy materializer instead of a decoded value: decode
+               it here, on the first read that needs it (off the hydration path), and cache the
+               result onto the entry so later reads skip the decode. Drop the materializer once
+               used — its closure pins the raw body string, so keeping it alongside the decoded
+               value would double memory for exactly the large payloads deferral targets. */
+            const warmValue = existing.value !== undefined ? existing.value : existing.warm?.()
+            existing.value = warmValue
+            existing.warm = undefined
+            const warmed = Promise.resolve(cloneWarmValue(warmValue)) as Promise<Return>
+            recordCacheKey(warmed, key)
+            return warmed
         }
         const responsePromise = invokeRemote(
             store,
@@ -209,13 +224,40 @@ export function cache<Args, Return>(
             args,
             options,
         )
-        return isRaw ? responsePromise : (responsePromise.then(decodeResponse) as Promise<Return>)
+        if (isRaw) {
+            return responsePromise
+        }
+        /* Tag the decoded value promise with its key so the SSR resume path can recognise a
+           cache-backed await value and defer a large one to a `{ defer, key }` marker. */
+        const decoded = responsePromise.then(decodeResponse) as Promise<Return>
+        recordCacheKey(decoded, key)
+        return decoded
     }
     /* Non-enumerable brand; selectorMatcher and the re-wrap guard read it. */
     Object.defineProperty(read, CACHE_WRAPPED, { value: fn })
     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
@@ -792,7 +834,7 @@ function settleRefetchFailure(store: CacheStore, entry: CacheEntry, status?: num
 }
 
 /* Folds new tags into an entry's existing set without duplicating them. */
-function mergeTags(existing: Set<string> | undefined, incoming: string | string[]): Set<string> {
+function mergeTags(existing: Set<string> | undefined, incoming: string[]): Set<string> {
     return new Set([...(existing ?? []), ...toTagSet(incoming)])
 }
 

package/src/lib/shared/cacheEntryFromSnapshot.ts

@@ -19,18 +19,38 @@ export function cacheEntryFromSnapshot(entry: CacheSnapshotEntry): CacheEntry {
         statusText: entry.statusText,
         headers,
     })
+    /* Deferred seed: decode nothing now — hand back a memoized materializer the first read
+       invokes, so hydration pays no payload decode. Eager seed: decode up front as before. */
+    const warm = entry.lazy
+        ? memoizeWarm(() => warmValueFromSnapshot(entry.status, headers, entry.body))
+        : undefined
     return {
         key: entry.key,
         promise: Promise.resolve(response),
         request: new Request(entry.url, { method: entry.method }),
         ttl: undefined,
         expiresAt: undefined,
-        value: warmValueFromSnapshot(entry.status, headers, entry.body),
+        value: entry.lazy ? undefined : warmValueFromSnapshot(entry.status, headers, entry.body),
+        warm,
         settled: true,
         hydrated: true,
     }
 }
 
+/* Wraps a warm decode so it runs at most once — the materialized value (including a
+   legitimate undefined for a non-warmable status) is cached after the first call. */
+function memoizeWarm(decode: () => unknown): () => unknown {
+    let materialized = false
+    let value: unknown
+    return () => {
+        if (!materialized) {
+            value = decode()
+            materialized = true
+        }
+        return value
+    }
+}
+
 /*
 Synchronously decodes a snapshot body so the warm entry reads without a
 microtask hop on first render. The json/text branches go through the shared

package/src/lib/shared/cacheKeyOf.ts

@@ -0,0 +1,7 @@
+import { cacheKeyStore } from './cacheKeyStore.ts'
+
+/* The store key behind a cache() read's promise, or undefined if it carries none
+   (a producer read, a raw Response read, or a non-cache promise). */
+export function cacheKeyOf(promise: Promise<unknown>): string | undefined {
+    return cacheKeyStore.get(promise)
+}

package/src/lib/shared/cacheKeyStore.ts

@@ -0,0 +1,8 @@
+/*
+WeakMap recording the cache key behind a `cache()` read's returned promise, so a
+consumer holding only the promise can recover its key. Mirrors remoteMetaStore (which
+records the synthesized Request the same way). The SSR resume path uses it to decide
+whether a `{#await cache()}` value is a large cache-backed read it can defer — shipping a
+`{ defer, key }` marker instead of the value. Collected with the promise.
+*/
+export const cacheKeyStore = new WeakMap<Promise<unknown>, string>()

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

@@ -4,7 +4,7 @@ import { HttpError } from './HttpError.ts'
 
 /*
 Builds the HttpError for a non-2xx response, parsing a typed-error body
-(`{ $abideError, data }`, emitted by `error(errors.x(...))` and validation 422)
+(`{ $abideError, data }`, emitted by an `error.typed(...)` constructor and validation 422)
 onto `.kind` / `.data`. Reads a clone so the original `response.body` stays
 unread for callers that inspect it. A non-JSON or malformed body leaves
 `.kind` / `.data` undefined (a plain `error(status, text)`). Shared by the

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

@@ -0,0 +1,6 @@
+import { cacheKeyStore } from './cacheKeyStore.ts'
+
+/* Tags a cache() read's returned promise with its store key (see cacheKeyStore). */
+export function recordCacheKey(promise: Promise<unknown>, key: string): void {
+    cacheKeyStore.set(promise, key)
+}