@timber-js/app 0.2.0-alpha.160 → 0.2.0-alpha.161

package/src/server/prebuilt-builder.ts

@@ -46,6 +46,7 @@ import { createElement } from 'react';
 
 import { requestContextAls } from './als-registry.js';
 import { ParamCoercionError } from './route-element-builder.js';
+import { ChildSegmentOutlet } from '../client/child-segment-outlet.js';
 import { coerceSegmentParams } from './param-coercion.js';
 import { DenySignal, RedirectSignal } from './primitives.js';
 import {
@@ -154,6 +155,8 @@ interface CandidateRoute {
   layoutsToLoad: ManifestFile[];
   /** Component IDs attributed to this route's page + layout chain. */
   componentIds: string[];
+  /** Component IDs from layout files (receive ChildSegmentOutlet as children). */
+  layoutComponentIds: Set<string>;
 }
 
 /**
@@ -176,15 +179,20 @@ function collectCandidateRoutes(
 
     if (node.page) {
       const componentIds = new Set<string>();
-      for (const file of [...chain, node.page]) {
-        for (const id of fileComponentMap[file.filePath] ?? []) componentIds.add(id);
-      }
+      const layoutIds = new Set<string>();
+      for (const f of chain)
+        for (const id of fileComponentMap[f.filePath] ?? []) {
+          componentIds.add(id);
+          layoutIds.add(id);
+        }
+      for (const id of fileComponentMap[node.page.filePath] ?? []) componentIds.add(id);
       if (componentIds.size > 0) {
         routes.push({
           urlPath: node.urlPath,
           page: node.page,
           layoutsToLoad: chain.filter((l) => (fileComponentMap[l.filePath] ?? []).length > 0),
           componentIds: Array.from(componentIds),
+          layoutComponentIds: layoutIds,
         });
       }
     }
@@ -252,15 +260,14 @@ async function enumerateCombos(
 
 // ─── Rendering ────────────────────────────────────────────────────────────
 
-/** Concatenate drained chunks without Buffer (the bundle also runs on Workers). */
 function concatChunks(chunks: Uint8Array[]): Uint8Array {
   let total = 0;
-  for (const chunk of chunks) total += chunk.byteLength;
+  for (const c of chunks) total += c.byteLength;
   const out = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, offset);
-    offset += chunk.byteLength;
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.byteLength;
   }
   return out;
 }
@@ -299,10 +306,10 @@ async function drainWithTimeout(
 
 /** Wrap payload bytes as a single-chunk stream for the smoke revival. */
 function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      controller.enqueue(bytes);
-      controller.close();
+  return new ReadableStream({
+    start(c) {
+      c.enqueue(bytes);
+      c.close();
     },
   });
 }
