@timber-js/app 0.2.0-alpha.196 → 0.2.0-alpha.198

package/src/server/ssr-render.ts

@@ -25,7 +25,7 @@ import { renderToReadableStream } from 'react-dom/server';
 
 import { createRenderTimeout, RenderTimeoutError } from './render-timeout.ts';
 import { logRenderError, logStreamingError } from './logger.ts';
-import { isAbortError, NOINDEX_SCRIPT } from './render-utils.ts';
+import { isAbortError, noindexScript } from './render-utils.ts';
 
 /**
  * React's production error sanitization message. When NODE_ENV=production,
@@ -124,6 +124,8 @@ export async function renderSsrStream(
   element: ReactNode,
   options?: {
     bootstrapScriptContent?: string;
+    /** Request CSP nonce — stamped by Fizz on the bootstrap and runtime scripts. */
+    nonce?: string;
     deferSuspenseFor?: number;
     signal?: AbortSignal;
     renderTimeoutMs?: number;
@@ -164,6 +166,8 @@ export async function renderSsrNodeStream(
   element: ReactNode,
   options?: {
     bootstrapScriptContent?: string;
+    /** Request CSP nonce — stamped by Fizz on the bootstrap and runtime scripts. */
+    nonce?: string;
     deferSuspenseFor?: number;
     signal?: AbortSignal;
     renderTimeoutMs?: number;
@@ -198,6 +202,7 @@ export async function renderSsrNodeStream(
 
     const { pipe, abort } = _renderToPipeableStream!(element, {
       bootstrapScriptContent: options?.bootstrapScriptContent || undefined,
+      nonce: options?.nonce,
 
       onShellReady() {
         if (deferMs && deferMs > 0) {
@@ -298,6 +303,8 @@ async function renderViaReadableStream(
   element: ReactNode,
   options?: {
     bootstrapScriptContent?: string;
+    /** Request CSP nonce — stamped by Fizz on the bootstrap and runtime scripts. */
+    nonce?: string;
     deferSuspenseFor?: number;
     signal?: AbortSignal;
     renderTimeoutMs?: number;
@@ -323,6 +330,7 @@ async function renderViaReadableStream(
   try {
     stream = await renderToReadableStream(element, {
       bootstrapScriptContent: options?.bootstrapScriptContent || undefined,
+      nonce: options?.nonce,
       signal: effectiveSignal,
       onError(error: unknown) {
         if (isAbortError(error) || effectiveSignal?.aborted) return;
@@ -387,7 +395,7 @@ async function renderViaReadableStream(
   }
   onFizzAllReadyResolved?.(fizzAllReadyResolved);
 
-  return wrapStreamWithErrorHandling(stream, signal);
+  return wrapStreamWithErrorHandling(stream, signal, options?.nonce);
 }
 
 // ─── Shared Utilities ────────────────────────────────────────────────────────
@@ -408,7 +416,8 @@ async function renderViaReadableStream(
 /** @internal Exported for testing only. */
 export function wrapStreamWithErrorHandling(
   stream: ReadableStream<Uint8Array>,
-  signal?: AbortSignal
+  signal?: AbortSignal,
+  nonce?: string
 ): ReadableStream<Uint8Array> {
   const reader = stream.getReader();
   const encoder = new TextEncoder();
@@ -428,7 +437,7 @@ export function wrapStreamWithErrorHandling(
           return;
         }
         logStreamingError({ error });
-        controller.enqueue(encoder.encode(NOINDEX_SCRIPT));
+        controller.enqueue(encoder.encode(noindexScript(nonce)));
         controller.close();
       }
     },

package/src/server/ssr-wrappers.tsx

@@ -1,5 +1,5 @@
 /**
- * SSR wrapper components that match the client-side component tree depth.
+ * SSR wrapper chain — the same components the client hydration tree renders.
  *
  * During hydration, React's useId() generates deterministic IDs based on
  * the component's position in the fiber tree. If the SSR tree has fewer
@@ -7,26 +7,39 @@
  * produces different IDs — causing hydration mismatches in libraries like
  * Radix UI that rely on useId() internally.
  *
- * The client tree (browser-entry.ts) wraps the RSC element with:
+ * The client tree (`renderTree` in browser-entry/router-init.ts, used by
+ * hydrate.ts too) wraps the RSC element with:
  *   NavigationRoot → Fragment(TopLoader, ...) →
- *     TimberNuqsAdapter → NuqsAdapterProvider → NavigationProvider → element
+ *     TimberNuqsAdapter → NuqsAdapterProvider →
+ *       SlotContentCacheContext.Provider → SegmentUpdateContext.Provider →
+ *         NavigationProvider → PayloadRoot → ParamsProvider → element
  *
- * The SSR tree must produce the same component boundaries. These wrappers
- * are no-op components that render children directly but exist as fiber
- * nodes to match the client's tree depth.
+ * The SSR tree renders the REAL NavigationProvider and PayloadRoot rather
+ * than no-op mirrors (TIM-1424). Two consequences:
  *
- * **What actually shifts an id is a fork, not depth.** `useId` derives from
+ * 1. `usePathname()` / `useSearchParams()` resolve from NavigationContext
+ *    during SSR — the same code path as the browser — with the request's
+ *    pathname and raw search string. The raw string preserves repeated
+ *    query keys (`?tag=a&tag=b`) and, since TIM-1428, is the only
+ *    representation of search state here — it feeds the nuqs SSR adapter
+ *    too, so no collapsed record exists to drift from it.
+ * 2. `useSegmentParams()` resolves from ParamsContext, published by
+ *    PayloadRoot from the same payload root row the browser will read —
+ *    one derivation on both sides instead of two that must agree.
+ *
+ * Per-request isolation is by construction: the provider values are part
+ * of this request's element tree, so concurrent requests cannot observe
+ * each other's values — stronger than the ALS path, which remains for
+ * `useCookie()` and the `_navContext` status-code channel.
+ *
+ * **What actually shifts a useId is a fork, not depth.** `useId` derives from
  * React's tree context, which only changes where a fiber has more than one
  * child — here, `Fragment(TopLoader, element)`. A single-child wrapper, plain
  * component or context provider, leaves every id below it unchanged; that is
- * verified, not assumed. So the client-only wrappers that take exactly one
- * child — `SegmentUpdateContext.Provider`, and `PayloadRoot` with the params
- * provider it renders (TIM-1297) — have no mirror here and need none. Mirror a
- * new wrapper only if it branches.
- *
- * `PendingNavigationProvider` and its `SsrPendingProvider` mirror were both
- * deleted with the dead pending context (TIM-1307). Removing them shifts no
- * id: it was a single-child provider, the case the rule above covers.
+ * verified by tests/ssr-wrapper-parity.test.ts, not assumed. So the
+ * client-only `SegmentUpdateContext.Provider` and
+ * `SlotContentCacheContext.Provider` (single child each) have no mirror
+ * here and need none. Mirror a new wrapper only if it branches.
  *
  * Related issues: facebook/react#24669, radix-ui/primitives#3700
  * See design/02-rendering-pipeline.md §"RSC → SSR → Client Hydration"
@@ -34,11 +47,13 @@
 
 import { createElement, Fragment, type ReactNode } from 'react';
 import { withNuqsSsrAdapter } from './nuqs-ssr-provider.tsx';
+import { NavigationProvider } from '../client/navigation-context.ts';
+import { PayloadRoot } from '../client/params-context.ts';
 
 /**
  * SSR equivalent of NavigationRoot.
  *
- * On the client, NavigationRoot uses useState and standalone startTransition,
+ * On the client, the router renders NavigationRoot via `root.render` in a transition,
  * rendering `Fragment(TopLoader, element)` — or the element alone when the top
  * loader is disabled.
  *
@@ -50,7 +65,7 @@ function SsrNavigationRoot({
   children,
   hasTopLoader,
 }: {
-  children: ReactNode;
+  children?: ReactNode;
   hasTopLoader: boolean;
 }): ReactNode {
   if (hasTopLoader) {
@@ -67,76 +82,81 @@ function SsrTopLoader(): ReactNode {
   return null;
 }
 
-/**
- * SSR equivalent of NavigationProvider.
- * Matches the context.Provider component boundary on the client.
- */
-function SsrNavigationProvider({ children }: { children: ReactNode }): ReactNode {
-  return children as ReactNode;
-}
-
 /**
  * SSR equivalent of TimberNuqsAdapter component boundary.
  * The actual NuqsAdapterProvider (from createAdapterProvider) is added
  * inside this wrapper via withNuqsSsrAdapter, matching the client's
  * TimberNuqsAdapter → NuqsAdapterProvider nesting.
  */
-function SsrNuqsWrapper({
-  searchParams,
-  children,
-}: {
-  searchParams: Record<string, string>;
-  children: ReactNode;
-}): ReactNode {
+function SsrNuqsWrapper({ search, children }: { search: string; children?: ReactNode }): ReactNode {
   // withNuqsSsrAdapter creates a NuqsAdapterProvider (from createAdapterProvider),
   // which is the same component factory used by TimberNuqsAdapter on the client.
   // Both produce the same internal component boundary depth.
-  return withNuqsSsrAdapter(searchParams, children);
+  return withNuqsSsrAdapter(search, children);
+}
+
+/** Per-request inputs for the SSR wrapper chain. */
+export interface SsrWrapOptions {
+  /** Request pathname for NavigationProvider. */
+  pathname: string;
+  /**
+   * Raw app-visible query string (`''` or `?…`) for NavigationProvider AND
+   * the nuqs SSR adapter — one representation, preserving repeated keys
+   * (`?tag=a&tag=b`) on both consumers (TIM-1428).
+   */
+  search: string;
+  /**
+   * The payload's params, or a thenable of them, for PayloadRoot — the
+   * `params` half of `splitPayloadRoot(root)`. Same source the browser
+   * hands to the same component during hydration.
+   */
+  paramsSource: unknown;
+  /** Whether the top loader is enabled (must match client config). */
+  hasTopLoader: boolean;
 }
 
 /**
  * Wrap the SSR element tree with the same component boundaries as the
- * client hydration tree. This ensures useId() generates matching IDs
- * on both sides.
+ * client hydration tree — real providers, not mirrors — so hooks resolve
+ * identically on both sides and useId() matches.
  *
- * Client tree (browser-entry.ts):
+ * Client tree (browser-entry/hydrate.ts):
  *   NavigationRoot
  *     → Fragment(TopLoader, element)
  *       → TimberNuqsAdapter
  *         → NuqsAdapterProvider (from createAdapterProvider)
- *           → NavigationProvider
- *             → [RSC element]
+ *           → SlotContentCacheContext.Provider (client-only, single child)
+ *             → SegmentUpdateContext.Provider  (client-only, single child)
+ *               → NavigationProvider
+ *                 → PayloadRoot → ParamsProvider
+ *                   → [RSC element]
  *
  * SSR tree (this function):
  *   SsrNavigationRoot
  *     → Fragment(SsrTopLoader, element)
  *       → SsrNuqsWrapper
  *         → NuqsAdapterProvider (from withNuqsSsrAdapter → createAdapterProvider)
- *           → SsrNavigationProvider
- *             → [RSC element]
- *
- * @param element - The decoded RSC element
- * @param searchParams - Request search params for nuqs SSR adapter
- * @param hasTopLoader - Whether the top loader is enabled (must match client config)
+ *           → NavigationProvider              (real — same component)
+ *             → PayloadRoot → ParamsProvider  (real — same components)
+ *               → [RSC element]
  */
-export function wrapSsrElement(
-  element: ReactNode,
-  searchParams: Record<string, string>,
-  hasTopLoader: boolean
-): ReactNode {
-  // Build inside-out to match the client's createElement chain:
-  //   NavigationProvider(TimberNuqsAdapter(element))
-  //   → passed as initial to NavigationRoot
-  //   → NavigationRoot renders Fragment(TopLoader, initial)
+export function wrapSsrElement(element: ReactNode, opts: SsrWrapOptions): ReactNode {
+  // Build inside-out to match the client's createElement chain in
+  // hydrate.ts / router-init.ts renderTree().
+
+  // 1. Innermost: PayloadRoot publishes the payload's params over the tree.
+  const withParams = createElement(PayloadRoot, { source: opts.paramsSource }, element);
 
-  // 1. Innermost: NavigationProvider equivalent
-  const withNav = createElement(SsrNavigationProvider, null, element);
+  // 2. NavigationProvider with the request's address-bar state.
+  const withNav = createElement(
+    NavigationProvider,
+    { value: { pathname: opts.pathname, search: opts.search } },
+    withParams
+  );
 
-  // 2. TimberNuqsAdapter equivalent (wraps withNuqsSsrAdapter for the actual nuqs provider)
-  // eslint-disable-next-line react/no-children-prop -- createElement API
-  const withNuqs = createElement(SsrNuqsWrapper, { searchParams, children: withNav });
+  // 3. TimberNuqsAdapter equivalent (wraps withNuqsSsrAdapter for the actual nuqs provider)
+  const withNuqs = createElement(SsrNuqsWrapper, { search: opts.search }, withNav);
 
-  // 3. Outermost: NavigationRoot equivalent (the TopLoader fork)
-  // eslint-disable-next-line react/no-children-prop -- createElement API
-  return createElement(SsrNavigationRoot, { hasTopLoader, children: withNuqs });
+  // 4. Outermost: NavigationRoot equivalent (the TopLoader fork)
+  return createElement(SsrNavigationRoot, { hasTopLoader: opts.hasTopLoader }, withNuqs);
 }

package/src/server/types.ts

@@ -26,6 +26,16 @@ export interface MiddlewareContext {
   segmentParams: CoercedParams;
   /** Declare early hints for critical resources. Appends Link headers. */
   earlyHints: (hints: EarlyHint[]) => void;
+  /**
+   * Per-request CSP nonce, generated on first read. Put it in the
+   * `Content-Security-Policy` header you set via `ctx.headers`, and the
+   * framework stamps the same value on every inline `<script>` in the
+   * response (React's bootstrap and Suspense runtime, the RSC payload
+   * scripts, and its own). Reading it is the opt-in: a request whose
+   * middleware never reads `ctx.nonce` renders without nonce attributes.
+   * See design/13-security.md §"Content Security Policy".
+   */
+  readonly nonce: string;
 }
 
 /**

package/src/shared/slot-params.ts

@@ -77,10 +77,9 @@ export function resolveSegmentParams(
  * while memoized children below it lose their memoization.
  *
  * Keyed on the *identities* of the two records, not their contents: both are
- * replaced rather than mutated on every navigation (`setCurrentParams`,
- * `setCurrentSlotParams`, and the server's per-request store), so identity is
- * the correct equality here and a deep comparison would be slower and no more
- * accurate.
+ * replaced rather than mutated on every navigation (`ParamsProvider`'s memoized
+ * value and the server's per-request store), so identity is the correct
+ * equality here and a deep comparison would be slower and no more accurate.
  *
  * A `WeakMap` chain rather than a `Map`, so a superseded navigation's records
  * and their merges become collectable as soon as nothing else holds them.

package/src/shims/navigation-rsc.ts

@@ -0,0 +1,47 @@
+/**
+ * Shim: next/navigation → RSC environment only
+ *
+ * RSC's stripped-down React provides neither `useContext` nor `createContext`,
+ * so the real hook modules cannot be evaluated there. This shim exports
+ * throwing stubs for every client hook, with the same error messages the
+ * guards previously produced inline, and re-exports the server functions
+ * from @timber-js/app/server unchanged.
+ *
+ * The shims plugin resolves `next/navigation` to this file in the RSC
+ * environment, `navigation.ts` in SSR, and `navigation-client.ts` in the
+ * browser. This split eliminates the `typeof React.useContext !== 'function'`
+ * guards that React Compiler flagged as conditional hook calls (TIM-1420).
+ */
+
+function clientOnlyHook(name: string, extra?: string): never {
+  throw new Error(
+    `[timber] ${name}() is only available in Client Components. ` +
+      (extra ?? "Add 'use client' to the module that calls it.")
+  );
+}
+
+export function usePathname(): string {
+  clientOnlyHook('usePathname');
+}
+
+export function useSearchParams(): URLSearchParams {
+  clientOnlyHook('useSearchParams');
+}
+
+export function useSegmentParams(): Record<string, unknown> {
+  clientOnlyHook(
+    'useSegmentParams',
+    "In a Server Component, use getSegmentParams() from '@timber-js/app/server'; " +
+      "otherwise add 'use client' to the module that calls it."
+  );
+}
+
+export { useSegmentParams as useParams };
+
+export {
+  useRouter,
+  useSelectedLayoutSegment,
+  useSelectedLayoutSegments,
+} from '@timber-js/app/client';
+
+export { redirect, redirectExternal, RedirectType } from '@timber-js/app/server';

package/dist/_chunks/build-manifest-DWppEdLB.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-manifest-DWppEdLB.js","names":[],"sources":["../../src/server/build-manifest.ts"],"sourcesContent":["/**\n * Build manifest types and utilities for CSS and JS asset tracking.\n *\n * The build manifest maps route segment file paths to their output\n * chunks from Vite's client build. This enables:\n * - <link rel=\"stylesheet\"> injection in HTML <head>\n * - <script type=\"module\"> with hashed URLs in production\n * - <link rel=\"modulepreload\"> for client chunk dependencies\n * - Link preload headers for Early Hints (103)\n *\n * In dev mode, Vite's HMR client handles CSS/JS injection, so the build\n * manifest is empty. In production, it's populated from Vite's\n * .vite/manifest.json after the client build.\n *\n * Design docs: 18-build-system.md §\"Build Manifest\", 02-rendering-pipeline.md §\"Early Hints\"\n */\n\n/** A font asset entry in the build manifest. */\nexport interface ManifestFontEntry {\n  /** URL path to the font file (e.g. `/_timber/fonts/inter-latin-400-abc123.woff2`). */\n  href: string;\n  /** Font format (e.g. `woff2`). */\n  format: string;\n  /** Crossorigin attribute — always `anonymous` for fonts. */\n  crossOrigin: string;\n}\n\n/** Build manifest mapping input file paths to output asset URLs. */\nexport interface BuildManifest {\n  /** Map from input file path (relative to project root) to output CSS URLs. */\n  css: Record<string, string[]>;\n  /** Map from input file path to output JS chunk URL (hashed filename). */\n  js: Record<string, string>;\n  /** Map from input file path to transitive JS dependency URLs for modulepreload. */\n  modulepreload: Record<string, string[]>;\n  /** Map from input file path to font assets used by that module. */\n  fonts: Record<string, ManifestFontEntry[]>;\n  /**\n   * Cache-busting hashes for metadata route files (opengraph-image, etc.).\n   * Map from file path (relative to project root) to short content hash.\n   * In dev mode this is empty — a startup nonce is used instead.\n   */\n  metadataRouteHashes?: Record<string, string>;\n  /**\n   * Static request-dependency map from the Vite plugin's module-graph analysis.\n   * Map from segment entry file path to whether it's request-dependent.\n   * Used by buildSegmentInfo() for X-Timber-Segments in production.\n   */\n  requestDep?: Record<string, boolean>;\n}\n\n/**\n * Empty build manifest used in dev mode, and the single source of truth for\n * what an empty manifest contains.\n *\n * `virtual:timber-build-manifest` serializes this constant into its generated\n * source rather than restating it — one literal for the dev module, one for the\n * production module's `globalThis.__TIMBER_BUILD_MANIFEST__ ?? …` fallback.\n * They were three hand-written objects that had already drifted: this one and\n * the dev literal were missing `requestDep` while the production fallback had\n * it, so a reader who grepped the built bundle for `requestDep` found the one\n * copy that mentioned it and read the fallback as the shipped map (TIM-1300).\n * A field added here now reaches every copy.\n */\nexport const EMPTY_BUILD_MANIFEST: BuildManifest = {\n  css: {},\n  js: {},\n  modulepreload: {},\n  fonts: {},\n  metadataRouteHashes: {},\n  requestDep: {},\n};\n\n/** Segment shape expected by collectRouteCss (matches ManifestSegmentNode). */\ninterface SegmentWithFiles {\n  layout?: { filePath: string };\n  page?: { filePath: string };\n}\n\n/**\n * Collect all CSS files needed for a matched route's segment chain.\n *\n * Walks segments root → leaf, collecting CSS for each layout and page.\n * Deduplicates while preserving order (root layout CSS first).\n */\nexport function collectRouteCss(segments: SegmentWithFiles[], manifest: BuildManifest): string[] {\n  const seen = new Set<string>();\n  const result: string[] = [];\n\n  for (const segment of segments) {\n    for (const file of [segment.layout, segment.page]) {\n      if (!file) continue;\n      const cssFiles = manifest.css[file.filePath];\n      if (!cssFiles) continue;\n      for (const url of cssFiles) {\n        if (!seen.has(url)) {\n          seen.add(url);\n          result.push(url);\n        }\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Generate <link rel=\"stylesheet\"> tags for CSS URLs.\n *\n * Returns an HTML string to prepend to headHtml for injection\n * via injectHead() before </head>.\n */\nexport function buildCssLinkTags(cssUrls: string[]): string {\n  // Emit only <link rel=\"stylesheet\"> — no preload tags. CSS preloading\n  // is handled by 103 Early Hints (Link header) which fires before the\n  // HTML stream. Float also emits `<link rel=\"stylesheet\" data-precedence>`\n  // at the top of <head> during Fizz rendering — the browser discovers\n  // CSS from that tag. A <link rel=\"preload\"> here would arrive *after*\n  // Float's stylesheet tag and trigger \"Preload was ignored\" warnings.\n  return cssUrls.map((url) => `<link rel=\"stylesheet\" href=\"${url}\">`).join('');\n}\n\n// ─── Font utilities ──────────────────────────────────────────────────────\n\n/**\n * Collect all font entries needed for a matched route's segment chain.\n *\n * Walks segments root → leaf, collecting fonts for each layout and page.\n * Deduplicates by href while preserving order.\n */\nexport function collectRouteFonts(\n  segments: SegmentWithFiles[],\n  manifest: BuildManifest\n): ManifestFontEntry[] {\n  const seen = new Set<string>();\n  const result: ManifestFontEntry[] = [];\n\n  for (const segment of segments) {\n    for (const file of [segment.layout, segment.page]) {\n      if (!file) continue;\n      const fonts = manifest.fonts[file.filePath];\n      if (!fonts) continue;\n      for (const entry of fonts) {\n        if (!seen.has(entry.href)) {\n          seen.add(entry.href);\n          result.push(entry);\n        }\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Generate <link rel=\"preload\"> tags for font assets.\n *\n * Font preloads use `as=font` and always include `crossorigin` (required\n * for font preloads even for same-origin resources per the spec).\n */\nexport function buildFontPreloadTags(fonts: ManifestFontEntry[]): string {\n  return fonts\n    .map(\n      (f) =>\n        `<link rel=\"preload\" href=\"${f.href}\" as=\"font\" type=\"font/${f.format}\" crossorigin=\"${f.crossOrigin}\">`\n    )\n    .join('');\n}\n\n// ─── JS chunk utilities ──────────────────────────────────────────────────\n\n/**\n * Collect modulepreload URLs for a matched route's segment chain.\n *\n * Walks segments root → leaf, collecting transitive JS dependencies\n * for each layout and page. Deduplicates across segments.\n */\nexport function collectRouteModulepreloads(\n  segments: SegmentWithFiles[],\n  manifest: BuildManifest\n): string[] {\n  const seen = new Set<string>();\n  const result: string[] = [];\n\n  for (const segment of segments) {\n    for (const file of [segment.layout, segment.page]) {\n      if (!file) continue;\n      const preloads = manifest.modulepreload[file.filePath];\n      if (!preloads) continue;\n      for (const url of preloads) {\n        if (!seen.has(url)) {\n          seen.add(url);\n          result.push(url);\n        }\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Generate <link rel=\"modulepreload\"> tags for JS dependency URLs.\n *\n * Modulepreload hints tell the browser to fetch and parse JS modules\n * before they're needed, reducing waterfall latency for dynamic imports.\n */\nexport function buildModulepreloadTags(urls: string[]): string {\n  return urls.map((url) => `<link rel=\"modulepreload\" href=\"${url}\">`).join('');\n}\n"],"mappings":";;;;;;;;;;;;;;AAgEA,IAAa,uBAAsC;CACjD,KAAK,CAAC;CACN,IAAI,CAAC;CACL,eAAe,CAAC;CAChB,OAAO,CAAC;CACR,qBAAqB,CAAC;CACtB,YAAY,CAAC;AACf;;;;;;;AAcA,SAAgB,gBAAgB,UAA8B,UAAmC;CAC/F,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,SAAmB,CAAC;CAE1B,KAAK,MAAM,WAAW,UACpB,KAAK,MAAM,QAAQ,CAAC,QAAQ,QAAQ,QAAQ,IAAI,GAAG;EACjD,IAAI,CAAC,MAAM;EACX,MAAM,WAAW,SAAS,IAAI,KAAK;EACnC,IAAI,CAAC,UAAU;EACf,KAAK,MAAM,OAAO,UAChB,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG;GAClB,KAAK,IAAI,GAAG;GACZ,OAAO,KAAK,GAAG;EACjB;CAEJ;CAGF,OAAO;AACT;;;;;;;AA0BA,SAAgB,kBACd,UACA,UACqB;CACrB,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,SAA8B,CAAC;CAErC,KAAK,MAAM,WAAW,UACpB,KAAK,MAAM,QAAQ,CAAC,QAAQ,QAAQ,QAAQ,IAAI,GAAG;EACjD,IAAI,CAAC,MAAM;EACX,MAAM,QAAQ,SAAS,MAAM,KAAK;EAClC,IAAI,CAAC,OAAO;EACZ,KAAK,MAAM,SAAS,OAClB,IAAI,CAAC,KAAK,IAAI,MAAM,IAAI,GAAG;GACzB,KAAK,IAAI,MAAM,IAAI;GACnB,OAAO,KAAK,KAAK;EACnB;CAEJ;CAGF,OAAO;AACT;;;;;;;AAyBA,SAAgB,2BACd,UACA,UACU;CACV,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,SAAmB,CAAC;CAE1B,KAAK,MAAM,WAAW,UACpB,KAAK,MAAM,QAAQ,CAAC,QAAQ,QAAQ,QAAQ,IAAI,GAAG;EACjD,IAAI,CAAC,MAAM;EACX,MAAM,WAAW,SAAS,cAAc,KAAK;EAC7C,IAAI,CAAC,UAAU;EACf,KAAK,MAAM,OAAO,UAChB,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG;GAClB,KAAK,IAAI,GAAG;GACZ,OAAO,KAAK,GAAG;EACjB;CAEJ;CAGF,OAAO;AACT"}

package/dist/_chunks/cache-api-CQeYzA5g.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-api-CQeYzA5g.js","names":[],"sources":["../../src/cache/stable-stringify.ts","../../src/cache/singleflight.ts","../../src/cache/invalidation-epoch.ts","../../src/cache/timber-cache.ts","../../src/cache/handler-store.ts","../../src/cache/redis-handler.ts","../../src/cache/tag-aware-handler.ts","../../src/cache/index.ts","../../src/server/version-skew.ts","../../src/server/prebuilt/manifest-tag-index.ts","../../src/server/prebuilt/payload-source.ts","../../src/server/prebuilt/overlay.ts","../../src/cache/cache-api.ts"],"sourcesContent":["/**\n * Deterministic JSON serialization with sorted object keys.\n * Used for cache key generation — ensures { a: 1, b: 2 } and { b: 2, a: 1 }\n * produce the same string.\n *\n * Matches JSON.stringify semantics for toJSON: Date serializes to its ISO\n * string, URL to its href, and class instances with a custom toJSON use it.\n * Map and Set serialize their entries explicitly (insertion-order\n * independent). Values that would serialize lossily — functions, symbols,\n * and non-plain objects with no enumerable own state (RegExp, class\n * instances holding data behind getters or internal slots) — throw instead:\n * every such value would collapse to the same cache key, silently returning\n * one argument's cached data for another (TIM-1020).\n */\nexport function stableStringify(value: unknown): string {\n  if (value === null || value === undefined) return String(value);\n\n  const type = typeof value;\n  if (type === 'function' || type === 'symbol') {\n    throw new TypeError(\n      `stableStringify: cannot serialize a ${type} into a stable cache key — ` +\n        'all such values would collide. Provide an explicit `key` option to cache().'\n    );\n  }\n  if (type !== 'object') return JSON.stringify(value);\n\n  if (Array.isArray(value)) {\n    return '[' + value.map((item) => stableStringify(item)).join(',') + ']';\n  }\n\n  // Honor toJSON like JSON.stringify does (Date → ISO string, URL → href,\n  // custom class serialization). JSON.stringify does not re-invoke toJSON\n  // on the value it returns, so a toJSON that returns `this` falls through\n  // to plain own-property serialization instead of recursing forever.\n  const withToJSON = value as { toJSON?: () => unknown };\n  if (typeof withToJSON.toJSON === 'function') {\n    const json = withToJSON.toJSON();\n    if (json !== value) return stableStringify(json);\n  }\n\n  // Map/Set have no enumerable own properties — serialize entries explicitly.\n  // Entries are sorted after serialization so insertion order doesn't change\n  // the key. The Map(/Set( prefixes can't collide with object ('{'), array\n  // ('['), or string ('\"') output.\n  if (value instanceof Map) {\n    const entries = [...value.entries()].map(\n      ([k, v]) => stableStringify(k) + '=>' + stableStringify(v)\n    );\n    return 'Map(' + entries.sort().join(',') + ')';\n  }\n  if (value instanceof Set) {\n    const members = [...value].map((member) => stableStringify(member));\n    return 'Set(' + members.sort().join(',') + ')';\n  }\n\n  const obj = value as Record<string, unknown>;\n  const keys = Object.keys(obj).sort();\n  const pairs: string[] = [];\n  for (const key of keys) {\n    if (obj[key] === undefined) continue;\n    // A callable own toJSON only reaches this loop via the returns-`this`\n    // fall-through above. It's the serialization protocol, not data —\n    // JSON.stringify omits it too.\n    if (key === 'toJSON' && typeof obj[key] === 'function') continue;\n    pairs.push(JSON.stringify(key) + ':' + stableStringify(obj[key]));\n  }\n\n  // A non-plain object that serializes to '{}' carries its state behind\n  // getters or internal slots (RegExp, sessions, ORM entities). Serializing\n  // it would give every instance the same cache key.\n  if (pairs.length === 0) {\n    const proto = Object.getPrototypeOf(value);\n    if (proto !== Object.prototype && proto !== null) {\n      const name = (value as object).constructor?.name || 'Object';\n      throw new TypeError(\n        `stableStringify: ${name} instance has no serializable own state — ` +\n          'all instances would share one cache key. Provide an explicit `key` ' +\n          'option to cache(), or add a toJSON() method.'\n      );\n    }\n  }\n\n  return '{' + pairs.join(',') + '}';\n}\n","/**\n * Singleflight coalesces concurrent calls with the same key into a single\n * execution. All callers receive the same result (or error).\n *\n * Per-process, in-memory. Each process coalesces independently.\n *\n * An optional `timeoutMs` prevents hung `fn()` calls from permanently\n * blocking all future callers for that key. When set, `fn()` is raced\n * against a timeout — if the timeout fires first, the promise rejects\n * with `SingleflightTimeoutError`, `finally` cleans up the key, and\n * subsequent callers can retry. See TIM-518.\n */\n\nexport interface SingleflightOptions {\n  /** Maximum time (ms) a coalesced call may run before being rejected. */\n  timeoutMs?: number;\n}\n\nexport interface Singleflight {\n  do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;\n}\n\n/**\n * Error thrown when a singleflight call exceeds `timeoutMs`.\n * Exported so callers can distinguish timeout from other errors.\n */\nexport class SingleflightTimeoutError extends Error {\n  constructor(key: string, timeoutMs: number) {\n    super(`Singleflight timeout: key \"${key}\" exceeded ${timeoutMs}ms`);\n    this.name = 'SingleflightTimeoutError';\n  }\n}\n\nexport function createSingleflight(opts?: SingleflightOptions): Singleflight {\n  const inflight = new Map<string, Promise<unknown>>();\n  const timeoutMs = opts?.timeoutMs;\n\n  return {\n    do<T>(key: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {\n      const existing = inflight.get(key);\n      if (existing) return existing as Promise<T>;\n\n      const ac = new AbortController();\n      let promise: Promise<T>;\n\n      if (timeoutMs != null && timeoutMs > 0) {\n        // Race fn() against a timeout to prevent hung calls from\n        // permanently blocking the key. See TIM-518.\n        // Abort the signal on timeout so the callback can skip\n        // side effects (e.g. cache writes). See TIM-1092.\n        promise = new Promise<T>((resolve, reject) => {\n          const timer = setTimeout(() => {\n            ac.abort();\n            reject(new SingleflightTimeoutError(key, timeoutMs));\n          }, timeoutMs);\n          try {\n            fn(ac.signal).then(\n              (value) => {\n                clearTimeout(timer);\n                resolve(value);\n              },\n              (err) => {\n                clearTimeout(timer);\n                reject(err);\n              }\n            );\n          } catch (err) {\n            clearTimeout(timer);\n            reject(err);\n          }\n        });\n      } else {\n        promise = fn(ac.signal);\n      }\n\n      const tracked = promise.finally(() => {\n        inflight.delete(key);\n      });\n\n      inflight.set(key, tracked);\n      return tracked as Promise<T>;\n    },\n  };\n}\n","/**\n * Per-process invalidation epoch tracking for timber.cache (TIM-1028).\n *\n * handler.set for a cache miss runs after `fn()` resolves. An explicit\n * `cache.invalidate({ tag })` / `revalidateTag` that lands while fn is in\n * flight would otherwise be silently undone — the just-invalidated value\n * re-stored as fresh for the full TTL, resurrecting pre-mutation data.\n *\n * Every invalidation bumps a monotonic epoch and records it against the\n * invalidated key/tag. Before storing a result, the cache wrapper checks\n * whether its key or any of its tags were invalidated after fn started and\n * skips the write if so. Skipping is always safe: the only cost is one\n * extra cache miss on the next call.\n *\n * Scope: per-process, like the singleflight map. An invalidation issued by\n * another instance against a shared handler (Redis/KV) during fn flight is\n * not observable here — closing that window fully would require store-level\n * versioning, which no CacheHandler backend offers.\n */\n\nlet epoch = 0;\n\n/**\n * Last-invalidated epoch per `key:<k>` / `tag:<t>` entry. Insertion order is\n * epoch order (entries are re-inserted on update), so the oldest entry is\n * always first — pruning evicts lowest epochs.\n */\nconst lastInvalidated = new Map<string, number>();\n\n/**\n * Bound on tracked entries so high-cardinality tag invalidation (e.g.\n * per-user tags) cannot grow this map without limit.\n */\nconst MAX_TRACKED_ENTRIES = 10_000;\n\n/**\n * Highest epoch evicted from the map. Any execution that started at or\n * before this epoch conservatively counts as invalidated — history was\n * truncated, so we can no longer prove it wasn't.\n */\nlet evictedEpochFloor = 0;\n\n/** The current epoch. Capture before running fn(), pass to wasInvalidatedSince. */\nexport function currentInvalidationEpoch(): number {\n  return epoch;\n}\n\n/**\n * Record an invalidation. Call BEFORE handler.invalidate() so an execution\n * whose set-check races the invalidation errs toward skipping the write.\n */\nexport function recordInvalidation(opts: { key?: string; tag?: string }): void {\n  epoch++;\n  if (opts.key) track(`key:${opts.key}`);\n  if (opts.tag) track(`tag:${opts.tag}`);\n}\n\nfunction track(entry: string): void {\n  lastInvalidated.delete(entry);\n  lastInvalidated.set(entry, epoch);\n  while (lastInvalidated.size > MAX_TRACKED_ENTRIES) {\n    const oldest = lastInvalidated.entries().next().value;\n    if (oldest === undefined) break;\n    evictedEpochFloor = Math.max(evictedEpochFloor, oldest[1]);\n    lastInvalidated.delete(oldest[0]);\n  }\n}\n\n/**\n * Whether the key or any tag was invalidated after `startEpoch` (the epoch\n * captured when fn started executing).\n */\nexport function wasInvalidatedSince(startEpoch: number, key: string, tags: string[]): boolean {\n  return lastInvalidationEpochFor(key, tags) > startEpoch;\n}\n\n/**\n * The highest epoch at which the key or any of the tags was invalidated\n * (0 if never). Used to scope the singleflight key: callers arriving after\n * an invalidation must not coalesce onto a flight that started before it —\n * they would receive the pre-invalidation result the invalidation was\n * issued to discard.\n */\nexport function lastInvalidationEpochFor(key: string, tags: string[]): number {\n  let last = evictedEpochFloor;\n  const keyEpoch = lastInvalidated.get(`key:${key}`);\n  if (keyEpoch !== undefined && keyEpoch > last) last = keyEpoch;\n  for (const tag of tags) {\n    const tagEpoch = lastInvalidated.get(`tag:${tag}`);\n    if (tagEpoch !== undefined && tagEpoch > last) last = tagEpoch;\n  }\n  return last;\n}\n","import type { CacheHandler, CacheOptions } from './index.ts';\nimport { stableStringify } from './stable-stringify.ts';\nimport { createSingleflight } from './singleflight.ts';\nimport {\n  currentInvalidationEpoch,\n  lastInvalidationEpochFor,\n  wasInvalidatedSince,\n} from './invalidation-epoch.ts';\nimport { addSpanEventSync } from '../server/tracing.ts';\nimport { logSwrRefetchFailed, swallow } from '../server/logger.ts';\nimport { getWaitUntil } from '../server/waituntil-bridge.ts';\nimport { fnv1aHash } from './fast-hash.ts';\n\nlet defaultSingleflight = createSingleflight();\n\n/**\n * Per-key monotonic generation counter for CAS writes (TIM-1158).\n *\n * Unbounded, like the singleflight map — the key space is the same set of\n * cache keys the handler already tracks. Pruning was removed because it\n * desyncs from MemoryCacheHandler.generations: a pruned key restarts at 1\n * while the handler still holds the old higher generation, causing fresh\n * writes to be rejected as stale.\n */\nconst writeGenerations = new Map<string, number>();\nfunction nextGeneration(key: string): number {\n  const gen = (writeGenerations.get(key) ?? 0) + 1;\n  writeGenerations.set(key, gen);\n  return gen;\n}\n\n/**\n * Set the timeout for the module-level default singleflight.\n * Called at framework boot with renderTimeoutMs from timber.config.ts so that\n * cache calls without a per-call timeoutMs still get deadlock protection.\n * See design/06-caching.md §\"Singleflight Timeout — Deadlock Risk\".\n */\nexport function setDefaultSingleflightTimeout(timeoutMs: number): void {\n  defaultSingleflight = createSingleflight({ timeoutMs });\n}\n\n/**\n * Generate a cache key from function identity and serialized args.\n *\n * Uses FNV-1a (fast non-crypto hash) instead of SHA-256. Cache keys don't\n * need collision resistance — they need speed. The fnId prefix provides\n * namespace isolation; the hash covers the args.\n *\n * See TIM-370 for perf motivation.\n */\nfunction defaultKeyGenerator(fnId: string, args: unknown[]): string {\n  const raw = fnId + ':' + stableStringify(args);\n  return fnId + ':' + fnv1aHash(raw);\n}\n\n/**\n * Resolve tags from the options — supports static array or function form.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction resolveTags<Fn extends (...args: any[]) => any>(\n  opts: CacheOptions<Fn>,\n  args: Parameters<Fn>\n): string[] {\n  if (!opts.tags) return [];\n  if (Array.isArray(opts.tags)) return opts.tags;\n  return opts.tags(...args);\n}\n\n/** Per-process count of byte-identical fn sources seen by deriveFallbackFnId. */\nconst fallbackIdOccurrences = new Map<string, number>();\nlet hasWarnedFallbackId = false;\n\n/**\n * Derive a fallback fnId for callsites the timber-cache-transform Vite plugin\n * could not statically detect (aliased bindings, user re-export wrappers).\n *\n * The base is fnv1a(fn.toString()) — deterministic across instances and cold\n * starts of the same build, so two *different* functions can never swap fnIds\n * by module-evaluation order (the TIM-997 poisoning scenario that the old\n * process-local counter allowed; see TIM-1054). A per-process occurrence\n * suffix disambiguates byte-identical duplicate sources. That residue is the\n * one remaining hazard: closures produced by the same factory share source\n * text but capture different values, and their occurrence order may differ\n * across instances — such callsites need an explicit `key` option.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction deriveFallbackFnId(fn: (...args: any[]) => any): string {\n  const sourceHash = fnv1aHash(fn.toString());\n  const occurrence = fallbackIdOccurrences.get(sourceHash) ?? 0;\n  fallbackIdOccurrences.set(sourceHash, occurrence + 1);\n\n  if (!hasWarnedFallbackId && typeof process !== 'undefined' && process.env?.NODE_ENV !== 'test') {\n    hasWarnedFallbackId = true;\n    console.warn(\n      '[timber] cache() callsite has no build-time stable ID and no explicit `key` option — ' +\n        'the call is not statically visible to the timber Vite plugin (e.g. an aliased ' +\n        'binding like `const c = cache` or a re-export wrapper module). Falling back to a ' +\n        'function-source hash for the cache key. With a shared CacheHandler (Redis/KV) this ' +\n        'is safe for distinct functions, but byte-identical closures from a factory can swap ' +\n        'cache entries across instances. Provide an explicit `key` option to make the cache ' +\n        'key contract stable and auditable.'\n    );\n  }\n\n  return `timber-cache:fn:${sourceHash}:${occurrence}`;\n}\n\n/**\n * Creates a cached wrapper around an async function.\n *\n * - FNV-1a default keys with normalized JSON args\n * - Singleflight: concurrent misses → single execution AND single\n *   handler.set — the write happens inside the coalesced callback (TIM-1028)\n * - Writes are skipped when the key/tags were invalidated while fn was in\n *   flight, so explicit invalidation is never silently undone (TIM-1028)\n * - SWR: serve stale immediately, background refetch\n * - Tags as string[] or function of args\n * - The handler is resolved per invocation via `getHandler`, never captured\n *   at wrapper-creation time — module-scope cache() wrappers created before\n *   the framework's boot wiring calls setCacheHandler() still use the\n *   configured handler once it arrives (TIM-1029)\n * - No ALS dependency for correctness — cache() works outside a request\n *   context. The waitUntil ALS bridge is read optionally so the SWR\n *   background refetch survives handler return on Workers/Lambda.\n *\n * Cache hits/misses are recorded as OTEL span events on the enclosing\n * span (not child spans). The DevSpanProcessor reads these for dev log output.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function createCache<Fn extends (...args: any[]) => Promise<any>>(\n  fn: Fn,\n  opts: CacheOptions<Fn>,\n  getHandler: () => CacheHandler,\n  stableId?: string\n): Fn {\n  // With an explicit `key` option the fnId never reaches key generation, so\n  // no fallback derivation (or warning) is needed in that case.\n  const fnId = stableId ?? (opts.key ? undefined : deriveFallbackFnId(fn));\n\n  // Per-call timeoutMs gets a dedicated singleflight instance. Otherwise\n  // resolve defaultSingleflight per invocation (not captured at creation\n  // time) so wrappers created before boot pick up the timeout once\n  // setDefaultSingleflightTimeout is called (TIM-1032, same rationale as\n  // getCacheHandler for TIM-1029).\n  const perCallSf =\n    opts.timeoutMs !== undefined ? createSingleflight({ timeoutMs: opts.timeoutMs }) : undefined;\n\n  // Cast to Fn to preserve the original function's generic call signature.\n  // Without this, generic type parameters (e.g. <T> in apiFetch<T>) are\n  // erased and callers lose type safety on the return type.\n  return (async (...args: Parameters<Fn>): Promise<Awaited<ReturnType<Fn>>> => {\n    const sf = perCallSf ?? defaultSingleflight;\n    const key = opts.key ? opts.key(...args) : defaultKeyGenerator(fnId as string, args);\n\n    const cacheStart = performance.now();\n    const cached = await getHandler().get(key);\n\n    if (cached && !cached.stale) {\n      // Record as OTEL span event on enclosing span (not a child span).\n      // Fire-and-forget — no microtask overhead on the cache hot path.\n      addSpanEventSync('timber.cache.hit', {\n        key,\n        duration_ms: Math.round(performance.now() - cacheStart),\n      });\n      return cached.value as Awaited<ReturnType<Fn>>;\n    }\n\n    // From here fn() will execute (SWR refetch or miss). Scope the\n    // singleflight key by the last invalidation epoch affecting this\n    // key/tags: a caller arriving after an invalidation must not coalesce\n    // onto a flight that started before it — it would receive the\n    // pre-invalidation result the invalidation was issued to discard.\n    // NUL separator: cannot collide with user-provided key strings.\n    const tags = resolveTags(opts, args);\n    const flightKey = `${key}\\u0000${lastInvalidationEpochFor(key, tags)}`;\n\n    /**\n     * Run fn and store the result — exactly once per coalesced execution,\n     * inside the singleflight callback. The write is skipped when:\n     * - the key/tags were invalidated after fn started (TIM-1028), or\n     * - the singleflight timed out (signal aborted) — the timed-out\n     *   flight's write could overwrite a newer value from a subsequent\n     *   flight (TIM-1092), or\n     * - the handler rejects the write because a newer generation has\n     *   already been stored (TIM-1158 CAS guard).\n     */\n    const executeAndStore = async (signal: AbortSignal): Promise<Awaited<ReturnType<Fn>>> => {\n      const startEpoch = currentInvalidationEpoch();\n      const generation = nextGeneration(key);\n      const result = await fn(...args);\n      if (!signal.aborted && !wasInvalidatedSince(startEpoch, key, tags)) {\n        try {\n          await getHandler().set(key, result, { ttl: opts.ttl, tags, generation });\n        } catch (err) {\n          // Cache-write failure must not fail the request (TIM-1046).\n          // JSON-serializing handlers (Redis, KV) throw on BigInt; network\n          // errors can surface from any shared handler. The result is valid\n          // — serve it uncached rather than rejecting a successful fn().\n          swallow(err, `cache set failed for key \"${key}\"`);\n        }\n      }\n      return result;\n    };\n\n    if (cached && cached.stale && opts.staleWhileRevalidate) {\n      // Record stale cache hit as OTEL span event (fire-and-forget).\n      addSpanEventSync('timber.cache.hit', {\n        key,\n        duration_ms: Math.round(performance.now() - cacheStart),\n        stale: true,\n      });\n      // Serve stale immediately, trigger background refetch\n      const refetch = sf\n        .do(`swr:${flightKey}`, async (signal) => {\n          try {\n            await executeAndStore(signal);\n          } catch (err) {\n            // Failed refetch — stale entry continues to be served.\n            logSwrRefetchFailed({ cacheKey: key, error: err });\n          }\n        })\n        .catch(() => {\n          // Singleflight promise rejection handled — stale continues.\n        });\n      // Platforms that cancel work when the handler returns (Cloudflare\n      // Workers, Lambda) would otherwise kill the refetch mid-flight —\n      // stale data re-served forever. Register the (never-rejecting)\n      // refetch with the request's waitUntil; undefined outside a request\n      // context or on platforms without lifecycle extension (Node servers\n      // keep floating promises alive, so behavior there is unchanged).\n      getWaitUntil()?.(refetch);\n      return cached.value as Awaited<ReturnType<Fn>>;\n    }\n\n    // Cache miss (or stale without SWR) — execute with singleflight.\n    // The handler.set lives inside the coalesced callback, so N concurrent\n    // misses produce exactly one write (TIM-1028).\n    const result = await sf.do(flightKey, executeAndStore);\n\n    // Record cache miss as OTEL span event (fire-and-forget).\n    addSpanEventSync('timber.cache.miss', {\n      key,\n      duration_ms: Math.round(performance.now() - cacheStart),\n    });\n\n    return result;\n  }) as unknown as Fn;\n}\n","/**\n * Module-level cache handler singleton.\n *\n * Lazily initialized to MemoryCacheHandler on first access. The framework\n * replaces this at boot from timber.config.ts via setCacheHandler().\n *\n * This module avoids importing from ./index to prevent circular dependencies.\n */\n\n// Inline the interface to avoid circular import with index.ts\ninterface CacheHandlerLike {\n  get(key: string): Promise<{ value: unknown; stale: boolean } | null>;\n  set(key: string, value: unknown, opts: { ttl: number; tags: string[] }): Promise<void>;\n  invalidate(opts: { key?: string; tag?: string }): Promise<void>;\n}\n\nlet handler: CacheHandlerLike | null = null;\n\nlet explicitlyConfigured = false;\n\n/** Replace the active cache handler. Called by the framework at boot. */\nexport function setCacheHandler(h: CacheHandlerLike): void {\n  handler = h;\n  explicitlyConfigured = true;\n}\n\n/** Whether the handler was explicitly configured (vs the default in-memory fallback). */\nexport function isCacheHandlerConfigured(): boolean {\n  return explicitlyConfigured;\n}\n\n/**\n * Get the active cache handler. Creates a default MemoryCacheHandler on\n * first access if none has been set via setCacheHandler().\n */\nexport function getCacheHandler(): CacheHandlerLike {\n  if (!handler) {\n    // Inline a minimal LRU cache to avoid circular dep with index.ts.\n    // In production, the framework always calls setCacheHandler() at boot.\n    handler = createDefaultHandler();\n  }\n  return handler;\n}\n\nfunction createDefaultHandler(): CacheHandlerLike {\n  const store = new Map<string, { value: unknown; expiresAt: number; tags: string[] }>();\n  const maxEntries = 1000;\n\n  return {\n    async get(key) {\n      const entry = store.get(key);\n      if (!entry) return null;\n      store.delete(key);\n      store.set(key, entry);\n      const stale = Date.now() > entry.expiresAt;\n      return { value: entry.value, stale };\n    },\n    async set(key, value, opts) {\n      if (store.has(key)) store.delete(key);\n      while (store.size >= maxEntries) {\n        const oldest = store.keys().next().value;\n        if (oldest !== undefined) store.delete(oldest);\n        else break;\n      }\n      store.set(key, { value, expiresAt: Date.now() + opts.ttl * 1000, tags: opts.tags });\n    },\n    async invalidate(opts) {\n      if (opts.key) store.delete(opts.key);\n      if (opts.tag) {\n        for (const [key, entry] of store) {\n          if (entry.tags.includes(opts.tag)) store.delete(key);\n        }\n      }\n    },\n  };\n}\n","import type { CacheHandler } from './index.ts';\nimport { warnLossyJsonValue } from './json-lossy-check.ts';\n\n/**\n * Minimal Redis client contract for `RedisCacheHandler`.\n *\n * This is deliberately NOT the native shape of any client library. ioredis,\n * node-redis v4, and @upstash/redis all disagree on TTL argument shapes\n * (positional `'EX'` vs `{ EX }` vs `{ ex }`), method casing (`sadd` vs\n * `sAdd`), and array handling in `del` — a contract that pattern-matches one\n * client lets another silently drop the expiry (TIM-1030: node-redis ignored\n * the positional `'EX'` and wrote keys with no TTL). Instead, TTL semantics\n * are explicit in the signature and you adapt your client with a thin\n * wrapper, so a mismatch is a type error rather than silent unbounded\n * keyspace growth.\n *\n * @example ioredis\n * ```ts\n * import Redis from 'ioredis';\n * const redis = new Redis(process.env.REDIS_URL);\n * const client: RedisClient = {\n *   get: (k) => redis.get(k),\n *   set: (k, v, ttl) => redis.set(k, v, 'EX', ttl),\n *   expireNX: (k, s) => redis.expire(k, s, 'NX'),\n *   expireGT: (k, s) => redis.expire(k, s, 'GT'),\n *   del: (k) => redis.del(k),\n *   sadd: (k, ...m) => redis.sadd(k, ...m),\n *   srem: (k, ...m) => redis.srem(k, ...m),\n *   smembers: (k) => redis.smembers(k),\n *   ttl: (k) => redis.ttl(k),\n *   execMulti: async (ops) => {\n *     const p = redis.multi();\n *     for (const op of ops) {\n *       switch (op.op) {\n *         case 'set': p.set(op.key, op.value, 'EX', op.ttlSeconds); break;\n *         case 'sadd': p.sadd(op.key, ...op.members); break;\n *         case 'expireNX': p.expire(op.key, op.seconds, 'NX'); break;\n *         case 'expireGT': p.expire(op.key, op.seconds, 'GT'); break;\n *         case 'del': p.del(op.key); break;\n *       }\n *     }\n *     await p.exec();\n *   },\n * };\n * ```\n *\n * @example node-redis v4\n * ```ts\n * import { createClient } from 'redis';\n * const redis = createClient({ url: process.env.REDIS_URL });\n * await redis.connect();\n * const client: RedisClient = {\n *   get: (k) => redis.get(k),\n *   set: (k, v, ttl) => redis.set(k, v, { EX: ttl }),\n *   expireNX: (k, s) => redis.expire(k, s, 'NX'),\n *   expireGT: (k, s) => redis.expire(k, s, 'GT'),\n *   del: (k) => redis.del(k),\n *   sadd: (k, ...m) => redis.sAdd(k, m),\n *   srem: (k, ...m) => redis.sRem(k, m),\n *   smembers: (k) => redis.sMembers(k),\n *   ttl: (k) => redis.ttl(k),\n * };\n * ```\n *\n * @example @upstash/redis\n * ```ts\n * import { Redis } from '@upstash/redis';\n * // automaticDeserialization must be off: the handler stores JSON strings\n * // and parses them itself — auto-parsing would hand back objects.\n * const redis = new Redis({ url, token, automaticDeserialization: false });\n * const client: RedisClient = {\n *   get: (k) => redis.get(k),\n *   set: (k, v, ttl) => redis.set(k, v, { ex: ttl }),\n *   expireNX: (k, s) => redis.expire(k, s, 'NX'),\n *   expireGT: (k, s) => redis.expire(k, s, 'GT'),\n *   del: (k) => redis.del(k),\n *   sadd: (k, ...m) => redis.sadd(k, m[0], ...m.slice(1)),\n *   srem: (k, ...m) => redis.srem(k, m[0], ...m.slice(1)),\n *   smembers: (k) => redis.smembers(k),\n *   ttl: (k) => redis.ttl(k),\n * };\n * ```\n */\nexport type RedisWriteOp =\n  | { op: 'set'; key: string; value: string; ttlSeconds: number }\n  | { op: 'sadd'; key: string; members: string[] }\n  | { op: 'expireNX'; key: string; seconds: number }\n  | { op: 'expireGT'; key: string; seconds: number }\n  | { op: 'del'; key: string };\n\nexport interface RedisClient {\n  /** `GET key` — the stored string, or null when absent. */\n  get(key: string): Promise<string | null>;\n  /**\n   * `SET key value EX ttlSeconds` — store with an expiry. The TTL is a\n   * required positional argument so no adapter can forget it.\n   */\n  set(key: string, value: string, ttlSeconds: number): Promise<unknown>;\n  /**\n   * `EXPIRE key seconds NX` — set the TTL only if the key has no existing\n   * expiry (Redis 7.0+). Used to set the initial TTL on new tag sets.\n   */\n  expireNX(key: string, seconds: number): Promise<unknown>;\n  /**\n   * `EXPIRE key seconds GT` — update the TTL only if the new value is greater\n   * than the current one (Redis 7.0+). Used to extend tag set TTLs without\n   * allowing a short-TTL writer to shrink them.\n   */\n  expireGT(key: string, seconds: number): Promise<unknown>;\n  /** `DEL key` — delete a single key. Multi-key deletes loop per key. */\n  del(key: string): Promise<unknown>;\n  /** `SADD key member [member ...]` — add members to a set. */\n  sadd(key: string, ...members: string[]): Promise<unknown>;\n  /** `SREM key member [member ...]` — remove members from a set. */\n  srem(key: string, ...members: string[]): Promise<unknown>;\n  /** `SMEMBERS key` — all members of a set. */\n  smembers(key: string): Promise<string[]>;\n  /**\n   * `TTL key` — remaining time-to-live in seconds. Returns -2 if the key does\n   * not exist, -1 if the key exists but has no expiry.\n   */\n  ttl(key: string): Promise<number>;\n  /**\n   * Execute a batch of write operations atomically via `MULTI/EXEC`.\n   * When provided, `set()` uses this to make tag-index writes and the data\n   * write atomic — no `invalidate({tag})` can interleave. Optional: when\n   * absent, operations run sequentially (correct but not race-free).\n   */\n  execMulti?(ops: RedisWriteOp[]): Promise<void>;\n}\n\nconst KEY_PREFIX = 'timber:cache:';\nconst TAG_PREFIX = 'timber:tag:';\n\n/**\n * Redis-backed CacheHandler for distributed caching.\n *\n * All instances sharing the same Redis see each other's cache entries and\n * invalidations. Tag-based invalidation uses Redis Sets to track which keys\n * belong to which tags.\n *\n * Bring your own Redis client wrapped to the {@link RedisClient} contract —\n * see the adapter examples on the interface for ioredis, node-redis v4, and\n * @upstash/redis.\n */\nexport class RedisCacheHandler implements CacheHandler {\n  private client: RedisClient;\n  private prefix: string;\n\n  constructor(client: RedisClient, opts?: { prefix?: string }) {\n    this.client = client;\n    this.prefix = opts?.prefix ?? '';\n  }\n\n  private cacheKey(key: string): string {\n    return `${this.prefix}${KEY_PREFIX}${key}`;\n  }\n\n  private tagKey(tag: string): string {\n    return `${this.prefix}${TAG_PREFIX}${tag}`;\n  }\n\n  async get(key: string): Promise<{ value: unknown; stale: boolean } | null> {\n    const raw = await this.client.get(this.cacheKey(key));\n    if (raw === null) return null;\n\n    const entry = JSON.parse(raw) as { value: unknown; expiresAt: number };\n    const stale = Date.now() > entry.expiresAt;\n    return { value: entry.value, stale };\n  }\n\n  async set(\n    key: string,\n    value: unknown,\n    opts: { ttl: number; tags: string[]; generation?: number }\n  ): Promise<void> {\n    warnLossyJsonValue(value, key);\n    const ck = this.cacheKey(key);\n    const expiresAt = Date.now() + opts.ttl * 1000;\n\n    // Serialize upfront so BigInt/non-serializable errors throw before any\n    // writes — prevents tag indexes pointing at stale data from a prior set().\n    const payload = JSON.stringify({ value, expiresAt, tags: opts.tags });\n\n    // Redis TTL with generous margin beyond the logical TTL to allow SWR reads\n    // on stale entries. The logical staleness is determined by expiresAt.\n    // We use 2x TTL + 60s as the Redis expiry so stale entries remain\n    // available for SWR background refetches.\n    const redisTtlSeconds = Math.max(opts.ttl * 2 + 60, 120);\n\n    const writeOps: RedisWriteOp[] = [];\n    for (const tag of opts.tags) {\n      writeOps.push({ op: 'sadd', key: this.tagKey(tag), members: [key] });\n      writeOps.push({ op: 'expireNX', key: this.tagKey(tag), seconds: redisTtlSeconds });\n      writeOps.push({ op: 'expireGT', key: this.tagKey(tag), seconds: redisTtlSeconds });\n    }\n    writeOps.push({ op: 'set', key: ck, value: payload, ttlSeconds: redisTtlSeconds });\n\n    if (this.client.execMulti) {\n      await this.client.execMulti(writeOps);\n    } else {\n      for (const op of writeOps) {\n        await this.execOp(op);\n      }\n    }\n  }\n\n  private async execOp(op: RedisWriteOp): Promise<void> {\n    switch (op.op) {\n      case 'set':\n        await this.client.set(op.key, op.value, op.ttlSeconds);\n        break;\n      case 'sadd':\n        await this.client.sadd(op.key, ...op.members);\n        break;\n      case 'expireNX':\n        await this.client.expireNX(op.key, op.seconds);\n        break;\n      case 'expireGT':\n        await this.client.expireGT(op.key, op.seconds);\n        break;\n      case 'del':\n        await this.client.del(op.key);\n        break;\n    }\n  }\n\n  async invalidate(opts: { key?: string; tag?: string }): Promise<void> {\n    if (opts.key) {\n      const raw = await this.client.get(this.cacheKey(opts.key));\n      if (raw !== null) {\n        const entry = JSON.parse(raw) as { tags?: string[] };\n        if (entry.tags) {\n          await Promise.all(entry.tags.map((tag) => this.client.srem(this.tagKey(tag), opts.key!)));\n        }\n      }\n      await this.client.del(this.cacheKey(opts.key));\n    }\n\n    if (opts.tag) {\n      const tk = this.tagKey(opts.tag);\n      const keys = await this.client.smembers(tk);\n\n      // Re-check each member before deleting — the tag set can contain stale\n      // memberships from entries whose tags changed since they were added.\n      // Mirrors TagAwareCacheHandler's eager strategy (tag-aware-handler.ts:183-198).\n      await Promise.all(\n        keys.map(async (k) => {\n          const raw = await this.client.get(this.cacheKey(k));\n          if (raw === null) {\n            await this.client.srem(tk, k);\n            return;\n          }\n          const entry = JSON.parse(raw) as { tags?: string[] };\n          if (entry.tags?.includes(opts.tag!)) {\n            await this.client.del(this.cacheKey(k));\n          }\n          await this.client.srem(tk, k);\n        })\n      );\n\n      // Clean up the now-empty tag set so it doesn't consume memory\n      const remaining = await this.client.smembers(tk);\n      if (remaining.length === 0) {\n        await this.client.del(tk);\n      }\n    }\n  }\n}\n","/**\n * TagAwareCacheHandler — wraps any CacheStore and adds tag-based invalidation.\n *\n * Three strategies, selected by store capabilities (best available wins):\n *\n * 1. **Native** (store has setWithTags + invalidateTag): Delegates entirely.\n *    The store owns tag indexing. Used for Vercel Runtime Cache, DO-backed\n *    stores, or any platform with first-class tag support.\n *\n * 2. **Eager** (store has sadd/smembers/srem/sdel): Maintains an inverted\n *    index via atomic set operations. Invalidation enumerates the set and\n *    deletes entries. Used for Redis.\n *\n * 3. **Lazy** (bare get/set/del only): Version-stamps entries with tag\n *    counters. Invalidation bumps a counter (O(1)). Reads validate stored\n *    versions against current. Race-free, correct under eventual consistency.\n *    Used for Cloudflare KV.\n *\n * Implements the CacheHandler interface consumed by timber-cache.ts.\n */\n\nimport type { CacheHandler } from './index.ts';\nimport type { CacheStore } from './store.ts';\n\nconst DATA_PREFIX = 'd:';\nconst TAG_SET_PREFIX = 'ts:';\nconst TAG_VERSION_PREFIX = 'tv:';\n\ntype Strategy = 'native' | 'eager' | 'lazy';\n\n/** Stored entry format for eager strategy. */\ninterface EagerEntry {\n  value: unknown;\n  expiresAt: number;\n  tags: string[];\n}\n\n/** Stored entry format for lazy (version-stamp) strategy. */\ninterface LazyEntry {\n  value: unknown;\n  expiresAt: number;\n  tags: string[];\n  tagVersions: Record<string, number>;\n}\n\nfunction detectStrategy(store: CacheStore): Strategy {\n  if (store.setWithTags && store.invalidateTag) return 'native';\n  if (store.sadd && store.smembers && store.srem && store.sdel) return 'eager';\n  return 'lazy';\n}\n\nexport class TagAwareCacheHandler implements CacheHandler {\n  private store: CacheStore;\n  private prefix: string;\n  private strategy: Strategy;\n\n  constructor(store: CacheStore, opts?: { prefix?: string }) {\n    this.store = store;\n    this.prefix = opts?.prefix ?? 'timber:';\n    this.strategy = detectStrategy(store);\n  }\n\n  get consistency(): 'strong' | 'eventual' | 'local' {\n    return this.store.consistency;\n  }\n\n  private dataKey(key: string): string {\n    return `${this.prefix}${DATA_PREFIX}${key}`;\n  }\n\n  /** Namespace tags for native stores so prefix isolates shared stores. */\n  private prefixTags(tags: string[]): string[] {\n    return tags.map((t) => `${this.prefix}${t}`);\n  }\n\n  private tagSetKey(tag: string): string {\n    return `${this.prefix}${TAG_SET_PREFIX}${tag}`;\n  }\n\n  private tagVersionKey(tag: string): string {\n    return `${this.prefix}${TAG_VERSION_PREFIX}${tag}`;\n  }\n\n  async get(key: string): Promise<{ value: unknown; stale: boolean } | null> {\n    const raw = await this.store.get(this.dataKey(key));\n    if (raw === null) return null;\n\n    if (this.strategy === 'native' || this.strategy === 'eager') {\n      const entry = JSON.parse(raw) as EagerEntry;\n      const stale = Date.now() > entry.expiresAt;\n      return { value: entry.value, stale };\n    }\n\n    // Lazy: validate tag versions before returning\n    const entry = JSON.parse(raw) as LazyEntry;\n    if (entry.tags.length > 0) {\n      const currentVersions = await this.getTagVersions(entry.tags);\n      for (const tag of entry.tags) {\n        const stored = entry.tagVersions[tag] ?? 0;\n        const current = currentVersions[tag] ?? 0;\n        if (current > stored) return null;\n      }\n    }\n    const stale = Date.now() > entry.expiresAt;\n    return { value: entry.value, stale };\n  }\n\n  async set(\n    key: string,\n    value: unknown,\n    opts: { ttl: number; tags: string[]; generation?: number }\n  ): Promise<void> {\n    const physicalTtl = Math.max(opts.ttl * 2 + 60, 120);\n\n    if (this.strategy === 'native') {\n      const entry: EagerEntry = {\n        value,\n        expiresAt: Date.now() + opts.ttl * 1000,\n        tags: opts.tags,\n      };\n      const payload = JSON.stringify(entry);\n      if (opts.tags.length > 0) {\n        await this.store.setWithTags!(\n          this.dataKey(key),\n          payload,\n          physicalTtl,\n          this.prefixTags(opts.tags)\n        );\n      } else {\n        await this.store.set(this.dataKey(key), payload, physicalTtl);\n      }\n      return;\n    }\n\n    if (this.strategy === 'eager') {\n      const entry: EagerEntry = {\n        value,\n        expiresAt: Date.now() + opts.ttl * 1000,\n        tags: opts.tags,\n      };\n      await this.store.set(this.dataKey(key), JSON.stringify(entry), physicalTtl);\n      if (opts.tags.length > 0) {\n        await Promise.all(\n          opts.tags.map((tag) => this.store.sadd!(this.tagSetKey(tag), [key], physicalTtl))\n        );\n      }\n      return;\n    }\n\n    // Lazy: snapshot current tag versions into the entry\n    const tagVersions = opts.tags.length > 0 ? await this.getTagVersions(opts.tags) : {};\n    const entry: LazyEntry = {\n      value,\n      expiresAt: Date.now() + opts.ttl * 1000,\n      tags: opts.tags,\n      tagVersions,\n    };\n    await this.store.set(this.dataKey(key), JSON.stringify(entry), physicalTtl);\n  }\n\n  async invalidate(opts: { key?: string; tag?: string }): Promise<void> {\n    if (opts.key) {\n      if (this.strategy === 'eager') {\n        const raw = await this.store.get(this.dataKey(opts.key));\n        if (raw !== null) {\n          const entry = JSON.parse(raw) as EagerEntry;\n          if (entry.tags.length > 0) {\n            await Promise.all(\n              entry.tags.map((tag) => this.store.srem!(this.tagSetKey(tag), [opts.key!]))\n            );\n          }\n        }\n      }\n      await this.store.del(this.dataKey(opts.key));\n    }\n\n    if (opts.tag) {\n      const tag = opts.tag;\n      if (this.strategy === 'native') {\n        await this.store.invalidateTag!(`${this.prefix}${tag}`);\n      } else if (this.strategy === 'eager') {\n        const members = await this.store.smembers!(this.tagSetKey(tag));\n        // Verify each member still carries the tag before deleting — the set\n        // can contain stale memberships from overwritten entries or LRU eviction.\n        // Remove only the snapshot members (via srem, not sdel) so concurrent\n        // writes that add new members between smembers() and cleanup are preserved.\n        await Promise.all(\n          members.map(async (k) => {\n            const raw = await this.store.get(this.dataKey(k));\n            if (raw === null) {\n              await this.store.srem!(this.tagSetKey(tag), [k]);\n              return;\n            }\n            const entry = JSON.parse(raw) as EagerEntry;\n            if (entry.tags.includes(tag)) {\n              await this.store.del(this.dataKey(k));\n              await this.store.srem!(this.tagSetKey(tag), [k]);\n            } else {\n              await this.store.srem!(this.tagSetKey(tag), [k]);\n            }\n          })\n        );\n      } else {\n        await this.bumpTagVersion(opts.tag);\n      }\n    }\n  }\n\n  // --- Lazy strategy helpers ---\n\n  private async getTagVersions(tags: string[]): Promise<Record<string, number>> {\n    const versions: Record<string, number> = {};\n    await Promise.all(\n      tags.map(async (tag) => {\n        const raw = await this.store.get(this.tagVersionKey(tag));\n        versions[tag] = raw !== null ? parseInt(raw, 10) : 0;\n      })\n    );\n    return versions;\n  }\n\n  private async bumpTagVersion(tag: string): Promise<void> {\n    const key = this.tagVersionKey(tag);\n    const raw = await this.store.get(key);\n    const stored = raw !== null ? parseInt(raw, 10) : 0;\n    // max(stored, now) + 1: strictly advancing even within the same\n    // millisecond (two bumps in 1ms produce N, N+1 not N, N). On\n    // eventually-consistent stores the read can be stale, but Date.now()\n    // provides a floor — regression only if BOTH the read is stale AND the\n    // clock is behind, bounded by the store's propagation window (~60s).\n    const version = Math.max(stored, Date.now()) + 1;\n    // Version keys must outlive all data entries stamped with them. Data\n    // entries use physical TTL of max(ttl*2+60, 120); 365 days exceeds any\n    // practical cache lifetime.\n    await this.store.set(key, String(version), 365 * 86400);\n  }\n}\n","// @timber-js/app/cache — Caching primitives\n\nimport { estimateByteSize } from './sizeof.ts';\n\nexport interface CacheHandler {\n  get(key: string): Promise<{ value: unknown; stale: boolean } | null>;\n  set(\n    key: string,\n    value: unknown,\n    opts: { ttl: number; tags: string[]; generation?: number }\n  ): Promise<void>;\n  invalidate(opts: { key?: string; tag?: string }): Promise<void>;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface CacheOptions<Fn extends (...args: any[]) => any> {\n  ttl: number;\n  key?: (...args: Parameters<Fn>) => string;\n  staleWhileRevalidate?: boolean;\n  tags?: string[] | ((...args: Parameters<Fn>) => string[]);\n  /** Timeout (ms) for singleflight-coalesced calls. Prevents hung fn() from\n   *  permanently blocking all future callers for the same cache key. See TIM-518. */\n  timeoutMs?: number;\n}\n\nexport interface MemoryCacheHandlerOptions {\n  /** Maximum number of entries. Oldest accessed entries are evicted first. Default: 1000. */\n  maxEntries?: number;\n  /**\n   * @deprecated Use `maxEntries` instead. Will be removed in a future release.\n   * Alias for `maxEntries` — maximum number of entries (not bytes).\n   */\n  maxSize?: number;\n  /** Maximum total byte budget for all cached values. Oldest entries are evicted when exceeded. Default: no limit. */\n  maxBytes?: number;\n  /** Maximum byte size for a single cache entry. Entries exceeding this are silently dropped. Default: no limit. */\n  maxEntryBytes?: number;\n}\n\nexport class MemoryCacheHandler implements CacheHandler {\n  private store = new Map<\n    string,\n    { value: unknown; expiresAt: number; tags: string[]; byteSize: number }\n  >();\n  private generations = new Map<string, number>();\n  private maxEntries: number;\n  private maxBytes: number | undefined;\n  private maxEntryBytes: number | undefined;\n  private currentBytes = 0;\n  private readonly _trackBytes: boolean;\n\n  constructor(opts?: MemoryCacheHandlerOptions) {\n    // maxEntries takes precedence over deprecated maxSize\n    this.maxEntries = opts?.maxEntries ?? opts?.maxSize ?? 1000;\n    this.maxBytes = opts?.maxBytes;\n    this.maxEntryBytes = opts?.maxEntryBytes;\n    this._trackBytes = this.maxBytes !== undefined || this.maxEntryBytes !== undefined;\n  }\n\n  async get(key: string) {\n    const entry = this.store.get(key);\n    if (!entry) return null;\n\n    // Move to end of Map (most recently used) for LRU ordering\n    this.store.delete(key);\n    this.store.set(key, entry);\n\n    const stale = Date.now() > entry.expiresAt;\n    return { value: entry.value, stale };\n  }\n\n  async set(\n    key: string,\n    value: unknown,\n    opts: { ttl: number; tags: string[]; generation?: number }\n  ) {\n    // CAS guard: skip write if a newer generation has already been written\n    if (opts.generation !== undefined) {\n      const current = this.generations.get(key) ?? 0;\n      if (opts.generation < current) return;\n    }\n\n    const byteSize = this._trackBytes ? estimateByteSize(value) : 0;\n\n    // Reject entries exceeding per-entry byte limit\n    if (this.maxEntryBytes !== undefined && byteSize > this.maxEntryBytes) {\n      return;\n    }\n\n    // If key already exists, delete first to refresh insertion order and reclaim bytes\n    if (this.store.has(key)) {\n      const existing = this.store.get(key)!;\n      this.currentBytes -= existing.byteSize;\n      this.store.delete(key);\n    }\n\n    // Evict oldest entries (front of Map) if at entry count capacity\n    while (this.store.size >= this.maxEntries) {\n      this.evictOldest();\n    }\n\n    // Evict oldest entries if byte budget would be exceeded\n    if (this.maxBytes !== undefined) {\n      while (this.currentBytes + byteSize > this.maxBytes && this.store.size > 0) {\n        this.evictOldest();\n      }\n      // If the single entry exceeds the total byte budget, don't store it\n      if (this.currentBytes + byteSize > this.maxBytes) {\n        return;\n      }\n    }\n\n    // Record generation only after all admission checks pass\n    if (opts.generation !== undefined) {\n      this.generations.set(key, opts.generation);\n    }\n\n    this.store.set(key, {\n      value,\n      expiresAt: Date.now() + opts.ttl * 1000,\n      tags: opts.tags,\n      byteSize,\n    });\n    this.currentBytes += byteSize;\n  }\n\n  async invalidate(opts: { key?: string; tag?: string }) {\n    if (opts.key) {\n      const entry = this.store.get(opts.key);\n      if (entry) {\n        this.currentBytes -= entry.byteSize;\n        this.store.delete(opts.key);\n      }\n      this.generations.delete(opts.key);\n    }\n    if (opts.tag) {\n      for (const [key, entry] of this.store) {\n        if (entry.tags.includes(opts.tag)) {\n          this.currentBytes -= entry.byteSize;\n          this.store.delete(key);\n          this.generations.delete(key);\n        }\n      }\n    }\n  }\n\n  /** Number of entries currently in the cache. */\n  get size(): number {\n    return this.store.size;\n  }\n\n  /** Estimated total byte size of all cached values. Only tracked when maxBytes or maxEntryBytes is configured; returns 0 otherwise. */\n  get bytes(): number {\n    return this.currentBytes;\n  }\n\n  /** Evict the oldest entry (front of Map). */\n  private evictOldest(): void {\n    const oldest = this.store.keys().next().value;\n    if (oldest !== undefined) {\n      const entry = this.store.get(oldest)!;\n      this.currentBytes -= entry.byteSize;\n      this.store.delete(oldest);\n      this.generations.delete(oldest);\n    }\n  }\n}\n\nexport { RedisCacheHandler } from './redis-handler.ts';\nexport type { RedisClient, RedisWriteOp } from './redis-handler.ts';\nexport { cache } from './cache-api.ts';\nexport { setCacheHandler, getCacheHandler } from './handler-store.ts';\nexport { setDefaultSingleflightTimeout } from './timber-cache.ts';\n// NOTE: registerCachedFunction (runtime for 'use cache' directive) removed.\n// Future feature pending design doc. See design/06-caching.md.\nexport { estimateByteSize } from './sizeof.ts';\n\n// --- Cache Store layering (design/46) ---\nexport { TagAwareCacheHandler } from './tag-aware-handler.ts';\nexport type { CacheStore } from './store.ts';\n// stableStringify, createSingleflight, and SingleflightTimeoutError are\n// internal utilities used by the cache implementation. They are not\n// re-exported here — import directly from the source files if needed\n// within the package. See TIM-720.\n","/**\n * Version Skew Detection — graceful recovery when stale clients hit new deployments.\n *\n * When a new version of the app is deployed, clients with open tabs still have\n * the old JavaScript bundle. Without version skew handling, these stale clients\n * will experience:\n *\n * 1. Server action calls that crash (action IDs are content-hashed)\n * 2. Chunk load failures (old filenames gone from CDN)\n * 3. RSC payload mismatches (component references differ between builds)\n *\n * This module implements deployment ID comparison:\n * - A per-build deployment ID is generated at build time (see build-manifest.ts)\n * - The client sends it via `X-Timber-Deployment-Id` header on every RSC/action request\n * - The server compares it against the current build's ID\n * - On mismatch: signal the client to reload (not crash)\n *\n * The deployment ID is always-on in production. Dev mode skips the check\n * (HMR handles code updates without full reloads).\n *\n * See design/25-production-deployments.md, TIM-446\n */\n\n// ─── Constants ───────────────────────────────────────────────────\n\n/** Header sent by the client with every RSC/action request. */\nexport const DEPLOYMENT_ID_HEADER = 'X-Timber-Deployment-Id';\n\n/** Response header that signals the client to do a full page reload. */\nexport const RELOAD_HEADER = 'X-Timber-Reload';\n\n// ─── Deployment ID ───────────────────────────────────────────────\n\n/**\n * The current build's deployment ID. Set at startup from the manifest init\n * module (globalThis.__TIMBER_DEPLOYMENT_ID__). Null in dev mode.\n */\nlet currentDeploymentId: string | null = null;\n\n/**\n * Set the current deployment ID. Called once at server startup from the\n * manifest init module. In dev mode this is never called (deployment ID\n * checks are skipped).\n */\nexport function setDeploymentId(id: string): void {\n  currentDeploymentId = id;\n}\n\n/**\n * Get the current deployment ID. Returns null in dev mode.\n */\nexport function getDeploymentId(): string | null {\n  return currentDeploymentId;\n}\n\n// ─── Skew Detection ──────────────────────────────────────────────\n\n/** Result of a version skew check. */\nexport interface SkewCheckResult {\n  /** Whether the client's deployment ID matches the server's. */\n  ok: boolean;\n  /** The client's deployment ID (null if header not sent — e.g., initial page load). */\n  clientId: string | null;\n}\n\n/**\n * Check if a request's deployment ID matches the current build.\n *\n * Returns `{ ok: true }` when:\n * - Dev mode (no deployment ID set — HMR handles updates)\n * - No deployment ID header (initial page load, non-RSC request)\n * - Deployment IDs match\n *\n * Returns `{ ok: false }` when:\n * - Client sends a deployment ID that differs from the current build\n */\nexport function checkVersionSkew(req: Request): SkewCheckResult {\n  // Dev mode — no deployment ID checks (HMR handles updates)\n  if (!currentDeploymentId) {\n    return { ok: true, clientId: null };\n  }\n\n  const clientId = req.headers.get(DEPLOYMENT_ID_HEADER);\n\n  // No header — initial page load or non-RSC request. Always OK.\n  if (!clientId) {\n    return { ok: true, clientId: null };\n  }\n\n  // Compare deployment IDs\n  if (clientId === currentDeploymentId) {\n    return { ok: true, clientId };\n  }\n\n  return { ok: false, clientId };\n}\n\n/**\n * Apply version skew reload headers to a response.\n * Sets X-Timber-Reload: 1 to signal the client to do a full page reload.\n */\nexport function applyReloadHeaders(headers: Headers): void {\n  headers.set(RELOAD_HEADER, '1');\n}\n","/**\n * Manifest tag index — maps tags to seed cache keys for tombstone writes.\n *\n * When `revalidateTag(tag)` fires, the framework must write tombstones for\n * every build-seed entry carrying that tag. The manifest records tags per\n * entry; this module inverts the index at startup so the lookup is O(1) per\n * tag instead of a full manifest scan per invalidation.\n *\n * The index is built lazily on first access and cached for the process\n * lifetime — the manifest is immutable within a deploy.\n *\n * See design/45-cache-lifetimes.md §ISR mechanics.\n */\n\nimport type { PrebuiltManifest } from './payload-source.ts';\n\nexport interface SeedKeyInfo {\n  componentId: string;\n  cacheKey: string;\n}\n\n/**\n * Build the inverted tag → seed key index from the manifest.\n *\n * Returns a Map where each tag maps to the set of (componentId, cacheKey)\n * pairs whose manifest entries carry that tag. Only entries with non-empty\n * `tags` arrays participate.\n */\nexport function buildTagIndex(manifest: PrebuiltManifest): Map<string, SeedKeyInfo[]> {\n  const index = new Map<string, SeedKeyInfo[]>();\n  for (const [componentId, component] of Object.entries(manifest)) {\n    if (!component || typeof component !== 'object' || !('entries' in component)) continue;\n    for (const [cacheKey, entry] of Object.entries(component.entries)) {\n      if (!entry.tags || entry.tags.length === 0) continue;\n      for (const tag of entry.tags) {\n        let list = index.get(tag);\n        if (!list) {\n          list = [];\n          index.set(tag, list);\n        }\n        list.push({ componentId, cacheKey });\n      }\n    }\n  }\n  return index;\n}\n","/**\n * Prebuilt payload source — the adapter seam through which the runtime\n * reads build-time flight artifacts (`.timber/dist/prebuilt/`).\n *\n * The runtime never touches the filesystem directly: adapters register a\n * source at startup (Node: fs reads; Cloudflare: the assets binding —\n * design/44-render-at-build-time.md §Adapter Integration). Artifacts are\n * produced by the post-build capture pass (TIM-1119, prebuilt-builder.ts);\n * adapter registration of the source is TIM-1122. Until a source is\n * registered (adapter not wired yet, dev mode, no artifacts built), every\n * lookup misses and cache.component wrappers render live — the designed\n * dynamic-fallback behavior.\n *\n * Phase 3 (design/45 runtime tier) inserts the CacheHandler overlay lookup\n * in front of `lookupPrebuiltPayload` — overlay first, then artifact. The\n * single-lookup-function shape here is that seam.\n */\n\nimport { initTagIndex, resetTagIndex } from './overlay.ts';\nimport type { CoercedParams } from '../../shared/param-value.ts';\n\nexport interface PrebuiltManifestEntry {\n  /** Segment params this entry was captured under. */\n  params: CoercedParams;\n  /** Payload path relative to the prebuilt/ directory. */\n  file: string;\n  /** Payload size in bytes (build report / diagnostics). */\n  bytes?: number;\n  /** Runtime invalidation tags (design/45 ISR tier). */\n  tags?: string[];\n  /** Epoch ms when this entry was captured (seed freshness for ISR). */\n  buildTimestamp?: number;\n}\n\nexport interface PrebuiltManifest {\n  [componentId: string]: {\n    entries: Record<string, PrebuiltManifestEntry>;\n    /** When true, the component does not read segment params — the cache key uses `{}`. */\n    paramIndependent?: boolean;\n  };\n}\n\nexport interface PrebuiltPayloadSource {\n  /** Load prebuilt/manifest.json. Null when no artifacts exist. */\n  loadManifest(): Promise<PrebuiltManifest | null>;\n  /** Read a `.flight` payload by manifest file path. Null when missing. */\n  readPayload(file: string): Promise<Uint8Array | null>;\n}\n\nlet source: PrebuiltPayloadSource | null = null;\nlet manifestPromise: Promise<PrebuiltManifest | null> | null = null;\n\n/**\n * Ceiling on the memoized manifest load. Without it, a stalled\n * `loadManifest()` would leave `manifestPromise` pending forever and every\n * subsequent cache.component render would await the same hung promise —\n * the coalesced-promise deadlock class from design/13-security.md (A5).\n * On expiry the load memoizes as null (permanent dynamic fallback, same\n * policy as a failed load) and callers proceed immediately.\n */\nconst MANIFEST_LOAD_TIMEOUT_MS = 5_000;\n\n/**\n * Per-read ceiling on payload reads. The read is awaited inside a server\n * component render — a stalled adapter promise would otherwise hang the\n * RSC stream until the render timeout kills the whole page, when the\n * correct degradation is a miss → live render (codex review round 4 on\n * PR #835).\n */\nconst PAYLOAD_READ_TIMEOUT_MS = 5_000;\n\n/** Race a source promise against a timeout that resolves to `fallback`. */\nasync function withTimeout<T>(\n  work: Promise<T>,\n  timeoutMs: number,\n  fallback: T,\n  onTimeout: () => void\n): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  try {\n    return await Promise.race([\n      work,\n      new Promise<T>((resolve) => {\n        timer = setTimeout(() => {\n          onTimeout();\n          resolve(fallback);\n        }, timeoutMs);\n      }),\n    ]);\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\nasync function loadManifestWithTimeout(\n  src: PrebuiltPayloadSource\n): Promise<PrebuiltManifest | null> {\n  let manifest: PrebuiltManifest | null;\n  try {\n    manifest = await withTimeout(src.loadManifest(), MANIFEST_LOAD_TIMEOUT_MS, null, () => {\n      console.error(\n        `[timber] prebuilt manifest load exceeded ${MANIFEST_LOAD_TIMEOUT_MS}ms — all cache.component lookups will render dynamically`\n      );\n    });\n  } catch (error) {\n    console.error(\n      '[timber] failed to load prebuilt manifest — all cache.component lookups will miss:',\n      error\n    );\n    return null;\n  }\n  if (manifest) {\n    initTagIndex(manifest);\n  }\n  return manifest;\n}\n\n/**\n * Register the payload source. Called once at server startup by the\n * adapter/entry wiring (TIM-1122); tests inject fakes. Passing null\n * unregisters (and drops the memoized manifest).\n */\nexport function setPrebuiltPayloadSource(next: PrebuiltPayloadSource | null): void {\n  source = next;\n  manifestPromise = null;\n  if (!next) resetTagIndex();\n}\n\n/**\n * Whether a source is registered — the gate for both marker emission and\n * splice-transform installation. False means zero prebuilt overhead.\n */\nexport function hasPrebuiltPayloadSource(): boolean {\n  return source !== null;\n}\n\n/**\n * Ensure the manifest is loaded (and the tag index initialized). No-op\n * when no source is registered. Used by the tombstone path to avoid\n * skipping tombstones on cold processes where the first request is an\n * action rather than a page render.\n */\nexport async function ensureManifestLoaded(): Promise<void> {\n  if (source === null) return;\n  manifestPromise ??= loadManifestWithTimeout(source);\n  await manifestPromise;\n}\n\n/**\n * Look up a manifest entry (metadata only, no payload read).\n * Used by the overlay to check seed existence and freshness.\n */\nexport async function isParamIndependent(componentId: string): Promise<boolean> {\n  if (source === null) return false;\n  manifestPromise ??= loadManifestWithTimeout(source);\n  const manifest = await manifestPromise;\n  return manifest?.[componentId]?.paramIndependent === true;\n}\n\nexport async function getManifestEntry(\n  componentId: string,\n  cacheKey: string\n): Promise<PrebuiltManifestEntry | null> {\n  if (source === null) return null;\n  manifestPromise ??= loadManifestWithTimeout(source);\n  const manifest = await manifestPromise;\n  return manifest?.[componentId]?.entries?.[cacheKey] ?? null;\n}\n\n/**\n * Look up a cached payload: manifest entry → payload bytes.\n * Null on any miss or read failure — callers fall back to live render.\n *\n * The manifest is loaded once and memoized (design/44 §manifest.json:\n * loaded at startup, held in memory; payloads read on demand). A failed\n * manifest load is memoized as null rather than retried per-request — a\n * broken artifact should degrade to dynamic rendering, not add a failing\n * read to every request.\n */\nexport async function lookupPrebuiltPayload(\n  componentId: string,\n  cacheKey: string\n): Promise<Uint8Array | null> {\n  if (source === null) return null;\n  manifestPromise ??= loadManifestWithTimeout(source);\n  const manifest = await manifestPromise;\n  const entry = manifest?.[componentId]?.entries?.[cacheKey];\n  if (!entry) return null;\n  try {\n    return await withTimeout(source.readPayload(entry.file), PAYLOAD_READ_TIMEOUT_MS, null, () => {\n      console.error(\n        `[timber] prebuilt payload read for \"${entry.file}\" exceeded ${PAYLOAD_READ_TIMEOUT_MS}ms — rendering dynamically`\n      );\n    });\n  } catch (error) {\n    console.error(\n      `[timber] failed to read prebuilt payload \"${entry.file}\" for ${componentId} — rendering dynamically:`,\n      error\n    );\n    return null;\n  }\n}\n","/**\n * Component cache overlay — runtime CacheHandler layer for ISR.\n *\n * Sits in front of the immutable build artifact (`.flight` files) and\n * stores replacement payloads and tombstones via the configured\n * CacheHandler. Overlay entries are per-deploy namespaced:\n *   `timber:c:{deploymentId}:{componentId}:{hash}`\n *\n * The CacheHandler contract is untouched — tombstones and the tag index\n * live above the interface as value conventions. Redis, KV, and custom\n * handlers work unmodified.\n *\n * See design/45-cache-lifetimes.md §ISR mechanics.\n */\n\nimport { getCacheHandler, isCacheHandlerConfigured } from '../../cache/handler-store.ts';\nimport { MemoryCacheHandler } from '../../cache/index.ts';\nimport { getDeploymentId } from '../version-skew.ts';\nimport { buildTagIndex, type SeedKeyInfo } from './manifest-tag-index.ts';\nimport type { PrebuiltManifest } from './payload-source.ts';\nimport { ensureManifestLoaded } from './payload-source.ts';\n\n/** Default ceiling TTL for tag-only entries (24 hours), in seconds. */\nconst CEILING_TTL_SECONDS = 24 * 60 * 60;\n\n/** Deploy-long physical TTL for seed-backed overlay records (90 days). */\nconst DEPLOY_LONG_TTL_SECONDS = 90 * 24 * 60 * 60;\n\n// ─── Overlay record shapes (value conventions above CacheHandler) ────────\n\n/**\n * A cached component flight payload stored in the overlay.\n * The `_t` discriminant distinguishes this from a tombstone.\n */\nexport interface ComponentOverlayRecord {\n  _t: 'co';\n  /** Base64-encoded flight payload bytes. */\n  p: string;\n  /** Logical freshness deadline (Date.now() + ttl * 1000). */\n  fu: number;\n  /** Whether a build-artifact seed exists for this key. */\n  s: boolean;\n}\n\n/**\n * A tombstone marking a build seed as invalidated.\n * Written by revalidateTag for seeds carrying the invalidated tag.\n */\nexport interface ComponentTombstoneRecord {\n  _t: 'ct';\n}\n\ntype OverlayValue = ComponentOverlayRecord | ComponentTombstoneRecord;\n\nexport function isOverlayRecord(v: unknown): v is ComponentOverlayRecord {\n  return v !== null && typeof v === 'object' && (v as Record<string, unknown>)._t === 'co';\n}\n\nexport function isTombstone(v: unknown): v is ComponentTombstoneRecord {\n  return v !== null && typeof v === 'object' && (v as Record<string, unknown>)._t === 'ct';\n}\n\n// ─── Overlay key generation ──────────────────────────────────────────────\n\nexport function overlayKey(componentId: string, cacheKey: string): string {\n  const deploymentId = getDeploymentId() ?? 'dev';\n  return `timber:c:${deploymentId}:${componentId}:${cacheKey}`;\n}\n\n// ─── Overlay read ────────────────────────────────────────────────────────\n\nexport interface OverlayLookupResult {\n  kind: 'fresh' | 'stale' | 'tombstone';\n  /** The overlay value (null for tombstones). */\n  record: ComponentOverlayRecord | null;\n  /** Raw flight payload bytes (decoded from base64). Null for tombstones. */\n  payload: Uint8Array | null;\n}\n\n/**\n * Look up an overlay entry in the cache handler.\n * Returns null on a clean miss (no overlay entry at all).\n */\nexport async function lookupOverlay(\n  componentId: string,\n  cacheKey: string\n): Promise<OverlayLookupResult | null> {\n  const handler = getCacheHandler();\n  const key = overlayKey(componentId, cacheKey);\n  const result = await handler.get(key);\n  if (!result) return null;\n\n  const value = result.value as OverlayValue;\n  if (isTombstone(value)) {\n    return { kind: 'tombstone', record: null, payload: null };\n  }\n  if (isOverlayRecord(value)) {\n    const logicallyStale = Date.now() > value.fu;\n    return {\n      kind: logicallyStale ? 'stale' : 'fresh',\n      record: value,\n      payload: base64ToBytes(value.p),\n    };\n  }\n  // Unknown value shape — treat as miss (forward compatibility).\n  return null;\n}\n\n// ─── Overlay write ───────────────────────────────────────────────────────\n\n/**\n * Resolve the effective TTL for a component's runtime lifetime.\n * Tag-only entries (no explicit ttl) get the ceiling TTL (design/45\n * §Tag-only entries carry a ceiling TTL).\n */\nexport function effectiveTtl(ttl: number | undefined): number {\n  return ttl ?? CEILING_TTL_SECONDS;\n}\n\n/**\n * Store a component flight payload in the overlay.\n */\nexport async function storeOverlayEntry(\n  componentId: string,\n  cacheKey: string,\n  payloadBytes: Uint8Array,\n  opts: {\n    ttl?: number;\n    tags: string[];\n    hasSeed: boolean;\n  }\n): Promise<void> {\n  const handler = getCacheHandler();\n  const key = overlayKey(componentId, cacheKey);\n  const logicalTtl = effectiveTtl(opts.ttl);\n  const physicalTtl = opts.hasSeed ? DEPLOY_LONG_TTL_SECONDS : logicalTtl;\n\n  const record: ComponentOverlayRecord = {\n    _t: 'co',\n    p: bytesToBase64(payloadBytes),\n    fu: Date.now() + logicalTtl * 1000,\n    s: opts.hasSeed,\n  };\n\n  await handler.set(key, record, { ttl: physicalTtl, tags: opts.tags });\n}\n\n// ─── Tombstone writes ────────────────────────────────────────────────────\n\nlet tagIndex: Map<string, SeedKeyInfo[]> | null = null;\n\n/**\n * Initialize the tag index from the prebuilt manifest. Called once when the\n * manifest is loaded. Without a manifest (no prebuilt components), this is\n * never called and revalidateTag skips the tombstone path entirely.\n */\nexport function initTagIndex(manifest: PrebuiltManifest): void {\n  tagIndex = buildTagIndex(manifest);\n  emitIsrDiagnosticIfNeeded(manifest);\n}\n\n/**\n * Get the tag index, if initialized.\n * @internal — exported for testing.\n */\nexport function getTagIndex(): Map<string, SeedKeyInfo[]> | null {\n  return tagIndex;\n}\n\n/**\n * Reset the tag index (for tests).\n * @internal\n */\nexport function resetTagIndex(): void {\n  tagIndex = null;\n}\n\n/**\n * Write tombstones for all seed entries carrying the given tag.\n * Called from cache.invalidate (cache-api.ts) AFTER the handler's own\n * invalidation clears overlay entries.\n *\n * The tombstone prevents the immutable seed from being served after\n * invalidation — without it, a handler.invalidate that clears the overlay\n * would expose the (now-stale) build artifact on the next request.\n *\n * Ensures the manifest is loaded first so cold-process actions that\n * invalidate before any page render still write tombstones.\n */\nexport async function writeTombstonesForTag(tag: string): Promise<void> {\n  if (!tagIndex) {\n    await ensureManifestLoaded();\n  }\n  if (!tagIndex) return;\n  const seeds = tagIndex.get(tag);\n  if (!seeds || seeds.length === 0) return;\n\n  const handler = getCacheHandler();\n  const tombstone: ComponentTombstoneRecord = { _t: 'ct' };\n\n  await Promise.all(\n    seeds.map((seed) => {\n      const key = overlayKey(seed.componentId, seed.cacheKey);\n      return handler.set(key, tombstone, {\n        ttl: DEPLOY_LONG_TTL_SECONDS,\n        tags: [tag],\n      });\n    })\n  );\n}\n\n// ─── ISR build diagnostic ────────────────────────────────────────────────\n\nlet isrDiagnosticEmitted = false;\n\nfunction emitIsrDiagnosticIfNeeded(manifest: PrebuiltManifest): void {\n  if (isrDiagnosticEmitted) return;\n\n  const handler = getCacheHandler();\n  const isMemoryBased = handler instanceof MemoryCacheHandler || !isCacheHandlerConfigured();\n  if (!isMemoryBased) return;\n\n  for (const [, component] of Object.entries(manifest)) {\n    if (!component || typeof component !== 'object' || !('entries' in component)) continue;\n    for (const [, entry] of Object.entries(component.entries)) {\n      if (entry.tags && entry.tags.length > 0) {\n        isrDiagnosticEmitted = true;\n        console.warn(\n          '[timber] tag revalidation of prerendered components requires a shared cache ' +\n            'handler in multi-instance deployments. The current MemoryCacheHandler is ' +\n            'per-process — revalidateTag on one instance will not purge the build seed ' +\n            'on others. Configure a shared handler (Redis, KV) for production ISR.'\n        );\n        return;\n      }\n    }\n  }\n}\n\n/**\n * Reset the diagnostic flag (for tests).\n * @internal\n */\nexport function resetIsrDiagnostic(): void {\n  isrDiagnosticEmitted = false;\n}\n\n// ─── Encoding helpers ────────────────────────────────────────────────────\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  return Buffer.from(bytes).toString('base64');\n}\n\nfunction base64ToBytes(b64: string): Uint8Array {\n  return new Uint8Array(Buffer.from(b64, 'base64'));\n}\n","import type { CacheOptions } from './index.ts';\nimport type { PrebuiltComponentOptions } from '../server/prebuilt-runtime.ts';\nimport { createCache } from './timber-cache.ts';\nimport { getCacheHandler } from './handler-store.ts';\nimport { recordInvalidation } from './invalidation-epoch.ts';\nimport { writeTombstonesForTag } from '../server/prebuilt/overlay.ts';\nimport { getCdnPurgeHandler } from '../cdn/purge-store.ts';\n\nconst componentFallbackWarned = new WeakSet<object>();\n\n/**\n * Cache namespace — `cache.data`, `cache.component`, `cache.invalidate`.\n *\n * ```ts\n * import { cache } from '@timber-js/app/cache';\n *\n * const getUser = cache.data(\n *   async (id: string) => db.users.findUnique({ where: { id } }),\n *   { ttl: 60, tags: (id) => [`user:${id}`] }\n * );\n * ```\n */\nexport const cache = {\n  /**\n   * Wrap an async function with cross-request caching.\n   *\n   * The configured cache handler (defaults to MemoryCacheHandler, overridable\n   * via timber.config.ts) is re-resolved on every call, so module-scope\n   * wrappers created before `setCacheHandler()` still pick up the configured\n   * handler (TIM-1029).\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  data<Fn extends (...args: any[]) => Promise<any>>(\n    fn: Fn,\n    opts: CacheOptions<Fn>,\n    stableId?: string\n  ): Fn {\n    return createCache(fn, opts, getCacheHandler, stableId);\n  },\n\n  /**\n   * Invalidate cache entries by tag or key.\n   *\n   * ```ts\n   * cache.invalidate({ tag: 'products' });\n   * cache.invalidate({ key: 'user:abc' });\n   * ```\n   */\n  async invalidate(opts: { key?: string; tag?: string }): Promise<void> {\n    // Record before the handler delete so a cached fn in flight skips its\n    // post-resolve set instead of resurrecting the invalidated value (TIM-1028).\n    recordInvalidation(opts);\n    await getCacheHandler().invalidate(opts);\n    // Write tombstones for build-seed entries carrying the tag (design/45\n    // §ISR mechanics). Runs AFTER handler.invalidate so the tombstone\n    // overwrites the cleared overlay slot. This covers ALL invalidation\n    // paths — actions, webhooks, route handlers — not just executeAction.\n    if (opts.tag) {\n      await writeTombstonesForTag(opts.tag);\n    }\n    // Trigger CDN purge if a handler is configured (design/25 §Layer 2).\n    // Purge is best-effort: a CDN API failure or timeout must not block\n    // cache invalidation. 10s ceiling prevents a hung CDN API from stalling\n    // the entire revalidateTag/action flow.\n    if (opts.tag) {\n      const purgeHandler = getCdnPurgeHandler();\n      if (purgeHandler) {\n        try {\n          await Promise.race([\n            purgeHandler.purgeTags([opts.tag]),\n            new Promise<void>((_, reject) =>\n              setTimeout(() => reject(new Error('CDN purge timed out (10s)')), 10_000)\n            ),\n          ]);\n        } catch (err) {\n          console.error('[timber] CDN purge failed for tag:', err);\n        }\n      }\n    }\n  },\n\n  /**\n   * Runtime fallback for `cache.component(...)` callsites the timber-prebuilt\n   * transform does not rewrite — nested/computed/argument-position forms (see\n   * plugins/prebuilt.ts). Only module-scope `const X = cache.component(...)`\n   * declarations are transformed and eligible for prebuilding; everything else\n   * lands here, warns once per component, and renders dynamically. Same\n   * safety-net pattern as the data cache's runtime fnId fallback (TIM-1054):\n   * an untraceable callsite degrades in performance, never in correctness.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  component<C extends (props: any) => unknown>(\n    componentFn: C,\n    _options?: PrebuiltComponentOptions\n  ): C {\n    if (!componentFallbackWarned.has(componentFn)) {\n      componentFallbackWarned.add(componentFn);\n      const name = componentFn.name || 'anonymous component';\n      console.warn(\n        `[timber] cache.component: \"${name}\" was not transformed at build time — ` +\n          `rendering dynamically. Only module-scope declarations ` +\n          `(const X = cache.component(...)) are prebuilt.`\n      );\n    }\n    return componentFn;\n  },\n};\n"],"mappings":"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"}