vinext 1.3.1 → 1.4.1

package/dist/server/app-page-probe.js

@@ -1,5 +1,4 @@
 import { isPromiseLike } from "../utils/promise.js";
-import { probeAppPageLayouts } from "./app-page-execution.js";
 import { Fragment, isValidElement } from "react";
 //#region src/server/app-page-probe.ts
 const DEFAULT_SUBTREE_PROBE_MAX_DEPTH = 32;
@@ -63,10 +62,9 @@ async function resolveReactLazyType(lazyType) {
 	}
 }
 /**
-* Invokes server-component children returned by a layout probe so per-layout
-* skip eligibility observes data dependencies created below the layout's
-* immediate function body. The real RSC render remains authoritative; probe
-* failures only make static-layout skip fall back to render-and-send.
+* Invokes the server components a layout renders, so the error-path layout
+* probe sees an HTTP access fallback thrown below the layout's own function
+* body. The real RSC render remains authoritative.
 */
 async function probeReactServerSubtree(node, options = {}) {
 	const maxDepth = options.maxDepth ?? DEFAULT_SUBTREE_PROBE_MAX_DEPTH;
@@ -118,36 +116,5 @@ async function probeReactServerSubtree(node, options = {}) {
 	};
 	await visit(node, 0);
 }
-async function probeAppPageBeforeRender(options) {
-	let layoutFlags = {};
-	if (options.skipProbes) return {
-		response: null,
-		layoutFlags
-	};
-	if (options.layoutCount > 0) {
-		const layoutProbeResult = await probeAppPageLayouts({
-			layoutCount: options.layoutCount,
-			async onLayoutError(layoutError, layoutIndex) {
-				const specialError = options.resolveSpecialError(layoutError);
-				if (!specialError) return null;
-				return options.renderLayoutSpecialError(specialError, layoutIndex);
-			},
-			probeLayoutAt: options.probeLayoutAt,
-			runWithSuppressedHookWarning(probe) {
-				return options.runWithSuppressedHookWarning(probe);
-			},
-			classification: options.classification
-		});
-		layoutFlags = layoutProbeResult.layoutFlags;
-		if (layoutProbeResult.response) return {
-			response: layoutProbeResult.response,
-			layoutFlags
-		};
-	}
-	return {
-		response: null,
-		layoutFlags
-	};
-}
 //#endregion
-export { probeAppPageBeforeRender, probeReactServerSubtree };
+export { probeReactServerSubtree };

package/dist/server/app-page-render.d.ts

@@ -1,12 +1,10 @@
-import { ClientReuseManifestParseResult, ClientReuseManifestSkipDisposition } from "./client-reuse-manifest.js";
 import { AppOutgoingElements } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import "../shims/navigation.js";
-import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
+import { AppPageFontPreload, AppPageSpecialError } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
 import { AppRenderErrorContextOverrides } from "./app-rsc-error-handler.js";