@@ -332,7 +339,8 @@ async function renderEntry(
   registration: PrebuiltRegistration,
   props: Record<string, unknown>,
   coercedParams: Record<string, string | string[]>,
-  timeoutMs: number
+  timeoutMs: number,
+  isLayout: boolean
 ): Promise<EntryOutcome> {
   const storeHandle = createBuildTimeStore(registration.id, coercedParams);
   const { store, violations } = storeHandle;
@@ -348,9 +356,15 @@ async function renderEntry(
     // synthetic store (segmentParams.get() inside the component).
     // Tag resolution also runs inside this scope so function-form tags
     // that read segment params see the synthetic store (codex P2 on PR #858).
+    // Layout captures get <ChildSegmentOutlet /> as children so the
+    // cached payload has a context-driven hole (design/45, TIM-1181).
+    const renderProps =
+      isLayout && !('children' in props)
+        ? { ...props, children: createElement(ChildSegmentOutlet as React.FC) }
+        : props;
     bytes = await requestContextAls.run(store, async () => {
       const stream = renderToReadableStream(
-        createElement(registration.component as RenderableComponent, props),
+        createElement(registration.component as RenderableComponent, renderProps),
         {
           onError(error: unknown) {
             failure ??= error ?? new Error('unknown render error');
@@ -422,7 +436,7 @@ function warnNestingClamps(
   let count = 0;
   for (const { innerId, options } of nested) {
     if (options.ttl === undefined && options.tags === undefined) continue;
-    const pairKey = `${outerId}${innerId}`;
+    const pairKey = `${outerId} ${innerId}`;
     if (warnedPairs.has(pairKey)) continue;
     warnedPairs.add(pairKey);
     count++;
@@ -448,6 +462,15 @@ function resolveCapturedTags(
   return resolved.length > 0 ? resolved : undefined;
 }
 
+/** Buffered entry pending the param-independence decision (TIM-1175). */
+interface PendingEntry {
+  callSiteProps: Record<string, unknown>;
+  cacheKey: string;
+  combo: ParamCombo;
+  bytes: Uint8Array;
+  tags: string[] | undefined;
+}
+
 /**
  * Capture flight payloads for every attributed, registered, prerender-tier
  * component across the route manifest. See module docblock for the flow.
@@ -465,9 +488,18 @@ export async function capturePrebuiltPayloads(
   const warnedPairs = new Set<string>();
   const reportedMissingRegistrations = new Set<string>();
   const eagerLoadedChunks = new Set<string>();
-  // Components confirmed to not read segmentParams during their first
-  // render — subsequent param combos reuse the first render's bytes.
-  const paramIndependentComponents = new Set<string>();
+  // Components already emitted as param-independent — skip on second route.
+  const emittedParamIndependent = new Set<string>();
+  // (componentId, propsKey) pairs that rendered at least once without
+  // reading segment params. Segment param access is structural (the
+  // component either calls getSegmentParams() or it doesn't), so if the
+  // first combo doesn't trigger it, subsequent combos won't either —
+  // skip them to avoid redundant renders. Tracked per props set so a
+  // failed variant doesn't suppress retries for a different variant.
+  const provenParamIndependent = new Set<string>();
+  // Per-component: whether ANY combo read segmentParams, plus buffered
+  // entries awaiting the param-independence decision after all combos.
+  const pendingByComponent = new Map<string, { anyParamRead: boolean; entries: PendingEntry[] }>();
 
   const skip = (issue: CaptureIssue) => {
     summary.skipped.push(issue);
@@ -594,8 +626,8 @@ export async function capturePrebuiltPayloads(
         }
         // Runtime tier (ttl/tags without prerender) does no build work.
         if (registration.options.prerender !== true) continue;
-        // Param-independent: first combo's renders cover all combos.
-        if (paramIndependentComponents.has(componentId)) continue;
+        // Already emitted as param-independent from a prior route.
+        if (emittedParamIndependent.has(componentId)) continue;
 
         // One entry per distinct call-site props object (design/44 §Props
         // Derivation, TIM-1142). When no call-site props were captured,
@@ -608,7 +640,23 @@ export async function capturePrebuiltPayloads(
         const propsSets: Record<string, unknown>[] =
           capturedProps && capturedProps.length > 0 ? [...capturedProps] : [{}];
 
+        let pending = pendingByComponent.get(componentId);
+        if (!pending) {
+          pending = { anyParamRead: false, entries: [] };
+          pendingByComponent.set(componentId, pending);
+        }
+
         for (const callSiteProps of propsSets) {
+          // Already rendered this (component, props) pair without reading
+          // params — additional combos produce identical payloads. Tracked
+          // per props set so a failed variant doesn't suppress retries.
+          // Guard on !anyParamRead: if another prop variant already proved
+          // param-dependent, this variant needs per-combo entries too since
+          // the emit phase uses a component-level paramIndependent flag.
+          const propsKey = JSON.stringify(callSiteProps);
+          const proofKey = `${componentId}\0${propsKey}`;
+          if (provenParamIndependent.has(proofKey) && !pending.anyParamRead) continue;
+
           const cacheKey = computeComponentCacheKey(callSiteProps, coercedParams);
           if (cacheKey === null) {
             skip({
@@ -621,11 +669,27 @@ export async function capturePrebuiltPayloads(
             });
             continue;
           }
-          const entryKey = `${componentId}${cacheKey}`;
+          const entryKey = `${componentId} ${cacheKey}`;
           if (seenEntries.has(entryKey)) continue;
           seenEntries.add(entryKey);
 
-          const outcome = await renderEntry(registration, callSiteProps, coercedParams, timeoutMs);
+          const isLayout = route.layoutComponentIds.has(componentId);
+          const outcome = await renderEntry(
+            registration,
+            callSiteProps,
+            coercedParams,
+            timeoutMs,
+            isLayout
+          );
+          // Track param reads immediately — before any failure continue —
+          // so a combo that reads params then fails still prevents
+          // param-independent classification (codex P1 on PR #869).
+          if (outcome.segmentParamsRead) {
+            pending.anyParamRead = true;
+            provenParamIndependent.delete(proofKey);
+          } else if (outcome.failure === null && !pending.anyParamRead) {
+            provenParamIndependent.add(proofKey);
+          }
           summary.nestingWarnings += warnNestingClamps(
             componentId,
             outcome.nested,
@@ -665,32 +729,46 @@ export async function capturePrebuiltPayloads(
             continue;
           }
 
-          // After the first successful render, if the component never
-          // read segmentParams, mark it param-independent — remaining
-          // combos reuse this render's bytes without re-rendering.
-          const isParamIndep = !outcome.segmentParamsRead;
-          if (isParamIndep) {
-            paramIndependentComponents.add(componentId);
-          }
-
-          const finalCacheKey = isParamIndep
-            ? (computeComponentCacheKey(callSiteProps, {}) ?? cacheKey)
-            : cacheKey;
-          const hasProps = Object.keys(callSiteProps).length > 0;
-          await options.onEntry({
-            componentId,
-            cacheKey: finalCacheKey,
-            params: isParamIndep ? {} : combo,
-            ...(hasProps ? { props: callSiteProps } : {}),
+          pending.entries.push({
+            callSiteProps,
+            cacheKey,
+            combo,
             bytes: outcome.bytes!,
             tags: outcome.resolvedTags,
-            ...(isParamIndep ? { paramIndependent: true } : {}),
           });
-          summary.captured++;
         }
       }
     }
   }
 
+  // Emit buffered entries. Param-independent = ALL combos rendered and
+  // NONE read segmentParams → collapse to one entry per props set (TIM-1175).
+  for (const [componentId, pending] of pendingByComponent) {
+    const isParamIndep = !pending.anyParamRead && pending.entries.length > 0;
+    if (isParamIndep) emittedParamIndependent.add(componentId);
+    const emittedProps = isParamIndep ? new Set<string>() : null;
+    for (const entry of pending.entries) {
+      if (emittedProps) {
+        const propsKey = JSON.stringify(entry.callSiteProps);
+        if (emittedProps.has(propsKey)) continue;
+        emittedProps.add(propsKey);
+      }
+      const hasProps = Object.keys(entry.callSiteProps).length > 0;
+      const finalCacheKey = isParamIndep
+        ? (computeComponentCacheKey(entry.callSiteProps, {}) ?? entry.cacheKey)
+        : entry.cacheKey;
+      await options.onEntry({
+        componentId,
+        cacheKey: finalCacheKey,
+        params: isParamIndep ? {} : entry.combo,
+        ...(hasProps ? { props: entry.callSiteProps } : {}),
+        bytes: entry.bytes,
+        tags: entry.tags,
+        ...(isParamIndep ? { paramIndependent: true } : {}),
+      });
+      summary.captured++;
+    }
+  }
+
   return summary;
 }

package/src/server/prebuilt-runtime.ts

@@ -37,6 +37,7 @@ import { createElement } from 'react';
 
 import { requestContextAls, type RequestContextStore } from './als-registry.js';
 import { computeComponentCacheKey, tryCanonicalize } from './prebuilt/cache-key.js';
+import { ChildSegmentOutlet } from '../client/child-segment-outlet.js';
 import {
   isCaptureActive,
   noteWrapperRender,
@@ -510,7 +511,29 @@ async function tryRevivePayload(
   const keyParams = paramIndep ? {} : resolveKeyParams(store);
   if (keyParams === null) return null;
 
-  const cacheKey = computeComponentCacheKey(props ?? {}, keyParams);
+  // Strip `children` from the cache key ONLY when it is the framework-
+  // injected ChildSegmentOutlet. Layout components receive
+  // <ChildSegmentOutlet /> as children — a deterministic client reference
+  // that is the same on every request, so it should not vary the key.
+  // User-provided React element children (e.g., <Cached><A /></Cached>)
+  // are NOT stripped — they remain unkeyable so the component renders
+  // live, which is correct: the cache cannot distinguish <A> from <B>.
+  // See design/45-cache-lifetimes.md §Layout Propagation, TIM-1181.
+  const allProps = (props ?? {}) as Record<string, unknown>;
+  let keyProps: Record<string, unknown>;
+  const childrenValue = allProps.children;
+  const isChildSegmentOutlet =
+    childrenValue != null &&
+    typeof childrenValue === 'object' &&
+    'type' in childrenValue &&
+    (childrenValue as { type: unknown }).type === ChildSegmentOutlet;
+  if (isChildSegmentOutlet) {
+    const { children: _children, ...rest } = allProps;
+    keyProps = rest;
+  } else {
+    keyProps = allProps;
+  }
+  const cacheKey = computeComponentCacheKey(keyProps, keyParams);
   if (cacheKey === null) return null;
 
   const outcome =

package/src/server/primitives.ts

@@ -416,11 +416,6 @@ export class RenderError<
 
 // ─── waitUntil ──────────────────────────────────────────────────────────────
 
-/** Minimal interface for adapters that support background work. */
-export interface WaitUntilAdapter {
-  waitUntil?(promise: Promise<unknown>): void;
-}
-
 // Intentional per-app singleton — warn-once flag that persists for the
 // lifetime of the process/isolate. Not per-request; do not migrate to ALS.
 let _waitUntilWarned = false;
@@ -429,30 +424,20 @@ let _waitUntilWarned = false;
  * Register a promise to be kept alive after the response is sent.
  * Maps to `ctx.waitUntil()` on Cloudflare Workers and similar platforms.
  *
- * In production, the platform adapter installs a per-request waitUntil
- * function via ALS (see waituntil-bridge.ts). This function checks the
- * ALS bridge first, then falls back to the legacy adapter argument.
- *
- * If neither is available, a warning is logged once and the promise is
- * left to resolve (or reject) without being tracked.
+ * The platform adapter installs a per-request waitUntil function via ALS
+ * (see waituntil-bridge.ts). If no ALS handler is available, a warning
+ * is logged once and the promise is left to resolve (or reject) without
+ * being tracked.
  *
  * @param promise - The background work to keep alive.
- * @param adapter - Optional legacy adapter (prefer ALS bridge in production).
  */
-export function waitUntil(promise: Promise<unknown>, adapter?: WaitUntilAdapter): void {
-  // Check ALS bridge first (installed by generated entry points)
+export function waitUntil(promise: Promise<unknown>): void {
   const alsFn = _getWaitUntil();
   if (alsFn) {
     alsFn(promise);
     return;
   }
 
-  // Fall back to legacy adapter argument
-  if (adapter && typeof adapter.waitUntil === 'function') {
-    adapter.waitUntil(promise);
-    return;
-  }
-
   if (!_waitUntilWarned) {
     _waitUntilWarned = true;
     console.warn(

package/src/server/route-element-builder.ts

@@ -44,6 +44,8 @@ import type { DenyPageEntry } from './deny-boundary.js';
 import { resolveSlotElement } from './slot-resolver.js';
 import { SegmentProvider } from '../client/segment-context.js';
 import { SegmentOutlet } from '../client/segment-outlet.js';
+import { ChildSegmentOutlet } from '../client/child-segment-outlet.js';
+import { ChildSegmentProvider } from '../client/child-segment-provider.js';
 
 import { wrapSegmentWithErrorBoundaries } from './error-boundary-wrapper.js';
 import type { InterceptionContext } from './pipeline.js';
@@ -126,7 +128,7 @@ export function isClientReference(component: unknown): boolean {
   );
 }
 
-// ─── Param Coercion Error ─────────────────────────────────────────────────
+// ─── Typed Errors ────────────────────────────────────────────────────────
 
 /**
  * Thrown when a defineSegmentParams codec's parse() fails.
@@ -139,6 +141,17 @@ export class ParamCoercionError extends Error {
   }
 }
 
+/**
+ * Thrown when a matched route has no page component in its leaf segment.
+ * The pipeline catches this and renders the custom 404 page.
+ */
+export class NoPageComponentError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NoPageComponentError';
+  }
+}
+
 // ─── Types ────────────────────────────────────────────────────────────────
 
 /** Layout entry with component and segment. */
@@ -352,7 +365,7 @@ export async function buildRouteElement(
           `  [${i}] ${s.segmentName} (page: ${s.page ? 'yes' : 'no'}, layout: ${s.layout ? 'yes' : 'no'}, children: ${s.children?.length ?? 0})${i === segments.length - 1 ? ' ← leaf' : ''}`
       )
       .join('\n');
-    throw new Error(
+    throw new NoPageComponentError(
       `No page component found for route: ${new URL(req.url).pathname}\nMatched segments:\n${segmentInfo}`
     );
   }
@@ -650,13 +663,18 @@ export async function buildRouteElement(
           : segment.urlPath;
 
       // Build the layout element.
-      // Same client reference guard as pages — client layouts must not be
-      // called as functions. OTEL tracing is skipped for client components.
+      // Layouts receive <ChildSegmentOutlet /> as children — a stable client
+      // reference — instead of the varying inner content. The actual child
+      // content is provided via ChildSegmentProvider above the layout.
+      // This makes layout cache.component hits possible: the cached payload
+      // contains a deterministic children reference, not varying content.
+      // See design/45-cache-lifetimes.md §Layout Propagation.
+      const childOutlet = h(ChildSegmentOutlet, {});
       let layoutElement: React.ReactElement;
       if (isClientReference(layoutComponent)) {
         layoutElement = h(layoutComponent, {
           ...slotProps,
-          children: element,
+          children: childOutlet,
         });
       } else {
         // Server component layout — wrap with OTEL tracing AND DenySignal
@@ -686,10 +704,17 @@ export async function buildRouteElement(
         };
         layoutElement = h(TracedLayout, {
           ...slotProps,
-          children: element,
+          children: childOutlet,
         });
       }
 
+      // Wrap the layout in ChildSegmentProvider so ChildSegmentOutlet
+      // (inside the layout's children) can read the actual child content.
+      layoutElement = h(ChildSegmentProvider, {
+        childContent: element,
+        children: layoutElement,
+      });
+
       const segmentProviderElement = h(SegmentProvider, {
         segments: segmentPath,
         segmentId,

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

@@ -108,12 +108,6 @@ 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) {
-  // Load the user's instrumentation.ts — register() is awaited before the
-  // server accepts any requests. The logger and onRequestError hooks are
-  // wired into the framework. This runs once at startup.
-  // See design/17-logging.md §"register() — Server Startup"
-  await loadInstrumentation(loadUserInstrumentation);
-
   // 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.
@@ -125,16 +119,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     setDeploymentId(deploymentId);
   }
 
-  // Wire the configured cache handler into the module-level singleton (TIM-599).
-  // The cacheHandler is a class instance (e.g. RedisCacheHandler) that can't be
-  // JSON-serialized into virtual:timber-config. Instead, virtual:timber-cache-handler
-  // dynamically imports the user's timber.config.ts and extracts the handler.
-  const userCacheHandler = await loadCacheHandler();
-  if (userCacheHandler) {
-    const { setCacheHandler } = await import('../../cache/handler-store.js');
-    setCacheHandler(userCacheHandler as Parameters<typeof setCacheHandler>[0]);
-  }
-
   // Wire the CDN purge handler so revalidateTag triggers CDN purge (TIM-1166).
   const userCdnPurge = await loadCdnPurgeHandler();
   if (userCdnPurge) {
@@ -148,17 +132,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     setCdnPurgeHandler(new WorkersCachePurge());
   }
 
-  // Propagate renderTimeoutMs into the default singleflight so cache calls
-  // without a per-call timeoutMs still get deadlock protection (TIM-1032).
-  const renderTimeoutMs = (runtimeConfig as Record<string, unknown>).renderTimeoutMs as
-    | number
-    | undefined;
-  if (renderTimeoutMs) {
-    const { setDefaultSingleflightTimeout } = await import('../../cache/timber-cache.js');
-    setDefaultSingleflightTimeout(renderTimeoutMs);
-    setComponentRefreshTimeout(renderTimeoutMs);
-  }
-
   // Wire the prebuilt payload source so cache.component wrappers can look
   // up cached flight payloads at request time (TIM-1122). The source is
   // platform-aware: Node/Nitro reads from disk; Cloudflare reads from
@@ -216,13 +189,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
   const matchRoute = createRouteMatcher(manifest);
   const matchMetadataRoute = createMetadataRouteMatcher(manifest);
 
-  // TIM-931: Register global schema codecs for param coercion.
-  // When app/schema.ts exists, globalSchemaCodecs is a Record<string, Codec>;
-  // otherwise null. Registered once at startup so all coercion paths
-  // (pipeline-phases.ts, action-middleware-runner.ts, revalidation) share
-  // the same codec source.
-  setGlobalSchemaCodecs(globalSchemaCodecs);
-
   // Build the client bootstrap configuration.
   // When client JavaScript is disabled, no scripts are injected
   // (unless enableHMRInDev is true in dev mode — then only HMR client).
@@ -559,15 +525,49 @@ export function __timber_capturePrebuilt(
   return capturePrebuiltPayloads(routeManifest, options);
 }
 
-const { handler: _handler, pipelineConfig: _pipelineConfig } = await createRequestHandler(
-  routeManifest,
-  config
-);
+// Schema codecs are needed by both the capture path (param coercion) and
+// the request handler, so register them unconditionally.
+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.js');
+  setDefaultSingleflightTimeout(renderTimeoutMs);
+  setComponentRefreshTimeout(renderTimeoutMs);
+}
+
+// Run instrumentation before the capture-mode guard — components may
+// depend on globals or SDKs initialized in register().
+await loadInstrumentation(loadUserInstrumentation);
+
+// Wire the cache handler — prebuilt components may call timber.cache
+// during capture and must see the configured store, not the fallback.
+const userCacheHandler = await loadCacheHandler();
+if (userCacheHandler) {
+  const { setCacheHandler } = await import('../../cache/handler-store.js');
+  setCacheHandler(userCacheHandler as Parameters<typeof setCacheHandler>[0]);
+}
+
+// In capture mode the plugin only calls __timber_capturePrebuilt — skip
+// the remaining production startup (CDN purge, OTEL, route matchers)
+// which is expensive and unnecessary.
+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;
+}
 
 /**
  * The pipeline configuration object. Exported so the dev server can set
  * `devPipelineErrorHandler` after import without a module-level singleton.
  */
-export const pipelineConfig = _pipelineConfig;
+export const pipelineConfig = _pipelineConfig!;
 
-export default _handler;
+export default _handler!;

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

@@ -31,7 +31,11 @@ import type { LayoutEntry } from '../deny-renderer.js';
 import { renderDenyPage, renderDenyPageAsRsc } from '../deny-renderer.js';
 import type { ClientBootstrapConfig } from '../html-injectors.js';
 import type { InterceptionContext, RouteMatch } from '../pipeline.js';
-import { buildRouteElement, ParamCoercionError } from '../route-element-builder.js';
+import {
+  buildRouteElement,
+  NoPageComponentError,
+  ParamCoercionError,
+} from '../route-element-builder.js';
 import type { ManifestSegmentNode } from '../route-matcher.js';
 import { recordTiming } from '../server-timing.js';
 import { requestContextAls } from '../als-registry.js';
@@ -117,7 +121,7 @@ export async function renderRoute(
       return renderNoMatchPage(req, rootSegment, responseHeaders, clientBootstrap);
     }
     // No PageComponent found — same treatment as param coercion: render custom 404.
-    if (error instanceof Error && error.message.startsWith('No page component')) {
+    if (error instanceof NoPageComponentError) {
       if (process.env.NODE_ENV !== 'production') {
         console.warn(`[timber] ${error.message}`);
       }

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

@@ -101,11 +101,11 @@ export async function buildRscPayloadResponse(
   // Check for redirect/deny signals detected during initial rendering
   const trackedRedirect = signals.redirectSignal as RedirectSignal | null;
   if (trackedRedirect) {
-    reader.cancel();
+    reader.cancel().catch(() => {});
     return buildRedirectResponse(trackedRedirect, req, responseHeaders);
   }
   if (signals.denySignal) {
-    reader.cancel();
+    reader.cancel().catch(() => {});
     return renderDenyPageAsRsc(
       signals.denySignal,
       segments,

package/src/server/server-only-guard-noop.js

@@ -0,0 +1,3 @@
+// No-op module for Node.js and vitest resolution of #server-only-guard.
+// The shims plugin intercepts this specifier in the client environment
+// and returns the server-only poison pill instead.