@timber-js/app 0.2.0-alpha.200 → 0.2.0-alpha.202

package/src/server/rsc-entry/error-renderer.ts

@@ -1,13 +1,9 @@
 /**
  * RSC Error & No-Match Renderers — handles error pages and 404s.
  *
- * All error pages (TSX and MDX) render through the RSC → SSR pipeline:
- * - TSX ('use client'): Error is converted to SerializableError, wrapped
- *   with ErrorReconstituter to reconstitute a real Error on the client.
- * - MDX (server component): Receives plain props ({ status }), no wrapper needed.
- *
- * This unified approach replaces the former SSR-only bypass for TSX error
- * pages. See design/spike-TIM-565-unify-error-pages.md for the full analysis.
+ * Error pages are 'use client' components rendered through the RSC → SSR
+ * pipeline: the Error is converted to SerializableError, wrapped with
+ * ErrorReconstituter to reconstitute a real Error on the client.
  *
  * Design docs: 10-error-handling.md §"Three-Tier Error Page Rendering"
  */
@@ -38,7 +34,6 @@ import { ErrorReconstituter } from '../../client/error-reconstituter.tsx';
 import type { SerializableError } from '../../client/error-reconstituter.tsx';
 import { loadModule } from '../safe-load.ts';
 import { sourceMapError } from '../dev-source-map.ts';
-import { isMdxFilePath as isMdxFile } from '../utils/mdx-file.ts';
 import { defaultStatusPageResponse } from '../default-status-page.ts';
 import { rscErrorEnvelope } from '../rsc-error-envelope.ts';
 
