@timber-js/app 0.2.0-alpha.204 → 0.2.0-alpha.205

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

@@ -23,7 +23,6 @@ import { getCspNonce } from '../csp-nonce.ts';
 import { renderDenyPage, renderDenyPageAsRsc } from '../deny-renderer.ts';
 import type { DefaultPageRenderer, LayoutEntry } from '../deny-renderer.ts';
 import type { NavContext } from '../ssr-bridge-types.ts';
-import { createDebugChannelSink } from './helpers.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { withPublishedParams } from '../publish-params.ts';
 import { getCookiesForSsr } from '../cookie-context.ts';
@@ -291,7 +290,6 @@ async function renderErrorPageViaRsc(
       onError(err: unknown) {
         logRenderError({ method: req.method, path: url.pathname, error: err });
       },
-      debugChannel: createDebugChannelSink(),
     });
 
     const [ssrStream, inlineStream] = teeWithErrorPropagation(rscStream);
@@ -402,14 +400,7 @@ export async function renderNoMatchPage(
   const match: RouteMatch = { segments, segmentParams: {}, middlewareChain: [] };
 
   if (isRscRequest(req)) {
-    return renderDenyPageAsRsc(
-      deny,
-      segments,
-      layoutComponents,
-      req,
-      responseHeaders,
-      createDebugChannelSink
-    );
+    return renderDenyPageAsRsc(deny, segments, layoutComponents, req, responseHeaders);
   }
 
   return renderDenyPage(
@@ -420,7 +411,6 @@ export async function renderNoMatchPage(
     match,
     responseHeaders,
     clientBootstrap,
-    createDebugChannelSink,
     callSsr,
     defaultPage
   );

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

@@ -5,104 +5,12 @@
  */
 
 import type { ManifestSegmentNode } from '../route-matcher.ts';
-import { swallow } from '../logger.ts';
 import { computeSegmentKeys, computeSegmentTreePaths } from '../../routing/segment-keys.ts';
 import type { SegmentInfo } from '../../shared/segment-info.ts';
 import type { SlotSkipEntry } from '../slot-resolver.ts';
 import { isClientReference } from '../utils/element-type.ts';
 import { isStaticRequestDependent } from '../request-dep.ts';
 
-/**
- * No-op — returns undefined so no debugChannel is passed to Flight.
- * Debug rows ride the main stream inline (React's default behavior).
- *
- * Production Flight emits no debug rows. In dev, inline debug rows
- * are handled by the Flight client for owner stack resolution.
- *
- * A writable-only debugChannel triggers a react-server-dom-webpack
- * >=19.3.0 Flight client regression (owner/stack refs parsed after
- * stream close produce "Connection closed" errors).
- */
-export function createDebugChannelSink(): undefined {
-  return undefined;
-}
-
-// ─── Debug Channel Collector (dev mode only) ────────────────────────────
-
-/**
- * Parsed component debug info extracted from the Flight debug channel.
- *
- * Contains only component names, environment labels, and stack frames —
- * never source code or props. See design/13-security.md §"Server source
- * never reaches the client".
- */
-export interface DebugComponentEntry {
-  name: string;
-  env: string | null;
-  key: string | null;
-  stack: unknown[] | null;
-}
-
-/**
- * Parse React Flight debug rows into component entries.
- *
- * The Flight debug channel writes rows in `hexId:json\n` format. Each row
- * with a JSON object containing a `name` field is a component debug info
- * entry. Rows without `name` (timing rows, reference rows like `D"$id"`)
- * are skipped.
- *
- * Security: `props` are explicitly stripped from parsed entries — they may
- * contain rendered output or user data. Only `name`, `env`, `key`, and
- * `stack` are retained.
- */
-export function parseDebugRows(text: string): DebugComponentEntry[] {
-  if (!text) return [];
-
-  const entries: DebugComponentEntry[] = [];
-  const lines = text.split('\n');
-
-  for (const line of lines) {
-    if (!line) continue;
-
-    // Flight row format: hexId:payload
-    const colonIdx = line.indexOf(':');
-    if (colonIdx === -1) continue;
-
-    let payload = line.slice(colonIdx + 1);
-
-    // React Flight debug rows may have a type-tag prefix before the JSON
-    // object (e.g., "D{...}" for debug info rows). Strip the single-char
-    // tag so the JSON parser sees the object. Non-JSON payloads like
-    // D"$a" reference rows are caught by the JSON.parse try/catch below.
-    // See TIM-556.
-    if (payload.length > 0 && payload[0] !== '{' && payload[0] !== '[' && payload[0] !== '"') {
-      payload = payload.slice(1);
-    }
-
-    // Skip payloads that still aren't JSON objects after tag stripping
-    if (!payload.startsWith('{')) continue;
-
-    try {
-      const parsed = JSON.parse(payload);
-      if (typeof parsed !== 'object' || parsed === null) continue;
-      if (typeof parsed.name !== 'string') continue;
-
-      // Strip props — may contain source-derived data or user data.
-      // Only retain: name, env, key, stack.
-      entries.push({
-        name: parsed.name,
-        env: parsed.env ?? null,
-        key: parsed.key ?? null,
-        stack: Array.isArray(parsed.stack) ? parsed.stack : null,
-      });
-    } catch (e) {
-      swallow(e, 'malformed JSON in RSC client reference row');
-    }
-  }
-
-  return entries;
-}
-
 /**
  * Build segment metadata for the X-Timber-Segments response header.
  * Describes the rendered segment chain with request-dependency status,

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

@@ -60,7 +60,6 @@ import { renderNoMatchPage } from './error-renderer.ts';
 import { renderRoute } from './render-route.ts';
 import { isDebug, isDevMode, setDebugFromConfig } from '../debug.ts';
 import { setSourceMapCallback } from '../dev-source-map.ts';
-import { requestContextAls } from '../als-registry.ts';
 import { capturePrebuiltPayloads } from '../prebuilt-builder.ts';
 import { setPrebuiltPayloadSource } from '../prebuilt/payload-source.ts';
 import { setRscFunctions, setComponentRefreshTimeout } from '../prebuilt-runtime.ts';
@@ -97,10 +96,6 @@ export function setDevSourceMapHandler(handler: (error: Error) => void): void {
   setSourceMapCallback(handler);
 }
 
-// Dev-only: debug components getter is stored per-request in ALS
-// (RequestContextStore.debugComponentsGetter) to avoid cross-request
-// race conditions. See TIM-557.
-
 /**
  * Create the RSC request handler from the route manifest.
  *
@@ -299,7 +294,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
           rootSegment: manifest.root,
           buildManifest: typedBuildManifest,
           globalError: manifest.globalError,
-          devDebugRegistry: pipelineConfig.devDebugRegistry,
         },
         interception
       );
@@ -351,14 +345,7 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     onPipelineError: isDev
       ? (error: Error, phase: string) => {
           if (pipelineConfig.devPipelineErrorHandler) {
-            // For render-phase errors, include RSC debug component data
-            // from the Flight debug channel (if available from the current request).
-            const store = requestContextAls.getStore();
-            const debugComponents =
-              phase === 'render' && store?.debugComponentsGetter
-                ? store.debugComponentsGetter()
-                : undefined;
-            pipelineConfig.devPipelineErrorHandler(error, phase, debugComponents);
+            pipelineConfig.devPipelineErrorHandler(error, phase);
           }
         }
       : undefined,

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

@@ -35,13 +35,12 @@ import { buildRouteElement, NoPageComponentError } from '../route-element-builde
 import { ParamCoercionError } from '../param-coercion.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import { recordTiming } from '../server-timing.ts';
-import { requestContextAls } from '../als-registry.ts';
 import { parseClientStateTree } from '../state-tree-diff.ts';
 
 import { getFirstDeniedSegmentIndex } from '../deny-boundary.ts';
 import { handleApiRoute } from './api-handler.ts';
 import { renderErrorPage, renderNoMatchPage } from './error-renderer.ts';
-import { buildRedirectResponse, createDebugChannelSink } from './helpers.ts';
+import { buildRedirectResponse } from './helpers.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { buildRscPayloadResponse } from './rsc-payload.ts';
 import { renderRscStream } from './rsc-stream.ts';
@@ -60,7 +59,6 @@ export interface RenderRouteDeps {
   rootSegment: ManifestSegmentNode;
   buildManifest: BuildManifest;
   globalError?: { load: () => Promise<unknown>; filePath: string };
-  devDebugRegistry?: import('../../dev-tools/debug-channel.ts').DebugChannelRegistry;
 }
 
 /**
@@ -199,24 +197,8 @@ export async function renderRoute(
 
   // Render to RSC Flight stream with signal tracking.
   const _rscStart = performance.now();
-  // 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
-  );
+  const { rscStream, signals } = renderRscStream(payload, req, leafDenyChain);
 
-  // Store the debug components getter in ALS so onPipelineError can
-  // include component tree context for render-phase errors (dev mode only).
-  // Per-request via ALS — no cross-request race. See TIM-557.
-  const alsStore = requestContextAls.getStore();
-  if (alsStore) {
-    alsStore.debugComponentsGetter = getDebugComponents;
-  }
   recordTiming({
     name: 'rsc-init',
     dur: Math.round(performance.now() - _rscStart),
@@ -239,7 +221,6 @@ export async function renderRoute(
         layoutComponents as LayoutEntry[],
         req,
         responseHeaders,
-        createDebugChannelSink,
         getFirstDeniedSegmentIndex()
       );
     }
@@ -251,7 +232,6 @@ export async function renderRoute(
       match,
       responseHeaders,
       clientBootstrap,
-      createDebugChannelSink,
       callSsr,
       undefined,
       getFirstDeniedSegmentIndex()
@@ -310,6 +290,5 @@ export async function renderRoute(
     deferSuspenseFor,
     globalError,
     slotSkipInfo,
-    debugRequestId,
   });
 }

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

@@ -26,7 +26,7 @@ import type { LayoutComponentEntry } from '../route-element-builder.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import type { SlotSkipEntry } from '../slot-resolver.ts';
 
-import { buildRedirectResponse, buildSegmentInfo, createDebugChannelSink } from './helpers.ts';
+import { buildRedirectResponse, buildSegmentInfo } from './helpers.ts';
 import { RSC_CONTENT_TYPE } from '../../shared/rsc-media-type.ts';
 
 import { rscErrorEnvelope } from '../rsc-error-envelope.ts';
@@ -178,7 +178,6 @@ export async function buildRscPayloadResponse(
       layoutComponents as LayoutEntry[],
       req,
       responseHeaders,
-      createDebugChannelSink,
       getDeniedIdx()
     );
   }

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

@@ -27,8 +27,7 @@ import {
 } from '../primitives.ts';
 import { checkAndWarnRscPropError } from '../rsc-prop-warnings.ts';
 
-import { isAbortError, type DebugComponentEntry } from './helpers.ts';
-import type { DebugChannelRegistry } from '../../dev-tools/debug-channel.ts';
+import { isAbortError } from './helpers.ts';
 import { isDebug } from '../debug.ts';
 import { isDevMode } from '../debug.ts';
 
@@ -78,10 +77,6 @@ export interface RenderSignals {
 export interface RscStreamResult {
   rscStream: ReadableStream<Uint8Array> | undefined;
   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;
 }
 
 /**
@@ -98,8 +93,7 @@ export interface RscStreamResult {
 export function renderRscStream(
   payload: RscPayloadRoot,
   req: Request,
-  leafDenyChain?: DenyPageEntry[],
-  devDebugRegistry?: DebugChannelRegistry
+  leafDenyChain?: DenyPageEntry[]
 ): RscStreamResult {
   const signals: RenderSignals = {
     denySignal: null,
@@ -111,14 +105,6 @@ export function renderRscStream(
 
   let rscStream: ReadableStream<Uint8Array> | undefined;
 
-  // No debugChannel — debug rows ride the main RSC stream inline.
-  // Production Flight emits none. In dev, the browser Flight client
-  // handles inline debug rows for owner stack resolution (React's
-  // default behavior). A writable-only debugChannel triggers a
-  // react-server-dom-webpack >=19.3.0 Flight client regression.
-  const debugChannel = undefined;
-  const debugRequestId = undefined;
-
   try {
     rscStream = renderToReadableStream(
       payload,
@@ -243,7 +229,6 @@ export function renderRscStream(
             errorId,
           });
         },
-        debugChannel,
       },
       {
         onClientReference(info: { id: string; name: string; deps: unknown }) {
@@ -272,16 +257,5 @@ export function renderRscStream(
     }
   }
 
-  return {
-    rscStream,
-    signals,
-    // 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:
-      debugChannel && 'getComponents' in debugChannel
-        ? (debugChannel as { getComponents: () => DebugComponentEntry[] }).getComponents
-        : undefined,
-    debugRequestId,
-  };
+  return { rscStream, signals };
 }

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

@@ -27,12 +27,7 @@ import type { SlotSkipEntry } from '../slot-resolver.ts';
 import type { NavContext } from '../ssr-bridge-types.ts';
 
 import { htmlEscapeJsonString } from '../flight-scripts.ts';
-import {
-  buildRedirectResponse,
-  buildSegmentInfo,
-  createDebugChannelSink,
-  isAbortError,
-} from './helpers.ts';
+import { buildRedirectResponse, buildSegmentInfo, isAbortError } from './helpers.ts';
 import { getCookiesForSsr } from '../cookie-context.ts';
 import { getDenyStatus, getFirstDeniedSegmentIndex } from '../deny-boundary.ts';
 import { renderErrorPage, type GlobalErrorFile } from './error-renderer.ts';
@@ -105,7 +100,6 @@ interface SsrRenderOptions {
   /** Tier 2 global-error.tsx file, if present in app/. */
   globalError?: GlobalErrorFile;
   slotSkipInfo?: SlotSkipEntry[];
-  debugRequestId?: string;
 }
 
 /**
@@ -198,12 +192,7 @@ 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)) +
-      // 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>`
-        : ''),
+      (clientJsDisabled ? '' : flightInitScript(nonce)),
     getHeadSegmentScript: clientJsDisabled
       ? undefined
       : () =>
@@ -250,7 +239,6 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
         match,
         responseHeaders,
         clientBootstrap,
-        createDebugChannelSink,
         callSsr,
         undefined,
         resolvedDeniedIndex()
@@ -437,7 +425,6 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
           match,
           responseHeaders,
           clientBootstrap,
-          createDebugChannelSink,
           callSsr,
           undefined,
           resolvedDeniedIndex()

package/src/server/slot-resolver.ts

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

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

@@ -65,10 +65,6 @@ 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> {
@@ -160,7 +156,7 @@ function ContainedSlotComponent(props: {
   fallback: ReactNode;
 }): ReactNode | Promise<ReactNode> {
   const { component: Component, componentProps, fallback } = props;
-  const containment: Containment = { fallback, opaque: undefined, wrapCount: 0 };
+  const containment: Containment = { fallback, opaque: undefined };
   let result: unknown;
   try {
     result = Component(componentProps);
@@ -208,16 +204,13 @@ 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,
+        ...(key !== null ? { key } : undefined),
       };
-      return createElement(
-        ContainedSlotComponent,
-        effectiveKey === null ? wrapped : { ...wrapped, key: effectiveKey }
-      );
+      return createElement(ContainedSlotComponent, wrapped);
     }
     // Host elements, fragments, Suspense, client references, providers, and
     // wrappers this walk already made: keep the type, contain whatever server
@@ -225,7 +218,23 @@ function walk(node: unknown, c: Containment, seen: WeakSet<object>): unknown {
     // slots).
     const nextProps = walk(props, c, seen);
     if (nextProps === props) return node;
-    return createElement(type, key === null ? nextProps : { ...(nextProps as object), key });
+    // JSX compiles `<Flex><A /><B /></Flex>` to separate createElement
+    // arguments that React does not key-validate, but the walk produces
+    // `{ children: [A, B] }` inside props — an array that React treats as
+    // dynamic and warns about missing keys. For 2+ children, spread them as
+    // separate arguments to restore the JSX calling convention. For 0–1
+    // children, pass the array as a single child argument to preserve the
+    // array shape — spreading `[x]` would collapse it to a bare element,
+    // breaking components that call `children.map()`.
+    const { children, ...rest } = nextProps as Record<string, unknown>;
+    const propsWithKey = key === null ? rest : { ...rest, key };
+    if (Array.isArray(children) && children.length > 1) {
+      return createElement(type, propsWithKey, ...(children as ReactNode[]));
+    }
+    if (children !== undefined) {
+      return createElement(type, propsWithKey, children as ReactNode);
+    }
+    return createElement(type, propsWithKey);
   }
 
   if (isPlainObject(node)) {
@@ -257,8 +266,7 @@ function walk(node: unknown, c: Containment, seen: WeakSet<object>): unknown {
 export function containSlotSubtree(
   tree: ReactNode,
   fallback: ReactNode,
-  opaque?: ReactNode,
-  slotName?: string
+  opaque?: ReactNode
 ): ReactNode {
-  return walk(tree, { fallback, opaque, slotName, wrapCount: 0 }, new WeakSet()) as ReactNode;
+  return walk(tree, { fallback, opaque }, new WeakSet()) as ReactNode;
 }

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"}