vinext 1.3.1 → 1.4.0

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

@@ -1,10 +1,8 @@
 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 { 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";
+import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
+import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, createRscRedirectLocation } from "./app-rsc-cache-busting.js";
+import { isHTTPAccessFallbackError, isThrownNavigationError } from "../shims/navigation-errors.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { renderSsrErrorMetaTags } from "./app-ssr-error-meta.js";
@@ -61,6 +59,12 @@ const APP_PAGE_SLOT_ERROR_NOT_FOUND_BOUNDARY = Symbol.for("vinext.appPage.slotEr
 * which no slot tag marks either.
 */
 const APP_PAGE_PAGE_ERROR = Symbol.for("vinext.appPage.pageError");
+/**
+* Marker we tag onto an error a route layout's own component threw, holding
+* that layout's index. Its boundaries wrap only its `children`, so the
+* boundary above the layout catches it, as for a slot the layout renders.
+*/
+const APP_PAGE_LAYOUT_ERROR_LAYOUT_INDEX = Symbol.for("vinext.appPage.layoutErrorLayoutIndex");
 function tagAppPageHttpAccessFallbackError(error, tags) {
 	if (!isHTTPAccessFallbackError(error)) return error;
 	const source = error;
@@ -85,9 +89,17 @@ function tagAppPageSlotError(error, layoutIndex, notFoundBoundary) {
 function tagAppPagePageError(error) {
 	return tagAppPageHttpAccessFallbackError(error, { [APP_PAGE_PAGE_ERROR]: { value: true } });
 }
+function tagAppPageLayoutError(error, layoutIndex) {
+	return tagAppPageHttpAccessFallbackError(error, { [APP_PAGE_LAYOUT_ERROR_LAYOUT_INDEX]: { value: layoutIndex } });
+}
 function isAppPagePageError(error) {
 	return !!error && typeof error === "object" && Reflect.get(error, APP_PAGE_PAGE_ERROR) === true;
 }
+function getAppPageLayoutErrorLayoutIndex(error) {
+	if (!error || typeof error !== "object") return null;
+	const layoutIndex = Reflect.get(error, APP_PAGE_LAYOUT_ERROR_LAYOUT_INDEX);
+	return typeof layoutIndex === "number" ? layoutIndex : null;
+}
 function getAppPageSlotErrorLayoutIndex(error) {
 	if (!error || typeof error !== "object") return null;
 	const layoutIndex = Reflect.get(error, APP_PAGE_SLOT_ERROR_LAYOUT_INDEX);
@@ -149,8 +161,10 @@ function resolveAppPageSpecialError(error) {
 * 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.
 */
 function resolveAppPageShellSpecialError(error, renderedSpecialErrors) {
 	const specialError = resolveAppPageSpecialError(error);
@@ -163,14 +177,32 @@ function resolveAppPageShellSpecialError(error, renderedSpecialErrors) {
 	if (specialError.kind !== "http-access-fallback") return specialError;
 	const skipsSlotCaughtNotFound = specialError.statusCode === 404 && renderedSpecialErrors.every((rendered) => isAppPagePageError(rendered) || getAppPageSlotErrorLayoutIndex(rendered) !== null);
 	let slotLayoutIndex = null;
+	let layoutIndex = null;
+	let unattributed = false;
 	for (const rendered of renderedSpecialErrors) {
+		const throwingLayoutIndex = getAppPageLayoutErrorLayoutIndex(rendered);
+		if (throwingLayoutIndex !== null) {
+			if (layoutIndex === null || throwingLayoutIndex < layoutIndex) layoutIndex = throwingLayoutIndex;
+			continue;
+		}
 		if (skipsSlotCaughtNotFound && getAppPageSlotErrorNotFoundBoundary(rendered) !== null) continue;
-		const layoutIndex = getAppPageSlotErrorLayoutIndex(rendered);
-		if (layoutIndex !== null && (slotLayoutIndex === null || layoutIndex < slotLayoutIndex)) slotLayoutIndex = layoutIndex;
+		const slotOwnerIndex = getAppPageSlotErrorLayoutIndex(rendered);
+		if (slotOwnerIndex !== null) {
+			if (slotLayoutIndex === null || slotOwnerIndex < slotLayoutIndex) slotLayoutIndex = slotOwnerIndex;
+			continue;
+		}
+		if (!isAppPagePageError(rendered) && resolveAppPageSpecialError(rendered)?.fromMetadata !== true) unattributed = true;
+	}
+	if (layoutIndex !== null && slotLayoutIndex !== null) {
+		if (layoutIndex <= slotLayoutIndex) slotLayoutIndex = null;
+		else layoutIndex = null;
 	}
-	return slotLayoutIndex === null ? specialError : {
+	if (slotLayoutIndex === null && layoutIndex === null && !unattributed) return specialError;
+	return {
 		...specialError,
-		slotLayoutIndex
+		...slotLayoutIndex !== null ? { slotLayoutIndex } : {},
+		...layoutIndex !== null ? { layoutIndex } : {},
+		...unattributed ? { unattributed: true } : {}
 	};
 }
 /**
@@ -194,6 +226,7 @@ function resolveAppPageCaughtNotFoundBoundaries(error, renderedSpecialErrors) {
 	let caughtInSlot = false;
 	for (const rendered of renderedSpecialErrors) {
 		if (resolveAppPageSpecialError(rendered)?.fromMetadata === true) return null;
+		if (getAppPageLayoutErrorLayoutIndex(rendered) !== null) return null;
 		const boundary = getAppPageSlotErrorNotFoundBoundary(rendered);
 		if (boundary !== null) {
 			caughtInSlot = true;
@@ -230,21 +263,62 @@ function resolveAppPageSpecialErrorStoredHeaders(specialError, basePath) {
 	if (specialError.kind !== "redirect") return void 0;
 	return { location: applyAppPageRedirectBasePath(specialError.location, basePath) };
 }
+const REDIRECT_BASES = [{
+	host: "a.redirect-base.vinext.invalid",
+	protocol: "https:"
+}, {
+	host: "b.redirect-base.vinext.invalid",
+	protocol: "http:"
+}];
+function resolveAgainstPlaceholder(location, requestUrl, placeholder) {
+	const base = new URL(requestUrl);
+	base.protocol = placeholder.protocol;
+	base.host = placeholder.host;
+	base.port = "";
+	const resolved = new URL(location, base);
+	return {
+		relative: resolved.origin === base.origin,
+		resolved
+	};
+}
+/**
+* A URL reference as the URL parser reads it, with every byte a header value
+* cannot carry percent-encoded. The parser trims C0 controls and spaces and
+* drops tabs and newlines; percent-decoding reverses the rest, including in a
+* host, so the client resolves it as it would the raw target.
+*/
+function toHeaderSafeUrlReference(location) {
+	return location.replace(/^[\u0000-\u0020]+|[\u0000-\u0020]+$/g, "").replace(/[\t\n\r]/g, "").replace(/[^\u0021-\u007e]+/g, (chars) => Array.from(new TextEncoder().encode(chars), (byte) => `%${byte.toString(16).toUpperCase().padStart(2, "0")}`).join(""));
+}
 /**
-* Returns a path-relative form (`/foo?bar`) of an absolute URL when it shares
-* the request's origin; otherwise returns the URL verbatim. Used so the digest
-* we embed in the flight payload matches Next.js's convention — the digest
-* stores the path the developer passed to `redirect("/about")`, not a
-* fully-qualified URL like `https://example.com/about`.
+* The redirect target embedded in the flight digest and its streamed
+* side-channel header. An absolute target stays in the digest as `redirect()`
+* received it, as in Next.js's digest, so every host that shares the cache
+* entry is sent to the same place; the header carries the same reference made
+* header-safe, so a protocol-relative or scheme-relative target still resolves
+* against the page each client fetched. A relative target resolves against the
+* request's path to a path-only form, which the client resolves against its
+* own origin. Resolving against two placeholder origins tells these apart the
+* way the URL parser does, never depends on the request's origin, and cannot
+* mistake an absolute target naming one placeholder for a relative one.
 */
-function sameOriginPathOrAbsolute(location, requestUrl) {
+function resolveRedirectTargets(location, requestUrl) {
 	try {
-		const resolved = new URL(location, requestUrl);
-		const requestOrigin = new URL(requestUrl).origin;
-		if (resolved.origin !== requestOrigin) return resolved.toString();
-		return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+		const [first, second] = REDIRECT_BASES.map((placeholder) => resolveAgainstPlaceholder(location, requestUrl, placeholder));
+		if (!first.relative || !second.relative) return {
+			digestUrl: location,
+			headerUrl: toHeaderSafeUrlReference(location)
+		};
+		const { pathname, search, hash } = first.resolved;
+		return {
+			digestUrl: `${pathname}${search}${hash}`,
+			headerUrl: `${pathname}${search}${hash}`
+		};
 	} catch {
-		return location;
+		return {
+			digestUrl: location,
+			headerUrl: toHeaderSafeUrlReference(location)
+		};
 	}
 }
 function buildMetadataRedirectHtmlResponse(options) {
@@ -263,7 +337,7 @@ async function buildAppPageSpecialErrorResponse(options) {
 	if (options.specialError.kind === "redirect") {
 		options.clearRequestContext();
 		const prefixedLocation = applyAppPageRedirectBasePath(options.specialError.location, options.basePath);
-		const digestUrl = sameOriginPathOrAbsolute(prefixedLocation, options.request.url);
+		const { digestUrl, headerUrl } = resolveRedirectTargets(prefixedLocation, options.request.url);
 		const digest = formatNextRedirectDigest({
 			type: options.specialError.type ?? "replace",
 			url: digestUrl,
@@ -282,7 +356,7 @@ async function buildAppPageSpecialErrorResponse(options) {
 			mergeMiddlewareResponseHeaders(headers, options.middlewareContext?.headers ?? null);
 			applyRscCompatibilityIdHeader(headers);
 			applyRscDeploymentIdHeader(headers);
-			headers.set(VINEXT_RSC_REDIRECT_HEADER, digestUrl);
+			headers.set(VINEXT_RSC_REDIRECT_HEADER, headerUrl);
 			headers.set(VINEXT_RSC_REDIRECT_TYPE_HEADER, options.specialError.type ?? "replace");
 			const pendingCookies = options.getAndClearPendingCookies?.() ?? [];
 			for (const cookie of pendingCookies) headers.append("Set-Cookie", cookie);
@@ -320,76 +394,6 @@ async function buildAppPageSpecialErrorResponse(options) {
 	const responseStatus = options.specialError.fromMetadata === true && options.serveStreamingMetadata !== false ? 200 : options.specialError.statusCode;
 	return mergeAppPageSpecialErrorHeaders(new Response(getAppPageStatusText(options.specialError.statusCode), { status: responseStatus }), options.middlewareContext);
 }
-/** See `LayoutFlags` type docblock in app-elements.ts for lifecycle. */
-async function probeAppPageLayouts(options) {
-	const layoutFlags = {};
-	const cls = options.classification ?? null;
-	return {
-		response: await options.runWithSuppressedHookWarning(async () => {
-			for (let layoutIndex = options.layoutCount - 1; layoutIndex >= 0; layoutIndex--) {
-				const buildTimeResult = cls?.buildTimeClassifications?.get(layoutIndex);
-				if (cls && buildTimeResult) {
-					const layoutId = cls.getLayoutId(layoutIndex);
-					layoutFlags[layoutId] = buildTimeResult === "static" ? "s" : "d";
-					const errorResponse = await probeLayoutForErrors(options, layoutIndex);
-					if (errorResponse) return errorResponse;
-					const observationDynamic = cls.isLayoutObservationDynamic?.(layoutId) === true;
-					layoutFlags[layoutId] = buildTimeResult === "dynamic" || observationDynamic ? "d" : "s";
-					if (cls.debugClassification) {
-						if (observationDynamic && buildTimeResult === "static") cls.debugClassification(layoutId, {
-							layer: "runtime-probe",
-							outcome: "dynamic"
-						});
-						else cls.debugClassification(layoutId, cls.buildTimeReasons?.get(layoutIndex) ?? { layer: "no-classifier" });
-					}
-					continue;
-				}
-				if (cls) {
-					const layoutId = cls.getLayoutId(layoutIndex);
-					try {
-						const { dynamicDetected } = await cls.runWithIsolatedDynamicScope(async () => {
-							const outcome = await runWithConnectionProbe(() => options.probeLayoutAt(layoutIndex));
-							return outcome.completed ? outcome.result : null;
-						});
-						const observationDynamic = cls.isLayoutObservationDynamic?.(layoutId) === true;
-						const layoutDynamic = dynamicDetected || observationDynamic;
-						layoutFlags[layoutId] = layoutDynamic ? "d" : "s";
-						if (cls.debugClassification) cls.debugClassification(layoutId, {
-							layer: "runtime-probe",
-							outcome: layoutDynamic ? "dynamic" : "static"
-						});
-					} catch (error) {
-						layoutFlags[layoutId] = "d";
-						if (cls.debugClassification) cls.debugClassification(layoutId, {
-							layer: "runtime-probe",
-							outcome: "dynamic",
-							error: error instanceof Error ? error.message : String(error)
-						});
-						const errorResponse = await options.onLayoutError(error, layoutIndex);
-						if (errorResponse) return errorResponse;
-					}
-					continue;
-				}
-				const errorResponse = await probeLayoutForErrors(options, layoutIndex);
-				if (errorResponse) return errorResponse;
-			}
-			return null;
-		}),
-		layoutFlags
-	};
-}
-async function probeLayoutForErrors(options, layoutIndex) {
-	const outcome = await runWithConnectionProbe(async () => {
-		try {
-			const layoutResult = options.probeLayoutAt(layoutIndex);
-			if (isPromiseLike(layoutResult)) await layoutResult;
-		} catch (error) {
-			return options.onLayoutError(error, layoutIndex);
-		}
-		return null;
-	});
-	return outcome.completed ? outcome.result : null;
-}
 async function readAppPageBinaryStream(stream) {
 	const reader = stream.getReader();
 	const chunks = [];
@@ -434,4 +438,4 @@ function buildAppPageFontLinkHeader(preloads) {
 	return preloads.map((preload) => `<${preload.href}>; rel=preload; as=font; type=${preload.type}; crossorigin`).join(", ");
 }
 //#endregion
-export { APP_PAGE_NOT_FOUND_BOUNDARY_ID, bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, probeAppPageLayouts, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, tagAppPageMetadataError, tagAppPagePageError, tagAppPageSlotError, teeAppPageRscStreamForCapture };
+export { APP_PAGE_NOT_FOUND_BOUNDARY_ID, bufferAppPageBinaryStream, buildAppPageFontLinkHeader, buildAppPageSpecialErrorResponse, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, tagAppPageLayoutError, tagAppPageMetadataError, tagAppPagePageError, tagAppPageSlotError, teeAppPageRscStreamForCapture };

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

@@ -21,6 +21,12 @@ export type AppPageHeadParallelRoute<TModule extends AppPageHeadModule = AppPage
   layoutParams?: readonly AppPageParams[] | null;
   layoutModule?: TModule | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
+  /**
+   * Whether each layout is in its page's own loader-tree segment, from the
+   * filesystem: route groups are segments, and an intercept's
+   * `layoutTreePositions` don't count its page's. Unmarked layouts are above it.
+   */
+  layoutsBesidePage?: readonly boolean[] | null;
   layoutTreePositions?: readonly number[] | null;
   moduleRoutePrefixSegments?: readonly string[] | null;
   moduleRouteSegments?: readonly string[] | null;
@@ -59,6 +65,11 @@ type AppPageHeadSlot<TModule extends AppPageHeadModule = AppPageHeadModule> = {
   /** Directory depth of the folder holding the `@slot` directory. */
   ownerTreePosition?: number | null;
   page?: TModule | null;
+  /**
+   * The active page's tree position below the slot root, route groups
+   * included, in the coordinates of `configLayoutTreePositions`.
+   */
+  pageTreePosition?: number | null;
   routeSegments?: readonly string[] | null;
 };
 type ResolveActiveParallelRouteHeadInputsOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
@@ -179,6 +190,8 @@ type AppPageSearchParamsCollection = {
   hasSearchParams: boolean;
   pageSearchParams: AppPageSearchParams;
 };
+/** Whether each intercepting layout is in its intercepting page's own directory. */
+export declare function resolveInterceptLayoutsBesidePage(layoutSegments: readonly (readonly string[])[] | null | undefined, branchSegments: readonly string[] | null | undefined): boolean[];
 export declare function resolveActiveParallelRouteHeadInputs<TModule extends AppPageHeadModule>(options: ResolveActiveParallelRouteHeadInputsOptions<TModule>): ActiveParallelRouteHeadInput<TModule>[];
 /**
  * Whether a slot intercept keeps the source route's head. Next.js's client

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

@@ -3,8 +3,8 @@ import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { searchParamsToRecord } from "../utils/query.js";
 import { mergeMetadataEntries, mergeParentMetadataEntries, mergeViewport, postProcessMetadata, resolveModuleMetadata as resolveModuleMetadata$1, resolveModuleViewport } from "../shims/metadata.js";
 import { tagAppPageMetadataError } from "./app-page-execution.js";
-import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { createAppMetadataModuleRoute, traceGenerateMetadata } from "./app-metadata-tracing.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 //#region src/server/app-page-head.ts
 /**
 * Wrapped {@link _resolveModuleMetadata} that tags any thrown error with the
@@ -25,6 +25,10 @@ async function resolveModuleMetadata(moduleRoute, ...args) {
 		throw tagAppPageMetadataError(error);
 	}
 }
+/** Whether each intercepting layout is in its intercepting page's own directory. */
+function resolveInterceptLayoutsBesidePage(layoutSegments, branchSegments) {
+	return (layoutSegments ?? []).map((segments) => segments.length === branchSegments?.length);
+}
 function resolveActiveParallelRouteHeadInputs(options) {
 	const slotEntries = Object.entries(options.slots ?? {});
 	return slotEntries.map(([slotKey, slot]) => {
@@ -56,6 +60,7 @@ function resolveActiveParallelRouteHeadInputs(options) {
 							...resolveParallelLayoutParams(options.interceptBranchSegments ?? segments, segments.length, options.interceptParams ?? options.params)
 						};
 					})],
+					layoutsBesidePage: [...slot.layout ? [false] : [], ...resolveInterceptLayoutsBesidePage(options.interceptLayoutSegments, options.interceptBranchSegments)],
 					layoutTreePositions: [...slot.layout ? [0] : [], ...interceptLayouts.filter(isPresent).map(() => options.routeSegments.length)],
 					pageModule: options.interceptPage,
 					params: options.interceptParams ?? options.params,
@@ -72,6 +77,8 @@ function resolveActiveParallelRouteHeadInputs(options) {
 		}
 		const slotRouteSegments = slot.routeSegments ?? options.routeSegments;
 		const moduleRouteSegments = slot.routeSegments ?? [];
+		const layoutTreePositions = [...slot.layout ? [0] : [], ...slot.configLayoutTreePositions ?? []];
+		const pageTreePosition = slot.pageTreePosition;
 		return {
 			head: {
 				layoutModules: [slot.layout, ...slot.configLayouts ?? []].filter(isPresent),
@@ -79,7 +86,8 @@ function resolveActiveParallelRouteHeadInputs(options) {
 					...ownerParams,
 					...resolveParallelLayoutParams(slot.routeSegments ?? options.routeSegments, treePosition, options.slotParams?.[slotKey] ?? options.params)
 				}))],
-				layoutTreePositions: [...slot.layout ? [0] : [], ...slot.configLayoutTreePositions ?? []],
+				...pageTreePosition == null ? {} : { layoutsBesidePage: layoutTreePositions.map((treePosition) => treePosition >= pageTreePosition) },
+				layoutTreePositions,
 				pageModule: slot.page,
 				params: slotParams,
 				...ownerRouteSegments.length > 0 ? { moduleRoutePrefixSegments: ownerRouteSegments } : {},
@@ -219,14 +227,20 @@ function createLayoutInputs(layoutModules, layoutTreePositions) {
 	}
 	return layoutInputs;
 }
-/** The walk's accumulated metadata, with its resolved title as the shown string. */
+/** The walk's accumulated metadata, with its resolved titles as the shown strings. */
 function toShownMetadata(accumulated) {
-	const title = accumulated.title;
-	if (title === void 0 || typeof title === "string") return accumulated;
-	return {
-		...accumulated,
-		title: title.absolute || void 0
+	const shown = (title) => typeof title === "object" && title ? title.absolute || void 0 : title;
+	const result = { ...accumulated };
+	if (typeof accumulated.title === "object") result.title = shown(accumulated.title);
+	if (accumulated.openGraph) result.openGraph = {
+		...accumulated.openGraph,
+		title: shown(accumulated.openGraph.title)
+	};
+	if (accumulated.twitter) result.twitter = {
+		...accumulated.twitter,
+		title: shown(accumulated.twitter.title)
 	};
+	return result;
 }
 function getParallelRouteModules(parallelRoute) {
 	return [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
@@ -236,6 +250,7 @@ function parallelRouteHasDynamicMetadata(parallelRoute) {
 }
 function createRouteHeadBranch(layoutInputs, routeSegments, params, pageModule) {
 	const segments = layoutInputs.map((layoutInput) => ({
+		besidePage: layoutInput.treePosition >= routeSegments.length,
 		module: layoutInput.module,
 		moduleRoute: createAppMetadataModuleRoute(routeSegments.slice(0, layoutInput.treePosition), "layout"),
 		page: false,
@@ -260,6 +275,7 @@ function createParallelRouteHeadBranch(parallelRoute, fallbackParams, fallbackRo
 	const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
 	const layoutParams = parallelRoute.layoutParams ?? [];
 	const segments = getParallelRouteModules(parallelRoute).map((module, index) => ({
+		besidePage: parallelRoute.layoutsBesidePage?.[index] ?? false,
 		module,
 		moduleRoute: createAppMetadataModuleRoute([...moduleRoutePrefixSegments, ...moduleRouteSegments.slice(0, layoutTreePositions[index] ?? 0)], "layout"),
 		page: false,
@@ -296,14 +312,14 @@ function createHiddenHeadBranch(hidden, slot, fallbackParams, fallbackRouteSegme
 * With `deferParentErrors`, `error` never waits on `parent`: what can only be
 * known after it goes to `deferredError` instead.
 */
-function startAppPageHeadItem(kind, segment, parent, deferParentErrors = false) {
+function startAppPageHeadItem(kind, segment, parent, deferParentErrors = false, stashed = parent) {
 	const observedParent = observeParent(parent);
 	const parentRead = new Promise((resolve) => {
 		observedParent.onRead = () => resolve(null);
 	});
 	const result = kind.resolve(segment, observedParent);
 	result.catch(() => null);
-	const resolved = parent.then((resolvedParent) => result.then((value) => value ? kind.merge(resolvedParent, value) : resolvedParent));
+	const resolved = parent.then((resolvedParent) => stashed.then((resolvedStashed) => result.then((value) => value ? kind.merge(resolvedParent, value, resolvedStashed) : resolvedParent)));
 	resolved.catch(() => null);
 	const mergeError = result.then((value) => value ? parent.then(() => resolved.then(() => null), () => null) : null, () => null);
 	const ownError = result.then(() => null, (error) => {
@@ -362,8 +378,12 @@ function walkAppPageHead(kind, route, slots, hiddenBranches, outletIndex) {
 	let resolved = Promise.resolve(kind.initial);
 	let slotBranchParent = null;
 	let afterOutlet = false;
-	const start = (segment, parent) => {
-		const item = startAppPageHeadItem(kind, segment, parent, !slotBranchParent && afterOutlet);
+	const lastBranch = slots.at(-1) ?? route;
+	const lastPage = lastBranch.segments.at(-1)?.page ? lastBranch.segments.at(-1) : void 0;
+	const lastPageLayout = lastPage && lastBranch.segments.at(-2);
+	let beforeLastPageLayout;
+	const start = (segment, parent, stashed) => {
+		const item = startAppPageHeadItem(kind, segment, parent, !slotBranchParent && afterOutlet, stashed);
 		if (item.deferredError) deferredErrors.push(item.deferredError);
 		if (slotBranchParent) {
 			const error = slotBranchParent.then(() => item.error, () => null);
@@ -379,7 +399,8 @@ function walkAppPageHead(kind, route, slots, hiddenBranches, outletIndex) {
 		return item;
 	};
 	const startShown = (segment) => {
-		const item = start(segment, resolved);
+		if (segment === lastPageLayout && segment.besidePage) beforeLastPageLayout = resolved;
+		const item = start(segment, resolved, segment === lastPage ? beforeLastPageLayout : void 0);
 		resolved = item.resolved;
 		return item.result;
 	};
@@ -489,9 +510,16 @@ function prepareAppPageHeadInner(options) {
 	const segmentSearchParamsObserver = (segment) => segment.page ? options.searchParamsObserver : void 0;
 	const metadataWalk = walkAppPageHead({
 		initial: {},
-		merge: (resolved, metadata) => {
+		merge: (resolved, metadata, stashed) => {
 			try {
-				return mergeParentMetadataEntries([{ metadata: resolved }, { metadata }]);
+				return mergeParentMetadataEntries(resolved === stashed ? [{ metadata: resolved }, { metadata }] : [
+					{ metadata: stashed },
+					{
+						isPage: true,
+						metadata: resolved
+					},
+					{ metadata }
+				]);
 			} catch (error) {
 				throw tagAppPageMetadataError(error);
 			}
@@ -540,4 +568,4 @@ function prepareAppPageHeadInner(options) {
 	};
 }
 //#endregion
-export { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveOrderedAppPageMetadata, slotInterceptKeepsSourceHead };
+export { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveInterceptLayoutsBesidePage, resolveOrderedAppPageMetadata, slotInterceptKeepsSourceHead };

package/dist/server/app-page-http-access-fallback-metadata.d.ts

@@ -33,6 +33,7 @@ type RouteNotFoundHeadPlanRoute<TModule extends AppPageHeadModule> = {
   notFounds?: readonly (TModule | null | undefined)[] | null;
   notFoundTreePosition?: number | null;
   routeSegments?: readonly string[] | null;
+  segmentNotFoundTreePositions?: readonly number[] | null;
 };
 /**
  * The not-found head a route's own head falls back to. Like Next.js's

package/dist/server/app-page-http-access-fallback-metadata.js

@@ -1,8 +1,8 @@
 import { isStaticGenerationAccessError } from "../shims/internal/headers-state.js";
 import { mergeViewport, resolveModuleViewport } from "../shims/metadata.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
-import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { createAppMetadataModuleRoute } from "./app-metadata-tracing.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { resolveOrderedAppPageMetadata } from "./app-page-head.js";
 import { resolveAppPageParentHttpAccessBoundary } from "./app-page-boundary.js";
 //#region src/server/app-page-http-access-fallback-metadata.ts
@@ -124,7 +124,7 @@ function createRouteNotFoundHeadPlanOptions(options) {
 	if (!boundaryModule) {
 		const parentBoundary = resolveAppPageParentHttpAccessBoundary({
 			layoutIndex: layoutModules.length,
-			rootNotFoundModule: options.rootNotFoundModule,
+			rootNotFoundModule: route.segmentNotFoundTreePositions ? null : options.rootNotFoundModule,
 			routeNotFoundModules: route.notFounds,
 			statusCode: 404
 		});

package/dist/server/app-page-layout-gate.d.ts

@@ -0,0 +1,35 @@
+//#region src/server/app-page-layout-gate.d.ts
+/**
+ * Holds an RSC response until the layouts above the route's first loading
+ * boundary have rendered, so that a layout's redirect(), notFound(),
+ * forbidden() or unauthorized() still answers the request: a redirect through
+ * the `X-Vinext-Rsc-Redirect` side channel, and the others with their
+ * boundary's status. The layouts render once, in the render itself. A
+ * signal from a component a layout renders streams in the payload, as in
+ * Next.js.
+ */
+export type AppPageLayoutGate = {
+  /** Holds the response until the layout with `layoutId` has rendered. */
+  hold(layoutId: string, layoutIndex: number): void;
+  /** Reports how the layout with `layoutId` rendered. */
+  settle(layoutId: string, failure?: {
+    error: unknown;
+  }): void;
+  /**
+   * The outermost held layout that threw, once every held layout `isRendered`
+   * includes has rendered, or null. An error elsewhere in the render doesn't
+   * stop the wait, as Flight goes on to render the other entries, but the
+   * render ending does: `ended` settles when its stream closes or errors.
+   */
+  wait(isRendered: (layoutId: string) => boolean, ended: Promise<unknown>): Promise<AppPageLayoutGateFailure | null>;
+};
+type AppPageLayoutGateFailure = {
+  error: unknown;
+  layoutIndex: number;
+};
+export declare function createAppPageLayoutGate(): AppPageLayoutGate;
+export declare function registerAppPageLayoutGate(elements: object, gate: AppPageLayoutGate): void;
+/** The gate of the layouts in `element`, an App Router elements record. */
+export declare function getAppPageLayoutGate(element: unknown): AppPageLayoutGate | null;
+//#endregion
+export {};

package/dist/server/app-page-layout-gate.js

@@ -0,0 +1,50 @@
+//#region src/server/app-page-layout-gate.ts
+function createAppPageLayoutGate() {
+	const held = /* @__PURE__ */ new Map();
+	const settled = /* @__PURE__ */ new Set();
+	let failure = null;
+	let ended = false;
+	let check = null;
+	return {
+		hold(layoutId, layoutIndex) {
+			held.set(layoutId, layoutIndex);
+		},
+		settle(layoutId, layoutFailure) {
+			const layoutIndex = held.get(layoutId);
+			if (layoutIndex === void 0 || settled.has(layoutId)) return;
+			settled.add(layoutId);
+			if (layoutFailure) {
+				if (failure === null || layoutIndex < failure.layoutIndex) failure = {
+					error: layoutFailure.error,
+					layoutIndex
+				};
+			}
+			check?.();
+		},
+		wait(isRendered, renderEnded) {
+			return new Promise((resolve) => {
+				check = () => {
+					for (const layoutId of held.keys()) if (!ended && !settled.has(layoutId) && isRendered(layoutId)) return;
+					check = null;
+					resolve(failure);
+				};
+				const end = () => {
+					ended = true;
+					check?.();
+				};
+				renderEnded.then(end, end);
+				check();
+			});
+		}
+	};
+}
+const appPageLayoutGates = /* @__PURE__ */ new WeakMap();
+function registerAppPageLayoutGate(elements, gate) {
+	appPageLayoutGates.set(elements, gate);
+}
+/** The gate of the layouts in `element`, an App Router elements record. */
+function getAppPageLayoutGate(element) {
+	return typeof element === "object" && element !== null ? appPageLayoutGates.get(element) ?? null : null;
+}
+//#endregion
+export { createAppPageLayoutGate, getAppPageLayoutGate, registerAppPageLayoutGate };

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

@@ -1,7 +1,6 @@
 import { AppPageParams } from "./app-page-boundary.js";
 //#region src/server/app-page-params.d.ts
 export declare function getAppPageSegmentParamName(segment: string): string | null;
-export declare function resolveAppPageSegmentParamScopeKeys(routeSegments: readonly string[] | null | undefined, treePosition: number): readonly string[];
 export declare function resolveAppPageSegmentParams(routeSegments: readonly string[] | null | undefined, treePosition: number, matchedParams: AppPageParams): AppPageParams;
 export declare function resolveAppPageBranchParams(branchSegments: readonly string[], treePosition: number, matchedParams: AppPageParams, scopedSegments?: readonly string[]): AppPageParams;
 //#endregion

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

@@ -8,19 +8,6 @@ function getAppPageSegmentParamName(segment) {
 function isEmptyOptionalCatchAll(segment, paramValue) {
 	return segment.startsWith("[[...") && Array.isArray(paramValue) && paramValue.length === 0;
 }
-function resolveAppPageSegmentParamScopeKeys(routeSegments, treePosition) {
-	const paramNames = [];
-	const seen = /* @__PURE__ */ new Set();
-	const segments = routeSegments ?? [];
-	const end = Math.min(Math.max(treePosition, 0), segments.length);
-	for (let index = 0; index < end; index++) {
-		const paramName = getAppPageSegmentParamName(segments[index]);
-		if (!paramName || seen.has(paramName)) continue;
-		seen.add(paramName);
-		paramNames.push(paramName);
-	}
-	return paramNames;
-}
 function resolveAppPageSegmentParams(routeSegments, treePosition, matchedParams) {
 	const segmentParams = {};
 	const segments = routeSegments ?? [];
@@ -43,4 +30,4 @@ function resolveAppPageBranchParams(branchSegments, treePosition, matchedParams,
 	return scopedParams;
 }
 //#endregion
-export { getAppPageSegmentParamName, resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams };
+export { getAppPageSegmentParamName, resolveAppPageBranchParams, resolveAppPageSegmentParams };

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

@@ -1,31 +1,13 @@
-import { LayoutFlags } from "./app-elements-wire.js";
-import { AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 //#region src/server/app-page-probe.d.ts
 type ProbeReactServerSubtreeOptions = Readonly<{
   maxDepth?: number;
   maxNodes?: number;
 }>;
 /**
- * Invokes server-component children returned by a layout probe so per-layout
- * skip eligibility observes data dependencies created below the layout's
- * immediate function body. The real RSC render remains authoritative; probe
- * failures only make static-layout skip fall back to render-and-send.
+ * Invokes the server components a layout renders, so the error-path layout
+ * probe sees an HTTP access fallback thrown below the layout's own function
+ * body. The real RSC render remains authoritative.
  */
 export declare function probeReactServerSubtree(node: unknown, options?: ProbeReactServerSubtreeOptions): Promise<void>;
-type ProbeAppPageBeforeRenderResult = {
-  response: Response | null;
-  layoutFlags: LayoutFlags;
-};
-type ProbeAppPageBeforeRenderOptions = {
-  skipProbes?: boolean;
-  layoutCount: number;
-  probeLayoutAt: (layoutIndex: number) => unknown;
-  renderLayoutSpecialError: (specialError: AppPageSpecialError, layoutIndex: number) => Promise<Response>;
-  resolveSpecialError: (error: unknown) => AppPageSpecialError | null;
-  runWithSuppressedHookWarning<T>(probe: () => Promise<T>): Promise<T>;
-  /** When provided, enables per-layout static/dynamic classification. */
-  classification?: LayoutClassificationOptions | null;
-};
-export declare function probeAppPageBeforeRender(options: ProbeAppPageBeforeRenderOptions): Promise<ProbeAppPageBeforeRenderResult>;
 //#endregion
 export {};