@@ -60,8 +55,6 @@ interface ErrorFileResolution {
   component: (...args: unknown[]) => unknown;
   /** Index of the segment where the file was found */
   segmentIndex: number;
-  /** Whether the file is MDX (server component) */
-  isMdx: boolean;
 }
 
 /**
@@ -95,7 +88,6 @@ async function resolveErrorFile(
           return {
             component: mod.default as (...args: unknown[]) => unknown,
             segmentIndex: i,
-            isMdx: isMdxFile(specificFile.filePath),
           };
         }
       }
@@ -108,7 +100,6 @@ async function resolveErrorFile(
           return {
             component: mod.default as (...args: unknown[]) => unknown,
             segmentIndex: i,
-            isMdx: isMdxFile(categoryFile.filePath),
           };
         }
       }
@@ -121,7 +112,6 @@ async function resolveErrorFile(
         return {
           component: mod.default as (...args: unknown[]) => unknown,
           segmentIndex: i,
-          isMdx: isMdxFile(segment.error.filePath),
         };
       }
     }
@@ -236,7 +226,7 @@ export async function renderErrorPage(
     return defaultStatusPageResponse(status, responseHeaders);
   }
 
-  const { component: errorComponent, segmentIndex, isMdx } = resolution;
+  const { component: errorComponent, segmentIndex } = resolution;
   const layoutsToWrap = getLayoutsForErrorFile(
     segments,
     layoutComponents,
@@ -247,7 +237,6 @@ export async function renderErrorPage(
   return renderErrorPageViaRsc(
     error,
     errorComponent,
-    isMdx,
     status,
     layoutsToWrap,
     req,
@@ -260,14 +249,12 @@ export async function renderErrorPage(
 /**
  * Render an error page through the RSC → SSR pipeline.
  *
- * Handles both TSX and MDX error pages:
- * - TSX: Wrapped with ErrorReconstituter to reconstitute Error on client
- * - MDX: Receives plain props ({ status }), rendered as server component
+ * Error pages are 'use client' components wrapped with ErrorReconstituter
+ * to reconstitute a real Error instance on the client.
  */
 async function renderErrorPageViaRsc(
   error: unknown,
   errorComponent: (...args: unknown[]) => unknown,
-  isMdx: boolean,
   status: number,
   layoutsToWrap: LayoutEntry[],
   req: Request,
@@ -278,26 +265,15 @@ async function renderErrorPageViaRsc(
   const h = createElement as (...args: unknown[]) => React.ReactElement;
   const url = new URL(req.url);
 
-  let element: React.ReactElement;
-
-  if (isMdx) {
-    // MDX error pages receive plain props — no Error serialization issue
-    element = h(errorComponent, { status });
-  } else {
-    // TSX error pages: wrap with ErrorReconstituter for Error reconstitution.
-    // The ErrorReconstituter is a 'use client' component that receives
-    // SerializableError (plain object) and reconstitutes a real Error
-    // before passing to the user's error component.
-    const serializedError = toSerializableError(error);
-    const digest = isRenderError(error) ? { code: error.code, data: error.digest.data } : null;
-
-    element = h(ErrorReconstituter, {
-      error: serializedError,
-      digest,
-      reset: undefined,
-      component: errorComponent,
-    });
-  }
+  const serializedError = toSerializableError(error);
+  const digest = isRenderError(error) ? { code: error.code, data: error.digest.data } : null;
+
+  let element: React.ReactElement = h(ErrorReconstituter, {
+    error: serializedError,
+    digest,
+    reset: undefined,
+    component: errorComponent,
+  });
 
   // Wrap in layouts
   for (let i = layoutsToWrap.length - 1; i >= 0; i--) {
@@ -358,7 +334,6 @@ async function renderErrorPageViaRsc(
  * Tier 2 — Render global-error.tsx as a standalone full-page replacement.
  *
  * No layout wrapping. The component must provide its own <html> and <body>.
- * All formats (TSX and MDX) go through RSC → SSR.
  *
  * See design/10-error-handling.md §"Tier 2 — Global Error Page"
  */
@@ -380,13 +355,10 @@ async function renderGlobalErrorPage(
   }
 
   const component = mod.default as (...args: unknown[]) => unknown;
-  const isMdx = isMdxFile(globalError.filePath);
 
-  // Reuse the unified RSC path with no layouts
   return renderErrorPageViaRsc(
     error,
     component,
-    isMdx,
     status,
     [], // No layouts — global-error is standalone
     req,

package/src/server/rsc-entry/helpers.ts

@@ -15,22 +15,21 @@ import { isStaticRequestDependent } from '../request-dep.ts';
 /**
  * Create a debug channel sink that discards all debug data.
  *
- * React Flight's dev mode serializes server component source code as `$E`
- * entries for DevTools. Without a separate debugChannel, this data is
- * embedded inline in the main RSC stream — leaking source code to the
- * browser. By providing a debug channel, debug data goes to a separate
- * stream that we drain and discard.
+ * Used in production to divert debug rows ($E source entries, component
+ * info) away from the main Flight stream. In dev mode, the debug channel
+ * is omitted entirely so debug rows (owner stacks) ride the main stream
+ * and reach the browser for console warning resolution.
  *
- * See design/13-security.md §"Server component source leak"
+ * Only provides `writable` — omitting `readable` avoids Flight's
+ * keepDebugAlive mode which holds deferred debug refs open per request.
  */
-export function createDebugChannelSink(): { readable: ReadableStream; writable: WritableStream } {
+export function createDebugChannelSink(): { writable: WritableStream } {
   const sink = new TransformStream();
   // Drain the readable side so the writable never back-pressures.
   sink.readable.pipeTo(new WritableStream()).catch(() => {});
-  return {
-    readable: new ReadableStream(), // no commands to send to Flight
-    writable: sink.writable,
-  };
+  // Only writable — omitting `readable` avoids Flight's keepDebugAlive
+  // mode which holds deferred debug refs open per request.
+  return { writable: sink.writable };
 }
 
 // ─── Debug Channel Collector (dev mode only) ────────────────────────────
@@ -49,62 +48,6 @@ export interface DebugComponentEntry {
   stack: unknown[] | null;
 }
 
-/**
- * A debug channel that collects Flight debug rows instead of discarding them.
- *
- * Used in dev mode to capture server component tree information for the
- * Vite error overlay. The collector provides the same `{ readable, writable }`
- * shape as the discard sink, plus methods to retrieve collected data.
- *
- * Security: only component names, environments, and stack frames are
- * extracted — props and source code are stripped. In production builds,
- * use `createDebugChannelSink()` instead (this function is never called).
- */
-export interface DebugChannelCollector {
-  readable: ReadableStream;
-  writable: WritableStream;
-  /** Get the raw collected text from the debug channel. */
-  getCollectedText(): string;
-  /** Get parsed component entries (names, stacks — no props or source). */
-  getComponents(): DebugComponentEntry[];
-}
-
-export function createDebugChannelCollector(): DebugChannelCollector {
-  const chunks: string[] = [];
-  const decoder = new TextDecoder();
-
-  const sink = new TransformStream();
-
-  // Collect chunks from the readable side instead of discarding them.
-  sink.readable
-    .pipeTo(
-      new WritableStream({
-        write(chunk: Uint8Array) {
-          chunks.push(decoder.decode(chunk, { stream: true }));
-        },
-        close() {
-          // Flush any remaining bytes in the decoder
-          const remaining = decoder.decode();
-          if (remaining) chunks.push(remaining);
-        },
-      })
-    )
-    .catch(() => {
-      // Stream abort — request cancelled. Not an error.
-    });
-
-  return {
-    readable: new ReadableStream(), // no commands to send to Flight
-    writable: sink.writable,
-    getCollectedText() {
-      return chunks.join('');
-    },
-    getComponents() {
-      return parseDebugRows(chunks.join(''));
-    },
-  };
-}
-
 /**
  * Parse React Flight debug rows into component entries.
  *

package/src/server/rsc-entry/index.ts

@@ -299,6 +299,7 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
           rootSegment: manifest.root,
           buildManifest: typedBuildManifest,
           globalError: manifest.globalError,
+          devDebugRegistry: pipelineConfig.devDebugRegistry,
         },
         interception
       );

package/src/server/rsc-entry/render-route.ts

@@ -60,6 +60,7 @@ export interface RenderRouteDeps {
   rootSegment: ManifestSegmentNode;
   buildManifest: BuildManifest;
   globalError?: { load: () => Promise<unknown>; filePath: string };
+  devDebugRegistry?: import('../../dev-tools/debug-channel.ts').DebugChannelRegistry;
 }
 
 /**
@@ -198,7 +199,16 @@ export async function renderRoute(
 
   // Render to RSC Flight stream with signal tracking.
   const _rscStart = performance.now();
-  const { rscStream, signals, getDebugComponents } = renderRscStream(payload, req, leafDenyChain);
+  // Only wire the HMR debug transport for HTML requests. RSC payload
+  // requests (client navigations) don't serve HTML with __timber_debug_id,
+  // so the browser can't subscribe — skip to avoid orphaned sessions.
+  const debugRegistry = isRscRequest(req) || clientJsDisabled ? undefined : deps.devDebugRegistry;
+  const { rscStream, signals, getDebugComponents, debugRequestId } = renderRscStream(
+    payload,
+    req,
+    leafDenyChain,
+    debugRegistry
+  );
 
   // Store the debug components getter in ALS so onPipelineError can
   // include component tree context for render-phase errors (dev mode only).
@@ -300,5 +310,6 @@ export async function renderRoute(
     deferSuspenseFor,
     globalError,
     slotSkipInfo,
+    debugRequestId,
   });
 }

package/src/server/rsc-entry/rsc-stream.ts

@@ -27,12 +27,8 @@ import {
 } from '../primitives.ts';
 import { checkAndWarnRscPropError } from '../rsc-prop-warnings.ts';
 
-import {
-  createDebugChannelSink,
-  createDebugChannelCollector,
-  isAbortError,
-  type DebugComponentEntry,
-} from './helpers.ts';
+import { createDebugChannelSink, isAbortError, type DebugComponentEntry } from './helpers.ts';
+import { createDevDebugChannel, type DebugChannelRegistry } from '../../dev-tools/debug-channel.ts';
 import { isDebug } from '../debug.ts';
 import { isDevMode } from '../debug.ts';
 
@@ -84,6 +80,8 @@ export interface RscStreamResult {
   signals: RenderSignals;
   /** Dev-only: server component debug info from the Flight debug channel. */
   getDebugComponents?: () => DebugComponentEntry[];
+  /** Dev-only: request ID for the debug channel HMR transport. */
+  debugRequestId?: string;
 }
 
 /**
@@ -100,7 +98,8 @@ export interface RscStreamResult {
 export function renderRscStream(
   payload: RscPayloadRoot,
   req: Request,
-  leafDenyChain?: DenyPageEntry[]
+  leafDenyChain?: DenyPageEntry[],
+  devDebugRegistry?: DebugChannelRegistry
 ): RscStreamResult {
   const signals: RenderSignals = {
     denySignal: null,
@@ -112,9 +111,18 @@ export function renderRscStream(
 
   let rscStream: ReadableStream<Uint8Array> | undefined;
 
-  // In dev mode, collect debug channel data for the error overlay.
-  // In production, use the discard sink (no overhead).
-  const debugChannel = isDevMode() ? createDebugChannelCollector() : createDebugChannelSink();
+  // Always provide a debugChannel to prevent $E source entries (which
+  // may contain bound-arg secrets) from leaking into the main stream.
+  //
+  // In dev mode with an HMR transport: use createDevDebugChannel which
+  // pipes debug data to the browser via WebSocket for owner stack
+  // resolution. In production (or dev without transport): use a sink
+  // that discards everything.
+  const debugChannel = devDebugRegistry
+    ? createDevDebugChannel(devDebugRegistry)
+    : createDebugChannelSink();
+  const debugRequestId =
+    'requestId' in debugChannel ? (debugChannel as { requestId: string }).requestId : undefined;
 
   try {
     rscStream = renderToReadableStream(
@@ -128,20 +136,13 @@ export function renderRscStream(
           if (isDenySignal(error)) {
             // Late addressing (TIM-1450): a nested-component deny escapes
             // all in-tree catch sites and arrives here without owners.
-            // Resolve it against the leaf deny chain — when the first match
-            // is non-MDX, stamp the full candidate list so the client can
-            // find the first reachable owner via its ancestry context.
+            // Resolve it against the leaf deny chain and stamp the full
+            // candidate list so the client can find the first reachable
+            // owner via its ancestry context.
             if (!error.owners && leafDenyChain) {
               const entries = matchDenyEntries(leafDenyChain, error.status);
-              if (entries.length > 0 && !entries[0].isMdx) {
-                // Only non-MDX entries are addressable — MDX boundaries hold
-                // pre-rendered fallbackElements without runtime props. TIM-1451
-                // will widen exact-code MDX; until then they stay on the
-                // re-render fallback path.
-                const nonMdx = entries.filter((e) => !e.isMdx);
-                if (nonMdx.length > 0) {
-                  error.owners = nonMdx.map((e) => e.ownerKey);
-                }
+              if (entries.length > 0) {
+                error.owners = entries.map((e) => e.ownerKey);
               }
             }
             // First-wins: two concurrent denies from separately serialized
@@ -279,11 +280,13 @@ export function renderRscStream(
   return {
     rscStream,
     signals,
-    // Expose the debug channel collector's getComponents in dev mode.
-    // The caller can retrieve component tree info when handling errors.
+    // In production, the debug channel collector's getComponents is available.
+    // In dev mode, debug rows ride the main stream (no separate channel), so
+    // this is undefined — the error overlay uses stack traces directly.
     getDebugComponents:
       'getComponents' in debugChannel
         ? (debugChannel as { getComponents: () => DebugComponentEntry[] }).getComponents
         : undefined,
+    debugRequestId,
   };
 }

package/src/server/rsc-entry/ssr-renderer.ts

@@ -105,6 +105,7 @@ interface SsrRenderOptions {
   /** Tier 2 global-error.tsx file, if present in app/. */
   globalError?: GlobalErrorFile;
   slotSkipInfo?: SlotSkipEntry[];
+  debugRequestId?: string;
 }
 
 /**
@@ -197,7 +198,12 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
       clientBootstrap.preloadLinks +
       // Initialize __timber_f in <head> so it exists before any streaming
       // chunk scripts arrive in <body>. See flight-scripts.ts, LOCAL-415.
-      (clientJsDisabled ? '' : flightInitScript(nonce)),
+      (clientJsDisabled ? '' : flightInitScript(nonce)) +
+      // Embed the debug channel request ID so the browser can subscribe
+      // to the correct HMR debug stream for owner stack resolution.
+      (opts.debugRequestId && !clientJsDisabled
+        ? `<script${nonceAttr(nonce)}>self.__timber_debug_id=${htmlEscapeJsonString(JSON.stringify(opts.debugRequestId))}</script>`
+        : ''),
     getHeadSegmentScript: clientJsDisabled
       ? undefined
       : () =>

package/src/server/slot-resolver.ts

@@ -156,7 +156,12 @@ export async function resolveSlotElement(
             const rendered = await scope(() =>
               (SlotPage as (props: Record<string, unknown>) => unknown)(props)
             );
-            return containSlotSubtree(rendered as React.ReactNode, denyFallback);
+            return containSlotSubtree(
+              rendered as React.ReactNode,
+              denyFallback,
+              undefined,
+              slotNode.segmentName
+            );
           } catch (error) {
             // RedirectSignal must propagate — the pipeline handles redirects
             // at the top level. Swallowing it here would silently return
@@ -189,12 +194,20 @@ export async function resolveSlotElement(
         element,
         h,
         scope,
-        denyFallback
+        denyFallback,
+        slotNode.segmentName
       );
 
       // Wrap with slot root's layout — INSIDE the access gate, so the layout
       // server component never executes when access.ts denies. See TIM-1074.
-      element = await wrapWithLayout(slotNode, element, h, scope, denyFallback);
+      element = await wrapWithLayout(
+        slotNode,
+        element,
+        h,
+        scope,
+        denyFallback,
+        slotNode.segmentName
+      );
 
       // Wrap in SlotAccessGate if slot root has access.ts. The gate is
       // OUTSIDE the layout, matching the segment model in
@@ -290,7 +303,8 @@ async function wrapWithIntermediateSegments(
   element: React.ReactElement,
   h: CreateElementFn,
   scope?: SlotParamScope,
-  denyFallback?: React.ReactNode
+  denyFallback?: React.ReactNode,
+  slotName?: string
 ): Promise<React.ReactElement> {
   for (let i = chain.length - 1; i > 0; i--) {
     const seg = chain[i];
@@ -300,7 +314,7 @@ async function wrapWithIntermediateSegments(
       errorBoundaryComponent: TimberErrorBoundary,
       isSlotBoundary: true,
     });
-    element = await wrapWithLayout(seg, element, h, scope, denyFallback);
+    element = await wrapWithLayout(seg, element, h, scope, denyFallback, slotName);
     element = await wrapWithAccessGate(seg, element, h, scope);
   }
   return element;
@@ -341,10 +355,16 @@ function ScopedSlotLayout(props: {
   layout: (props: Record<string, unknown>) => unknown;
   scope: SlotParamScope;
   denyFallback: React.ReactNode;
+  slotName: string | undefined;
   children: React.ReactElement;
 }): unknown {
   const rendered = props.scope(() => props.layout({ children: props.children }));
-  return containSlotSubtree(rendered as React.ReactNode, props.denyFallback, props.children);
+  return containSlotSubtree(
+    rendered as React.ReactNode,
+    props.denyFallback,
+    props.children,
+    props.slotName
+  );
 }
 
 /**
@@ -362,7 +382,8 @@ async function wrapWithLayout(
   element: React.ReactElement,
   h: CreateElementFn,
   scope?: SlotParamScope,
-  denyFallback: React.ReactNode = null
+  denyFallback: React.ReactNode = null,
+  slotName?: string
 ): Promise<React.ReactElement> {
   if (!node.layout) return element;
   const Layout = await loadComponent(node.layout);
@@ -373,6 +394,7 @@ async function wrapWithLayout(
     layout: Layout as (props: Record<string, unknown>) => unknown,
     scope,
     denyFallback,
+    slotName,
     children: element,
   });
 }

package/src/server/slot-subtree-contain.ts

@@ -65,6 +65,10 @@ interface Containment {
    * so the level below is not wrapped (and re-walked) a second time.
    */
   opaque: unknown;
+  /** Slot name (e.g. `@artists`) used as a key prefix for wrapped elements. */
+  slotName?: string;
+  /** Monotonic counter for disambiguating same-name sibling components. */
+  wrapCount: number;
 }
 
 function isThenable(value: unknown): value is Thenable<unknown> {
@@ -156,7 +160,7 @@ function ContainedSlotComponent(props: {
   fallback: ReactNode;
 }): ReactNode | Promise<ReactNode> {
   const { component: Component, componentProps, fallback } = props;
-  const containment: Containment = { fallback, opaque: undefined };
+  const containment: Containment = { fallback, opaque: undefined, wrapCount: 0 };
   let result: unknown;
   try {
     result = Component(componentProps);
@@ -204,12 +208,16 @@ function walk(node: unknown, c: Containment, seen: WeakSet<object>): unknown {
     const { type, key, props } = node;
     const component = type === ContainedSlotComponent ? undefined : serverComponentOf(type);
     if (component) {
+      const effectiveKey = key ?? (c.slotName ? `${c.slotName}:${c.wrapCount++}` : null);
       const wrapped = {
         component,
         componentProps: props as Record<string, unknown>,
         fallback: c.fallback,
       };
-      return createElement(ContainedSlotComponent, key === null ? wrapped : { ...wrapped, key });
+      return createElement(
+        ContainedSlotComponent,
+        effectiveKey === null ? wrapped : { ...wrapped, key: effectiveKey }
+      );
     }
     // Host elements, fragments, Suspense, client references, providers, and
     // wrappers this walk already made: keep the type, contain whatever server
@@ -249,7 +257,8 @@ function walk(node: unknown, c: Containment, seen: WeakSet<object>): unknown {
 export function containSlotSubtree(
   tree: ReactNode,
   fallback: ReactNode,
-  opaque?: ReactNode
+  opaque?: ReactNode,
+  slotName?: string
 ): ReactNode {
-  return walk(tree, { fallback, opaque }, new WeakSet()) as ReactNode;
+  return walk(tree, { fallback, opaque, slotName, wrapCount: 0 }, new WeakSet()) as ReactNode;
 }

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

@@ -1 +0,0 @@
-{"version":3,"file":"build-manifest-DTmSGLRz.js","names":[],"sources":["../../src/server/csp-nonce.ts","../../src/server/build-manifest.ts"],"sourcesContent":["/**\n * CSP nonce — per-request, generated on demand.\n *\n * timber emits several inline `<script>` tags per HTML response — React's\n * bootstrap script and Fizz runtime, the Flight init/chunk scripts, the\n * segment-tree script, and the post-flush noindex script. Under a strict\n * `Content-Security-Policy` (`script-src 'nonce-…' 'strict-dynamic'`) every\n * one of them needs the request's nonce or the browser refuses to run it.\n *\n * The app opts in by reading `ctx.nonce` in `middleware.ts` and putting it\n * in the CSP header it sets through `ctx.headers`. The first read generates\n * the value and stores it on the request context; the render pipeline reads\n * it back with `getCspNonce()` and stamps it on every inline script. A\n * request whose middleware never reads `ctx.nonce` has no nonce, and its\n * markup is byte-identical to a render without this feature. timber does\n * not parse the CSP header — the app owns the policy, timber owns the\n * markup, and `ctx.nonce` is the one value both are built from.\n *\n * `proxy.ts` cannot participate: it only sees the finished response from\n * `next()`, after the markup exists.\n *\n * See design/13-security.md §\"Content Security Policy\" (TIM-1414).\n */\n\nimport { requestContextAls } from './als-registry.ts';\n\n/**\n * Generate a CSP nonce: 128 random bits, base64. Matches CSP's\n * `base64-value` grammar, so it is valid in the header verbatim and safe\n * inside a double-quoted HTML attribute without escaping.\n */\nfunction generateNonce(): string {\n  const bytes = crypto.getRandomValues(new Uint8Array(16));\n  let binary = '';\n  for (const b of bytes) binary += String.fromCharCode(b);\n  return btoa(binary);\n}\n\n/**\n * The request's CSP nonce, creating it on first call. Backs the\n * `ctx.nonce` getter on `MiddlewareContext`. Outside a request context\n * (tests, build-time rendering) a fresh value is returned but not\n * retained, since there is no request for it to belong to.\n */\nexport function requestCspNonce(): string {\n  const store = requestContextAls.getStore();\n  if (!store) return generateNonce();\n  store.cspNonce ??= generateNonce();\n  return store.cspNonce;\n}\n\n/**\n * The request's CSP nonce if middleware asked for one, else `undefined` —\n * in which case the pipeline emits bare `<script>` tags.\n */\nexport function getCspNonce(): string | undefined {\n  return requestContextAls.getStore()?.cspNonce;\n}\n\n/**\n * The ` nonce=\"…\"` attribute fragment for a timber-generated `<script>` tag,\n * or `''` when the request has no nonce. Callers interpolate it directly\n * after the tag name: `` `<script${nonceAttr(nonce)}>` ``.\n *\n * The value comes from `generateNonce` and is base64, so no attribute\n * escaping is required.\n */\nexport function nonceAttr(nonce: string | undefined): string {\n  return nonce ? ` nonce=\"${nonce}\"` : '';\n}\n","/**\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAS,gBAAwB;CAC/B,MAAM,QAAQ,OAAO,gCAAgB,IAAI,WAAW,EAAE,CAAC;CACvD,IAAI,SAAS;CACb,KAAK,MAAM,KAAK,OAAO,UAAU,OAAO,aAAa,CAAC;CACtD,OAAO,KAAK,MAAM;AACpB;;;;;;;AAQA,SAAgB,kBAA0B;CACxC,MAAM,QAAQ,kBAAkB,SAAS;CACzC,IAAI,CAAC,OAAO,OAAO,cAAc;CACjC,MAAM,aAAa,cAAc;CACjC,OAAO,MAAM;AACf;;;;;;;;;;;;;;;;ACeA,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"}