vinext 1.3.1 → 1.4.1

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

@@ -1,34 +1,32 @@
 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 { isAppClientReference } from "./app-render-dependency.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, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders } from "./app-page-execution.js";
-import { resolveAppPageTraceOperation } from "./app-page-tracing.js";
-import { createAppPageTreePath } from "./app-page-route-wiring.js";
-import { traceResponseStart } from "./response-start-tracing.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 { shouldServeStreamingMetadata } from "./streaming-metadata.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
 import { createAppPageRscErrorTracker } from "./app-page-stream.js";
 import { getDefaultHttpAccessFallbackModule } from "./default-http-access-fallback-modules.js";
-import { createAppLayoutParamAccessTracker, isAppLayoutObservationUnsafeForStaticReuse } from "./app-layout-param-observation.js";
 import { consumeAppPageRenderObservationState, discardAppPageRenderState } from "./app-page-render-observation.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageMethodResponse } from "./app-page-method.js";
@@ -57,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);
 }
@@ -266,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);
@@ -324,9 +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,
@@ -387,7 +317,8 @@ 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);
@@ -412,7 +343,7 @@ 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",
@@ -450,24 +381,22 @@ async function dispatchAppPageInner(options) {
 							return baseRevalidatedOnSsrError(error, void 0, void 0);
 						},
 						reactMaxHeadersLength: options.reactMaxHeadersLength,
-						resolveCaughtNotFoundBoundaries: options.isRscRequest ? void 0 : (error) => resolveAppPageCaughtNotFoundBoundaries(error, rscErrorTracker.getCapturedSpecialErrors(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 (caughtDocument) return {
+							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, void 0, revalidationRouteHead);
 							if (document.status !== specialError.statusCode) return null;
@@ -519,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,
@@ -555,7 +488,7 @@ async function dispatchAppPageInner(options) {
 		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");
@@ -572,7 +505,7 @@ 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",
@@ -594,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);
 		},
@@ -631,11 +563,12 @@ async function dispatchAppPageInner(options) {
 		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,
 				onHeadPrepared
@@ -662,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,
@@ -692,7 +625,6 @@ async function dispatchAppPageInner(options) {
 			});
 			return { element: pageBuildResult.element };
 		},
-		clientReuseManifest: options.clientReuseManifest,
 		getDraftModeCookieHeader,
 		getFontLinks: options.getFontLinks,
 		getFontPreloads: options.getFontPreloads,