@@ -74,7 +72,6 @@ type RenderAppPageLifecycleOptionsBase = {
   peekRequestCacheLife?: () => AppPageRequestCacheLife | null;
   getDraftModeCookieHeader: () => string | null | undefined;
   handlerStart: number;
-  hasCustomGlobalError?: boolean;
   dynamicStaleTimeSeconds?: number;
   isDynamicError: boolean;
   isDraftMode: boolean;
@@ -110,7 +107,6 @@ type RenderAppPageLifecycleOptionsBase = {
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
   interceptionId?: string | null;
-  layoutCount: number;
   loadSsrHandler: () => Promise<AppPageSsrHandler>;
   middlewareContext: AppPageMiddlewareContext;
   navigationParams: Record<string, unknown>;
@@ -120,12 +116,10 @@ type RenderAppPageLifecycleOptionsBase = {
   abortPprFallbackShell?: () => void;
   rootParams?: RootParams;
   peekRenderObservationState?: () => AppPageRenderObservationState;
-  probeLayoutAt: (layoutIndex: number) => unknown;
   expireSeconds?: number;
   formState?: ReactFormState | null;
   revalidateSeconds: number | null;
   renderErrorBoundaryResponse: (error: unknown, errorOrigin: "rsc" | "ssr") => Promise<Response | null>;
-  renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
   renderPageSpecialError: (specialError: AppPageSpecialError, renderOptions?: AppPageSpecialErrorRenderOptions) => Promise<Response>;
   renderToReadableStream: (element: ReactNode | AppOutgoingElements, options: {
     onError: AppPageBoundaryOnError;
@@ -138,16 +132,11 @@ type RenderAppPageLifecycleOptionsBase = {
     prelude: ReadableStream<Uint8Array>;
   }>;
   routePattern: string;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
   scriptNonce?: string;
-  clientReuseManifest?: ClientReuseManifestParseResult;
-  skipDisposition?: ClientReuseManifestSkipDisposition;
   mountedSlotsHeader?: string | null;
   renderedPathAndSearch?: string | null;
   renderMode?: AppRscRenderMode;
   waitUntil?: (promise: Promise<void>) => void;
-  layoutParamAccess?: AppLayoutParamAccessTracker;
-  classification?: LayoutClassificationOptions | null;
 };
 type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
   element: AppPageRenderableElement;
@@ -163,7 +152,7 @@ type RenderAppPageLifecycleOptions = RenderAppPageLifecycleOptionsBase & ({
  * its response policy, such as error boundaries and special errors, get the
  * same header as the normal render.
  */
-export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, probeCacheLife?: AppPageRequestCacheLife | null): Response;
+export declare function applyIneligibleRouteCachePolicy(response: Response, options: Pick<RenderAppPageLifecycleOptions, "dynamicStaleTimeSeconds" | "isDraftMode" | "isDynamicError" | "isForceDynamic" | "isForceStatic" | "isProduction" | "isProgressiveActionRender" | "isRscRequest" | "isStaticEligible" | "middlewareContext" | "peekDynamicUsage" | "revalidateSeconds" | "scriptNonce">, requestCacheLife?: AppPageRequestCacheLife | null): Response;
 export declare function renderAppPageLifecycle(options: RenderAppPageLifecycleOptions): Promise<Response>;
 //#endregion
 export {};

package/dist/server/app-page-render.js

@@ -4,36 +4,33 @@ import { bindRequestContext } from "../shims/unified-request-context.js";
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER } from "./headers.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
-import { isRouteCacheabilityEvaluation, recordRouteCacheabilityClientTraceMetadataMarker } from "../shims/cacheability-classification.js";
+import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
+import { getRouteCacheabilityCaptureOptions, isRouteCacheabilityEvaluation, recordRouteCacheabilityClientTraceMetadataMarker } from "../shims/cacheability-classification.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders, isCdnResponsePolicyHeader } from "./cache-control.js";
 import "./app-rsc-render-mode.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";
-import { isRenderDynamicLatched, markDynamicUsage } from "../shims/internal/headers-state.js";
-import { peekDynamicUsage, runWithDetachedDynamicUsage } from "../shims/headers.js";
+import { isRenderDynamicLatched } from "../shims/internal/headers-state.js";
+import { peekDynamicUsage } from "../shims/headers.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
+import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
+import { copyLinkHeaderProvenance, getFrameworkLinkHeader } from "./app-response-header-provenance.js";
+import { traceResponseStartWithCompletion } from "./response-start-tracing.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { createArtifactCompatibilityEnvelope, createArtifactCompatibilityGraphVersion } from "./artifact-compatibility.js";
 import { AppElementsWire, isAppElementsRecord } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
 import { isBailoutToCSRError } from "../shims/navigation-errors.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
-import { applyPrerenderCacheLifeHeader, applyPrerenderCacheTagsHeader } from "./prerender-cache-life-header.js";
-import { copyLinkHeaderProvenance, getFrameworkLinkHeader } from "./app-response-header-provenance.js";
 import { applyClientStaleTimeHeader, applyEdgeRuntimeHeader, buildAppPageHtmlResponse, buildAppPageRscResponse, resolveAppPageHtmlResponsePolicy, resolveAppPageRscResponsePolicy, resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
-import { probeAppPageBeforeRender } from "./app-page-probe.js";
+import { getAppPageLayoutGate } from "./app-page-layout-gate.js";
 import { hasDigest } from "./app-rsc-errors.js";
 import { recordAppPageRenderError, traceAppPageRender } from "./app-page-tracing.js";
-import { traceResponseStartWithCompletion } from "./response-start-tracing.js";
-import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRenderObservation, buildRenderRequestApiObservations, createStaticLayoutArtifactReuseDecision } from "./cache-proof.js";
-import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
-import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
 import { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
-import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
 import { createAppPageRscRenderStatusResolver } from "./app-page-rsc-render-status.js";
 import { finalizeAppPageCacheabilityEvaluationResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
-import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
 //#region src/server/app-page-render.ts
 function buildResponseTiming(options) {
 	if (options.isProduction) return;
@@ -75,11 +72,11 @@ function applyRequestCacheLife(options) {
 * its response policy, such as error boundaries and special errors, get the
 * same header as the normal render.
 */
-function applyIneligibleRouteCachePolicy(response, options, probeCacheLife = null) {
+function applyIneligibleRouteCachePolicy(response, options, requestCacheLife = null) {
 	const cacheControl = resolveEarlyResponseCacheControl(options);
 	const isRscRedirect = options.isRscRequest && response.headers.has("X-Vinext-Rsc-Redirect");
 	if (!cacheControl) {
-		const staleTimeSeconds = isRscRedirect ? resolveClientStaleTimeSeconds(probeCacheLife) : void 0;
+		const staleTimeSeconds = isRscRedirect ? resolveClientStaleTimeSeconds(requestCacheLife) : void 0;
 		if (staleTimeSeconds === void 0) return response;
 		const stamped = cloneForStamping(response);
 		applyClientStaleTimeHeader(stamped.headers, staleTimeSeconds);
@@ -116,18 +113,6 @@ function resolveAppPageCacheWriteRevalidateSeconds(options) {
 	if (options.revalidateSeconds === null && (options.isForceStatic || options.isDynamicError)) return Infinity;
 	return options.revalidateSeconds;
 }
-/**
-* A loading-shell prefetch without a loading boundary that can never be stored
-* renders only the route tree (see buildAppPageElements), so no layout runs and
-* none is probed. Next.js runs no layout for its no-loading prefetch either.
-*/
-function isRouteTreeOnlyLoadingShell(options) {
-	if (options.renderMode !== "prefetch-loading-shell") return false;
-	if (options.isCacheCandidate === true) return false;
-	if (!isAppElementsRecord(options.element)) return false;
-	const routeId = options.element[AppElementsWire.keys.route];
-	return typeof routeId === "string" && options.element[routeId] === null;
-}
 function readRootBoundaryId(element) {
 	const rootLayoutTreePath = element[AppElementsWire.keys.rootLayout];
 	return typeof rootLayoutTreePath === "string" ? rootLayoutTreePath : null;
@@ -144,146 +129,6 @@ function createAppPageArtifactCompatibility(element, routePattern) {
 		rootBoundaryId
 	});
 }
-function readStringMetadata(element, key) {
-	const value = element[key];
-	return typeof value === "string" ? value : null;
-}
-function createStaticLayoutOutputScope(input) {
-	const routeId = readStringMetadata(input.element, AppElementsWire.keys.route);
-	if (routeId === null) return null;
-	return {
-		kind: "layout",
-		layoutId: input.layoutId,
-		rootBoundaryId: input.artifactCompatibility.rootBoundaryId,
-		routeId
-	};
-}
-function createRenderAndSendSkipDisposition() {
-	return {
-		code: "SKIP_MODEL_DISABLED",
-		enabled: false,
-		mode: "renderAndSend"
-	};
-}
-function rejectStaticLayoutObservation(entry, code, fields = {}) {
-	return {
-		kind: "rejected",
-		rejection: {
-			code,
-			entryId: entry.id,
-			fields
-		},
-		skipDisposition: createRenderAndSendSkipDisposition()
-	};
-}
-function rejectUnsafeStaticLayoutObservation(entry, layoutParamAccess) {
-	const observation = layoutParamAccess?.getLayoutObservation(entry.id);
-	if (!observation) return rejectStaticLayoutObservation(entry, "SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE");
-	const observationRejection = getStaticLayoutObservationSkipRejection(observation);
-	if (observationRejection) return rejectStaticLayoutObservation(entry, observationRejection.code, observationRejection.fields);
-	return null;
-}
-function createRenderLifecycleSkipDisposition(input) {
-	if (!input.isRscRequest || input.clientReuseManifest === void 0) return;
-	const clientReuseManifest = input.clientReuseManifest;
-	if (clientReuseManifest.kind !== "parsed" || clientReuseManifest.manifest.entries.length === 0) return;
-	if (!isAppElementsRecord(input.element) || input.artifactCompatibility === void 0) return {
-		code: "SKIP_MODEL_DISABLED",
-		enabled: false,
-		mode: "renderAndSend"
-	};
-	const element = input.element;
-	const artifactCompatibility = input.artifactCompatibility;
-	const staticLayoutIds = new Set(Object.entries(input.layoutFlags).filter(([, flag]) => flag === "s").map(([layoutId]) => layoutId));
-	return createClientReuseSkipTransportPlan({
-		manifest: clientReuseManifest,
-		verifyEntry(entry) {
-			if (entry.kind !== "layout" || !staticLayoutIds.has(entry.id) || AppElementsWire.parseElementKey(entry.id)?.kind !== "layout") return crossCheckClientReuseManifestEntryWithCache({
-				artifact: {
-					compatibility: artifactCompatibility,
-					invalidation: { kind: "unknown" },
-					payloadHash: null
-				},
-				cacheDecision: null,
-				entry
-			});
-			const currentOutput = createStaticLayoutOutputScope({
-				artifactCompatibility,
-				element,
-				layoutId: entry.id
-			});
-			if (currentOutput === null) return crossCheckClientReuseManifestEntryWithCache({
-				artifact: {
-					compatibility: artifactCompatibility,
-					invalidation: { kind: "unknown" },
-					payloadHash: null
-				},
-				cacheDecision: null,
-				entry
-			});
-			const observationRejection = rejectUnsafeStaticLayoutObservation(entry, input.layoutParamAccess);
-			if (observationRejection) return observationRejection;
-			const candidateRouteId = createStaticLayoutClientReuseRouteId(entry.id);
-			const candidateOutput = {
-				...currentOutput,
-				routeId: candidateRouteId
-			};
-			const candidateVariant = buildCacheVariantWithRouteBudget({
-				budget: DEFAULT_CACHE_VARIANT_BUDGET,
-				dimensions: [],
-				output: candidateOutput,
-				routeBudget: {
-					routeId: candidateRouteId,
-					variantCacheKeys: []
-				}
-			});
-			const skipArtifactCompatibility = candidateVariant.kind === "variant" ? createStaticLayoutClientReuseArtifactCompatibility({
-				artifactCompatibility,
-				layoutId: entry.id,
-				rootBoundaryId: candidateOutput.rootBoundaryId,
-				routeId: candidateOutput.routeId,
-				variantCacheKey: candidateVariant.variant.cacheKey
-			}) : artifactCompatibility;
-			const cacheDecision = createStaticLayoutArtifactReuseDecision({
-				candidateArtifactCompatibility: skipArtifactCompatibility,
-				candidateObservation: buildRenderObservation({
-					boundaryOutcome: { kind: "success" },
-					cacheability: "public",
-					cacheTags: [],
-					completeness: "complete",
-					dynamicFetches: [],
-					output: candidateOutput,
-					pathTags: [input.cleanPathname],
-					requestApis: buildRenderRequestApiObservations({
-						completeness: "complete",
-						observed: []
-					})
-				}),
-				candidateVariant,
-				currentArtifactCompatibility: skipArtifactCompatibility,
-				currentOutput
-			});
-			return crossCheckClientReuseManifestEntryWithCache({
-				artifact: {
-					compatibility: skipArtifactCompatibility,
-					invalidation: { kind: "valid" },
-					payloadHash: candidateVariant.kind === "variant" ? createStaticLayoutClientReusePayloadHash({
-						artifactCompatibility: skipArtifactCompatibility,
-						layoutId: entry.id,
-						rootBoundaryId: candidateOutput.rootBoundaryId,
-						routeId: candidateOutput.routeId,
-						variantCacheKey: candidateVariant.variant.cacheKey
-					}) : null
-				},
-				cacheDecision,
-				entry
-			});
-		}
-	}).skipDisposition;
-}
-function isSkipTransportEnabled(skipDisposition) {
-	return skipDisposition?.enabled === true;
-}
 /**
 * Wraps an RSC response body to report invalid dynamic usage errors after the
 * stream is fully consumed. In dev mode, errors from cookies()/headers() inside
@@ -385,7 +230,6 @@ async function prepareAppPageElement(options) {
 }
 async function renderAppPageLifecycleImpl(options, renderSpan) {
 	let dynamicUsageObserved = false;
-	let dynamicUsageFinalized = false;
 	const isCacheCandidateHtmlRender = options.isCacheCandidate === true && options.isPrerender !== true && !options.isRscRequest;
 	const readsRenderDynamicLatch = isCacheCandidateHtmlRender || !options.isRscRequest && options.pprFallbackShellSignal === void 0 && (options.isPrerender === true || isRouteCacheabilityEvaluation());
 	const readDynamicUsage = bindRequestContext(() => options.consumeDynamicUsage() || readsRenderDynamicLatch && isRenderDynamicLatched());
@@ -395,34 +239,6 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		if (!dynamicUsageObserved) dynamicUsageObserved = readDynamicUsage();
 		return dynamicUsageObserved;
 	};
-	const finalizeRenderDynamicUsage = () => {
-		if (!dynamicUsageFinalized) {
-			consumeRenderDynamicUsage();
-			dynamicUsageFinalized = true;
-		}
-		return dynamicUsageObserved;
-	};
-	const probeOutcome = await runWithDetachedDynamicUsage(() => probeAppPageBeforeRender({
-		skipProbes: options.pprFallbackShellSignal !== void 0 || isRouteTreeOnlyLoadingShell(options),
-		layoutCount: options.layoutCount,
-		probeLayoutAt(layoutIndex) {
-			return options.probeLayoutAt(layoutIndex);
-		},
-		renderLayoutSpecialError(specialError, layoutIndex) {
-			return options.renderLayoutSpecialError(specialError, layoutIndex);
-		},
-		resolveSpecialError: resolveAppPageSpecialError,
-		runWithSuppressedHookWarning(probe) {
-			return options.runWithSuppressedHookWarning(probe);
-		},
-		classification: options.classification
-	}));
-	const preRenderResult = probeOutcome.result;
-	if (preRenderResult.response) {
-		if (probeOutcome.dynamicDetected) markDynamicUsage();
-		return applyIneligibleRouteCachePolicy(preRenderResult.response, options, probeOutcome.cacheLife);
-	}
-	const layoutFlags = preRenderResult.layoutFlags;
 	const artifactCompatibility = createAppPageArtifactCompatibility(options.element, options.routePattern);
 	const rootBoundaryId = artifactCompatibility?.rootBoundaryId ?? null;
 	const renderEpoch = artifactCompatibility?.renderEpoch ?? null;
@@ -439,23 +255,13 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		rootBoundaryId,
 		routePattern: options.routePattern
 	});
-	const skipDisposition = options.skipDisposition ?? createRenderLifecycleSkipDisposition({
-		artifactCompatibility,
-		cleanPathname: options.cleanPathname,
-		clientReuseManifest: options.clientReuseManifest,
-		element: options.element,
-		isRscRequest: options.isRscRequest,
-		layoutFlags,
-		layoutParamAccess: options.layoutParamAccess
-	});
-	const shouldBypassRscCache = options.isRscRequest && isSkipTransportEnabled(skipDisposition) || options.bypassInterceptionContextCache === true;
+	const isPartialPayload = options.isRscRequest && isAppElementsRecord(options.element) && Object.hasOwn(options.element, AppElementsWire.keys.skippedLayoutIds);
+	const shouldBypassRscCache = options.bypassInterceptionContextCache === true || isPartialPayload;
 	const dynamicStaleTimeSeconds = options.dynamicStaleTimeSeconds ?? resolveConfiguredDynamicStaleTimeSeconds();
 	const outgoingElement = AppElementsWire.encodeOutgoingPayload({
 		element: options.element,
-		layoutFlags,
 		...dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic ? { dynamicStaleTimeSeconds } : {},
-		...artifactCompatibility ? { artifactCompatibility } : {},
-		skipDisposition: options.isRscRequest ? skipDisposition : void 0
+		...artifactCompatibility ? { artifactCompatibility } : {}
 	});
 	const compileEnd = options.isProduction ? void 0 : performance.now();
 	const errorContextOverrides = {
@@ -466,6 +272,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		...options.isPrerender ? { revalidateReason: "stale" } : {}
 	};
 	const baseOnError = options.createRscOnErrorHandler(options.cleanPathname, options.routePattern, errorContextOverrides);
+	const layoutGate = options.isRscRequest && options.isPrerender !== true && options.pprFallbackShellSignal === void 0 ? getAppPageLayoutGate(options.element) : null;
 	const rscErrorTracker = createAppPageRscErrorTracker((error, requestInfo, errorContext) => {
 		if (renderSpan) recordAppPageRenderError(renderSpan, error);
 		return baseOnError(error, requestInfo, errorContext);
@@ -484,6 +291,24 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 	});
 	let pprFallbackShellRsc = null;
 	if (options.pprFallbackShellSignal) pprFallbackShellRsc = new Uint8Array(await readAppPageBinaryStream(rscStream));
+	if (layoutGate) {
+		const [heldStream, watchedStream] = rscStream.tee();
+		rscStream = heldStream;
+		const watchedReader = watchedStream.getReader();
+		const renderEnded = (async () => {
+			while (!(await watchedReader.read()).done);
+		})();
+		const layoutFailure = await layoutGate.wait((layoutId) => isAppElementsRecord(outgoingElement) && Object.hasOwn(outgoingElement, layoutId), renderEnded);
+		watchedReader.cancel().catch(() => {});
+		const layoutSpecialError = layoutFailure ? resolveAppPageSpecialError(layoutFailure.error) : null;
+		if (layoutFailure && layoutSpecialError) {
+			rscStream.cancel().catch(() => {});
+			return applyIneligibleRouteCachePolicy(await options.renderPageSpecialError(layoutSpecialError.kind === "http-access-fallback" ? {
+				...layoutSpecialError,
+				layoutIndex: layoutFailure.layoutIndex
+			} : layoutSpecialError), options, options.peekRequestCacheLife?.() ?? options.getRequestCacheLife());
+		}
+	}
 	let revalidateSeconds = options.revalidateSeconds;
 	let expireSeconds = options.expireSeconds;
 	const shouldWaitForAllReady = options.isPrerender === true && options.isSpeculativePrerender !== true || options.renderWholeDocument === true;
@@ -501,10 +326,47 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 	const rscForResponse = rscCapture.ssrStream;
 	const capturedRscDataRef = { value: null };
 	if (rscCapture.sideStream && options.isRscRequest) capturedRscDataRef.value = readAppPageBinaryStream(rscCapture.sideStream);
+	const resolveInitialNavigationCacheMetadata = (dynamicUsed, requestCacheLife) => {
+		let kind;
+		if (options.isForceStatic) kind = "static";
+		else if (options.isForceDynamic || dynamicUsed) kind = "dynamic";
+		else {
+			const observation = options.peekRenderObservationState?.();
+			kind = observation && (observation.dynamicFetches.length > 0 || observation.requestApis.length > 0) ? "dynamic" : "static";
+		}
+		const staleTimeSeconds = resolveClientStaleTimeSeconds(requestCacheLife);
+		return {
+			kind,
+			...kind === "dynamic" && dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true ? { dynamicStaleTimeSeconds } : {},
+			...staleTimeSeconds === void 0 ? {} : { staleTimeSeconds: Math.floor(staleTimeSeconds) }
+		};
+	};
 	if (options.isRscRequest) {
-		const resolveRscRenderStatus = options.isProduction && shouldCaptureRscForCacheMetadata && capturedRscDataRef.value !== null && options.isPrerender !== true && options.isRoutePPREnabled !== true ? createAppPageRscRenderStatusResolver({
+		const capturedRscData = capturedRscDataRef.value;
+		const resolvesRscRenderStatus = options.isProduction && shouldCaptureRscForCacheMetadata && capturedRscData !== null && options.isPrerender !== true && options.isRoutePPREnabled !== true;
+		const isPageDocumentRender = options.isCacheCandidate === true && !options.scriptNonce && !options.mountedSlotsHeader && !options.interceptionContext && !options.interceptionId && (options.renderMode === void 0 || options.renderMode === "navigation");
+		const cdnCacheAdapter = getCdnCacheAdapter();
+		const captureAdmittedDocument = resolvesRscRenderStatus && isPageDocumentRender && !cdnCacheAdapter.ownsBackgroundRevalidation ? cdnCacheAdapter.captureAppPageDocument?.() : void 0;
+		const rendersDocument = isPageDocumentRender && (cdnCacheAdapter.ownsBackgroundRevalidation || captureAdmittedDocument !== void 0);
+		const resolveRscRenderStatus = resolvesRscRenderStatus ? createAppPageRscRenderStatusResolver({
 			basePath: options.basePath,
-			capturedRscData: capturedRscDataRef.value,
+			capturedRscData,
+			...rendersDocument ? { document: {
+				clientTraceMetadata: options.clientTraceMetadata,
+				...captureAdmittedDocument ? { deadlineAt: getRouteCacheabilityCaptureOptions()?.captureDeadlineAt } : {},
+				getFontData: () => createAppPageFontData({
+					getLinks: options.getFontLinks,
+					getPreloads: options.getFontPreloads,
+					getStyles: options.getFontStyles
+				}),
+				getInitialNavigationCacheMetadata: () => resolveInitialNavigationCacheMetadata(peekDynamicUsage(), options.peekRequestCacheLife?.()),
+				mirrorNextFlight: () => rscErrorTracker.getCapturedSpecialError() !== null,
+				onSsrError: createAppPageSsrErrorHandler(options.createRscOnErrorHandler(options.cleanPathname, options.routePattern, {
+					...errorContextOverrides,
+					renderSource: "server-rendering"
+				}), rscErrorTracker.isCapturedError),
+				reactMaxHeadersLength: options.reactMaxHeadersLength
+			} } : {},
 			getCapturedSpecialError: rscErrorTracker.getCapturedSpecialError,
 			getCapturedSpecialErrors: rscErrorTracker.getCapturedSpecialErrors,
 			isForceStatic: options.isForceStatic,
@@ -524,7 +386,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 			}));
 		}
 		const dynamicUsedDuringBuild = consumeRenderDynamicUsage();
-		const rscResponsePolicy = shouldBypassRscCache ? { cacheControl: NO_STORE_CACHE_CONTROL } : resolveAppPageRscResponsePolicy({
+		const rscResponsePolicy = isPartialPayload ? { cacheControl: resolveUncacheableCacheControl(options.isProduction) } : shouldBypassRscCache ? { cacheControl: NO_STORE_CACHE_CONTROL } : resolveAppPageRscResponsePolicy({
 			dynamicUsedDuringBuild,
 			isDraftMode: options.isDraftMode,
 			isDynamicError: options.isDynamicError,
@@ -535,7 +397,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 			expireSeconds,
 			revalidateSeconds
 		});
-		if (shouldBypassRscCache) options.isrDebug?.(options.bypassInterceptionContextCache === true ? "RSC cache write skipped (unverified interception context)" : "RSC cache write skipped (skip transport payload)", options.cleanPathname);
+		if (shouldBypassRscCache) options.isrDebug?.(isPartialPayload ? "RSC cache write skipped (partial payload)" : "RSC cache write skipped (unverified interception context)", options.cleanPathname);
 		const shouldEmitDynamicStaleTime = dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic && (dynamicUsedDuringBuild || options.isForceDynamic);
 		const staleTimePending = options.isPrerender !== true && mayResolveCacheLifeAfterHeaders && !dynamicUsedDuringBuild;
 		const rscResponse = buildAppPageRscResponse(rscForResponse, {
@@ -559,7 +421,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		const completionHeaders = new Headers(rscResponse.headers);
 		completionHeaders.set(VINEXT_RSC_COMPLETION_METADATA_HEADER, "1");
 		const completionResponse = dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true && !options.isForceStatic && rscResponse.body ? new Response(appendRscCompletionMetadata(rscResponse.body, () => {
-			if (!finalizeRenderDynamicUsage()) return void 0;
+			if (!consumeRenderDynamicUsage()) return void 0;
 			const completedServerStaleTimeSeconds = resolveClientStaleTimeSeconds(options.peekRequestCacheLife?.());
 			if (shouldEmitDynamicStaleTime && completedServerStaleTimeSeconds === void 0) return;
 			return {
@@ -575,9 +437,22 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		return finalizeAppPageRscCacheResponse(devRscResponse, {
 			capturedRscDataPromise: options.isProduction && shouldCaptureRscForCacheMetadata ? capturedRscDataRef.value : null,
 			bypassInterceptionContextCache: options.bypassInterceptionContextCache,
+			captureAdmittedDocument,
 			cleanPathname: options.cleanPathname,
-			consumeDynamicUsage: finalizeRenderDynamicUsage,
+			consumeDynamicUsage: consumeRenderDynamicUsage,
 			consumeRenderObservationState,
+			createHtmlRenderObservation(input) {
+				return createAppPageRenderObservation({
+					boundaryOutcome: { kind: "success" },
+					cacheability: "public",
+					cacheTags: input.cacheTags,
+					cleanPathname: options.cleanPathname,
+					completeness: "complete",
+					output: htmlOutputScope,
+					params: options.navigationParams,
+					state: input.state
+				});
+			},
 			createRscRenderObservation(input) {
 				return createAppPageRenderObservation({
 					boundaryOutcome: { kind: "success" },
@@ -598,6 +473,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				return readRequestCacheLifeForCachePolicy(options);
 			},
 			isrDebug: options.isrDebug,
+			isrHtmlKey: options.isrHtmlKey,
 			isrRscKey: options.isrRscKey,
 			isrSet: options.isrSet,
 			interceptionContext: options.interceptionContext,
@@ -746,6 +622,12 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		copyLinkHeaderProvenance(response.headers, prerenderResponse.headers);
 		return prerenderResponse;
 	};
+	const markPrerenderedDynamicShellSpecialError = (response, specialError) => {
+		if (options.isPrerender === true && response.status === specialError.statusCode && resolveEarlyResponseCacheControl(options) !== null && response.headers.get("cache-control")?.includes("no-store")) getRequestExecutionContext()?.recordPrerenderSpecialError?.({
+			headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath) ?? {},
+			status: response.status
+		});
+	};
 	const finalizeShellSpecialErrorResponse = (response, specialError) => {
 		if (response.status !== specialError.statusCode) return applyIneligibleRouteCachePolicy(response, options);
 		const dynamicUsedDuringRender = consumeRenderDynamicUsage();
@@ -801,24 +683,8 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 			};
 			return renderAppPageHtmlStream({
 				capturedRscDataRef,
-				getInitialNavigationCacheMetadata: () => {
-					let kind;
-					if (options.isForceStatic) kind = "static";
-					else if (options.isForceDynamic || dynamicUsedDuringHtmlRender || peekDynamicUsage()) kind = "dynamic";
-					else {
-						const observation = options.peekRenderObservationState?.();
-						kind = observation && (observation.dynamicFetches.length > 0 || observation.requestApis.length > 0) ? "dynamic" : "static";
-					}
-					const requestCacheLife = options.isPrerender === true ? requestCacheLifeForPrerender ?? options.peekRequestCacheLife?.() : options.peekRequestCacheLife?.();
-					const staleTimeSeconds = resolveClientStaleTimeSeconds(requestCacheLife);
-					return {
-						kind,
-						...kind === "dynamic" && dynamicStaleTimeSeconds !== void 0 && options.isPrerender !== true ? { dynamicStaleTimeSeconds } : {},
-						...staleTimeSeconds === void 0 ? {} : { staleTimeSeconds: Math.floor(staleTimeSeconds) }
-					};
-				},
+				getInitialNavigationCacheMetadata: () => resolveInitialNavigationCacheMetadata(dynamicUsedDuringHtmlRender || peekDynamicUsage(), options.isPrerender === true ? requestCacheLifeForPrerender ?? options.peekRequestCacheLife?.() : options.peekRequestCacheLife?.()),
 				fontData,
-				hasCustomGlobalError: options.hasCustomGlobalError,
 				navigationContext: options.getNavigationContext(),
 				basePath: options.basePath,
 				clientTraceMetadata: options.clientTraceMetadata,
@@ -832,7 +698,8 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				scriptNonce: options.scriptNonce,
 				sideStream: rscCapture.sideStream,
 				ssrHandler,
-				fallbackToErrorDocumentOnShellError: options.isPrerender === true && options.isSpeculativePrerender === true ? false : void 0,
+				fallbackToErrorDocumentOnShellError: !(options.isPrerender === true && options.isSpeculativePrerender === true),
+				isServerComponentError: rscErrorTracker.isCapturedError,
 				waitForAllReady: shouldWaitForAllReady,
 				isStaticGeneration: options.isPrerender === true,
 				isForceStatic: options.isForceStatic,
@@ -871,7 +738,9 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 	if (htmlRender.response) {
 		if (shellSpecialError && options.isProduction && options.isPrerender !== true && resolveEarlyResponseCacheControl(options) === null) return finalizeShellSpecialErrorResponse(htmlRender.response, shellSpecialError);
 		if (shellSpecialError && prerenderedSpecialError) return finalizePrerenderedShellSpecialErrorResponse(htmlRender.response, shellSpecialError, prerenderedSpecialError);
-		return applyIneligibleRouteCachePolicy(htmlRender.response, options);
+		const response = applyIneligibleRouteCachePolicy(htmlRender.response, options);
+		if (shellSpecialError) markPrerenderedDynamicShellSpecialError(response, shellSpecialError);
+		return response;
 	}
 	let htmlStream = htmlRender.htmlStream;
 	if (!htmlStream) throw new Error("[vinext] Expected an HTML stream when no fallback response was returned");

package/dist/server/app-page-request.d.ts

@@ -1,5 +1,4 @@
 import { AppPageSpecialError } from "./app-page-execution.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 //#region src/server/app-page-request.d.ts
 type AppPageParams = Record<string, string | string[]>;
 type GenerateStaticParams = (args: {
@@ -120,7 +119,7 @@ type ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts> = {
 type ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>;
 type ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
 type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
-  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, buildOptions?: {
+  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, buildOptions?: {
     observeMetadataSearchParamsAccess?: boolean;
     observePageSearchParamsAccess?: boolean;
   }) => Promise<TElement>;
@@ -130,7 +129,6 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   getRouteParamNames: (route: TRoute) => readonly string[];
   getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
-  layoutParamAccess?: AppLayoutParamAccessTracker;
   resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
   renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
   resolveSearchParams?: (route: TRoute, searchParams: URLSearchParams) => Awaitable<URLSearchParams>;

package/dist/server/app-page-request.js

@@ -353,7 +353,7 @@ async function resolveAppPageIntercept(options) {
 			pathname: options.cleanPathname,
 			searchParams: renderSearchParams
 		});
-		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, renderSearchParams, options.layoutParamAccess);
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, renderSearchParams);
 		return {
 			interceptOpts: void 0,
 			response: await options.renderInterceptResponse(renderRoute, interceptElement)