vinext 1.3.0 → 1.4.0

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

@@ -3,8 +3,7 @@ import { AppElements } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageParams } from "./app-page-boundary.js";
-import { ApplyAppPageFileBasedMetadata } from "./app-page-head.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
+import { AppPagePreparedRouteHead, ApplyAppPageFileBasedMetadata } from "./app-page-head.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
@@ -31,6 +30,14 @@ export type AppPageInterceptOptions<TModule extends AppPageModule = AppPageModul
   interceptNotFoundBranchSegments?: readonly string[] | null;
   interceptNotFound?: TModule | null;
   interceptNotFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly (TModule | null | undefined)[] | null;
+  interceptForbiddenTreePositions?: readonly number[] | null;
+  interceptUnauthorizeds?: readonly (TModule | null | undefined)[] | null;
+  interceptUnauthorizedTreePositions?: readonly number[] | null;
+  interceptErrors?: readonly (AppPageErrorModule | null | undefined)[] | null;
+  interceptErrorTreePositions?: readonly number[] | null;
+  interceptNotFounds?: readonly (TModule | null | undefined)[] | null;
+  interceptNotFoundTreePositions?: readonly number[] | null;
   interceptPage?: TModule | null;
   interceptParams?: AppPageParams | null;
   interceptSlotId?: string | null;
@@ -57,6 +64,10 @@ export type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> =
   observePageSearchParamsAccess?: boolean;
   /** The route is `dynamic = "force-static"`, so pages read an empty query. */
   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. */
@@ -70,6 +81,12 @@ export type AppPagePageRequest<TModule extends AppPageModule = AppPageModule> =
   placeStreamedMetadataInHead?: boolean;
   /** Whether streamed render errors must be sanitized for client transport. */
   isProduction?: boolean;
