vinext 1.3.0 → 1.4.0

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

@@ -1,34 +1,34 @@
 import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import "../utils/protocol-headers.js";
 import { VINEXT_INTERCEPTION_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
-import "./headers.js";
+import { VINEXT_MOUNTED_LAYOUTS_HEADER } from "./headers.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { runInWorkStoreScope } from "../shims/internal/work-store-scope.js";
 import { beginRouteCacheability, isRouteCacheabilityIdentityProbe, isRouteCacheabilityProbe, markRouteCacheabilityPatternDynamic, readRouteCacheabilityState } from "../shims/cacheability-classification.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL } from "./app-rsc-render-mode.js";
-import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, peekDynamicUsage, peekRenderRequestApiUsage, runWithIsolatedDynamicUsage, setHeadersContext } from "../shims/headers.js";
-import { _captureRequestScopedCacheLifeAccessors } from "../shims/cache-request-state.js";
+import { coalesceOnDemandResponse } from "./isr-cache.js";
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithDetachedDynamicUsage, setHeadersContext } from "../shims/headers.js";
+import { _captureRequestScopedCacheLifeAccessors, _isOnDemandRevalidate } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground } from "../shims/fetch-cache.js";
 import { cacheabilityManifestPageState } from "./cacheability-manifest.js";
 import { isAppPageStaticEligible } from "./app-segment-config.js";
-import { AppElementsWire } from "./app-elements-wire.js";
-import "./app-elements.js";
-import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
-import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getFrameworkLinkHeader } from "./app-response-header-provenance.js";
+import { traceResponseStart } from "./response-start-tracing.js";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader } from "./app-rsc-cache-busting.js";
+import { parseMountedLayoutsHeader } from "./app-mounted-layouts.js";
 import { resolveUncacheableCacheControl } from "./app-page-response.js";
 import { buildRscRedirectFlightStream } from "./app-rsc-redirect-flight.js";
