vinext 1.3.0 → 1.4.0

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

@@ -1,38 +1,36 @@
 import { preserveFullyBufferedBodyMetadata } from "./fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 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 { deferUntilStreamConsumed } from "./defer-until-stream-consumed.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, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
-import { probeAppPageBeforeRender } from "./app-page-probe.js";
+import { buildAppPageFontLinkHeader, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, teeAppPageRscStreamForCapture } from "./app-page-execution.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 { buildAppPageHtmlDocumentResponse, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
-import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, createAppPageSsrErrorHandler, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { createAppPageRscRenderStatusResolver } from "./app-page-rsc-render-status.js";
 import { finalizeAppPageCacheabilityEvaluationResponse, finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
-import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
-import { appendRscCompletionMetadata } from "./rsc-completion-metadata.js";
-import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
-import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
 //#region src/server/app-page-render.ts
 function buildResponseTiming(options) {
 	if (options.isProduction) return;
@@ -74,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);
@@ -131,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
@@ -389,27 +247,6 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 		}
 		return dynamicUsageObserved;
 	};
-	const probeOutcome = await runWithDetachedDynamicUsage(() => probeAppPageBeforeRender({
-		skipProbes: options.pprFallbackShellSignal !== void 0,
-		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;
@@ -426,23 +263,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 = {
@@ -453,6 +280,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);
@@ -471,6 +299,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;
@@ -488,10 +334,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,
@@ -511,7 +394,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,
@@ -522,7 +405,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, {
@@ -562,9 +445,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,
 			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" },
@@ -585,6 +481,7 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				return readRequestCacheLifeForCachePolicy(options);
 			},
 			isrDebug: options.isrDebug,
+			isrHtmlKey: options.isrHtmlKey,
 			isrRscKey: options.isrRscKey,
 			isrSet: options.isrSet,
 			interceptionContext: options.interceptionContext,
@@ -788,22 +685,7 @@ 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(),
@@ -825,10 +707,11 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				isForceStatic: options.isForceStatic,
 				isCacheCandidate: isCacheCandidateHtmlRender,
 				onSsrError: createAppPageSsrErrorHandler(onSsrError, rscErrorTracker.isCapturedError),
-				mirrorNextFlight: () => rscErrorTracker.getCapturedSpecialError() !== null
+				mirrorNextFlight: () => rscErrorTracker.getCapturedSpecialError() !== null,
+				resolveCaughtNotFoundBoundaries: (error) => resolveAppPageCaughtNotFoundBoundaries(error, rscErrorTracker.getCapturedSpecialErrors(error))
 			});
 		},
-		async renderSpecialErrorResponse(specialError) {
+		async renderSpecialErrorResponse(specialError, caughtDocument) {
 			shellSpecialError = specialError;
 			const mayPrerender = mayPrerenderShellSpecialError();
 			if (mayStoreShellSpecialError() || mayPrerender) await settleCapturedRscRenderForCacheMetadata(capturedRscDataRef.value, peekRenderDynamicUsage);
@@ -836,7 +719,18 @@ async function renderAppPageLifecycleImpl(options, renderSpan) {
 				dynamicUsed: consumeRenderDynamicUsage(),
 				redirectMetadata: specialError.kind === "redirect" ? readPrerenderCacheMetadata() : null
 			};
-			return options.renderPageSpecialError(specialError, { isCacheCandidate: isCacheCandidateHtmlRender });
+			return options.renderPageSpecialError(specialError, {
+				isCacheCandidate: isCacheCandidateHtmlRender,
+				...caughtDocument ? { caughtDocument: buildAppPageHtmlDocumentResponse(caughtDocument.htmlStream, {
+					clearRequestContext: options.clearRequestContext,
+					fontLinkHeader,
+					isEdgeRuntime: options.isEdgeRuntime,
+					middlewareHeaders: null,
+					reactLinkHeader: caughtDocument.linkHeader,
+					reactMaxHeadersLength: options.reactMaxHeadersLength,
+					status: specialError.statusCode
+				}) } : {}
+			});
 		},
 		resolveSpecialError(error) {
 			return resolveAppPageShellSpecialError(error, rscErrorTracker.getCapturedSpecialErrors(error));

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: {
@@ -66,8 +65,11 @@ type AppPageInterceptMatch<TPage = unknown> = {
   interceptLoadings?: readonly unknown[] | null;
   interceptLoadingTreePositions?: readonly number[] | null;
   interceptNotFoundBranchSegments?: readonly string[] | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  interceptNotFoundTreePositions?: readonly number[] | null;
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
   sourceMatchedParams?: AppPageParams;
   page: TPage;
@@ -75,6 +77,15 @@ type AppPageInterceptMatch<TPage = unknown> = {
   notFound?: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  interceptForbiddenTreePositions?: readonly number[] | null;
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  interceptUnauthorizedTreePositions?: readonly number[] | null;
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[] | null;
+  interceptErrorTreePositions?: readonly number[] | null;
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   __loadState?: {
     page: TPage;
     pageLoading: Promise<TPage> | null;
@@ -108,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>;
@@ -118,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>;
@@ -140,4 +150,5 @@ export declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage,
 export declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>>;
 export declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;
 export declare function buildAppPageElement<TElement>(options: BuildAppPageElementOptions<TElement>): Promise<BuildAppPageElementResult<TElement>>;
-//#endregion
+//#endregion
+export {};

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

@@ -283,7 +283,7 @@ async function resolveAppPageInterceptState(options) {
 	if (!intercept) return { kind: "none" };
 	await loadAppInterceptPage(intercept);
 	await loadAppInterceptNotFound(intercept);
-	if (intercept.__loadInterceptLayouts || intercept.__loadInterceptLoadings) await loadAppInterceptLayouts(intercept);
+	if (intercept.__loadInterceptLayouts || intercept.__loadInterceptLoadings || intercept.__loadInterceptNotFounds || intercept.__loadInterceptForbiddens || intercept.__loadInterceptUnauthorizeds || intercept.__loadInterceptErrors) await loadAppInterceptLayouts(intercept);
 	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };
 	if (sourceRoute === options.currentRoute) return {
@@ -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)

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

@@ -2,14 +2,14 @@ import { VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-v
 import { NEXT_CACHE_TAGS_HEADER, NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_STALE_TIME_PENDING_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
+import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
 import { applyPrerenderCacheLifeHeader } from "./prerender-cache-life-header.js";
-import { markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
 	if (!timing) return;
-	const handlerStart = Math.round(timing.handlerStart);
+	const handlerStart = Math.round(Date.now() - (performance.now() - timing.handlerStart));
 	const compileMs = timing.compileEnd !== void 0 ? Math.round(timing.compileEnd - timing.handlerStart) : -1;
 	const renderMs = timing.responseKind === "html" && timing.renderEnd !== void 0 && timing.compileEnd !== void 0 ? Math.round(timing.renderEnd - timing.compileEnd) : -1;
 	headers.set(VINEXT_TIMING_HEADER, `${handlerStart},${compileMs},${renderMs}`);