+  /**
+   * Receives the route's head once this render starts resolving it, so a
+   * special-error fallback after the render can reuse it rather than calling
+   * generateMetadata() again.
+   */
+  onHeadPrepared?: (head: AppPagePreparedRouteHead) => void;
 };
 export type BuildPageElementsOptions<TModule extends AppPageModule = AppPageModule, TErrorModule extends AppPageErrorModule = AppPageErrorModule> = {
   applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
@@ -88,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,28 +1,75 @@
 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 { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
-import { resolveAppPageSpecialError } from "./app-page-execution.js";
-import { APP_PAGE_SEGMENT_KEY, isAppPageRouteGroupSegment, resolveAppPagePatternStateKey, resolveAppPageRouteStateKey } from "./app-page-segment-state.js";
+import { tagAppPagePageError, tagAppPageSlotError } from "./app-page-execution.js";
+import { createAppPageMetadataSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.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 { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs } from "./app-page-head.js";
-import { resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
-import { ClientPageRoot } from "../shims/client-page-root.js";
-import "./app-rsc-route-matching.js";
-import { resolveAppPageParentHttpAccessBoundary } from "./app-page-boundary.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
 import { createAppPageRenderIdentity } from "./app-page-render-identity.js";
-import { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
 import { shouldServeStreamingMetadata } from "./streaming-metadata.js";
-import { Suspense, cache, createElement } from "react";
+import { Fragment, Suspense, cache, createElement } from "react";
 //#region src/server/app-page-element-builder.ts
+/**
+* A sibling intercepting page that renders beside its intercepting layouts,
+* as Next.js renders each segment. The source route's layouts wait for the
+* page, so `Starter` invokes it ahead of the layouts, even when one of them
+* never renders its children, and `Outlet` renders its result where the
+* innermost layout renders its children.
+*/
+function createSiblingInterceptPageSlot(invokePage, releaseRenderDependency) {
+	let outcome = null;
+	function Starter() {
+		try {
+			const result = invokePage();
+			if (isPromiseLike(result)) Promise.resolve(result).catch(() => {});
+			outcome = { result };
+		} catch (error) {
+			if (!isAppRenderSuspension(error)) outcome = { error };
+			else {
+				Promise.resolve().then(releaseRenderDependency);
+				outcome = { suspended: true };
+			}
+		}
+		return null;
+	}
+	function readOutcome(current) {
+		if ("error" in current) throw current.error;
+		return "result" in current ? current.result : invokePage();
+	}
+	function Outlet() {
+		return outcome ? readOutcome(outcome) : invokePage();
+	}
+	return {
+		Outlet,
+		Starter
+	};
+}
+/** How many leading layouts two branches of one slot have in common. */
+function countSharedLeadingLayouts(visibleLayouts, hiddenLayouts) {
+	const visible = visibleLayouts ?? [];
+	const hidden = hiddenLayouts ?? [];
+	let count = 0;
+	while (count < visible.length && count < hidden.length && visible[count] === hidden[count]) count++;
+	return count;
+}
+async function AppPageInterceptMetadataOutlet(props) {
+	return props.resolveHead().interceptOutlet;
+}
+AppPageInterceptMetadataOutlet.displayName = "Vinext.InterceptMetadataOutlet";
 function resolveInterceptLayoutParams(branchSegments, layoutSegments, params) {
 	return resolveAppPageBranchParams(branchSegments, layoutSegments.length, params, layoutSegments);
 }
@@ -60,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, serveStreamingMetadata, placeStreamedMetadataInHead = false, isProduction = process.env.NODE_ENV === "production" } = 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;
@@ -127,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 ?? []
@@ -138,14 +186,39 @@ async function buildPageElements(options) {
 		} : {},
 		ownerTreePosition: route.routeSegments?.length ?? 0
 	} : null;
-	const parallelRoutes = [...primaryParallelRouteHeadInput ? [primaryParallelRouteHeadInput.head] : [], ...activeParallelRouteHeadInputs.map((input) => input.head)];
-	const metadataSearchParamsObserver = observeMetadataSearchParamsAccess ? createAppPageSearchParamsObserver() : void 0;
+	const interceptSlotKey = opts?.interceptPage != null && !isSiblingIntercept ? opts?.interceptSlotKey ?? null : null;
+	const sourceParallelRouteInputs = interceptSlotKey ? resolveActiveParallelRouteHeadInputs({
+		layoutTreePositions: route.layoutTreePositions,
+		params,
+		routeSegments: route.routeSegments ?? [],
+		slotParams: slotParamOverrides,
+		slots: route.slots ?? null
+	}) : null;
+	const keepsSourceHead = interceptSlotKey !== null && sourceParallelRouteInputs !== null && slotInterceptKeepsSourceHead({
+		interceptSlotKey,
+		route,
+		sourceParallelRoutes: sourceParallelRouteInputs
+	});
+	const headParallelRouteInputs = keepsSourceHead && sourceParallelRouteInputs ? sourceParallelRouteInputs : activeParallelRouteHeadInputs;
+	const parallelRoutes = [...primaryParallelRouteHeadInput ? [primaryParallelRouteHeadInput.head] : [], ...headParallelRouteInputs.map((input) => input.head)];
+	const interceptHeadInput = keepsSourceHead && interceptSlotKey ? activeParallelRouteHeadInputs.find((input) => input.slotKey === interceptSlotKey) : void 0;
+	const interceptSlotIndex = interceptHeadInput ? headParallelRouteInputs.findIndex((input) => input.slotKey === interceptSlotKey) : -1;
+	const hiddenParallelRoutes = interceptHeadInput ? [{
+		parallelRouteIndex: interceptSlotIndex === -1 ? -1 : interceptSlotIndex + (primaryParallelRouteHeadInput ? 1 : 0),
+		route: interceptHeadInput.head,
+		sharedLayoutCount: interceptSlotIndex === -1 ? 0 : countSharedLeadingLayouts(headParallelRouteInputs[interceptSlotIndex].head.layoutModules, interceptHeadInput.head.layoutModules)
+	}] : null;
+	const outletSlotIndex = interceptSlotKey !== null && !keepsSourceHead ? headParallelRouteInputs.findIndex((input) => input.slotKey === interceptSlotKey) : -1;
+	const outletParallelRouteIndex = outletSlotIndex === -1 ? null : outletSlotIndex + (primaryParallelRouteHeadInput ? 1 : 0);
+	const metadataSearchParamsObserver = createAppPageMetadataSearchParamsObserver(observeMetadataSearchParamsAccess);
 	const headOptions = {
 		applyFileBasedMetadata: options.applyFileBasedMetadata,
 		basePath: options.basePath ?? "",
+		hiddenParallelRoutes,
 		layoutModules: route.layouts,
 		layoutTreePositions: route.layoutTreePositions,
 		metadataRoutes,
+		outletParallelRouteIndex,
 		pageModule: isSiblingIntercept ? null : effectivePageModule ?? null,
 		parallelRoutes,
 		params: effectiveParams,
@@ -158,54 +231,38 @@ async function buildPageElements(options) {
 	const { pageSearchParams } = collectAppPageSearchParams(searchParams);
 	const streamGeneratedHead = serveStreamingMetadata ?? shouldServeStreamingMetadata(pageRequest.request.headers.get("user-agent") ?? "", options.htmlLimitedBots);
 	const metadataPlacement = hasDynamicMetadata && streamGeneratedHead && !placeStreamedMetadataInHead ? "body" : "head";
-	const resolveNotFoundFallbackPlanOptions = () => {
-		const routeBoundaryModule = route.notFound;
-		const parentBoundary = resolveAppPageParentHttpAccessBoundary({
-			layoutIndex: route.layouts.length,
-			rootForbiddenModule,
-			rootNotFoundModule,
-			rootUnauthorizedModule,
-			routeForbiddenModules: route.forbiddens,
-			routeNotFoundModules: route.notFounds,
-			routeUnauthorizedModules: route.unauthorizeds,
-			statusCode: 404
-		});
-		const boundaryModule = routeBoundaryModule ?? parentBoundary.module;
-		const boundaryTreePosition = routeBoundaryModule ? route.notFoundTreePosition : parentBoundary.layoutIndex === null ? null : route.layoutTreePositions?.[parentBoundary.layoutIndex];
-		return {
-			boundaryModule,
-			boundaryParams: boundaryModule && boundaryTreePosition != null ? resolveAppPageSegmentParams(route.routeSegments ?? [], boundaryTreePosition, effectiveParams) : {},
-			boundaryRouteSegments: (route.routeSegments ?? []).slice(0, boundaryTreePosition ?? 0),
-			errorConvention: "not-found",
-			layoutModules: route.layouts,
-			layoutTreePositions: route.layoutTreePositions,
-			parallelBranches: activeParallelRouteHeadInputs,
-			params: effectiveParams,
-			primaryParallelBranch: primaryParallelRouteHeadInput,
-			routeSegments: route.routeSegments ?? null
-		};
-	};
-	const resolveMetadataErrorTags = async (error) => {
-		if (resolveAppPageSpecialError(error)?.kind !== "http-access-fallback") return null;
-		return resolveHttpAccessFallbackMetadata({
+	const toClientError = (error) => isProduction ? sanitizeErrorForClient(error, "production") : error;
+	const resolveHead = cache(() => {
+		const preparedHead = prepareAppPageHead(headOptions);
+		const recoveredHead = recoverAppPageRouteHead(preparedHead, {
 			applyFileBasedMetadata: options.applyFileBasedMetadata,
 			basePath: options.basePath ?? "",
-			...resolveNotFoundFallbackPlanOptions(),
 			metadataRoutes,
+			resolvePlanOptions: () => createRouteNotFoundHeadPlanOptions({
+				parallelBranches: headParallelRouteInputs,
+				params: effectiveParams,
+				primaryParallelBranch: primaryParallelRouteHeadInput,
+				rootNotFoundModule,
+				route
+			}),
 			routePath: route.pattern
-		}).catch(() => null);
-	};
-	const toClientError = (error) => isProduction ? sanitizeErrorForClient(error, "production") : error;
-	const resolveHead = cache(() => {
-		const preparedHead = prepareAppPageHead(headOptions);
-		const outlet = Promise.all([preparedHead.metadata, preparedHead.viewport]).then(() => null, (error) => {
+		});
+		onHeadPrepared?.({
+			...recoveredHead,
+			metadataPlacement
+		});
+		const outlet = preparedHead.routeErrors.then(null, (error) => {
 			throw toClientError(error);
 		});
 		outlet.catch(() => null);
+		const interceptOutlet = preparedHead.hiddenErrors.then(null, (error) => {
+			throw toClientError(error);
+		});
+		interceptOutlet.catch(() => null);
 		return {
-			metadata: preparedHead.metadata.catch(resolveMetadataErrorTags),
-			outlet,
-			viewport: preparedHead.viewport.catch((error) => resolveAppPageSpecialError(error)?.kind === "http-access-fallback" ? resolveHttpAccessFallbackViewport(resolveNotFoundFallbackPlanOptions()).catch(() => ({})) : {})
+			...recoveredHead,
+			interceptOutlet,
+			outlet
 		};
 	});
 	const pageProps = { params: makeThenableParams(effectiveParams) };
@@ -217,7 +274,7 @@ async function buildPageElements(options) {
 	}, pageTreePosition) !== null;
 	const hasEmptyClientPageSearchParams = isForceStatic || isProduction && process.env.__NEXT_CONFIG_OUTPUT === "export";
 	const pageRenderDependency = EffectivePageComponent && !isReactOwnedAppComponent(EffectivePageComponent) ? createAppPageRenderDependency() : null;
-	const createPageElement = (PageComponent, props, renderDependency) => {
+	const createPageElement = (PageComponent, props, renderDependency, tagError) => {
 		if (searchParams && isAppClientReference(PageComponent)) {
 			const { searchParams: _slotSearchParams, ...pageProps } = props;
 			return createElement(ClientPageRoot, {
@@ -231,14 +288,19 @@ async function buildPageElements(options) {
 			if (searchParams) invocationProps.searchParams = observePageSearchParamsAccess ? makeObservedAppPageSearchParamsThenable(pageSearchParams) : makeThenableParams(pageSearchParams);
 			return createElement(PageComponent, withUseCachePageMarker(PageComponent, invocationProps));
 		}
+		return createElement(createPageInvoker(PageComponent, props, renderDependency, tagError));
+	};
+	const createPageInvoker = (PageComponent, props, renderDependency, tagError) => {
 		const PageInvoker = () => {
 			const invocationProps = { ...props };
 			if (searchParams) invocationProps.searchParams = observePageSearchParamsAccess ? makeObservedAppPageSearchParamsThenable(pageSearchParams) : makeThenableParams(pageSearchParams);
 			try {
-				const result = invokeAppComponent(PageComponent, withUseCachePageMarker(PageComponent, invocationProps));
+				const result = invokeAppComponent(PageComponent, withUseCachePageMarker(PageComponent, invocationProps), tagError);
 				if (isPromiseLike(result)) {
 					if (renderDependency) Promise.resolve().then(() => renderDependency.release());
-					return Promise.resolve(result).then((resolvedResult) => renderDependency ? renderAfterAppDependencies(resolvedResult, renderDependency.resultDependencies) : resolvedResult);
+					return Promise.resolve(result).then((resolvedResult) => renderDependency ? renderAfterAppDependencies(resolvedResult, renderDependency.resultDependencies) : resolvedResult, tagError === void 0 ? void 0 : (error) => {
+						throw tagError(error);
+					});
 				}
 				renderDependency?.release();
 				return renderDependency ? renderAfterAppDependencies(result, renderDependency.resultDependencies) : result;
@@ -248,17 +310,21 @@ async function buildPageElements(options) {
 					throw error;
 				}
 				renderDependency?.release();
-				throw error;
+				throw tagError === void 0 ? error : tagError(error);
 			}
 		};
-		return createElement(PageInvoker);
+		return PageInvoker;
 	};
 	const pageSearchParamsThenable = searchParams ? makeThenableParams(pageSearchParams) : void 0;
 	const mountedSlotIds = mountedSlotsHeader ? new Set(mountedSlotsHeader.split(" ")) : null;
-	const slotOverrides = buildSlotOverrides(route, params, routePath, opts);
-	const createSiblingInterceptElement = () => {
-		let element = isSiblingIntercept && EffectivePageComponent ? createPageElement(EffectivePageComponent, pageProps, pageRenderDependency) : null;
-		if (!isSiblingIntercept || element === null) return element;
+	const slotOverrides = buildSlotOverrides(route, params, routePath, opts, hiddenParallelRoutes || outletParallelRouteIndex !== null ? (() => {
+		const outlet = createElement(AppPageInterceptMetadataOutlet, { resolveHead });
+		return streamGeneratedHead ? createElement(Suspense, { fallback: null }, outlet) : outlet;
+	})() : null);
+	const createSiblingInterceptElement = (metadataOutlet) => {
+		if (!isSiblingIntercept || !EffectivePageComponent) return null;
+		const pageSlot = pageRenderDependency && opts?.interceptLayouts?.some((layoutModule) => layoutModule?.default) ? createSiblingInterceptPageSlot(createPageInvoker(EffectivePageComponent, pageProps, pageRenderDependency), pageRenderDependency.release) : null;
+		let element = createElement(Fragment, null, pageSlot ? createElement(pageSlot.Outlet) : createPageElement(EffectivePageComponent, pageProps, pageRenderDependency), metadataOutlet);
 		const layoutIndexesByTreePosition = /* @__PURE__ */ new Map();
 		for (const [index, layoutModule] of (opts?.interceptLayouts ?? []).entries()) {
 			if (!layoutModule) continue;
@@ -273,12 +339,56 @@ async function buildPageElements(options) {
 			const treePosition = opts?.interceptLoadingTreePositions?.[index];
 			if (treePosition !== void 0) loadingIndexesByTreePosition.set(treePosition, index);
 		}
-		const treePositions = Array.from(/* @__PURE__ */ new Set([...layoutIndexesByTreePosition.keys(), ...loadingIndexesByTreePosition.keys()])).sort((left, right) => left - right);
+		const notFoundsByTreePosition = /* @__PURE__ */ new Map();
+		for (const [index, notFoundModule] of (opts?.interceptNotFounds ?? []).entries()) {
+			const treePosition = opts?.interceptNotFoundTreePositions?.[index];
+			if (notFoundModule?.default && treePosition !== void 0) notFoundsByTreePosition.set(treePosition, notFoundModule.default);
+		}
+		const accessBoundaries = [...(opts?.interceptForbiddens ?? []).map((module, index) => [
+			module,
+			opts?.interceptForbiddenTreePositions?.[index],
+			ForbiddenBoundary
+		]), ...(opts?.interceptUnauthorizeds ?? []).map((module, index) => [
+			module,
+			opts?.interceptUnauthorizedTreePositions?.[index],
+			UnauthorizedBoundary
+		])];
+		const accessBoundaryTreePositions = accessBoundaries.flatMap(([module, treePosition]) => module?.default && treePosition != null ? [treePosition] : []);
+		const errorsByTreePosition = /* @__PURE__ */ new Map();
+		for (const [index, errorModule] of (opts?.interceptErrors ?? []).entries()) {
+			const treePosition = opts?.interceptErrorTreePositions?.[index];
+			if (errorModule?.default && treePosition !== void 0) errorsByTreePosition.set(treePosition, errorModule.default);
+		}
+		const treePositions = Array.from(/* @__PURE__ */ new Set([
+			...layoutIndexesByTreePosition.keys(),
+			...loadingIndexesByTreePosition.keys(),
+			...accessBoundaryTreePositions,
+			...notFoundsByTreePosition.keys(),
+			...errorsByTreePosition.keys()
+		])).sort((left, right) => left - right);
 		for (let index = treePositions.length - 1; index >= 0; index--) {
 			const treePosition = treePositions[index];
 			const loadingIndex = loadingIndexesByTreePosition.get(treePosition);
 			const LoadingComponent = loadingIndex === void 0 ? null : opts?.interceptLoadings?.[loadingIndex]?.default;
 			if (LoadingComponent) element = createElement(Suspense, { fallback: createElement(LoadingComponent) }, element);
+			const NotFoundComponent = notFoundsByTreePosition.get(treePosition);
+			if (NotFoundComponent) element = createElement(NotFoundBoundary, {
+				fallback: createElement(NotFoundComponent),
+				children: element
+			});
+			for (const [module, boundaryTreePosition, AccessBoundary] of accessBoundaries) {
+				const FallbackComponent = module?.default;
+				if (!FallbackComponent || boundaryTreePosition !== treePosition) continue;
+				element = createElement(AccessBoundary, {
+					fallback: createElement(FallbackComponent),
+					children: element
+				});
+			}
+			const ErrorComponent = errorsByTreePosition.get(treePosition);
+			if (ErrorComponent) element = createElement(ErrorBoundary, {
+				fallback: ErrorComponent,
+				children: element
+			});
 			const layoutIndexes = layoutIndexesByTreePosition.get(treePosition) ?? [];
 			for (let layoutOffset = layoutIndexes.length - 1; layoutOffset >= 0; layoutOffset--) {
 				const layoutIndex = layoutIndexes[layoutOffset];
@@ -291,18 +401,21 @@ async function buildPageElements(options) {
 				element = createElement(LayoutComponent, withUseCacheLayoutMarker(LayoutComponent, { params: makeThenableParams(interceptLayoutParams) }), element);
 			}
 		}
-		return element;
+		return pageSlot ? createElement(Fragment, null, createElement(pageSlot.Starter), element) : element;
 	};
 	return traceCreateComponentTree(() => {
 		if (effectivePageModule) traceGetLayoutOrPageModule(APP_PAGE_SEGMENT_KEY, () => effectivePageModule);
-		const siblingInterceptElement = createSiblingInterceptElement();
 		return buildAppPageElements({
-			element: isSiblingIntercept ? siblingInterceptElement : EffectivePageComponent ? createPageElement(EffectivePageComponent, pageProps, pageRenderDependency) : null,
-			createPageElement,
+			element: !isSiblingIntercept && EffectivePageComponent ? createPageElement(EffectivePageComponent, pageProps, pageRenderDependency, tagAppPagePageError) : null,
+			renderElementWithMetadataOutlet: isSiblingIntercept && EffectivePageComponent ? createSiblingInterceptElement : null,
+			createPageElement(component, props, slotLayoutIndex, slotNotFoundBoundary) {
+				return createPageElement(component, props, null, slotLayoutIndex === void 0 ? void 0 : (error) => tagAppPageSlotError(error, slotLayoutIndex, slotNotFoundBoundary));
+			},
 			globalErrorModule: globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE,
 			isRscRequest,
+			isUncacheableRender,
 			interceptionId: opts?.interceptionId ?? null,
-			layoutParamAccess: options.layoutParamAccess,
+			mountedLayouts,
 			mountedSlotIds,
 			makeThenableParams,
 			matchedParams: params,
@@ -342,18 +455,27 @@ async function buildPageElements(options) {
 * RSC suffix removed). 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) {
+function buildSlotOverrides(route, routeParams, routePath, opts, interceptMetadataOutlet) {
 	const overrides = {};
 	if (opts && opts.interceptSlotKey && opts.interceptPage && opts.interceptSlotKey !== "__vinext_page_intercept") overrides[opts.interceptSlotKey] = {
 		branchSegments: opts.interceptBranchSegments ?? null,
 		identitySegments: resolveInterceptedSlotIdentitySegments(opts.interceptSourcePageSegments, opts.interceptSlotKey),
+		forbiddenModules: opts.interceptForbiddens ?? null,
+		forbiddenTreePositions: opts.interceptForbiddenTreePositions ?? null,
 		layoutModules: opts.interceptLayouts || null,
 		layoutSegments: opts.interceptLayoutSegments ?? null,
 		loadingModules: opts.interceptLoadings || null,
 		loadingTreePositions: opts.interceptLoadingTreePositions ?? null,
+		metadataOutlet: interceptMetadataOutlet ?? null,
+		notFoundModules: opts.interceptNotFounds ?? null,
+		notFoundTreePositions: opts.interceptNotFoundTreePositions ?? null,
 		pageModule: opts.interceptPage,
 		params: opts.interceptParams || routeParams,
-		routeSegments: resolveInterceptedSlotSegments(opts.interceptSourcePageSegments, opts.interceptSlotKey)
+		routeSegments: resolveInterceptedSlotSegments(opts.interceptSourcePageSegments, opts.interceptSlotKey),
+		unauthorizedModules: opts.interceptUnauthorizeds ?? null,
+		unauthorizedTreePositions: opts.interceptUnauthorizedTreePositions ?? null,
+		errorModules: opts.interceptErrors ?? null,
+		errorTreePositions: opts.interceptErrorTreePositions ?? null
 	};
 	const slotParamOverrides = resolveSlotParamOverrides(route, routePath);
 	for (const [slotKey, params] of Object.entries(slotParamOverrides ?? {})) {

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

@@ -1,8 +1,13 @@
-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.
+ */
+export declare const APP_PAGE_NOT_FOUND_BOUNDARY_ID = "page";
 export type AppPageSpecialError = {
   kind: "redirect";
   location: string;
@@ -13,6 +18,19 @@ export type AppPageSpecialError = {
   kind: "http-access-fallback";
   statusCode: number;
   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;
@@ -79,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
@@ -130,9 +104,29 @@ export declare function resolveAppPageSpecialError(error: unknown): AppPageSpeci
  * generateMetadata() threw it comes from the errors the RSC render threw with
  * that digest. When the page threw one too, the page's decides. An error a
  * client component threw during SSR is the page's, since generateMetadata()
- * runs only in the RSC render.
+ * 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. 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;
+/**
+ * The parallel slot not-found boundaries that catch the `notFound()` that
+ * rejected an SSR shell, or null when any copy the RSC render threw isn't
+ * caught inside its slot. On the client, each slot's own not-found boundary
+ * catches its signal while the rest of the route renders, as in Next.js,
+ * which sends an empty error shell and renders them in the browser. A copy
+ * no slot threw is caught by the page's boundary beside them when the page
+ * threw it, including from a component the page renders, which nothing tags.
+ * One a layout or a template threw renders outside the caught boundaries, so
+ * the document's render from the same payload throws it again and takes the
+ * fallback, which keeps it above the slot's layout (see
+ * `resolveAppPageShellSpecialError`). Without a slot's, that fallback renders.
+ */
+export declare function resolveAppPageCaughtNotFoundBoundaries(error: unknown, renderedSpecialErrors: readonly unknown[]): readonly string[] | null;
 /**
  * The response headers stored with a page's special-error entries: a
  * redirect's own `location`, not the response's, which middleware may have
@@ -140,11 +134,9 @@ export declare function resolveAppPageShellSpecialError(error: unknown, rendered
  */
 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 {};