-import { buildAppPageSpecialErrorResponse, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
+import { buildAppPageSpecialErrorResponse, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
+import { resolveAppPageLayoutHttpAccessBoundary, resolveAppPageParentHttpAccessBoundary, resolveAppPageRootHttpAccessBoundaryTreePosition } from "./app-page-boundary.js";
+import { isAppClientReference } from "./app-render-dependency.js";
 import { resolveAppPageTraceOperation } from "./app-page-tracing.js";
-import { createAppPageTreePath } from "./app-page-route-wiring.js";
-import { traceResponseStart } from "./response-start-tracing.js";
-import { buildAppPageTags } from "./implicit-tags.js";
-import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
-import { createAppPageRscErrorTracker } from "./app-page-stream.js";
-import { resolveAppPageParentHttpAccessBoundary, resolveAppPageParentHttpAccessBoundaryModule } from "./app-page-boundary.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
-import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
+import { createAppPageRscErrorTracker } from "./app-page-stream.js";
+import { getDefaultHttpAccessFallbackModule } from "./default-http-access-fallback-modules.js";
+import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
+import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
 import { buildAppPageElement, resolveAppPageIntercept, resolveAppPageInterceptionRerenderTarget, validateAppPageDynamicParams } from "./app-page-request.js";
 import { applyIneligibleRouteCachePolicy, renderAppPageLifecycle } from "./app-page-render.js";
@@ -55,75 +55,6 @@ function resolveAppPageRouteBoundaryModule(route, statusCode) {
 	if (statusCode === 404) return route.notFound ?? null;
 	return null;
 }
-/**
-* Request-time counterpart to the build-time `classifyLayoutSegmentConfig`
-* (`build/report.ts`). Both classify a layout by its `dynamic`/`revalidate`
-* segment config and agree on the shared cases (the build-time version
-* normalizes `revalidate = false` to `Infinity` upstream, so both treat it as
-* static); keep them aligned when either changes.
-*
-* The meaningful difference is scope, not logic: this request-time pass reads
-* the resolved module value, so it classifies layouts that were never captured
-* at build time (e.g. dev mode). Its result is merged on top of the build-time
-* classification map in `createEffectiveLayoutClassifications`, so such layouts
-* are classified here where they previously were not.
-*/
-function classifyLayoutSegmentConfigFromModule(layout) {
-	if (!layout) return null;
-	switch (layout.dynamic) {
-		case "force-dynamic": return {
-			kind: "dynamic",
-			reason: {
-				layer: "segment-config",
-				key: "dynamic",
-				value: "force-dynamic"
-			}
-		};
-		case "force-static":
-		case "error": return {
-			kind: "static",
-			reason: {
-				layer: "segment-config",
-				key: "dynamic",
-				value: layout.dynamic
-			}
-		};
-	}
-	if (layout.revalidate === false || layout.revalidate === Infinity) return {
-		kind: "static",
-		reason: {
-			layer: "segment-config",
-			key: "revalidate",
-			value: Infinity
-		}
-	};
-	if (layout.revalidate === 0) return {
-		kind: "dynamic",
-		reason: {
-			layer: "segment-config",
-			key: "revalidate",
-			value: 0
-		}
-	};
-	return null;
-}
-function createEffectiveLayoutClassifications(route, includeReasons) {
-	const classifications = new Map(route.__buildTimeClassifications ?? []);
-	const reasons = includeReasons ? new Map(route.__buildTimeReasons ?? []) : null;
-	for (let index = 0; index < route.layouts.length; index++) {
-		const classification = classifyLayoutSegmentConfigFromModule(route.layouts[index]);
-		if (classification === null) continue;
-		classifications.set(index, classification.kind);
-		reasons?.set(index, classification.reason);
-	}
-	return {
-		buildTimeClassifications: classifications.size > 0 ? classifications : null,
-		buildTimeReasons: reasons && reasons.size > 0 ? reasons : null
-	};
-}
-function getEffectiveLayoutClassifications(route, debugClassification) {
-	return createEffectiveLayoutClassifications(route, debugClassification !== void 0);
-}
 function shouldReadAppPageCache(options) {
 	return options.isProduction && !options.isProgressiveActionRender && !options.isDraftMode && !options.isForceDynamic && (options.isRscRequest || !options.scriptNonce) && (options.revalidateSeconds === null || options.revalidateSeconds > 0);
 }
@@ -182,6 +113,14 @@ function toInterceptOptions(interceptionContext, intercept) {
 		interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
 		interceptNotFound: intercept.notFound,
 		interceptNotFoundTreePosition: intercept.notFoundTreePosition,
+		interceptForbiddens: intercept.interceptForbiddens,
+		interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+		interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+		interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+		interceptErrors: intercept.interceptErrors,
+		interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+		interceptNotFounds: intercept.interceptNotFounds,
+		interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
 		interceptPage: intercept.page,
 		interceptParams: intercept.matchedParams,
 		interceptSlotId: intercept.slotId ?? null,
@@ -256,8 +195,6 @@ async function dispatchAppPageInner(options) {
 	const shouldUseEmptySearchParams = isForceStatic || isPrefetchDynamicShell;
 	const hasRequestSearchParams = !shouldUseEmptySearchParams && hasSearchParams(options.searchParams);
 	const pageSearchParams = shouldUseEmptySearchParams ? new URLSearchParams() : options.searchParams;
-	const layoutParamAccess = createAppLayoutParamAccessTracker();
-	const activeLoadingTreePositions = getActiveLoadingTreePositions(route);
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
 	setCurrentFetchCacheMode(options.fetchCache ?? null);
 	setCurrentFetchRevalidate(currentRevalidateSeconds);
@@ -314,8 +251,12 @@ async function dispatchAppPageInner(options) {
 		scriptNonce: options.scriptNonce
 	});
 	const isNeverStoredPath = options.pprRuntime === void 0 && hasNoManifestAdmissionState(route.pattern);
-	const shouldReadCache = !isRouteCacheabilityProbe() && isCacheEligibleRender && !isNeverStoredPath;
+	const isStoredRender = !isRouteCacheabilityProbe() && isCacheEligibleRender && !isNeverStoredPath;
+	const isOnDemandRevalidate = _isOnDemandRevalidate();
+	const shouldReadCache = isStoredRender && !isOnDemandRevalidate;
 	const isCacheCandidate = isCacheEligibleRender && isStaticEligible && options.pprFallbackShell === void 0 && !isNeverStoredPath;
+	const isUncacheableRender = !(isCacheEligibleRender && isStaticEligible) && options.pprFallbackShell === void 0 && (options.pprRuntime === void 0 || !options.isProduction);
+	const mountedLayouts = isUncacheableRender && options.isRscRequest && (options.renderMode ?? "navigation") === "navigation" && options.interceptionContext === null && options.isProgressiveActionRender !== true ? parseMountedLayoutsHeader(options.request.headers.get(VINEXT_MOUNTED_LAYOUTS_HEADER)) : null;
 	if (shouldReadCache && isStaticEligible) {
 		traceOperation = resolveAppPageTraceOperation({
 			hasRequestSearchParams,
@@ -376,11 +317,18 @@ async function dispatchAppPageInner(options) {
 				isForceStatic,
 				revalidateSeconds: currentRevalidateSeconds
 			}),
-			renderFreshPageForCache: async () => {
+			isDynamicRscRequest: options.pprRuntime !== void 0 && options.isRscRequest && options.request.headers.get("Next-Router-Prefetch") !== "1" && options.renderedConcreteUrlPaths?.has(options.cleanPathname) !== true,
+			renderFreshPageForCache: async ({ renderDocument }) => {
 				const revalidationTarget = await resolveCacheRenderTarget();
 				const revalidationDynamicConfig = options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
 				const revalidationConfigRevalidateSeconds = options.resolveRouteRevalidateSeconds?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? currentRevalidateSeconds : null);
 				const revalidationRouteRevalidateSeconds = revalidationTarget.route === route ? void 0 : revalidationConfigRevalidateSeconds ?? (revalidationDynamicConfig === "force-static" || revalidationDynamicConfig === "error" || options.isProduction && options.pprRuntime === void 0 && options.resolveRouteStaticEligible(revalidationTarget.route) ? Infinity : null);
+				const revalidationRouteHead = {
+					observeSearchParams: revalidationDynamicConfig !== "force-static",
+					searchParams: new URLSearchParams(),
+					streamMetadata: false,
+					value: null
+				};
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
 					displayPathname: options.displayPathname,
@@ -395,12 +343,15 @@ async function dispatchAppPageInner(options) {
 					setNavigationContext: options.setNavigationContext
 				}, async () => {
 					const { renderAppPageCacheArtifacts } = await import("./app-page-cache-render.js");
-					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams(), void 0, {
+					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams(), {
 						isForceStatic: revalidationDynamicConfig === "force-static",
 						observeMetadataSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						observePageSearchParamsAccess: revalidationDynamicConfig !== "force-static",
 						serveStreamingMetadata: placeGeneratedMetadataInBody,
-						placeStreamedMetadataInHead: true
+						placeStreamedMetadataInHead: true,
+						onHeadPrepared(head) {
+							revalidationRouteHead.value = head;
+						}
 					});
 					const baseRevalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern, { revalidateReason: "stale" });
 					const baseRevalidatedOnSsrError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern, {
@@ -430,19 +381,24 @@ async function dispatchAppPageInner(options) {
 							return baseRevalidatedOnSsrError(error, void 0, void 0);
 						},
 						reactMaxHeadersLength: options.reactMaxHeadersLength,
-						async renderShellSpecialError(error) {
+						resolveCaughtNotFoundBoundaries: renderDocument ? (error) => resolveAppPageCaughtNotFoundBoundaries(error, rscErrorTracker.getCapturedSpecialErrors(error)) : void 0,
+						async renderShellSpecialError(error, caughtDocument) {
 							const specialError = resolveAppPageShellSpecialError(error, rscErrorTracker.getCapturedSpecialErrors(error));
 							if (!specialError) return null;
-							if (options.isRscRequest) {
-								if (specialError.fromMetadata === true) return null;
-								return {
-									headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath),
-									html: "",
-									status: specialError.statusCode
-								};
-							}
+							if (options.isRscRequest && specialError.fromMetadata === true) return null;
+							if (renderDocument && caughtDocument) return {
+								headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath),
+								html: caughtDocument.html,
+								linkHeader: caughtDocument.linkHeader,
+								status: specialError.statusCode
+							};
+							if (!renderDocument || options.isRscRequest) return {
+								headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath),
+								html: "",
+								status: specialError.statusCode
+							};
 							if (revalidationTarget.route !== route) return null;
-							const document = await renderPageSpecialError(options, specialError, false, revalidationTarget.interceptOpts, true);
+							const document = await renderPageSpecialError(options, specialError, false, revalidationTarget.interceptOpts, true, void 0, revalidationRouteHead);
 							if (document.status !== specialError.statusCode) return null;
 							return {
 								headers: resolveAppPageSpecialErrorStoredHeaders(specialError, options.basePath),
@@ -492,7 +448,11 @@ async function dispatchAppPageInner(options) {
 			params: options.staticParamsValidationParams ?? options.params
 		});
 		if (dynamicParamsResponse) {
-			const renderedNotFound = await options.renderHttpAccessFallbackPage(404, { matchedParams: options.params }, options.middlewareContext);
+			const boundaryModule = route.notFound ?? getDefaultHttpAccessFallbackModule(404);
+			const renderedNotFound = await options.renderHttpAccessFallbackPage(404, {
+				boundaryModule,
+				matchedParams: options.params
+			}, options.middlewareContext);
 			const cachePolicy = {
 				dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 				isDraftMode,
@@ -518,8 +478,17 @@ async function dispatchAppPageInner(options) {
 	let interceptDynamicConfig;
 	let interceptDynamicConfigResolved = false;
 	let isInterceptSourceKnownDynamic = false;
+	const renderedRouteHead = {
+		observeSearchParams: !isForceStatic,
+		searchParams: pageSearchParams,
+		streamMetadata: placeGeneratedMetadataInBody && options.renderWholeDocument !== true,
+		value: null
+	};
+	const onHeadPrepared = (head) => {
+		renderedRouteHead.value = head;
+	};
 	const interceptResult = await resolveAppPageIntercept({
-		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess) {
+		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams) {
 			const sourceDynamicConfig = interceptDynamicConfigResolved ? interceptDynamicConfig : options.resolveRouteDynamicConfig?.(interceptRoute);
 			if (sourceDynamicConfig === "force-static" || sourceDynamicConfig === "error") {
 				const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
@@ -536,12 +505,14 @@ async function dispatchAppPageInner(options) {
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
 			setCurrentFetchRevalidate(sourceRevalidateSeconds);
 			setCurrentForceDynamicFetchDefault(sourceDynamicConfig === "force-dynamic");
-			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess, {
+			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, {
 				isForceStatic: sourceDynamicConfig === "force-static",
 				observeMetadataSearchParamsAccess: sourceDynamicConfig !== "force-static",
 				observePageSearchParamsAccess: sourceDynamicConfig !== "force-static",
+				isUncacheableRender,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
-				placeStreamedMetadataInHead: options.renderWholeDocument === true
+				placeStreamedMetadataInHead: options.renderWholeDocument === true,
+				onHeadPrepared
 			});
 		},
 		cleanPathname: options.cleanPathname,
@@ -556,7 +527,6 @@ async function dispatchAppPageInner(options) {
 			return options.getSourceRoute(sourceRouteIndex);
 		},
 		isRscRequest: options.isRscRequest,
-		layoutParamAccess,
 		resolveNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts) {
 			return resolveAppPageNavigationParams(sourceRoute, navigationParams, pathname, interceptOpts);
 		},
@@ -591,20 +561,24 @@ async function dispatchAppPageInner(options) {
 	if (interceptResult.response) return interceptResult.response;
 	const buildCurrentPageElement = () => buildAppPageElement({
 		buildPageElement() {
+			renderedRouteHead.value = null;
 			if (options.actionFailed) throw options.actionError;
-			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, pageSearchParams, layoutParamAccess, {
+			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, pageSearchParams, {
 				isForceStatic,
 				observeMetadataSearchParamsAccess: !isForceStatic,
 				observePageSearchParamsAccess: !isForceStatic,
+				isUncacheableRender,
+				mountedLayouts: interceptResult.interceptOpts ? null : mountedLayouts,
 				serveStreamingMetadata: placeGeneratedMetadataInBody,
-				placeStreamedMetadataInHead: options.renderWholeDocument === true
+				placeStreamedMetadataInHead: options.renderWholeDocument === true,
+				onHeadPrepared
 			});
 		},
 		renderErrorBoundaryPage(buildError) {
 			return options.renderErrorBoundaryPage(buildError);
 		},
 		renderSpecialError(specialError) {
-			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts);
+			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts, false, void 0, renderedRouteHead);
 		},
 		resolveSpecialError: resolveAppPageSpecialError
 	});
@@ -621,13 +595,13 @@ async function dispatchAppPageInner(options) {
 		discardAppPageRenderState();
 	}
 	const navigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, interceptResult.interceptOpts);
-	const layoutClassifications = getEffectiveLayoutClassifications(route, options.debugClassification);
 	const activeFallbackShellState = options.pprRuntime?.getState() ?? null;
 	const pprFallbackShellSignal = activeFallbackShellState?.abortController.signal;
 	const pprFallbackShellReactSignal = activeFallbackShellState?.reactAbortController.signal;
 	const isSpeculativePrerender = isPrerender && options.request.headers.get("x-vinext-prerender-speculative") === "1";
 	const requestCacheLife = _captureRequestScopedCacheLifeAccessors();
-	return renderAppPageLifecycle({
+	const onDemandCacheWrites = isOnDemandRevalidate ? [] : null;
+	const lifecycleOptions = {
 		basePath: options.basePath,
 		bypassInterceptionContextCache: options.bypassInterceptionContextCache,
 		clientTraceMetadata: options.clientTraceMetadata,
@@ -651,7 +625,6 @@ async function dispatchAppPageInner(options) {
 			});
 			return { element: pageBuildResult.element };
 		},
-		clientReuseManifest: options.clientReuseManifest,
 		getDraftModeCookieHeader,
 		getFontLinks: options.getFontLinks,
 		getFontPreloads: options.getFontPreloads,
@@ -691,7 +664,6 @@ async function dispatchAppPageInner(options) {
 		interceptionContext: options.interceptionContext,
 		interceptionId,
 		expireSeconds: options.expireSeconds,
-		layoutCount: getAppPageLayoutProbeCount(route, activeLoadingTreePositions),
 		loadSsrHandler: options.loadSsrHandler,
 		middlewareContext: options.middlewareContext,
 		navigationParams,
@@ -702,7 +674,6 @@ async function dispatchAppPageInner(options) {
 		abortPprFallbackShell: activeFallbackShellState ? () => {
 			options.pprRuntime.beginFinalRender(activeFallbackShellState);
 		} : void 0,
-		layoutParamAccess,
 		rootParams: options.rootParams,
 		peekRenderObservationState() {
 			return {
@@ -710,24 +681,6 @@ async function dispatchAppPageInner(options) {
 				requestApis: peekRenderRequestApiUsage()
 			};
 		},
-		probeLayoutAt(layoutIndex) {
-			return options.probeLayoutAt(layoutIndex, layoutParamAccess);
-		},
-		classification: {
-			getLayoutId(index) {
-				const treePosition = route.layoutTreePositions?.[index] ?? 0;
-				return AppElementsWire.encodeLayoutId(createAppPageTreePath([...route.routeSegments], treePosition));
-			},
-			buildTimeClassifications: layoutClassifications.buildTimeClassifications,
-			buildTimeReasons: layoutClassifications.buildTimeReasons,
-			debugClassification: options.debugClassification,
-			isLayoutObservationDynamic(layoutId) {
-				return isAppLayoutObservationUnsafeForStaticReuse(layoutParamAccess.getLayoutObservation(layoutId));
-			},
-			async runWithIsolatedDynamicScope(fn) {
-				return runWithIsolatedDynamicUsage(fn);
-			}
-		},
 		dynamicStaleTimeSeconds: options.dynamicStaleTimeSeconds,
 		revalidateSeconds: currentRevalidateSeconds,
 		mountedSlotsHeader: options.mountedSlotsHeader,
@@ -735,64 +688,149 @@ async function dispatchAppPageInner(options) {
 		renderErrorBoundaryResponse(renderError, errorOrigin) {
 			return options.renderErrorBoundaryPage(renderError, errorOrigin);
 		},
-		renderLayoutSpecialError(specialError, layoutIndex) {
-			return renderLayoutSpecialError(options, specialError, layoutIndex, serveStreamingMetadata);
-		},
 		renderPageSpecialError(specialError, renderOptions) {
-			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts, renderOptions?.isCacheCandidate === true);
+			return renderPageSpecialError(options, specialError, serveStreamingMetadata, interceptResult.interceptOpts, renderOptions?.isCacheCandidate === true, renderOptions?.caughtDocument, renderedRouteHead);
 		},
 		renderToReadableStream: options.renderToReadableStream,
 		hasCustomGlobalError: options.hasCustomGlobalError,
 		prerenderToReadableStream: options.prerenderToReadableStream,
 		routePattern: route.pattern,
-		runWithSuppressedHookWarning(probe) {
-			return options.runWithSuppressedHookWarning(probe);
-		},
 		scriptNonce: options.scriptNonce,
 		waitUntil(cachePromise) {
+			onDemandCacheWrites?.push(cachePromise);
 			getRequestExecutionContext()?.waitUntil(cachePromise);
 		}
-	});
+	};
+	const renderResponse = async () => {
+		const response = await renderAppPageLifecycle(lifecycleOptions);
+		if (onDemandCacheWrites) await Promise.all(onDemandCacheWrites);
+		return response;
+	};
+	if (isOnDemandRevalidate && isStoredRender && isStaticEligible && !(options.isRscRequest && options.mountedSlotsHeader)) {
+		const cacheKey = options.isRscRequest ? options.isrRscKey(options.cleanPathname, null, options.renderMode, options.interceptionContext, interceptionId) : options.isrHtmlKey(options.cleanPathname);
+		return coalesceOnDemandResponse(`${options.request.method}:${cacheKey}`, options.request.method, renderResponse);
+	}
+	return renderResponse();
 }
-async function renderLayoutSpecialError(options, specialError, layoutIndex, serveStreamingMetadata) {
-	return buildAppPageSpecialErrorResponse({
-		basePath: options.basePath,
-		buildRscRedirectFlightStream: (rscOptions) => buildRscRedirectFlightStream({
-			renderToReadableStream: options.renderToReadableStream,
-			digest: rscOptions.digest
-		}),
-		clearRequestContext: options.clearRequestContext,
-		getAndClearPendingCookies,
-		serveStreamingMetadata,
-		isEdgeRuntime: options.isEdgeRuntime,
-		isRscRequest: options.isRscRequest,
-		middlewareContext: options.middlewareContext,
-		renderFallbackPage(statusCode) {
-			const parentBoundaryModule = resolveAppPageParentHttpAccessBoundaryModule({
-				layoutIndex,
-				rootForbiddenModule: options.rootForbiddenModule,
-				rootNotFoundModule: options.rootNotFoundModule,
-				rootUnauthorizedModule: options.rootUnauthorizedModule,
-				routeForbiddenModules: options.route.forbiddens,
-				routeNotFoundModules: options.route.notFounds,
-				routeUnauthorizedModules: options.route.unauthorizeds,
-				statusCode
+/**
+* A signal the route's own render threw keeps the route's head, reusing the
+* one that render prepared. A progressive server action's signal doesn't:
+* Next.js answers it with a not-found tree in place of the page
+* (`createNotFoundLoaderTree`), so the page's metadata never applies.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/app-render.tsx
+*/
+function resolveFallbackRouteHead(options, renderedRouteHead) {
+	if (options.actionFailed || !renderedRouteHead) return null;
+	const { value, ...render } = renderedRouteHead;
+	return {
+		...render,
+		prepared: value
+	};
+}
+/**
+* The outermost layout above every loading boundary whose subtree throws the
+* HTTP access fallback with `statusCode`. The document's shell rejected with
+* one that a component nothing tags threw: one a layout renders, the page
+* renders or a template. This runs only on that error path, as a layout's own
+* component tags what it throws.
+*/
+async function findAppPageLayoutSubtreeSpecialErrorIndex(options, statusCode, limit) {
+	const layoutCount = Math.min(limit, getAppPageLayoutProbeCount(options.route, getActiveLoadingTreePositions(options.route)));
+	if (layoutCount === 0) return null;
+	return await runWithDetachedDynamicUsage(() => options.runWithSuppressedHookWarning(async () => {
+		for (let layoutIndex = 0; layoutIndex < layoutCount; layoutIndex++) {
+			const outcome = await runWithConnectionProbe(async () => {
+				try {
+					await options.probeLayoutAt(layoutIndex);
+					return false;
+				} catch (error) {
+					const specialError = resolveAppPageSpecialError(error);
+					return specialError?.kind === "http-access-fallback" && specialError.statusCode === statusCode;
+				}
 			});
-			const fallbackOptions = {
-				layouts: options.route.layouts.slice(0, layoutIndex),
-				matchedParams: options.params
-			};
-			if (parentBoundaryModule) {
-				fallbackOptions.boundaryComponent = parentBoundaryModule.default;
-				fallbackOptions.boundaryModule = parentBoundaryModule;
-			}
-			return options.renderHttpAccessFallbackPage(statusCode, fallbackOptions, null);
-		},
-		request: options.request,
-		specialError
+			if (outcome.completed && outcome.result) return layoutIndex;
+		}
+		return null;
+	}));
+}
+/**
+* The fallback for a special error a layout threw, or a parallel slot that
+* layout renders: the boundary above the layout catches it. With
+* `insideLayout`, the layout re-renders around its own segment's boundary
+* instead. Without a segment boundary, Next.js' built-in not-found,
+* forbidden or unauthorized page renders inside the root layout, or without
+* it when the root layout, or a slot beside it outside `insideLayout`, threw.
+*/
+function renderLayoutBoundaryFallback(options, statusCode, layoutIndex, fallbackOptions) {
+	const { route } = options;
+	const layoutTreePositions = route.layoutTreePositions ?? [];
+	const boundaryModules = statusCode === 403 ? route.segmentForbiddens : statusCode === 401 ? route.segmentUnauthorizeds : route.segmentNotFounds;
+	const boundaryTreePositions = statusCode === 403 ? route.segmentForbiddenTreePositions : statusCode === 401 ? route.segmentUnauthorizedTreePositions : route.segmentNotFoundTreePositions;
+	const insideLayout = fallbackOptions.insideLayout === true;
+	const ownLayoutTreePosition = layoutTreePositions[layoutIndex];
+	const layoutTreePosition = ownLayoutTreePosition === void 0 || !insideLayout ? ownLayoutTreePosition : ownLayoutTreePosition + 1;
+	const renderedLayoutCount = insideLayout ? layoutIndex + 1 : layoutIndex;
+	const boundary = layoutTreePosition === void 0 ? null : resolveAppPageLayoutHttpAccessBoundary({
+		boundaryModules: boundaryModules ?? [],
+		boundaryTreePositions: boundaryTreePositions ?? [],
+		layoutTreePosition
+	});
+	const boundaryModule = boundary?.module ?? getDefaultHttpAccessFallbackModule(statusCode);
+	if (!boundaryModule) return Promise.resolve(null);
+	const boundaryTreePosition = Math.max(boundary?.treePosition ?? 0, resolveAppPageRootHttpAccessBoundaryTreePosition(route.routeSegments, layoutTreePositions, layoutTreePosition));
+	const headBoundary = resolveAppPageLayoutHttpAccessBoundary({
+		boundaryModules: boundaryModules ?? [],
+		boundaryTreePositions: boundaryTreePositions ?? [],
+		layoutTreePosition: Number.POSITIVE_INFINITY
+	});
+	return options.renderHttpAccessFallbackPage(statusCode, {
+		boundaryComponent: boundaryModule.default,
+		boundaryModule,
+		headBoundaryModule: headBoundary?.module ?? boundaryModule,
+		headLayouts: fallbackOptions.headLayouts,
+		...fallbackOptions.intercept ? { intercept: fallbackOptions.intercept } : {},
+		...fallbackOptions.isCacheCandidate ? { isCacheCandidate: true } : {},
+		layouts: route.layouts.filter((_, index) => index < renderedLayoutCount && (layoutTreePositions[index] ?? 0) <= boundaryTreePosition),
+		matchedParams: options.params,
+		...fallbackOptions.routeHead ? { routeHead: fallbackOptions.routeHead } : {}
+	}, null);
+}
+/**
+* The fallback for a page's `notFound()` / `forbidden()` / `unauthorized()`.
+* Next.js wraps each segment's children in its boundaries, with or without a
+* layout, so the route's deepest boundary catches the signal and replaces
+* every layout below its segment. Without one, the built-in not-found,
+* forbidden or unauthorized page renders inside the root layout. Returns
+* `null` for routes without segment data.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-component-tree.tsx
+*/
+function renderPageSegmentBoundaryFallback(options, statusCode, intercept, isCacheCandidate, routeHead) {
+	const { route } = options;
+	const boundaryModules = statusCode === 403 ? route.segmentForbiddens : statusCode === 401 ? route.segmentUnauthorizeds : route.segmentNotFounds;
+	const boundaryTreePositions = statusCode === 403 ? route.segmentForbiddenTreePositions : statusCode === 401 ? route.segmentUnauthorizedTreePositions : route.segmentNotFoundTreePositions;
+	if (!boundaryTreePositions) return null;
+	const boundary = resolveAppPageLayoutHttpAccessBoundary({
+		boundaryModules: boundaryModules ?? [],
+		boundaryTreePositions,
+		layoutTreePosition: Number.POSITIVE_INFINITY
 	});
+	const boundaryModule = boundary?.module ?? getDefaultHttpAccessFallbackModule(statusCode);
+	if (!boundaryModule) return Promise.resolve(null);
+	const layoutTreePositions = route.layoutTreePositions ?? [];
+	const boundaryTreePosition = Math.max(boundary?.treePosition ?? 0, resolveAppPageRootHttpAccessBoundaryTreePosition(route.routeSegments, layoutTreePositions, Number.POSITIVE_INFINITY));
+	return options.renderHttpAccessFallbackPage(statusCode, {
+		boundaryComponent: boundaryModule.default,
+		boundaryModule,
+		headLayouts: route.layouts,
+		intercept,
+		...isCacheCandidate ? { isCacheCandidate } : {},
+		layouts: route.layouts.filter((_, index) => (layoutTreePositions[index] ?? 0) <= boundaryTreePosition),
+		matchedParams: options.params,
+		...routeHead ? { routeHead } : {}
+	}, null);
 }
-async function renderPageSpecialError(options, specialError, serveStreamingMetadata, intercept, isCacheCandidate = false) {
+async function renderPageSpecialError(options, specialError, serveStreamingMetadata, intercept, isCacheCandidate = false, caughtDocument, renderedRouteHead = null) {
+	const routeHead = resolveFallbackRouteHead(options, renderedRouteHead);
 	return buildAppPageSpecialErrorResponse({
 		basePath: options.basePath,
 		buildRscRedirectFlightStream: (rscOptions) => buildRscRedirectFlightStream({
@@ -805,7 +843,27 @@ async function renderPageSpecialError(options, specialError, serveStreamingMetad
 		isEdgeRuntime: options.isEdgeRuntime,
 		isRscRequest: options.isRscRequest,
 		middlewareContext: options.middlewareContext,
-		renderFallbackPage(statusCode) {
+		async renderFallbackPage(statusCode) {
+			if (caughtDocument) return caughtDocument;
+			if (specialError.kind === "http-access-fallback") {
+				let layoutIndex = specialError.layoutIndex ?? null;
+				if (specialError.unattributed === true) layoutIndex = await findAppPageLayoutSubtreeSpecialErrorIndex(options, statusCode, layoutIndex ?? (specialError.slotLayoutIndex === void 0 ? options.route.layouts.length : specialError.slotLayoutIndex + 1)) ?? layoutIndex;
+				if (layoutIndex !== null) return renderLayoutBoundaryFallback(options, statusCode, layoutIndex, {
+					headLayouts: options.route.layouts.slice(0, layoutIndex),
+					intercept,
+					isCacheCandidate,
+					routeHead
+				});
+			}
+			if (specialError.kind === "http-access-fallback" && specialError.slotLayoutIndex !== void 0) return renderLayoutBoundaryFallback(options, statusCode, specialError.slotLayoutIndex, {
+				headLayouts: options.route.layouts,
+				insideLayout: specialError.slotLayoutIndex === 0 && (statusCode === 404 || isAppClientReference(options.route.layouts[0]?.default)),
+				intercept,
+				isCacheCandidate,
+				routeHead
+			});
+			const pageBoundaryFallback = renderPageSegmentBoundaryFallback(options, statusCode, intercept, isCacheCandidate, routeHead);
+			if (pageBoundaryFallback) return pageBoundaryFallback;
 			const routeBoundaryModule = resolveAppPageRouteBoundaryModule(options.route, statusCode);
 			const layoutCount = options.route.layouts.length;
 			const { module: parentBoundaryModule, layoutIndex: boundaryLayoutIndex } = resolveAppPageParentHttpAccessBoundary({
@@ -822,7 +880,8 @@ async function renderPageSpecialError(options, specialError, serveStreamingMetad
 			const fallbackOptions = {
 				intercept,
 				...isCacheCandidate ? { isCacheCandidate } : {},
-				matchedParams: options.params
+				matchedParams: options.params,
+				...routeHead ? { routeHead } : {}
 			};
 			if (useLayoutAlignedBoundary && boundaryLayoutIndex !== null) {
 				fallbackOptions.layouts = options.route.layouts.slice(0, boundaryLayoutIndex + 1);