@timber-js/app 0.2.0-alpha.207 → 0.2.0-alpha.209

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

@@ -1,5 +1,6 @@
 /**
- * RSC Error & No-Match Renderers — handles error pages and 404s.
+ * RSC Error Renderer — handles error pages. (The 404 page for an unmatched
+ * URL is a deny page, assembled by `deny-fallback.ts`.)
  *
  * Error pages are 'use client' components rendered through the RSC → SSR
  * pipeline: the Error is converted to SerializableError, wrapped with
@@ -13,15 +14,14 @@ import { renderToReadableStream } from '../../rsc-runtime/rsc.ts';
 
 import type { RouteMatch } from '../pipeline.ts';
 import { logRenderError } from '../logger.ts';
+import { loadFallbackModule, reportRenderError } from '../pipeline-helpers.ts';
 import { appVisibleSearch } from '../../shared/rsc-cache-key.ts';
-import { getSlotParamsForClient } from '../request-context.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
-import { isRenderError, DenySignal, RenderError } from '../primitives.ts';
+import { errorDigestId } from '../../shared/error-digest.ts';
 import type { ClientBootstrapConfig } from '../html-injectors.ts';
 import { flightInitScript, htmlEscapeJsonString } from '../flight-scripts.ts';
 import { getCspNonce } from '../csp-nonce.ts';
-import { renderDenyPage, renderDenyPageAsRsc } from '../deny-renderer.ts';
-import type { DefaultPageRenderer, LayoutEntry } from '../deny-renderer.ts';
+import type { LayoutEntry } from '../deny-renderer.ts';
 import type { NavContext } from '../ssr-bridge-types.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { withPublishedParams } from '../publish-params.ts';
@@ -31,8 +31,7 @@ import { teeWithErrorPropagation } from '../stream-utils.ts';
 import { isDevMode } from '../debug.ts';
 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 type { ManifestLoader } from '../safe-load.ts';
 import { defaultStatusPageResponse } from '../default-status-page.ts';
 import { rscErrorEnvelope } from '../rsc-error-envelope.ts';
 
@@ -67,6 +66,7 @@ interface ErrorFileResolution {
 async function resolveErrorFile(
   status: number,
   segments: ManifestSegmentNode[],
+  load: (file: ManifestLoader) => Promise<Record<string, unknown> | null>,
   maxIndex?: number
 ): Promise<ErrorFileResolution | null> {
   const start =
@@ -79,10 +79,11 @@ async function resolveErrorFile(
       const statusKey = String(status);
       const specificFile = segment.statusFiles[statusKey];
       if (specificFile) {
-        // .catch: if the error page module itself fails to load (syntax error,
-        // missing file), fall through to next tier instead of recursive failure.
+        // `load` returns null when the error page module itself fails to
+        // load (syntax error, missing file), after reporting it, so the next
+        // tier answers instead of a recursive failure.
         // See TIM-584, design/spike-TIM-551-dynamic-import-audit.md §H1.
-        const mod = await loadModule(specificFile).catch(() => null);
+        const mod = await load(specificFile);
         if (mod?.default) {
           return {
             component: mod.default as (...args: unknown[]) => unknown,
@@ -94,7 +95,7 @@ async function resolveErrorFile(
       // Check 5xx.tsx category catch-all
       const categoryFile = segment.statusFiles['5xx'];
       if (categoryFile && status >= 500 && status <= 599) {
-        const mod = await loadModule(categoryFile).catch(() => null);
+        const mod = await load(categoryFile);
         if (mod?.default) {
           return {
             component: mod.default as (...args: unknown[]) => unknown,
@@ -106,7 +107,7 @@ async function resolveErrorFile(
 
     // Check error.tsx
     if (segment.error) {
-      const mod = await loadModule(segment.error).catch(() => null);
+      const mod = await load(segment.error);
       if (mod?.default) {
         return {
           component: mod.default as (...args: unknown[]) => unknown,
@@ -154,7 +155,7 @@ function toSerializableError(error: unknown): SerializableError {
 }
 
 /**
- * Render an error page for unhandled throws or RenderError outside Suspense.
+ * Render an error page for an unhandled throw outside Suspense.
  *
  * All error pages (TSX and MDX) go through RSC → SSR:
  * - TSX: ErrorReconstituter wrapper converts SerializableError → real Error
@@ -164,13 +165,13 @@ function toSerializableError(error: unknown): SerializableError {
  * envelope instead. Every tier below produces an HTML document, and the
  * client's Flight decoder is waiting for `text/x-component`; handing it HTML
  * crashes the decode. The check lives here rather than at the call sites
- * because it holds for all five of them, and the deny path's equivalent split
- * (`renderDenyPage` / `renderDenyPageAsRsc`) had already been forgotten at one
- * of this function's — the synchronous render-error exit in `render-route.ts`
- * (TIM-1322). Four of the five are unreachable for an RSC request today
- * (`render-route.ts` returns the payload before it reaches SSR, and
- * `outcomeToResponse` answers RSC errors itself), so this fires on one path
- * and guards the rest against drift.
+ * because it holds for every one of them, and the deny path's equivalent split
+ * (the deny fallback's page / Flight branches) had already been forgotten at one
+ * of this function's — a since-deleted synchronous render-error exit in
+ * `render-route.ts` (TIM-1322). Neither remaining caller is reachable for an
+ * RSC request today (`render-route.ts` returns the payload before it reaches
+ * SSR, and `outcomeToResponse` answers RSC errors itself), so this guards
+ * against drift rather than firing on a live path.
  */
 export async function renderErrorPage(
   error: unknown,
@@ -184,24 +185,25 @@ export async function renderErrorPage(
   globalError?: GlobalErrorFile,
   firstDeniedIndex = Infinity
 ): Promise<Response> {
-  // The error itself is not logged here — every producer of a `renderError`
-  // signal already logged it at the point it was caught (`rsc-stream.ts`'s
-  // `onError`, `outcomeToResponse`), so a log on this exit would double up.
+  // The error itself is not logged here — every producer already logged it
+  // where it was caught, so a log on this exit would double up: `rsc-stream.ts`'s
+  // `onError` for an error the RSC render threw, Fizz's `onError`
+  // (`ssr-render.ts`) for a shell error SSR threw itself, `outcomeToResponse`
+  // for a pipeline error. Each of them is also the error's one
+  // `onRequestError` report, except Fizz's, which reaches no hook; see
+  // design/17 §"Which errors reach it".
   if (isRscRequest(req)) {
     return rscErrorEnvelope(status, responseHeaders);
   }
 
-  // Source-map the error's stack trace in dev mode so the error page
-  // shows original source positions instead of transpiled/bundled ones.
-  // See TIM-811.
-  sourceMapError(error);
   // Walk segments from leaf to root to find the error component.
   // When firstDeniedIndex is finite, bound the walk so error files below
   // the denied segment are not selected — matching the deny renderer's
   // behavior. For plain errors (firstDeniedIndex = Infinity), the full
   // chain is searched. See TIM-1358.
   const errorMaxIndex = firstDeniedIndex < Infinity ? firstDeniedIndex : undefined;
-  const resolution = await resolveErrorFile(status, segments, errorMaxIndex);
+  const load = (file: ManifestLoader) => loadFallbackModule(file, req, segments);
+  const resolution = await resolveErrorFile(status, segments, load, errorMaxIndex);
 
   // Tier 2: No segment-level error file — try global-error.tsx
   if (!resolution && globalError) {
@@ -265,7 +267,9 @@ async function renderErrorPageViaRsc(
   const url = new URL(req.url);
 
   const serializedError = toSerializableError(error);
-  const digest = isRenderError(error) ? { code: error.code, data: error.digest.data } : null;
+  // The ID the server logged this error with, when it crossed Flight — a
+  // shell crash SSR relays here. A pipeline error has none.
+  const digest = errorDigestId(error);
 
   let element: React.ReactElement = h(ErrorReconstituter, {
     error: serializedError,
@@ -288,22 +292,16 @@ async function renderErrorPageViaRsc(
     const rscStream = renderToReadableStream(withPublishedParams(element), {
       signal: req.signal,
       onError(err: unknown) {
-        logRenderError({ method: req.method, path: url.pathname, error: err });
+        reportRenderError(err, req, { segments: match.segments });
       },
     });
 
     const [ssrStream, inlineStream] = teeWithErrorPropagation(rscStream);
 
-    // Params ride the payload root, beside the tree, so there is no
-    // bootstrap script. Read here for the SSR-side ALS context below.
-    const slotParams = getSlotParamsForClient();
-
     const nonce = getCspNonce();
     const navContext: NavContext = {
       pathname: url.pathname,
       search: appVisibleSearch(url).search,
-      segmentParams: match.segmentParams,
-      slotParams,
       statusCode: status,
       responseHeaders,
       headHtml: flightInitScript(nonce),
@@ -317,7 +315,7 @@ async function renderErrorPageViaRsc(
     // `await` inside the try on purpose: SSR of the error page fails
     // asynchronously far more often than synchronously, and returning the
     // promise bare let every such rejection escape this guard.
-    return await callSsr(ssrStream, navContext);
+    return (await callSsr(ssrStream, navContext)).response;
   } catch (renderError) {
     // The error page itself failed to render — guards against recursive
     // errors in user error page code. Terminates in the framework default
@@ -344,10 +342,10 @@ async function renderGlobalErrorPage(
   responseHeaders: Headers,
   clientBootstrap: ClientBootstrapConfig
 ): Promise<Response> {
-  // .catch: if global-error.tsx fails to load or exports no component, it is
-  // not a usable Tier 2 match — fall through to the framework default page
-  // rather than a blank body. See TIM-584, TIM-1258.
-  const mod = await loadModule(globalError).catch(() => null);
+  // If global-error.tsx fails to load (reported) or exports no component, it
+  // is not a usable Tier 2 match — fall through to the framework default
+  // page rather than a blank body. See TIM-584, TIM-1258.
+  const mod = await loadFallbackModule(globalError, req, match.segments);
   if (!mod?.default) {
     return defaultStatusPageResponse(status, responseHeaders);
   }
@@ -365,53 +363,3 @@ async function renderGlobalErrorPage(
     clientBootstrap
   );
 }
-
-/**
- * Render a 404 page for URLs that don't match any route.
- *
- * Uses the root segment's 404.tsx (or 4xx.tsx / error.tsx fallback)
- * wrapped in the root layout, via the same renderDenyPage path
- * used for in-route deny() calls.
- */
-export async function renderNoMatchPage(
-  req: Request,
-  rootSegment: ManifestSegmentNode,
-  responseHeaders: Headers,
-  clientBootstrap: ClientBootstrapConfig,
-  defaultPage?: DefaultPageRenderer
-): Promise<Response> {
-  const segments = [rootSegment];
-
-  // Load root layout if present. A layout that fails to import or evaluate
-  // must not take the 404 down with it — render the status page unwrapped,
-  // as renderFallbackError does for the same reason.
-  const layoutComponents: LayoutEntry[] = [];
-  if (rootSegment.layout) {
-    const mod = await loadModule(rootSegment.layout).catch(() => null);
-    if (mod?.default) {
-      layoutComponents.push({
-        component: mod.default as (...args: unknown[]) => unknown,
-        segment: rootSegment,
-      });
-    }
-  }
-
-  const deny = new DenySignal(404);
-  const match: RouteMatch = { segments, segmentParams: {}, middlewareChain: [] };
-
-  if (isRscRequest(req)) {
-    return renderDenyPageAsRsc(deny, segments, layoutComponents, req, responseHeaders);
-  }
-
-  return renderDenyPage(
-    deny,
-    segments,
-    layoutComponents,
-    req,
-    match,
-    responseHeaders,
-    clientBootstrap,
-    callSsr,
-    defaultPage
-  );
-}

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

@@ -106,10 +106,8 @@ export function buildSegmentInfo(
 }
 
 // Re-export consolidated helpers from their single source of truth.
-// Callers within rsc-entry/ import from this file; the implementations
-// live in pipeline-helpers.ts (buildRedirectResponse) and render-utils.ts
-// (isAbortError). See TIM-1071 item 1.
-export { buildRedirectResponse } from '../pipeline-helpers.ts';
+// Callers within rsc-entry/ import from this file; the implementation
+// lives in render-utils.ts. See TIM-1071 item 1.
 export { isAbortError } from '../render-utils.ts';
 
 // escapeHtml is now imported from server/utils/escape-html.ts

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

@@ -40,6 +40,7 @@ import globalSchemaCodecs from 'virtual:timber-schema';
 
 import { wrapPipelineWithActionDispatch, buildActionDispatcher } from './wrap-action-dispatch.ts';
 import type { BodyLimitsConfig } from '../body-limits.ts';
+import type { DevHooks } from '../../dev-tools/dev-page-shell.ts';
 import type { BuildManifest } from '../build-manifest.ts';
 import { resolveLogMode } from '../../dev-tools/logger.ts';
 import { sendEarlyHints103 } from '../early-hints-sender.ts';
@@ -56,13 +57,13 @@ import { createRevalidateRendererFactory } from './revalidate-renderer.ts';
 import { renderFallbackError as renderFallback } from '../fallback-error.ts';
 import { loadInstrumentation } from '../instrumentation.ts';
 import { createDenyFallbackRenderer } from './deny-fallback.ts';
-import { renderNoMatchPage } from './error-renderer.ts';
+import { DenySignal } from '../primitives.ts';
 import { renderRoute } from './render-route.ts';
 import { isDebug, isDevMode, setDebugFromConfig } from '../debug.ts';
-import { setSourceMapCallback } from '../dev-source-map.ts';
 import { capturePrebuiltPayloads } from '../prebuilt-builder.ts';
 import { setPrebuiltPayloadSource } from '../prebuilt/payload-source.ts';
 import { setRscFunctions, setComponentRefreshTimeout } from '../prebuilt-runtime.ts';
+import { installReactCacheBridge } from '../react-cache-bridge.ts';
 import { setKeyDisciplineStrict } from '../prebuilt/key-discipline.ts';
 import { createAutoSitemapHandler } from '../sitemap-handler.ts';
 import { generateStaticSite } from '../static-generator.ts';
@@ -82,18 +83,16 @@ function resolveServerTimingMode(
   return 'total';
 }
 
+/** The dev server's hooks. Empty in production. */
+let devHooks: DevHooks = {};
+
 /**
- * Set the dev source-map handler.
- *
- * Called by the dev server after importing this module to wire Vite's
- * module graph source-mapping into the error rendering pipeline. Errors
- * rendered by renderErrorPage / renderFallbackError will have their
- * stack traces rewritten to show original source positions.
- *
- * No-op in production.
+ * Set the dev hooks. Called by the dev server after it imports this module;
+ * the handler reads them at request time, so a later call takes effect on
+ * the next request.
  */
-export function setDevSourceMapHandler(handler: (error: Error) => void): void {
-  setSourceMapCallback(handler);
+export function setDevHooks(hooks: DevHooks): void {
+  devHooks = hooks;
 }
 
 /**
@@ -103,12 +102,11 @@ export function setDevSourceMapHandler(handler: (error: Error) => void): void {
  * 103 Early Hints → middleware.ts → render (RSC → SSR → HTML).
  */
 async function createRequestHandler(manifest: typeof routeManifest, runtimeConfig: typeof config) {
-  // Initialize deployment ID for version skew detection (TIM-446).
-  // The manifest init module sets globalThis.__TIMBER_DEPLOYMENT_ID__ at startup.
-  // In dev mode this is undefined — skew checks are skipped.
-  const deploymentId = (globalThis as Record<string, unknown>).__TIMBER_DEPLOYMENT_ID__ as
-    | string
-    | undefined;
+  // Initialize deployment ID for version skew detection (TIM-446). It is
+  // serialized into virtual:timber-config at build time — the same value the
+  // browser entry sends back — and is null in dev, where skew checks are
+  // skipped.
+  const deploymentId = (runtimeConfig as Record<string, unknown>).deploymentId as string | null;
   if (deploymentId) {
     const { setDeploymentId } = await import('../version-skew.ts');
     setDeploymentId(deploymentId);
@@ -181,6 +179,19 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     renderToReadableStream: rscMod.renderToReadableStream,
   });
 
+  // One React.cache scope per request, shared by proxy.ts, middleware.ts,
+  // route handlers, and the render (TIM-1529). Flight installs its
+  // dispatcher lazily, so the warm-up constructs one throwaway render.
+  const bridge = installReactCacheBridge(() => {
+    rscMod.renderToReadableStream(null, { onError() {} }).cancel();
+  });
+  if (!bridge.installed) {
+    console.warn(
+      `[timber] React.cache bridge not installed (${bridge.reason}) — React.cache ` +
+        `will not dedupe between middleware.ts and the render.`
+    );
+  }
+
   const matchRoute = createRouteMatcher(manifest);
   const matchMetadataRoute = createMetadataRouteMatcher(manifest);
 
@@ -196,7 +207,10 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     ((runtimeConfig as Record<string, unknown>).clientSegmentCache as boolean) ?? false;
   const clientBootstrap = buildClientScripts({
     ...runtimeConfig,
-    clientJavascript: clientJsConfig ?? { disabled: false, enableHMRInDev: false },
+    clientJavascript: clientJsConfig ?? {
+      disabled: false,
+      enableHMRInDev: false,
+    },
     devBrowserLogs: (runtimeConfig as Record<string, unknown>).devBrowserLogs as string | undefined,
     buildManifest: buildManifest as BuildManifest,
   });
@@ -213,7 +227,9 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
   // `timber.config.ts` without needing to plumb config through each action.
   // See TIM-816 and design/08-forms-and-actions.md §"Validation errors".
   const formsConfig = (runtimeConfig as Record<string, unknown>).forms as
-    | { stripSensitiveFields?: import('../sensitive-fields.ts').SensitiveFieldsOption }
+    | {
+        stripSensitiveFields?: import('../sensitive-fields.ts').SensitiveFieldsOption;
+      }
     | undefined;
   if (formsConfig) {
     const { setGlobalSensitiveFieldsConfig } = await import('../sensitive-fields.ts');
@@ -241,10 +257,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     const devLogMode = resolveLogMode();
     if (devLogMode !== 'quiet') {
       await initDevTracing({ mode: devLogMode, slowPhaseMs });
-      // Patch globalThis.fetch to create OTEL spans for fetch calls.
-      // Spans appear as children of the active component span in the dev log tree.
-      const { instrumentDevFetch } = await import('../../dev-tools/instrumentation.ts');
-      instrumentDevFetch();
     }
   }
 
@@ -257,6 +269,14 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     ? { kind: 'lazy', loader: manifest.proxy.load }
     : undefined;
 
+  // The one assembler of deny pages: signals that escape a phase, the
+  // no-match 404, and the missing-page 404. See deny-fallback.ts,
+  // design/04-authorization.md, design/10-error-handling.md.
+  const renderDenyFallback = createDenyFallbackRenderer({
+    rootSegment: manifest.root,
+    clientBootstrap,
+  });
+
   const pipelineConfig: PipelineConfig = {
     proxy: proxyConfig,
     matchRoute,
@@ -280,7 +300,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
       req: Request,
       match: RouteMatch,
       responseHeaders: Headers,
-      _requestHeaderOverlay: Headers,
       interception?: InterceptionContext
     ) => {
       return renderRoute(
@@ -291,7 +310,7 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
           clientBootstrap,
           clientJsDisabled,
           clientSegmentCache,
-          rootSegment: manifest.root,
+          renderDenyFallback,
           buildManifest: typedBuildManifest,
           globalError: manifest.globalError,
         },
@@ -321,9 +340,9 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
         ? (_status: number, headers: Headers) => {
             const routes = devPage.collectRoutes(manifest.root);
             const pathname = new URL(req.url).pathname;
-            // devHmrOptions is set by the dev server after this module is
-            // imported (read at request time, not closure-capture time).
-            const html = devPage.generateDev404Page(pathname, routes, pipelineConfig.devHmrOptions);
+            // Read at request time: the dev server sets the hooks after
+            // this module is imported.
+            const html = devPage.generateDev404Page(pathname, routes, devHooks.hmrOptions);
             return new Response(html, {
               status: 404,
               headers: {
@@ -334,7 +353,8 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
           }
         : undefined;
 
-      return renderNoMatchPage(req, manifest.root, responseHeaders, clientBootstrap, defaultPage);
+      // With no match, the fallback renders the root chain's 404 page.
+      return renderDenyFallback(new DenySignal(404), req, responseHeaders, undefined, defaultPage);
     },
     interceptionRewrites: manifest.interceptionRewrites,
     matchInterceptedRoute: createInterceptedRouteMatcher(manifest.root),
@@ -343,18 +363,15 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     slowRequestMs: (runtimeConfig as Record<string, unknown>).slowRequestMs as number | undefined,
     serverTiming: resolveServerTimingMode(runtimeConfig, isDev),
     onPipelineError: isDev
-      ? (error: Error, phase: string) => {
-          if (pipelineConfig.devPipelineErrorHandler) {
-            pipelineConfig.devPipelineErrorHandler(error, phase);
-          }
-        }
+      ? (error: Error, phase: string) => devHooks.onPipelineError?.(error, phase)
       : undefined,
 
-    renderFallbackError: (error, req, responseHeaders) =>
+    renderFallbackError: (error, req, responseHeaders, match) =>
       renderFallback(
         error,
         req,
         responseHeaders,
+        match,
         isDev,
         manifest.root,
         clientBootstrap,
@@ -369,15 +386,12 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
         isDev ? manifest.viteRoot : undefined,
         // HMR options for the dev error page's auto-reload WebSocket —
         // set by the dev server after import, read at request time.
-        isDev ? pipelineConfig.devHmrOptions : undefined
+        isDev ? devHooks.hmrOptions : undefined
       ),
     // Deny fallback — renders the deny page (403.tsx, 404.tsx, etc.) for
     // DenySignals that escape from middleware or the render phase.
     // See deny-fallback.ts, design/04-authorization.md, design/10-error-handling.md.
-    renderDenyFallback: createDenyFallbackRenderer({
-      rootSegment: manifest.root,
-      clientBootstrap,
-    }),
+    renderDenyFallback,
     // Auto-generated sitemap handler — enabled when sitemap.enabled is true
     // and no user-authored sitemap exists at the app root.
     // See design/16-metadata.md §"Auto-generated Sitemap"
@@ -423,7 +437,7 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     csrfConfig,
   });
 
-  return { handler, pipelineConfig };
+  return handler;
 }
 
 // Re-export for generated entry points (e.g., Nitro node-server/bun) to wrap
@@ -487,12 +501,13 @@ setGlobalSchemaCodecs(globalSchemaCodecs);
 
 // Singleflight timeout protects against deadlocked cache calls — needed
 // in both capture mode (components may call timber.cache) and normal mode.
-const renderTimeoutMs = (config as Record<string, unknown>).renderTimeoutMs as number | undefined;
-if (renderTimeoutMs) {
-  const { setDefaultSingleflightTimeout } = await import('../../cache/timber-cache.ts');
-  setDefaultSingleflightTimeout(renderTimeoutMs);
-  setComponentRefreshTimeout(renderTimeoutMs);
-}
+// Always wired: an unbounded singleflight deadlocks a key forever
+// (TIM-1440). plugins/entries.ts resolves the value (0 → ceiling) before
+// it reaches the runtime config.
+const renderTimeoutMs = (config as Record<string, unknown>).renderTimeoutMs as number;
+const { setDefaultSingleflightTimeout } = await import('../../cache/timber-cache.ts');
+setDefaultSingleflightTimeout(renderTimeoutMs);
+setComponentRefreshTimeout(renderTimeoutMs);
 
 const cacheConfig = (config as Record<string, unknown>).cache as
   | { strictKeyDiscipline?: boolean }
@@ -519,18 +534,9 @@ if (userCacheHandler) {
 const isCaptureMode = !!(globalThis as Record<string, unknown>).__TIMBER_CAPTURE_MODE__;
 
 let _handler: ((req: Request) => Promise<Response>) | undefined;
-let _pipelineConfig: PipelineConfig | undefined;
 
 if (!isCaptureMode) {
-  const result = await createRequestHandler(routeManifest, config);
-  _handler = result.handler;
-  _pipelineConfig = result.pipelineConfig;
+  _handler = await createRequestHandler(routeManifest, config);
 }
 
-/**
- * The pipeline configuration object. Exported so the dev server can set
- * `devPipelineErrorHandler` after import without a module-level singleton.
- */
-export const pipelineConfig = _pipelineConfig!;
-
 export default _handler!;