@timber-js/app 0.2.0-alpha.171 → 0.2.0-alpha.173

package/src/server/prebuilt-runtime.ts

@@ -38,7 +38,7 @@ import { createElement } from 'react';
 import { requestContextAls, type RequestContextStore } from './als-registry.js';
 import { computeComponentCacheKey, splitSlotProps, tryCanonicalize } from './prebuilt/cache-key.js';
 import {
-  isChildSegmentOutletElement,
+  isChildrenSlotOutletElement,
   resolveSlotNames,
   prepareSlotRender,
   wrapInSlotsProvider,
@@ -196,7 +196,7 @@ function resolveKeyParams(store: {
  * exactly when production would serve the cache path rather than the
  * live fallback (dev/prod parity, codex P2 on PR #890): requires an ALS
  * store, keyable params (slot-param divergence unkeys), and keyable data
- * props (after the ChildSegmentOutlet strip).
+ * props (after the children slot outlet strip).
  */
 function isSlotRenderKeyable(dataProps: Record<string, unknown>): boolean {
   const store = requestContextAls.getStore();
@@ -204,7 +204,7 @@ function isSlotRenderKeyable(dataProps: Record<string, unknown>): boolean {
   const keyParams = resolveKeyParams(store);
   if (keyParams === null) return false;
   let keyProps = dataProps;
-  if (isChildSegmentOutletElement(keyProps.children)) {
+  if (isChildrenSlotOutletElement(keyProps.children)) {
     const { children: _children, ...rest } = keyProps;
     keyProps = rest;
   }
@@ -547,23 +547,23 @@ async function tryRevivePayload(
   if (keyParams === null) return null;
 
   // 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>.
+  // injected children slot outlet (<SlotOutlet slot="children" />).
+  // Layout components receive this 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 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.
   // keyPropsOverride = slot component (TIM-1173): the wrapper already
   // split out slot props; only data props participate in the key. The
-  // ChildSegmentOutlet strip applies to EITHER source — a cached layout
+  // children outlet strip applies to EITHER source — a cached layout
   // declaring only named slots (slots: ['modal']) still receives the
   // framework-injected children outlet in its data props, and it must not
   // unkey the render there any more than on the non-slot path (codex P2
   // on PR #890).
   const allProps = (props ?? {}) as Record<string, unknown>;
   let keyProps = keyPropsOverride ?? allProps;
-  if (isChildSegmentOutletElement(keyProps.children)) {
+  if (isChildrenSlotOutletElement(keyProps.children)) {
     const { children: _children, ...rest } = keyProps;
     keyProps = rest;
   }

package/src/server/request-context.ts

@@ -14,7 +14,13 @@
  * and design/11-platform.md §"AsyncLocalStorage".
  */
 
-import { requestContextAls, type RequestContextStore } from './als-registry.js';
+import {
+  requestContextAls,
+  taintScopeAls,
+  markAccessorTouched,
+  type RequestContextStore,
+  type TaintScope,
+} from './als-registry.js';
 import { _setGetSearchParamsFn } from '../search-params/define.js';
 import { _setGetSegmentParamsFn } from '../segment-params/define.js';
 import { consumeSeededCookies } from './cookie-context.js';
@@ -39,6 +45,7 @@ export function getHeaders(): ReadonlyHeaders {
         'It can only be used in middleware, access checks, server components, and server actions.'
     );
   }
+  markAccessorTouched();
   return store.headers;
 }
 
@@ -51,6 +58,7 @@ export function getHeaders(): ReadonlyHeaders {
  * @internal — not part of the public API. Use `getHeaders().get(name)` instead.
  */
 export function getHeader(name: string): string | undefined {
+  // getHeaders() already calls markAccessorTouched()
   const headers = getHeaders();
   return headers.get(name) ?? undefined;
 }
@@ -68,6 +76,7 @@ export function getSearchParams(): URLSearchParams {
         'It can only be used in middleware, access checks, server components, and server actions.'
     );
   }
+  markAccessorTouched();
   return store.searchParams;
 }
 
@@ -217,6 +226,49 @@ export function getRequestSearchString(): string {
   return store?.searchString ?? '';
 }
 
+// ─── Request Accessor Taint Tracking ─────────────────────────────────────
+// Used by segment/slot skip decisions to determine whether a component
+// actually reads per-request data, replacing the AsyncFunction heuristic.
+
+/**
+ * Run a callback inside a taint tracking scope. Returns whether any
+ * request accessor (getHeaders, getSearchParams, cookies) was called
+ * during the callback's execution.
+ *
+ * Uses a dedicated ALS so concurrent async components (Flight renders
+ * siblings in parallel) each get their own isolated scope. The shared
+ * push/pop stack model was unsound under concurrency.
+ *
+ * Results are stored in the request context's taintResults map, keyed
+ * by segment/slot ID, for buildSegmentInfo() to consume.
+ *
+ * @internal — framework use only (route-element-builder.ts, slot-resolver.ts)
+ */
+export async function runInTaintScope<T>(segmentKey: string, fn: () => T | Promise<T>): Promise<T> {
+  const store = requestContextAls.getStore();
+  const scope: TaintScope = { touched: false };
+  try {
+    const result = await taintScopeAls.run(scope, fn);
+    if (store) {
+      if (!store.taintResults) store.taintResults = new Map();
+      // OR-merge: once a key is tainted, it stays tainted. A second scope
+      // for the same key (e.g. default.tsx fallback after a denied slot page)
+      // must not overwrite an earlier true with false.
+      store.taintResults.set(
+        segmentKey,
+        scope.touched || (store.taintResults.get(segmentKey) ?? false)
+      );
+    }
+    return result;
+  } catch (error) {
+    if (store) {
+      if (!store.taintResults) store.taintResults = new Map();
+      store.taintResults.set(segmentKey, true);
+    }
+    throw error;
+  }
+}
+
 // ─── Types ────────────────────────────────────────────────────────────────
 
 /**

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

@@ -16,26 +16,13 @@
  */
 
 import { createElement, Fragment } from 'react';
-import { randomUUID } from 'node:crypto';
 
 import { withSpan } from './tracing.js';
 import type { RouteMatch } from './pipeline.js';
 import type { ManifestSegmentNode } from './route-matcher.js';
 import { resolveMetadata, renderMetadataToElements } from './metadata.js';
 import type { Metadata } from './types.js';
-import {
-  METADATA_ROUTE_CONVENTIONS,
-  getMetadataRouteAutoLink,
-  resolveServePathForFile,
-} from './metadata-routes.js';
-
-// In dev mode, use a per-startup nonce for metadata route cache busting
-// instead of per-file content hashes (avoids rehashing on every request).
-let _devNonce: string | undefined;
-function getDevNonce(): string {
-  _devNonce ??= randomUUID().slice(0, 8);
-  return _devNonce;
-}
+import { collectMetadataRouteHeadElements } from './metadata-routes.js';
 import { DenySignal, RedirectSignal } from './primitives.js';
 import { AccessGate } from './access-gate.js';
 import { requestContextAls } from './als-registry.js';
@@ -46,37 +33,18 @@ import {
   setDenyStatus,
 } from './deny-boundary.js';
 import type { DenyPageEntry } from './deny-boundary.js';
-import { resolveSlotElement } from './slot-resolver.js';
+import { LAYOUT_CHILDREN_SLOT } from './prebuilt/slots.js';
+import { resolveSlotProps, type SlotSkipEntry } 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 { SlotOutlet } from '../client/slot-outlet.js';
+import { SlotsProvider } from '../client/slot-provider.js';
 
 import { wrapSegmentWithErrorBoundaries } from './error-boundary-wrapper.js';
 import type { InterceptionContext } from './pipeline.js';
-import { shouldSkipSegment, computeSegmentKeys } from './state-tree-diff.js';
-import type { HeadElement } from './metadata.js';
-
-/**
- * Convert HeadElement descriptors to React elements for Float hoisting.
- *
- * React 19 Float hoists <title>, <meta>, and <link> rendered anywhere in
- * the tree into <head> during SSR, and manages them in document.head
- * during client-side rendering. This replaces the X-Timber-Head header
- * side-channel and the imperative client DOM applier.
- */
-export function headElementsToReact(elements: HeadElement[]): React.ReactElement {
-  const children: React.ReactElement[] = [];
-  for (let i = 0; i < elements.length; i++) {
-    const el = elements[i];
-    if (el.tag === 'title' && el.content !== undefined) {
-      children.push(createElement('title', { key: `t${i}` }, el.content));
-    } else if (el.attrs) {
-      children.push(createElement(el.tag, { key: `h${i}`, ...el.attrs }));
-    }
-  }
-  return createElement(Fragment, null, ...children);
-}
+import { shouldSkipSegment, computeSegmentKeys, type ClientStateTree } from './state-tree-diff.js';
+import { runInTaintScope } from './request-context.js';
+import { headElementsToReact } from './metadata.js';
 import { loadModule } from './safe-load.js';
 
 /**
@@ -191,6 +159,12 @@ export interface RouteElementResult {
    * See TIM-1045 (pages), TIM-1208 (layouts).
    */
   shellSettled?: Promise<void>;
+  /**
+   * Slot metadata for the X-Timber-Segments header. Contains info about
+   * all parallel route slots encountered during element tree construction,
+   * enabling the client to populate its segment cache with slot entries.
+   */
+  slotSkipInfo: SlotSkipEntry[];
 }
 
 // ─── Module Processing Helpers ─────────────────────────────────────────────
@@ -273,7 +247,7 @@ export async function buildRouteElement(
   req: Request,
   match: RouteMatch,
   interception?: InterceptionContext,
-  clientStateTree?: Set<string> | null,
+  clientStateTree?: ClientStateTree | null,
   metadataRouteHashes?: Record<string, string>
 ): Promise<RouteElementResult> {
   const segments = match.segments;
@@ -408,79 +382,15 @@ export async function buildRouteElement(
   const headElements = renderMetadataToElements(resolvedMetadata);
 
   // Auto-link metadata route files (icon, apple-icon, manifest, opengraph-image).
-  // opengraph-image emits both og:image and twitter:image (no separate twitter-image convention).
-  // Skip OG auto-linking when the user already declared images in metadata.
   // See design/16-metadata.md §"Auto-Linking"
-  const hasUserOgImage = Boolean(resolvedMetadata.openGraph?.images);
-  const hasUserTwitterImage = Boolean(resolvedMetadata.twitter?.images);
-  const requestUrl = new URL(req.url);
-  const requestPathname = requestUrl.pathname;
-  // In dev mode, use the request origin so OG URLs resolve to localhost.
-  // In production, use metadataBase (the canonical domain).
-  const ogBase =
-    process.env.NODE_ENV !== 'production'
-      ? new URL(requestUrl.origin)
-      : resolvedMetadata.metadataBase;
-
-  for (let si = 0; si < segments.length; si++) {
-    const segment = segments[si];
-    if (!segment.metadataRoutes) continue;
-    // Skip auto-linking for denied segments — same gate as metadata().
-    if (si >= firstDeniedIndex) continue;
-    for (const baseName of Object.keys(segment.metadataRoutes)) {
-      const convention = METADATA_ROUTE_CONVENTIONS[baseName];
-      if (!convention) continue;
-      // Non-nestable routes only auto-link from root
-      if (!convention.nestable && segment.urlPath !== '/') continue;
-      // Skip auto-linking entirely if user declared openGraph.images (covers both og + twitter)
-      if (convention.type === 'opengraph-image' && hasUserOgImage) continue;
-      // Build the href using the actual request path (not the pattern with [param]).
-      // For nestable routes, the metadata route sits under the same resolved path
-      // as the page. For root-only routes, use '/'.
-      const resolvedPrefix = convention.nestable
-        ? requestPathname === '/'
-          ? ''
-          : requestPathname
-        : '';
-      const metaFile = segment.metadataRoutes[baseName];
-      const fileServePath = metaFile?.filePath
-        ? resolveServePathForFile(baseName, metaFile.filePath)
-        : convention.serveExtension
-          ? `${convention.servePath}.${convention.serveExtension}`
-          : convention.servePath;
-      let href = `${resolvedPrefix}/${fileServePath}`;
-      // Append cache-bust query param for image metadata routes
-      if (convention.type === 'opengraph-image') {
-        const fileHash = metaFile?.filePath ? metadataRouteHashes?.[metaFile.filePath] : undefined;
-        const cacheBust = fileHash ?? getDevNonce();
-        href = `${href}?${cacheBust}`;
-      }
-      // Resolve to absolute URL for og:image/twitter:image (social crawlers need full URLs)
-      if (ogBase && convention.type === 'opengraph-image') {
-        href = new URL(href, ogBase).toString();
-      }
-      for (const autoLink of getMetadataRouteAutoLink(convention.type, href)) {
-        // Skip auto-linked twitter:image when user declared twitter.images
-        if (
-          hasUserTwitterImage &&
-          autoLink.tag === 'meta' &&
-          'name' in autoLink &&
-          autoLink.name === 'twitter:image'
-        )
-          continue;
-        if (autoLink.tag === 'link') {
-          const attrs: Record<string, string> = { rel: autoLink.rel, href: autoLink.href };
-          if (autoLink.type) attrs.type = autoLink.type;
-          headElements.push({ tag: 'link', attrs });
-        } else {
-          const attrs: Record<string, string> = { content: autoLink.content };
-          if (autoLink.property) attrs.property = autoLink.property;
-          if (autoLink.name) attrs.name = autoLink.name;
-          headElements.push({ tag: 'meta', attrs });
-        }
-      }
-    }
-  }
+  const autoLinkedElements = collectMetadataRouteHeadElements(
+    segments,
+    firstDeniedIndex,
+    resolvedMetadata,
+    new URL(req.url),
+    metadataRouteHashes
+  );
+  headElements.push(...autoLinkedElements);
 
   // Convert HeadElement descriptors to React elements for Float hoisting.
   // Placed at the page segment level so they're always re-rendered on
@@ -491,7 +401,7 @@ export async function buildRouteElement(
   const h = createElement as (...args: unknown[]) => React.ReactElement;
 
   // Shell settlement tracking (TIM-1045 pages, TIM-1208 layouts).
-  // ChildSegmentProvider is 'use client', so React Flight eagerly
+  // SlotsProvider is 'use client', so React Flight eagerly
   // serializes both the layout and child content as independent subtrees —
   // the page can settle before an outer layout. We need all deny-capable
   // components to settle before committing the HTTP status.
@@ -637,6 +547,14 @@ export async function buildRouteElement(
 
   let outermostSegmentProvider: React.ReactElement | null = null;
 
+  // Slot caching: the departing URL (X-Timber-URL header) and the
+  // destination URL (request URL) are compared to determine which
+  // slots' content has changed. Full URLs (with search) are passed
+  // so slot pages reading getSearchParams() are correctly re-rendered.
+  const departingUrl = req.headers.get('X-Timber-URL');
+  const destinationUrl = req.url;
+  const slotSkipInfo: SlotSkipEntry[] = [];
+
   for (let i = segments.length - 1; i >= 0; i--) {
     const segment = segments[i];
     const isLeaf = i === segments.length - 1;
@@ -682,9 +600,15 @@ export async function buildRouteElement(
     // This prevents leaking layout UI (sidebars, nav) on denied pages.
     // See design/04-authorization.md §"Access Failure".
     if (layoutComponent) {
-      // Resolve parallel slots for this layout.
-      // Compute the parent tree path so slots can build their full
-      // segment path for per-slot param storage in ALS.
+      // Resolve parallel slots for this layout, wrapping each in
+      // SegmentOutlet for client-side caching. Unchanged slots get
+      // skip=true so the client keeps its cached content.
+      //
+      // Skip slot resolution for denied segments (TIM-1229): when a
+      // parent segment's AccessGate denies, the layout never renders,
+      // so slot props are never consumed. Resolving them is wasted work
+      // and could trigger side effects in slot access.ts functions.
+      const segmentId = segmentKeys[i];
       const parentTreePath =
         '/' +
         segments
@@ -692,17 +616,21 @@ export async function buildRouteElement(
           .map((s) => s.segmentName)
           .filter(Boolean)
           .join('/');
-      const slotProps: Record<string, unknown> = {};
-      const slotEntries = Object.entries(segment.slots ?? {});
-      for (const [slotName, slotNode] of slotEntries) {
-        slotProps[slotName] = await resolveSlotElement(
-          slotNode as ManifestSegmentNode,
-          match,
-          h,
-          interception,
-          parentTreePath
-        );
-      }
+      const slotProps =
+        i >= firstDeniedIndex
+          ? {}
+          : await resolveSlotProps({
+              segment,
+              segmentId,
+              match,
+              h,
+              interception,
+              parentTreePath,
+              departingUrl,
+              destinationUrl,
+              clientStateTree: clientStateTree as ClientStateTree | null,
+              slotSkipInfo,
+            });
 
       // '/'.split('/') → ['', ''] (length 2), but root should be [''] (length 1).
       // The extra empty string makes useSelectedLayoutSegment skip the first URL segment.
@@ -710,16 +638,14 @@ export async function buildRouteElement(
       const segmentPath = rawPath.length === 2 && rawPath[1] === '' ? [''] : rawPath;
       const parallelRouteKeys = Object.keys(segment.slots ?? {});
 
-      const segmentId = segmentKeys[i];
-
       // Build the layout element.
-      // 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.
+      // Layouts receive <SlotOutlet slot={LAYOUT_CHILDREN_SLOT} /> as
+      // children — a stable client reference — instead of the varying
+      // inner content. The actual child content is provided via
+      // SlotsProvider above the layout. Uses a reserved slot name to
+      // avoid collision with user-declared cache.component slots.
       // See design/45-cache-lifetimes.md §Layout Propagation.
-      const childOutlet = h(ChildSegmentOutlet, {});
+      const childOutlet = h(SlotOutlet, { slot: LAYOUT_CHILDREN_SLOT });
       let layoutElement: React.ReactElement;
       if (isClientReference(layoutComponent)) {
         layoutElement = h(layoutComponent, {
@@ -737,10 +663,13 @@ export async function buildRouteElement(
         const layoutDenyPages = denyPageChains.get(i);
         const hasLayoutDenyChain = !!layoutDenyPages && layoutDenyPages.length > 0;
         const onLayoutSettled = hasLayoutDenyChain ? trackShellComponent() : undefined;
+        const taintKey = segmentId;
         const TracedLayout = async (props: Record<string, unknown>) => {
           try {
-            return await withSpan('timber.layout', { 'timber.segment': segmentId }, () =>
-              (layoutComponentRef as (props: Record<string, unknown>) => unknown)(props)
+            return await runInTaintScope(taintKey, () =>
+              withSpan('timber.layout', { 'timber.segment': segmentId }, () =>
+                (layoutComponentRef as (props: Record<string, unknown>) => unknown)(props)
+              )
             );
           } catch (error: unknown) {
             if (error instanceof DenySignal && layoutDenyPages) {
@@ -750,8 +679,6 @@ export async function buildRouteElement(
                 return denyElement;
               }
             }
-            // Non-deny errors (RedirectSignal, runtime errors) propagate normally
-            // to onError — signalDetected / renderError handling covers those.
             throw error;
           } finally {
             onLayoutSettled?.();
@@ -763,10 +690,10 @@ export async function buildRouteElement(
         });
       }
 
-      // Wrap the layout in ChildSegmentProvider so ChildSegmentOutlet
-      // (inside the layout's children) can read the actual child content.
-      layoutElement = h(ChildSegmentProvider, {
-        childContent: element,
+      // Wrap the layout in SlotsProvider so the SlotOutlet inside the
+      // layout's children can read the actual child content.
+      layoutElement = h(SlotsProvider, {
+        values: { [LAYOUT_CHILDREN_SLOT]: element },
         children: layoutElement,
       });
 
@@ -841,5 +768,6 @@ export async function buildRouteElement(
     deferSuspenseFor,
     skippedSegments,
     shellSettled,
+    slotSkipInfo,
   };
 }

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

@@ -7,6 +7,8 @@
 import type { ManifestSegmentNode } from '../route-matcher.js';
 import { swallow } from '../logger.js';
 import { computeSegmentKeys } from '../state-tree-diff.js';
+import type { SlotSkipEntry } from '../slot-resolver.js';
+import { isClientReference } from '../route-element-builder.js';
 
 /** RSC content type for client navigation payload requests. */
 export const RSC_CONTENT_TYPE = 'text/x-component';
@@ -166,43 +168,76 @@ export function parseDebugRows(text: string): DebugComponentEntry[] {
 
 /**
  * Build segment metadata for the X-Timber-Segments response header.
- * Describes the rendered segment chain with async status, enabling
- * the client to populate its segment cache for state tree diffing.
+ * Describes the rendered segment chain with request-dependency status,
+ * enabling the client to populate its segment cache for state tree diffing.
+ *
+ * Request-dependency is determined by render-time taint tracking via
+ * runInTaintScope(). If taint results are available (RSC payload path),
+ * segments/slots that called getHeaders()/getSearchParams()/cookies()
+ * are marked request-dependent. Missing taint data (SSR path) defaults
+ * to true (safe fallback — never incorrectly cached).
  *
- * Async detection: server components defined as `async function` have
- * constructor.name === 'AsyncFunction'. These layouts always re-render
- * on navigation (they may depend on request context like cookies/params).
  * See design/07-routing.md §"Server Diffing Rules".
  */
+interface SegmentInfoEntry {
+  path: string;
+  segmentId?: string;
+  isRequestDependent: boolean;
+  slot?: boolean;
+  parentSegment?: string;
+  denied?: boolean;
+}
+
 export function buildSegmentInfo(
   segments: ManifestSegmentNode[],
   layoutComponents: Array<{
     component: (...args: unknown[]) => unknown;
     segment: ManifestSegmentNode;
-  }>
-): Array<{ path: string; segmentId?: string; isAsync: boolean }> {
+  }>,
+  slotSkipInfo?: SlotSkipEntry[],
+  taintResults?: Map<string, boolean>,
+  orphanTaint?: boolean,
+  skippedSegmentKeys?: string[]
+): SegmentInfoEntry[] {
   const layoutBySegment = new Map(
     layoutComponents.map(({ component, segment }) => [segment, component])
   );
 
   const segmentKeys = computeSegmentKeys(segments);
-  const result: Array<{ path: string; segmentId?: string; isAsync: boolean }> = [];
+  const skippedSet = skippedSegmentKeys ? new Set(skippedSegmentKeys) : null;
+  const result: SegmentInfoEntry[] = [];
 
   for (let i = 0; i < segments.length; i++) {
     const segment = segments[i];
     const component = layoutBySegment.get(segment);
 
-    // Only emit entries for segments with layouts. Layoutless segments
-    // have no SegmentOutlet and must not appear in the client's merge
-    // target search (buildSegmentUpdates).
     if (!component) continue;
 
-    const isAsync = component.constructor?.name === 'AsyncFunction';
     const segmentId = segmentKeys[i];
+    let isRequestDependent: boolean;
+    if (isClientReference(component)) {
+      // Client components never execute on the server — they can't
+      // call getHeaders()/cookies()/getSearchParams(). Always cacheable.
+      isRequestDependent = false;
+    } else if (orphanTaint) {
+      isRequestDependent = true;
+    } else if (taintResults?.has(segmentId)) {
+      isRequestDependent = taintResults.get(segmentId)!;
+    } else if (skippedSet?.has(segmentId)) {
+      // Skipped segments have no taint data (runInTaintScope never ran).
+      // They're safe to mark non-request-dependent: a segment is only
+      // skippable because the client's state tree listed it, and the
+      // client only serializes non-request-dependent segments.
+      isRequestDependent = false;
+    } else {
+      // No taint data (SSR path or segment not yet rendered).
+      // Default to true — safe fallback that degrades to current behavior.
+      isRequestDependent = true;
+    }
 
-    const entry: { path: string; segmentId?: string; isAsync: boolean } = {
+    const entry: SegmentInfoEntry = {
       path: segment.urlPath,
-      isAsync,
+      isRequestDependent,
     };
     if (segmentId !== segment.urlPath) {
       entry.segmentId = segmentId;
@@ -210,6 +245,25 @@ export function buildSegmentInfo(
     result.push(entry);
   }
 
+  if (slotSkipInfo) {
+    for (const slot of slotSkipInfo) {
+      let slotRequestDependent = slot.isRequestDependent;
+      if (orphanTaint) {
+        slotRequestDependent = true;
+      } else if (taintResults?.has(slot.slotKey)) {
+        slotRequestDependent = taintResults.get(slot.slotKey)!;
+      }
+      const entry: SegmentInfoEntry = {
+        path: slot.slotKey,
+        isRequestDependent: slotRequestDependent,
+        slot: true,
+        parentSegment: slot.parentSegmentId,
+      };
+      if (slot.denied) entry.denied = true;
+      result.push(entry);
+    }
+  }
+
   return result;
 }
 

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

@@ -139,8 +139,14 @@ export async function renderRoute(
     desc: 'build element tree',
   });
 
-  const { element, layoutComponents, deferSuspenseFor, skippedSegments, shellSettled } =
-    routeResult;
+  const {
+    element,
+    layoutComponents,
+    deferSuspenseFor,
+    skippedSegments,
+    shellSettled,
+    slotSkipInfo,
+  } = routeResult;
 
   // Build head HTML for injection into the SSR output.
   // Collects CSS, fonts, and modulepreload from the build manifest for matched segments.
@@ -270,7 +276,8 @@ export async function renderRoute(
       layoutComponents,
       match,
       responseHeaders,
-      skippedSegments
+      skippedSegments,
+      slotSkipInfo
     );
   }
 
@@ -288,5 +295,6 @@ export async function renderRoute(
     headHtml,
     deferSuspenseFor,
     globalError,
+    slotSkipInfo,
   });
 }