@@ -732,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,
@@ -743,7 +674,6 @@ async function dispatchAppPageInner(options) {
 		abortPprFallbackShell: activeFallbackShellState ? () => {
 			options.pprRuntime.beginFinalRender(activeFallbackShellState);
 		} : void 0,
-		layoutParamAccess,
 		rootParams: options.rootParams,
 		peekRenderObservationState() {
 			return {
@@ -751,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,
@@ -776,24 +688,28 @@ async function dispatchAppPageInner(options) {
 		renderErrorBoundaryResponse(renderError, errorOrigin) {
 			return options.renderErrorBoundaryPage(renderError, errorOrigin);
 		},
-		renderLayoutSpecialError(specialError, layoutIndex) {
-			return renderLayoutSpecialError(options, specialError, layoutIndex, serveStreamingMetadata, renderedRouteHead);
-		},
 		renderPageSpecialError(specialError, renderOptions) {
 			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();
 }
 /**
 * A signal the route's own render threw keeps the route's head, reusing the
@@ -810,28 +726,31 @@ function resolveFallbackRouteHead(options, renderedRouteHead) {
 		prepared: value
 	};
 }
-async function renderLayoutSpecialError(options, specialError, layoutIndex, serveStreamingMetadata, renderedRouteHead) {
-	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) {
-			return renderLayoutBoundaryFallback(options, statusCode, layoutIndex, {
-				headLayouts: options.route.layouts.slice(0, layoutIndex),
-				routeHead: resolveFallbackRouteHead(options, renderedRouteHead)
+/**
+* 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;
+				}
 			});
-		},
-		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
@@ -923,8 +842,18 @@ async function renderPageSpecialError(options, specialError, serveStreamingMetad
 		isEdgeRuntime: options.isEdgeRuntime,
 		isRscRequest: options.isRscRequest,
 		middlewareContext: options.middlewareContext,
-		renderFallbackPage(statusCode) {
-			if (caughtDocument) return Promise.resolve(caughtDocument);
+		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)),

package/dist/server/app-page-element-builder.d.ts

@@ -4,7 +4,6 @@ import "./app-elements.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { AppPagePreparedRouteHead, ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppPageSemanticSegment } from "./app-page-segment-state.js";
 import { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute } from "./app-page-route-wiring.js";
 //#region src/server/app-page-element-builder.d.ts
@@ -67,6 +66,8 @@ export type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> =
   isForceStatic?: boolean;
   /** The render can never be stored (see buildAppPageElements). */
   isUncacheableRender?: boolean;
+  /** Layouts the navigating client holds (see buildAppPageElements). */
+  mountedLayouts?: ReadonlySet<string> | null;
   /** Observe page metadata `searchParams` access for cache-safety classification. */
   observeMetadataSearchParamsAccess?: boolean;
   /** Whether generated metadata may stream into the response body. */
@@ -104,7 +105,6 @@ export type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModu
   rootUnauthorizedModule?: TModule | null;
   /** File-based metadata routes (favicon, manifest, sitemap, etc.). */
   metadataRoutes: readonly MetadataFileRoute[];
-  layoutParamAccess?: AppLayoutParamAccessTracker;
   /**
    * Configured next.config `basePath`. Threaded through `resolveAppPageHead`
    * so file-based metadata route URLs emitted in <head> are prefixed.

package/dist/server/app-page-element-builder.js

@@ -1,23 +1,23 @@
 import { isPromiseLike } from "../utils/promise.js";
 import { APP_RSC_RENDER_MODE_NAVIGATION } from "./app-rsc-render-mode.js";
 import { matchRoutePattern } from "../routing/route-pattern.js";
-import { createAppPageRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, renderAfterAppDependencies } from "./app-render-dependency.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
 import { ErrorBoundary, ForbiddenBoundary, NotFoundBoundary, UnauthorizedBoundary } from "../shims/error-boundary.js";
 import { withUseCacheLayoutMarker, withUseCachePageMarker } from "../shims/internal/app-page-props-cache-key.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { tagAppPagePageError, tagAppPageSlotError } from "./app-page-execution.js";
-import { resolveAppPageBranchParams } from "./app-page-params.js";
-import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
-import { sanitizeErrorForClient } from "./app-rsc-errors.js";
-import { resolveAppPageModuleTraceSegment, traceCreateComponentTree, traceGetLayoutOrPageModule } from "./app-page-tracing.js";
-import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath, resolveAppPageLoadingModuleAtOrAbove } from "./app-page-route-wiring.js";
 import { createAppPageMetadataSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
-import { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, slotInterceptKeepsSourceHead } from "./app-page-head.js";
+import { resolveAppPageBranchParams } from "./app-page-params.js";
+import { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveInterceptLayoutsBesidePage, slotInterceptKeepsSourceHead } from "./app-page-head.js";
 import { createRouteNotFoundHeadPlanOptions, recoverAppPageRouteHead } from "./app-page-http-access-fallback-metadata.js";
 import { ClientPageRoot } from "../shims/client-page-root.js";
 import "./app-rsc-route-matching.js";
+import { createAppPageRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, renderAfterAppDependencies } from "./app-render-dependency.js";
+import { sanitizeErrorForClient } from "./app-rsc-errors.js";
+import { resolveAppPageModuleTraceSegment, traceCreateComponentTree, traceGetLayoutOrPageModule } from "./app-page-tracing.js";
+import { buildAppPageElements, createAppPageSourcePage, createAppPageTreePath, resolveAppPageLoadingModuleAtOrAbove } from "./app-page-route-wiring.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
@@ -107,7 +107,7 @@ function traceAppPageInterceptLayoutModules(modules, branchSegments, layoutSegme
 async function buildPageElements(options) {
 	const { route, params, routePath, displayPathname = routePath, pageRequest, globalErrorModule, rootNotFoundModule, rootForbiddenModule, rootUnauthorizedModule, metadataRoutes } = options;
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
-	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, isUncacheableRender = false, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production", onHeadPrepared } = pageRequest;
+	const { opts, searchParams, isRscRequest, mountedSlotsHeader, renderMode = APP_RSC_RENDER_MODE_NAVIGATION, observeMetadataSearchParamsAccess = false, observePageSearchParamsAccess = false, isForceStatic = false, isUncacheableRender = false, mountedLayouts = null, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production", onHeadPrepared } = pageRequest;
 	const pageModule = route.page;
 	const isSiblingIntercept = opts?.interceptSlotKey === "__vinext_page_intercept" && !!opts?.interceptPage;
 	const effectivePageModule = isSiblingIntercept ? opts.interceptPage : pageModule;
@@ -174,6 +174,7 @@ async function buildPageElements(options) {
 		head: {
 			layoutModules: opts?.interceptLayouts ?? [],
 			layoutParams: (opts?.interceptLayoutSegments ?? []).map((segments) => resolveInterceptLayoutParams(opts?.interceptBranchSegments ?? segments, segments, effectiveParams)),
+			layoutsBesidePage: resolveInterceptLayoutsBesidePage(opts?.interceptLayoutSegments, opts?.interceptBranchSegments),
 			pageModule: effectivePageModule ?? null,
 			params: effectiveParams,
 			routeSegments: opts?.interceptSourcePageSegments ?? route.routeSegments ?? []
@@ -414,7 +415,7 @@ async function buildPageElements(options) {
 			isRscRequest,
 			isUncacheableRender,
 			interceptionId: opts?.interceptionId ?? null,
-			layoutParamAccess: options.layoutParamAccess,
+			mountedLayouts,
 			mountedSlotIds,
 			makeThenableParams,
 			matchedParams: params,
@@ -450,9 +451,9 @@ async function buildPageElements(options) {
 *    slot-scoped params, which `app-page-route-wiring` then hands to the
 *    slot page instead of the route's matched params.
 *
-* `routePath` is the already-normalized request pathname (basePath stripped,
-* RSC suffix removed). Re-parsing `request.url` here would re-introduce the
-* basePath and silently break the match for any app that configures one.
+* `routePath` is the already-normalized request pathname (basePath stripped).
+* Re-parsing `request.url` here would re-introduce the basePath and silently
+* break the match for any app that configures one.
 */
 function buildSlotOverrides(route, routeParams, routePath, opts, interceptMetadataOutlet) {
 	const overrides = {};

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

@@ -1,10 +1,8 @@
-import { ClassificationReason } from "../build/layout-classification-types.js";
-import { LayoutFlags } from "./app-elements-wire.js";
-import "./app-elements.js";
 //#region src/server/app-page-execution.d.ts
 export declare function tagAppPageMetadataError<T>(error: T): T;
 export declare function tagAppPageSlotError<T>(error: T, layoutIndex: number, notFoundBoundary?: string): T;
 export declare function tagAppPagePageError<T>(error: T): T;
+export declare function tagAppPageLayoutError<T>(error: T, layoutIndex: number): T;
 /**
  * The id of the not-found boundary that catches the route page's notFound():
  * the page-level boundary, or the segment one it passes the signal up to.
@@ -22,6 +20,17 @@ export type AppPageSpecialError = {
   fromMetadata?: boolean;
   /** Set when a parallel slot threw it: the layout rendering the outermost such slot. */
   slotLayoutIndex?: number;
+  /**
+   * Set when a route layout's own component threw it, above any slot that
+   * did: the outermost such layout, whose boundary above catches it.
+   */
+  layoutIndex?: number;
+  /**
+   * Set when the render threw a copy nothing tagged: a server component
+   * that a layout, the page or a template renders. The document's
+   * fallback then finds out whether a layout's subtree threw it.
+   */
+  unattributed?: boolean;
 };
 export type AppPageFontPreload = {
   href: string;
@@ -88,50 +97,6 @@ type BuildAppPageSpecialErrorResponseOptions = {
   serveStreamingMetadata?: boolean;
   specialError: AppPageSpecialError;
 };
-type ProbeAppPageLayoutsResult = {
-  response: Response | null;
-  layoutFlags: LayoutFlags;
-};
-export type LayoutClassificationOptions = {
-  /** Build-time classifications from segment config or module graph, keyed by layout index. */
-  buildTimeClassifications?: ReadonlyMap<number, "static" | "dynamic"> | null;
-  /**
-   * Per-layout classification reasons keyed by layout index. Requires
-   * `VINEXT_DEBUG_CLASSIFICATION` at BOTH lifecycle points: at build time so
-   * the plugin patches the `__VINEXT_CLASS_REASONS` dispatch stub, and at
-   * runtime so the route object actually calls it. Setting the flag only at
-   * runtime leaves the stub returning `null`, and every build-time classified
-   * layout will fall through to `{ layer: "no-classifier" }` in the debug
-   * channel. The hot path never reads this and the wire payload is unchanged.
-   */
-  buildTimeReasons?: ReadonlyMap<number, ClassificationReason> | null;
-  /**
-   * Emits one log line per layout with the classification reason, keyed by
-   * layout ID. Set by the generator when `VINEXT_DEBUG_CLASSIFICATION` is
-   * active. When undefined, the probe loop skips debug emission entirely.
-   */
-  debugClassification?: (layoutId: string, reason: ClassificationReason) => void;
-  /** Maps layout index to its layout ID (e.g. "layout:/blog"). */
-  getLayoutId: (layoutIndex: number) => string;
-  /**
-   * Returns whether the completed per-layout observation makes static reuse
-   * unsafe even if the older dynamic scope did not report dynamic usage.
-   */
-  isLayoutObservationDynamic?: (layoutId: string) => boolean;
-  /** Runs a function with isolated dynamic usage tracking per layout. */
-  runWithIsolatedDynamicScope: <T>(fn: () => T | Promise<T>) => Promise<{
-    result: T;
-    dynamicDetected: boolean;
-  }>;
-};
-type ProbeAppPageLayoutsOptions = {
-  layoutCount: number;
-  onLayoutError: (error: unknown, layoutIndex: number) => Promise<Response | null>;
-  probeLayoutAt: (layoutIndex: number) => unknown;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
-  /** When provided, enables per-layout static/dynamic classification. */
-  classification?: LayoutClassificationOptions | null;
-};
 export declare function resolveAppPageSpecialError(error: unknown): AppPageSpecialError | null;
 /**
  * Resolve the special error that rejected an SSR shell. An error from the RSC
@@ -142,8 +107,10 @@ export declare function resolveAppPageSpecialError(error: unknown): AppPageSpeci
  * runs only in the RSC render. A notFound() / forbidden() / unauthorized()
  * a parallel slot's page threw is caught above the layout rendering it,
  * unless the slot's own not-found catches its notFound() and every other copy
- * is the page's or another slot's. A copy neither threw, such as a template's,
- * keeps the fallback above that layout.
+ * is the page's or another slot's. One a route layout threw is caught above
+ * that layout, and the outermost such layout wins. A copy nothing tagged,
+ * such as a template's or one from a component a layout or the page renders,
+ * marks the error unattributed.
  */
 export declare function resolveAppPageShellSpecialError(error: unknown, renderedSpecialErrors: readonly unknown[]): AppPageSpecialError | null;
 /**
@@ -167,11 +134,9 @@ export declare function resolveAppPageCaughtNotFoundBoundaries(error: unknown, r
  */
 export declare function resolveAppPageSpecialErrorStoredHeaders(specialError: AppPageSpecialError, basePath: string | undefined): Record<string, string> | undefined;
 export declare function buildAppPageSpecialErrorResponse(options: BuildAppPageSpecialErrorResponseOptions): Promise<Response>;
-/** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
-export declare function probeAppPageLayouts(options: ProbeAppPageLayoutsOptions): Promise<ProbeAppPageLayoutsResult>;
 export declare function readAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
 export declare function bufferAppPageBinaryStream(stream: ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array>>;
 export declare function teeAppPageRscStreamForCapture(stream: ReadableStream<Uint8Array>, shouldCapture: boolean): AppPageRscStreamCapture;
 export declare function buildAppPageFontLinkHeader(preloads: readonly AppPageFontPreload[] | null | undefined): string;
 //#endregion
-export type { LayoutFlags };
+export {};