vinext 1.2.1 → 1.3.1

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

@@ -4,25 +4,72 @@ 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 { 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 { 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 { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs } from "./app-page-head.js";
-import { resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport } from "./app-page-http-access-fallback-metadata.js";
+import { createAppPageMetadataSearchParamsObserver, makeObservedAppPageSearchParamsThenable } from "./app-page-search-params-observation.js";
+import { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, 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 { 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, 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;
@@ -138,14 +185,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 +230,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 +273,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 +287,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 +309,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 +338,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,16 +400,19 @@ 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,
 			mountedSlotIds,
@@ -342,18 +454,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

@@ -3,6 +3,13 @@ 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;
+/**
+ * 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 +20,8 @@ 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;
 };
 export type AppPageFontPreload = {
   href: string;
@@ -130,9 +139,27 @@ 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. A copy neither threw, such as a template's,
+ * keeps the fallback above that layout.
  */
 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

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

@@ -1,7 +1,7 @@
 import { VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER } from "./headers.js";
 import { isPromiseLike } from "../utils/promise.js";
 import { runWithConnectionProbe } from "../shims/headers.js";
-import { isThrownNavigationError } from "../shims/navigation-errors.js";
+import { isHTTPAccessFallbackError, isThrownNavigationError } from "../shims/navigation-errors.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { copyLinkHeaderProvenance, getFrameworkLinkHeader, markFrameworkLinkHeaders } from "./app-response-header-provenance.js";
@@ -40,6 +40,69 @@ function tagAppPageMetadataError(error) {
 	} catch {}
 	return error;
 }
+/**
+* Marker we tag onto an error a parallel slot's page or default component
+* threw, holding the index of the layout that renders the slot. Next.js
+* attaches HTTP access fallback boundaries only to each segment's `children`,
+* so a slot's `notFound()` is caught by the boundary above that layout, not
+* by the route's deepest boundary as the page's is.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/create-component-tree.tsx
+*/
+const APP_PAGE_SLOT_ERROR_LAYOUT_INDEX = Symbol.for("vinext.appPage.slotErrorLayoutIndex");
+/**
+* Marker holding the id of the slot's own not-found boundary that catches the
+* slot's `notFound()` on the client, when one does. The document then renders
+* that boundary caught (see `resolveAppPageCaughtNotFoundBoundaries`).
+*/
+const APP_PAGE_SLOT_ERROR_NOT_FOUND_BOUNDARY = Symbol.for("vinext.appPage.slotErrorNotFoundBoundary");
+/**
+* Marker we tag onto an error the route's page component threw, so that the
+* document's fallback can tell it from one a layout or a template threw,
+* which no slot tag marks either.
+*/
+const APP_PAGE_PAGE_ERROR = Symbol.for("vinext.appPage.pageError");
+function tagAppPageHttpAccessFallbackError(error, tags) {
+	if (!isHTTPAccessFallbackError(error)) return error;
+	const source = error;
+	const tagged = Object.setPrototypeOf(new Error(String(Reflect.get(source, "message"))), Object.getPrototypeOf(source));
+	Object.defineProperties(tagged, {
+		...Object.getOwnPropertyDescriptors(source),
+		stack: {
+			value: Reflect.get(source, "stack"),
+			configurable: true,
+			writable: true
+		},
+		...tags
+	});
+	return tagged;
+}
+function tagAppPageSlotError(error, layoutIndex, notFoundBoundary) {
+	return tagAppPageHttpAccessFallbackError(error, {
+		[APP_PAGE_SLOT_ERROR_LAYOUT_INDEX]: { value: layoutIndex },
+		[APP_PAGE_SLOT_ERROR_NOT_FOUND_BOUNDARY]: { value: notFoundBoundary }
+	});
+}
+function tagAppPagePageError(error) {
+	return tagAppPageHttpAccessFallbackError(error, { [APP_PAGE_PAGE_ERROR]: { value: true } });
+}
+function isAppPagePageError(error) {
+	return !!error && typeof error === "object" && Reflect.get(error, APP_PAGE_PAGE_ERROR) === true;
+}
+function getAppPageSlotErrorLayoutIndex(error) {
+	if (!error || typeof error !== "object") return null;
+	const layoutIndex = Reflect.get(error, APP_PAGE_SLOT_ERROR_LAYOUT_INDEX);
+	return typeof layoutIndex === "number" ? layoutIndex : null;
+}
+/**
+* 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.
+*/
+const APP_PAGE_NOT_FOUND_BOUNDARY_ID = "page";
+function getAppPageSlotErrorNotFoundBoundary(error) {
+	if (!error || typeof error !== "object") return null;
+	const boundary = Reflect.get(error, APP_PAGE_SLOT_ERROR_NOT_FOUND_BOUNDARY);
+	return typeof boundary === "string" ? boundary : null;
+}
 function getAppPageStatusText(statusCode) {
 	return statusCode === 403 ? "Forbidden" : statusCode === 401 ? "Unauthorized" : "Not Found";
 }
@@ -83,16 +146,62 @@ function resolveAppPageSpecialError(error) {
 * 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. A copy neither threw, such as a template's,
+* keeps the fallback above that layout.
 */
 function resolveAppPageShellSpecialError(error, renderedSpecialErrors) {
 	const specialError = resolveAppPageSpecialError(error);
 	if (!specialError || specialError.fromMetadata === true) return specialError;
 	if (isThrownNavigationError(error)) return specialError;
-	return renderedSpecialErrors.length > 0 && renderedSpecialErrors.every((rendered) => resolveAppPageSpecialError(rendered)?.fromMetadata === true) ? {
+	if (renderedSpecialErrors.length > 0 && renderedSpecialErrors.every((rendered) => resolveAppPageSpecialError(rendered)?.fromMetadata === true)) return {
 		...specialError,
 		fromMetadata: true
-	} : specialError;
+	};
+	if (specialError.kind !== "http-access-fallback") return specialError;
+	const skipsSlotCaughtNotFound = specialError.statusCode === 404 && renderedSpecialErrors.every((rendered) => isAppPagePageError(rendered) || getAppPageSlotErrorLayoutIndex(rendered) !== null);
+	let slotLayoutIndex = null;
+	for (const rendered of renderedSpecialErrors) {
+		if (skipsSlotCaughtNotFound && getAppPageSlotErrorNotFoundBoundary(rendered) !== null) continue;
+		const layoutIndex = getAppPageSlotErrorLayoutIndex(rendered);
+		if (layoutIndex !== null && (slotLayoutIndex === null || layoutIndex < slotLayoutIndex)) slotLayoutIndex = layoutIndex;
+	}
+	return slotLayoutIndex === null ? specialError : {
+		...specialError,
+		slotLayoutIndex
+	};
+}
+/**
+* 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.
+*/
+function resolveAppPageCaughtNotFoundBoundaries(error, renderedSpecialErrors) {
+	const specialError = resolveAppPageSpecialError(error);
+	if (specialError?.kind !== "http-access-fallback" || specialError.statusCode !== 404) return null;
+	if (isThrownNavigationError(error) || renderedSpecialErrors.length === 0) return null;
+	const boundaries = /* @__PURE__ */ new Set();
+	let caughtInSlot = false;
+	for (const rendered of renderedSpecialErrors) {
+		if (resolveAppPageSpecialError(rendered)?.fromMetadata === true) return null;
+		const boundary = getAppPageSlotErrorNotFoundBoundary(rendered);
+		if (boundary !== null) {
+			caughtInSlot = true;
+			boundaries.add(boundary);
+		} else if (getAppPageSlotErrorLayoutIndex(rendered) === null) boundaries.add(APP_PAGE_NOT_FOUND_BOUNDARY_ID);
+		else return null;
+	}
+	return caughtInSlot ? Array.from(boundaries) : null;
 }
 /**
 * Resolves a redirect() target against the request URL and prepends the
@@ -325,4 +434,4 @@ function buildAppPageFontLinkHeader(preloads) {
 	return preloads.map((preload) => `<${preload.href}>; rel=preload; as=font; type=${preload.type}; crossorigin`).join(", ");
 }
 //#endregion
-export { bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, tagAppPageMetadataError, teeAppPageRscStreamForCapture };
+export { APP_PAGE_NOT_FOUND_BOUNDARY_ID, bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, tagAppPageMetadataError, tagAppPagePageError, tagAppPageSlotError, teeAppPageRscStreamForCapture };