vinext 1.3.0 → 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 { 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";
@@ -40,6 +38,83 @@ 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");
+/**
+* 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;
+	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 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);
+	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 +158,83 @@ 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. 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);
 	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;
+	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 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;
+	}
+	if (slotLayoutIndex === null && layoutIndex === null && !unattributed) return specialError;
+	return {
+		...specialError,
+		...slotLayoutIndex !== null ? { slotLayoutIndex } : {},
+		...layoutIndex !== null ? { layoutIndex } : {},
+		...unattributed ? { unattributed: true } : {}
+	};
+}
+/**
+* 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;
+		if (getAppPageLayoutErrorLayoutIndex(rendered) !== null) 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
@@ -121,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) {
@@ -154,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,
@@ -173,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);
@@ -211,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 = [];
@@ -325,4 +438,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, readAppPageBinaryStream, resolveAppPageCaughtNotFoundBoundaries, resolveAppPageShellSpecialError, resolveAppPageSpecialError, resolveAppPageSpecialErrorStoredHeaders, tagAppPageLayoutError, tagAppPageMetadataError, tagAppPagePageError, tagAppPageSlotError, teeAppPageRscStreamForCapture };

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

@@ -1,7 +1,7 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppPageParams } from "./app-page-boundary.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
-import { Metadata, ResolvedViewport } from "../shims/metadata.js";
+import { Metadata, ResolvedViewport, Viewport } from "../shims/metadata.js";
 import { applyFileBasedMetadata } from "./file-based-metadata.js";
 //#region src/server/app-page-head.d.ts
 export type AppPageSearchParams = Record<string, string | string[]>;
@@ -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;
@@ -34,15 +40,36 @@ export type ActiveParallelRouteHeadInput<TModule extends AppPageHeadModule = App
   notFoundModuleRouteSegments?: readonly string[] | null;
   notFoundParams?: AppPageParams | null;
   ownerTreePosition: number;
+  /** The `slots` key of the slot this branch renders in. */
+  slotKey?: string;
+};
+/**
+ * A branch whose head Next.js resolves but never shows: a slot intercept's
+ * layouts and page beside the source page. It renders in the slot at
+ * `parallelRouteIndex` of `parallelRoutes` and shares that slot's first
+ * `sharedLayoutCount` layouts, which resolve once for both.
+ */
+export type AppPageHiddenParallelRoute<TModule extends AppPageHeadModule = AppPageHeadModule> = {
+  parallelRouteIndex: number;
+  route: AppPageHeadParallelRoute<TModule>;
+  sharedLayoutCount: number;
 };
 type AppPageHeadSlot<TModule extends AppPageHeadModule = AppPageHeadModule> = {
   configLayouts?: readonly (TModule | null | undefined)[] | null;
   configLayoutTreePositions?: readonly number[] | null;
   layout?: TModule | null;
   layoutIndex?: number;
+  name?: string | null;
   notFound?: TModule | null;
   notFoundTreePosition?: number | null;
+  /** 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> = {
@@ -72,9 +99,22 @@ type ResolveAppPageHeadOptions<TModule extends AppPageHeadModule = AppPageHeadMo
    */
   basePath?: string;
   fallbackOnFileMetadataError?: boolean;
+  /**
+   * Branches whose head Next.js resolves but never shows, such as a slot
+   * intercept beside the source page. Their own generateMetadata() and
+   * generateViewport() run once, after every branch before them in the loader
+   * tree, and their errors reach `hiddenErrors` rather than the head.
+   */
+  hiddenParallelRoutes?: readonly AppPageHiddenParallelRoute<TModule>[] | null;
   layoutModules: readonly (TModule | null | undefined)[];
   layoutTreePositions?: readonly number[] | null;
   metadataRoutes: readonly MetadataFileRoute[];
+  /**
+   * The index in `parallelRoutes` of a shown branch whose own errors reach
+   * `hiddenErrors` rather than `routeErrors`, such as a slot intercept that
+   * heads the route: Next.js throws them in that page's own segment.
+   */
+  outletParallelRouteIndex?: number | null;
   pageModule?: TModule | null;
   parallelRoutes?: readonly AppPageHeadParallelRoute<TModule>[] | null;
   params: AppPageParams;
@@ -103,14 +143,78 @@ export type ResolveAppPageHeadResult = {
   viewport: ResolvedViewport;
 };
 export type PreparedAppPageHead = Omit<ResolveAppPageHeadResult, "metadata" | "viewport"> & {
+  /**
+   * Rejects with the first own error, in loader-tree order, of an item of
+   * `hiddenParallelRoutes` or of `outletParallelRouteIndex`, or with the
+   * head's own failure when that outlet branch heads the route.
+   */
+  hiddenErrors: Promise<null>;
   metadata: Promise<Metadata | null>;
+  /**
+   * Rejects with the first own error, in loader-tree order, of every other
+   * item, or with the head's own failure. Those errors never wait on the
+   * outlet branch; what only the outlet branch settling makes known, a later
+   * item's failed merge or its error after reading `parent`, counts after them.
+   */
+  routeErrors: Promise<null>;
   viewport: Promise<ResolvedViewport>;
 };
+/**
+ * A route's head as one render prepared it, for a later render to reuse. Each
+ * branch already settled its own signals, so neither rejects.
+ */
+export type AppPagePreparedRouteHead = {
+  /** The `dynamic = "error"` access error either branch dropped, which still fails the render. */
+  accessError: Promise<Error | null>;
+  metadata: Promise<Metadata | null>;
+  /** Where that render places generateMetadata()'s tags: "body" streams them. */
+  metadataPlacement: "body" | "head";
+  /** `null` when its resolution failed, so the head has no viewport tags. */
+  viewport: Promise<Viewport | null>;
+};
+/**
+ * A special-error fallback for a signal the matched route's render threw keeps
+ * the route's own head: the head that render prepared, or, when it never
+ * started one, a fresh resolution with that render's query and placement.
+ */
+export type AppPageFallbackRouteHead = {
+  /** Whether metadata's `searchParams` reads count as dynamic usage, as in the render. */
+  observeSearchParams: boolean;
+  prepared: AppPagePreparedRouteHead | null;
+  /** The query the render read: a rewrite's, or none for a static render. */
+  searchParams: URLSearchParams;
+  /** Whether the render streams generated metadata into the body. */
+  streamMetadata: boolean;
+};
 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
+ * renders the head of the first leaf on a children-first walk of its router
+ * tree that skips `default` segments, and a slot intercept keeps the leaves
+ * before its slot from the source route. When one of them is a page, such as
+ * the source page in `children`, the source head stays; otherwise the walk
+ * reaches the intercept's leaf, headed by the intercepting render.
+ * `sourceParallelRoutes` are the source route's own slot branches, in the
+ * walk's order (resolveActiveParallelRouteHeadInputs).
+ * https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/router-reducer/reducers/find-head-in-cache.ts
+ */
+export declare function slotInterceptKeepsSourceHead(options: {
+  interceptSlotKey: string;
+  /** The source route; its `children` is a page unless it renders a default. */
+  route: {
+    childrenSlot?: {
+      state: string;
+    } | null;
+    page?: unknown;
+  };
+  sourceParallelRoutes: readonly ActiveParallelRouteHeadInput[];
+}): boolean;
 export declare function collectAppPageSearchParams(searchParams: URLSearchParams | null | undefined): AppPageSearchParamsCollection;
 /**
  * Resolve an explicit metadata-source sequence.
@@ -125,7 +229,7 @@ export declare function resolveAppPageHead<TModule extends AppPageHeadModule>(op
  * Whether any segment of the page's head exports `generateMetadata()`. Known
  * from the modules alone, so callers can place the head before resolving it.
  */
-export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadModule>(options: Pick<ResolveAppPageHeadOptions<TModule>, "layoutModules" | "pageModule" | "parallelRoutes">): boolean;
+export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadModule>(options: Pick<ResolveAppPageHeadOptions<TModule>, "hiddenParallelRoutes" | "layoutModules" | "pageModule" | "parallelRoutes">): boolean;
 /**
  * Start metadata and viewport resolution without coupling their completion.
  *
@@ -134,4 +238,5 @@ export declare function hasAppPageDynamicMetadata<TModule extends AppPageHeadMod
  * callers use {@link resolveAppPageHead} and observe the same result as before.
  */
 export declare function prepareAppPageHead<TModule extends AppPageHeadModule>(options: ResolveAppPageHeadOptions<TModule>): PreparedAppPageHead;
-//#endregion
+//#endregion
+export {};