vinext 1.3.0 → 1.4.0

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

@@ -1,9 +1,10 @@
+import { compareFolderNames } from "../utils/compare.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
 import { searchParamsToRecord } from "../utils/query.js";
-import { mergeMetadataEntries, mergeViewport, postProcessMetadata, resolveModuleMetadata as resolveModuleMetadata$1, resolveModuleViewport } from "../shims/metadata.js";
-import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { mergeMetadataEntries, mergeParentMetadataEntries, mergeViewport, postProcessMetadata, resolveModuleMetadata as resolveModuleMetadata$1, resolveModuleViewport } from "../shims/metadata.js";
 import { tagAppPageMetadataError } from "./app-page-execution.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
@@ -24,8 +25,13 @@ 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) {
-	return Object.entries(options.slots ?? {}).map(([slotKey, slot]) => {
+	const slotEntries = Object.entries(options.slots ?? {});
+	return slotEntries.map(([slotKey, slot]) => {
 		const ownerTreePosition = options.layoutTreePositions?.[slot.layoutIndex ?? 0] ?? 0;
 		const ownerRouteSegments = options.routeSegments.slice(0, ownerTreePosition);
 		const ownerParams = resolveAppPageSegmentParams(options.routeSegments, ownerTreePosition, options.params);
@@ -54,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,
@@ -64,11 +71,14 @@ function resolveActiveParallelRouteHeadInputs(options) {
 					notFoundModuleRouteSegments: interceptNotFoundRouteSegments,
 					notFoundParams: interceptNotFoundParams
 				} : {},
-				ownerTreePosition
+				ownerTreePosition,
+				slotKey
 			};
 		}
 		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),
@@ -76,21 +86,93 @@ 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 } : {},
 				...slot.routeSegments ? {} : { moduleRouteSegments },
 				routeSegments: slotRouteSegments
 			},
-			...slot.notFound ? {
+			...slot.notFound && slot.page ? {
 				notFoundModule: slot.notFound,
 				notFoundModuleRouteSegments: [...ownerRouteSegments, ...moduleRouteSegments.slice(0, slot.notFoundTreePosition ?? 0)],
 				notFoundParams
 			} : {},
-			ownerTreePosition
+			ownerTreePosition,
+			slotKey
+		};
+	}).map((input, index) => {
+		const [slotKey, slot] = slotEntries[index];
+		return {
+			directoryDepth: slot.ownerTreePosition ?? input.ownerTreePosition,
+			input,
+			name: slot.name ?? slotKey
 		};
-	}).sort((left, right) => right.ownerTreePosition - left.ownerTreePosition);
+	}).sort((left, right) => right.directoryDepth - left.directoryDepth || compareFolderNames(left.name, right.name)).map(({ input }) => input);
+}
+/**
+* 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
+*/
+function slotInterceptKeepsSourceHead(options) {
+	const { route } = options;
+	if (route.page != null && (route.childrenSlot?.state ?? "active") === "active") return true;
+	const interceptIndex = options.sourceParallelRoutes.findIndex((input) => input.slotKey === options.interceptSlotKey);
+	return options.sourceParallelRoutes.slice(0, interceptIndex === -1 ? void 0 : interceptIndex).some((input) => input.head.pageModule != null);
+}
+/**
+* Like Promise.all, but awaits the already-started promises one at a time, so
+* the first rejection in this order wins, not the first to settle. Next.js's
+* accumulateMetadata and accumulateViewport await their loader-tree items this
+* way, so an earlier segment's signal beats a later one's. Each promise is
+* handled up front, so none rejects unhandled.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/metadata/resolve-metadata.ts
+*/
+async function allInOrder(promises) {
+	for (const promise of promises) promise.catch(() => null);
+	const results = [];
+	for (const promise of promises) results.push(await promise);
+	return results;
+}
+/**
+* A segment's `parent` that records a rejection its resolver saw, through
+* `await` or any other `then()`, so that an error the resolver took from
+* `parent` can be told from its own, even when both are the same value.
+*/
+var ObservedParent = class extends Promise {
+	static get [Symbol.species]() {
+		return Promise;
+	}
+	rejection = null;
+	/** Whether the resolver read it, and what to call when it first does. */
+	read = false;
+	onRead = null;
+	then(onFulfilled, onRejected) {
+		if (!this.read) {
+			this.read = true;
+			this.onRead?.();
+		}
+		return super.then(onFulfilled, (error) => {
+			this.rejection = { error };
+			if (onRejected) return onRejected(error);
+			throw error;
+		});
+	}
+};
+function observeParent(parent) {
+	const observed = new ObservedParent((resolveParent, rejectParent) => {
+		parent.then(resolveParent, rejectParent);
+	});
+	Promise.prototype.then.call(observed, void 0, () => null);
+	return observed;
 }
 function isPresent(value) {
 	return value !== null && value !== void 0;
@@ -145,42 +227,20 @@ function createLayoutInputs(layoutModules, layoutTreePositions) {
 	}
 	return layoutInputs;
 }
-async function resolveLayoutMetadata(layoutInputs, params, routeSegments) {
-	const layoutMetadataPromises = [];
-	let accumulatedMetadata = Promise.resolve({});
-	for (const layoutInput of layoutInputs) {
-		const parentForLayout = accumulatedMetadata;
-		const layoutParams = resolveAppPageSegmentParams(routeSegments, layoutInput.treePosition, params);
-		const metadataPromise = resolveModuleMetadata(createAppMetadataModuleRoute(routeSegments.slice(0, layoutInput.treePosition), "layout"), layoutInput.module, layoutParams, void 0, parentForLayout);
-		layoutMetadataPromises.push(metadataPromise);
-		metadataPromise.catch(() => null);
-		accumulatedMetadata = metadataPromise.then(async (metadataResult) => {
-			if (metadataResult) return mergeMetadataEntries([{ metadata: await parentForLayout }, { metadata: metadataResult }]);
-			return parentForLayout;
-		});
-		accumulatedMetadata.catch(() => null);
-	}
-	return Promise.all(layoutMetadataPromises);
-}
-function resolveLayoutViewport(layoutInputs, params, routeSegments) {
-	const viewportPromises = [];
-	let accumulatedViewport = Promise.resolve(mergeViewport([]));
-	for (const layoutInput of layoutInputs) {
-		const parentForLayout = accumulatedViewport;
-		const layoutParams = resolveAppPageSegmentParams(routeSegments, layoutInput.treePosition, params);
-		const viewportPromise = resolveModuleViewport(layoutInput.module, layoutParams, void 0, parentForLayout);
-		viewportPromises.push(viewportPromise);
-		viewportPromise.catch(() => null);
-		accumulatedViewport = mergeResolvedViewport(parentForLayout, viewportPromise);
-		accumulatedViewport.catch(() => null);
-	}
-	return {
-		resolvedViewport: accumulatedViewport,
-		viewportResults: Promise.all(viewportPromises)
+/** The walk's accumulated metadata, with its resolved titles as the shown strings. */
+function toShownMetadata(accumulated) {
+	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)
 	};
-}
-function mergeResolvedViewport(parent, viewport) {
-	return Promise.all([parent, viewport]).then(([resolvedParent, resolvedViewport]) => resolvedViewport ? mergeViewport([resolvedParent, resolvedViewport]) : resolvedParent);
+	if (accumulated.twitter) result.twitter = {
+		...accumulated.twitter,
+		title: shown(accumulated.twitter.title)
+	};
+	return result;
 }
 function getParallelRouteModules(parallelRoute) {
 	return [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
@@ -188,70 +248,193 @@ function getParallelRouteModules(parallelRoute) {
 function parallelRouteHasDynamicMetadata(parallelRoute) {
 	return getParallelRouteModules(parallelRoute).some(hasGenerateMetadata) || hasGenerateMetadata(parallelRoute.pageModule);
 }
-async function resolveParallelRouteMetadata(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent, searchParamsObserver) {
+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,
+		params: resolveAppPageSegmentParams(routeSegments, layoutInput.treePosition, params)
+	}));
+	if (pageModule) segments.push({
+		module: pageModule,
+		moduleRoute: createAppMetadataModuleRoute(routeSegments, "page"),
+		page: true,
+		params
+	});
+	return {
+		routeSegments,
+		segments
+	};
+}
+function createParallelRouteHeadBranch(parallelRoute, fallbackParams, fallbackRouteSegments) {
 	const params = parallelRoute.params ?? fallbackParams;
 	const routeSegments = parallelRoute.routeSegments ?? fallbackRouteSegments;
 	const moduleRoutePrefixSegments = parallelRoute.moduleRoutePrefixSegments ?? [];
 	const moduleRouteSegments = parallelRoute.moduleRouteSegments ?? routeSegments;
-	const metadataResults = [];
-	const metadataSources = [];
-	let accumulatedMetadata = parent;
-	const layoutModules = getParallelRouteModules(parallelRoute);
 	const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
 	const layoutParams = parallelRoute.layoutParams ?? [];
-	for (const [index, layoutModule] of layoutModules.entries()) {
-		const currentLayoutParams = layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params);
-		const layoutMetadata = await resolveModuleMetadata(createAppMetadataModuleRoute([...moduleRoutePrefixSegments, ...moduleRouteSegments.slice(0, layoutTreePositions[index] ?? 0)], "layout"), layoutModule, currentLayoutParams, void 0, accumulatedMetadata);
-		metadataResults.push(layoutMetadata);
-		metadataSources.push({
-			metadata: layoutMetadata,
-			routeSegments
-		});
-		if (layoutMetadata) {
-			accumulatedMetadata = accumulatedMetadata.then(async (parentMetadata) => mergeMetadataEntries([{ metadata: parentMetadata }, { metadata: layoutMetadata }]));
-			accumulatedMetadata.catch(() => null);
-		}
-	}
-	if (parallelRoute.pageModule) {
-		const pageMetadata = await resolveModuleMetadata(createAppMetadataModuleRoute([...moduleRoutePrefixSegments, ...moduleRouteSegments], "page"), parallelRoute.pageModule, params, pageSearchParams, accumulatedMetadata, searchParamsObserver);
-		metadataResults.push(pageMetadata);
-		metadataSources.push({
-			metadata: pageMetadata,
-			routeSegments
-		});
-	}
+	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,
+		params: layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params)
+	}));
+	if (parallelRoute.pageModule) segments.push({
+		module: parallelRoute.pageModule,
+		moduleRoute: createAppMetadataModuleRoute([...moduleRoutePrefixSegments, ...moduleRouteSegments], "page"),
+		page: true,
+		params
+	});
 	return {
-		metadataResults,
-		metadataSources
+		routeSegments,
+		segments
 	};
 }
-function resolveParallelRouteViewport(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent, searchParamsObserver) {
-	const params = parallelRoute.params ?? fallbackParams;
-	const routeSegments = parallelRoute.routeSegments ?? fallbackRouteSegments;
-	const layoutModules = getParallelRouteModules(parallelRoute);
-	const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
-	const layoutParams = parallelRoute.layoutParams ?? [];
-	const viewportPromises = [];
-	let accumulatedViewport = parent;
-	for (const [index, layoutModule] of layoutModules.entries()) {
-		const parentForLayout = accumulatedViewport;
-		const viewportPromise = resolveModuleViewport(layoutModule, layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params), void 0, parentForLayout);
-		viewportPromises.push(viewportPromise);
-		viewportPromise.catch(() => null);
-		accumulatedViewport = mergeResolvedViewport(parentForLayout, viewportPromise);
-		accumulatedViewport.catch(() => null);
-	}
-	if (parallelRoute.pageModule) {
-		const parentForPage = accumulatedViewport;
-		const viewportPromise = resolveModuleViewport(parallelRoute.pageModule, params, pageSearchParams, parentForPage, searchParamsObserver);
-		viewportPromises.push(viewportPromise);
-		viewportPromise.catch(() => null);
-		accumulatedViewport = mergeResolvedViewport(parentForPage, viewportPromise);
-		accumulatedViewport.catch(() => null);
+/** A hidden branch without the layouts it shares with its slot, which resolve once. */
+function createHiddenHeadBranch(hidden, slot, fallbackParams, fallbackRouteSegments) {
+	const branch = createParallelRouteHeadBranch(hidden.route, fallbackParams, fallbackRouteSegments);
+	const sharedLayoutCount = slot ? Math.min(hidden.sharedLayoutCount, slot.segments.filter((segment) => !segment.page).length) : 0;
+	return {
+		parallelRouteIndex: slot ? hidden.parallelRouteIndex : -1,
+		routeSegments: branch.routeSegments,
+		segments: branch.segments.filter((segment, index) => segment.page || index >= sharedLayoutCount),
+		sharedLayoutCount
+	};
+}
+/**
+* Start an item with everything resolved before it as `parent`, and merge its
+* value into that once both settle. Like Next.js's getResult, the resolver
+* starts now; like its accumulateMetadata and accumulateViewport, the merge
+* waits for the items before it, and its failure is the item's own error.
+*
+* 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, 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) => 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) => {
+		const rejection = observedParent.rejection;
+		if (rejection && Object.is(rejection.error, error)) return null;
+		throw error;
+	});
+	mergeError.catch(() => null);
+	ownError.catch(() => null);
+	if (!deferParentErrors) {
+		const error = ownError.then(() => mergeError);
+		error.catch(() => null);
+		return {
+			deferredError: null,
+			error,
+			resolved,
+			result
+		};
 	}
+	const readFirst = result.then(() => observedParent.read, () => observedParent.read);
+	const error = Promise.race([parentRead, readFirst.then((read) => read ? null : ownError)]);
+	const deferredError = readFirst.then((read) => read ? ownError.then(() => mergeError) : mergeError);
+	error.catch(() => null);
+	deferredError.catch(() => null);
+	return {
+		deferredError,
+		error,
+		resolved,
+		result
+	};
+}
+/**
+* Start metadata or viewport for every item, then merge their values one at
+* a time, in loader-tree order, as Next.js's prerenderMetadata and
+* accumulateMetadata (and their viewport twins) do. Next.js walks the tree
+* depth first, `children` before the named slots: the route's layouts and
+* page, then each slot's. A hidden branch starts in its slot's place, after
+* the layouts they share, from everything resolved there, and its values stay
+* out of the shown head.
+*
+* The items of a hidden branch and of the slot at `outletIndex` are the
+* slot's. Like Next.js, which throws only the first error, an error of theirs
+* counts only once everything before their branch resolved: one before it
+* belongs to that earlier item, and never also throws inside the slot.
+*
+* The route's errors never wait on the outlet branch, whose resolvers may
+* never settle. A route item after it counts its resolver's error in place
+* until the resolver reads `parent`; what is only known after `parent`, a
+* failed merge or an error after reading it, is deferred until every route
+* error in place is known.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/metadata/resolve-metadata.ts
+*/
+function walkAppPageHead(kind, route, slots, hiddenBranches, outletIndex) {
+	const errors = [];
+	const deferredErrors = [];
+	let resolved = Promise.resolve(kind.initial);
+	let slotBranchParent = null;
+	let afterOutlet = false;
+	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);
+			error.catch(() => null);
+			errors.push({
+				error,
+				owner: "slot"
+			});
+		} else errors.push({
+			error: item.error,
+			owner: "route"
+		});
+		return item;
+	};
+	const startShown = (segment) => {
+		if (segment === lastPageLayout && segment.besidePage) beforeLastPageLayout = resolved;
+		const item = start(segment, resolved, segment === lastPage ? beforeLastPageLayout : void 0);
+		resolved = item.resolved;
+		return item.result;
+	};
+	const startHidden = (parallelRouteIndex, sharedLayoutCount) => {
+		for (const hidden of hiddenBranches) {
+			if (hidden.parallelRouteIndex !== parallelRouteIndex || hidden.sharedLayoutCount !== sharedLayoutCount) continue;
+			const shownBranchParent = slotBranchParent;
+			slotBranchParent = resolved;
+			let parent = resolved;
+			for (const segment of hidden.segments) parent = start(segment, parent).resolved;
+			slotBranchParent = shownBranchParent;
+		}
+	};
+	const routeResults = route.segments.map(startShown);
+	const slotResults = slots.map((slot, index) => {
+		slotBranchParent = index === outletIndex ? resolved : null;
+		let layoutCount = 0;
+		const results = slot.segments.map((segment) => {
+			startHidden(index, layoutCount);
+			if (!segment.page) layoutCount++;
+			return startShown(segment);
+		});
+		if (!slot.segments.at(-1)?.page) startHidden(index, layoutCount);
+		slotBranchParent = null;
+		if (index === outletIndex && results.length > 0) afterOutlet = true;
+		return results;
+	});
+	startHidden(-1, 0);
 	return {
-		resolvedViewport: accumulatedViewport,
-		viewportResults: Promise.all(viewportPromises)
+		deferredErrors,
+		errors,
+		resolved,
+		route: routeResults,
+		slots: slotResults
 	};
 }
 /**
@@ -266,7 +449,7 @@ function resolveOrderedAppPageMetadata(options) {
 		const metadataPromises = [];
 		let accumulatedEntriesPromise = Promise.resolve([]);
 		for (const source of options.sources) {
-			const parentPromise = accumulatedEntriesPromise.then((entries) => entries.length > 0 ? mergeMetadataEntries(entries) : {});
+			const parentPromise = accumulatedEntriesPromise.then((entries) => entries.length > 0 ? mergeParentMetadataEntries(entries) : {});
 			const metadataPromise = resolveModuleMetadata(source.moduleRoute, source.module, source.params, source.searchParams, parentPromise, source.searchParamsObserver);
 			metadataPromises.push(metadataPromise);
 			metadataPromise.catch(() => null);
@@ -288,8 +471,10 @@ async function resolveAppPageHead(options) {
 	const prepared = prepareAppPageHead(options);
 	const [metadata, viewport] = await Promise.all([prepared.metadata, prepared.viewport]);
 	return {
-		...prepared,
+		hasDynamicMetadata: prepared.hasDynamicMetadata,
+		hasSearchParams: prepared.hasSearchParams,
 		metadata,
+		pageSearchParams: prepared.pageSearchParams,
 		viewport
 	};
 }
@@ -298,7 +483,7 @@ async function resolveAppPageHead(options) {
 * from the modules alone, so callers can place the head before resolving it.
 */
 function hasAppPageDynamicMetadata(options) {
-	return options.layoutModules.some(hasGenerateMetadata) || hasGenerateMetadata(options.pageModule) || (options.parallelRoutes ?? []).some(parallelRouteHasDynamicMetadata);
+	return options.layoutModules.some(hasGenerateMetadata) || hasGenerateMetadata(options.pageModule) || (options.parallelRoutes ?? []).some(parallelRouteHasDynamicMetadata) || (options.hiddenParallelRoutes ?? []).some((hidden) => parallelRouteHasDynamicMetadata(hidden.route));
 }
 /**
 * Start metadata and viewport resolution without coupling their completion.
@@ -316,73 +501,71 @@ function prepareAppPageHeadInner(options) {
 	const layoutInputs = createLayoutInputs(options.layoutModules, layoutTreePositions);
 	const layoutSourcePositions = layoutInputs.map((input) => input.treePosition);
 	const { hasSearchParams, pageSearchParams } = collectAppPageSearchParams(options.searchParams);
-	const layoutMetadataPromise = resolveLayoutMetadata(layoutInputs, options.params, routeSegments);
-	const layoutViewport = resolveLayoutViewport(layoutInputs, options.params, routeSegments);
-	const layoutViewportPromise = layoutViewport.viewportResults;
-	const layoutMetadataResultsForParent = layoutMetadataPromise.then((metadataResults) => metadataResults.filter(isPresent));
-	layoutMetadataResultsForParent.catch(() => null);
-	const pageParentPromise = layoutMetadataResultsForParent.then((metadataResults) => metadataResults.length > 0 ? mergeMetadataEntries(metadataResults.map((metadata) => ({ metadata }))) : {});
-	pageParentPromise.catch(() => null);
-	const pageMetadataPromise = options.pageModule ? resolveModuleMetadata(createAppMetadataModuleRoute(routeSegments, "page"), options.pageModule, options.params, pageSearchParams, pageParentPromise, options.searchParamsObserver) : Promise.resolve(null);
 	const parallelRoutes = options.parallelRoutes ?? [];
-	const parallelRouteMetadataPromise = Promise.all(parallelRoutes.map((parallelRoute) => resolveParallelRouteMetadata(parallelRoute, options.params, routeSegments, pageSearchParams, pageParentPromise, options.searchParamsObserver)));
-	const parallelRouteViewportPromises = [];
-	let accumulatedViewport = layoutViewport.resolvedViewport;
-	const pageParentViewport = accumulatedViewport;
-	const pageViewportPromise = options.pageModule ? resolveModuleViewport(options.pageModule, options.params, pageSearchParams, pageParentViewport, options.searchParamsObserver) : Promise.resolve(null);
-	if (options.pageModule) {
-		accumulatedViewport = mergeResolvedViewport(pageParentViewport, pageViewportPromise);
-		accumulatedViewport.catch(() => null);
-	}
-	for (const parallelRoute of parallelRoutes) {
-		const parallelViewport = resolveParallelRouteViewport(parallelRoute, options.params, routeSegments, pageSearchParams, accumulatedViewport, options.searchParamsObserver);
-		parallelRouteViewportPromises.push(parallelViewport.viewportResults);
-		accumulatedViewport = parallelViewport.resolvedViewport;
-	}
-	const parallelRouteViewportPromise = Promise.all(parallelRouteViewportPromises);
+	const route = createRouteHeadBranch(layoutInputs, routeSegments, options.params, options.pageModule);
+	const slots = parallelRoutes.map((parallelRoute) => createParallelRouteHeadBranch(parallelRoute, options.params, routeSegments));
+	const hiddenBranches = (options.hiddenParallelRoutes ?? []).map((hidden) => createHiddenHeadBranch(hidden, slots[hidden.parallelRouteIndex], options.params, routeSegments));
+	const outletIndex = options.outletParallelRouteIndex != null && options.outletParallelRouteIndex in slots ? options.outletParallelRouteIndex : -1;
+	const segmentSearchParams = (segment) => segment.page ? pageSearchParams : void 0;
+	const segmentSearchParamsObserver = (segment) => segment.page ? options.searchParamsObserver : void 0;
+	const metadataWalk = walkAppPageHead({
+		initial: {},
+		merge: (resolved, metadata, stashed) => {
+			try {
+				return mergeParentMetadataEntries(resolved === stashed ? [{ metadata: resolved }, { metadata }] : [
+					{ metadata: stashed },
+					{
+						isPage: true,
+						metadata: resolved
+					},
+					{ metadata }
+				]);
+			} catch (error) {
+				throw tagAppPageMetadataError(error);
+			}
+		},
+		resolve: (segment, parent) => resolveModuleMetadata(segment.moduleRoute, segment.module, segment.params, segmentSearchParams(segment), parent, segmentSearchParamsObserver(segment))
+	}, route, slots, hiddenBranches, outletIndex);
+	const viewportWalk = walkAppPageHead({
+		initial: mergeViewport([]),
+		merge: (resolved, viewport) => mergeViewport([resolved, viewport]),
+		resolve: (segment, parent) => resolveModuleViewport(segment.module, segment.params, segmentSearchParams(segment), parent, segmentSearchParamsObserver(segment))
+	}, route, slots, hiddenBranches, outletIndex);
 	const hasDynamicMetadata = hasAppPageDynamicMetadata(options);
-	const metadata = Promise.all([
-		layoutMetadataPromise,
-		pageMetadataPromise,
-		parallelRouteMetadataPromise
-	]).then(async ([layoutMetadataResults, pageMetadata, parallelRouteMetadata]) => {
-		const parallelMetadataResults = parallelRouteMetadata.flatMap((head) => head.metadataResults);
-		const parallelMetadataSources = parallelRouteMetadata.flatMap((head) => head.metadataSources);
-		const primaryPageHasTitle = pageMetadata != null && pageMetadata.title !== void 0;
-		const metadataEntries = [
-			...layoutMetadataResults.filter(isPresent).map((entry) => ({ metadata: entry })),
-			...pageMetadata ? [{
-				isPage: true,
-				metadata: pageMetadata
-			}] : [],
-			...parallelMetadataResults.filter(isPresent).map((entry) => ({
-				contributesTitle: !primaryPageHasTitle,
-				metadata: entry
-			}))
-		];
-		const resolvedMetadataBase = metadataEntries.length > 0 ? mergeMetadataEntries(metadataEntries) : null;
+	const metadata = metadataWalk.resolved.then(async (accumulated) => {
+		const [routeResults, slotResults] = await Promise.all([Promise.all(metadataWalk.route), Promise.all(metadataWalk.slots.map((results) => Promise.all(results)))]);
+		const layoutMetadataResults = routeResults.slice(0, layoutInputs.length);
+		const pageMetadata = options.pageModule ? routeResults[layoutInputs.length] ?? null : null;
+		const hasMetadata = [...routeResults, ...slotResults.flat()].some(isPresent);
 		const metadataSources = createMetadataSources(layoutMetadataResults, routeSegments, layoutSourcePositions, pageMetadata, Boolean(options.pageModule));
-		metadataSources.push(...parallelMetadataSources);
-		return finalizeAppPageMetadata(resolvedMetadataBase, metadataSources, options);
+		metadataSources.push(...slotResults.flatMap((results, index) => results.map((entry) => ({
+			metadata: entry,
+			routeSegments: slots[index].routeSegments
+		}))));
+		return finalizeAppPageMetadata(hasMetadata ? toShownMetadata(accumulated) : null, metadataSources, options);
 	});
-	const viewport = Promise.all([
-		layoutViewportPromise,
-		pageViewportPromise,
-		parallelRouteViewportPromise
-	]).then(([layoutViewportResults, pageViewport, parallelRouteViewports]) => mergeViewport([
-		...layoutViewportResults.filter(isPresent),
-		...pageViewport ? [pageViewport] : [],
-		...parallelRouteViewports.flat().filter(isPresent)
-	]));
+	const viewport = viewportWalk.resolved;
 	metadata.catch(() => null);
 	viewport.catch(() => null);
+	const metadataHeadError = metadataWalk.resolved.then(() => metadata.then(() => null), () => null);
+	const headErrorOwner = outletIndex === -1 ? "route" : "slot";
+	const errorsOf = (owner) => {
+		const walkErrors = (walk, headErrors) => allInOrder([...walk.errors.flatMap((item) => item.owner === owner ? [item.error] : []), ...headErrors]).then(() => owner === "route" ? allInOrder(walk.deferredErrors) : null);
+		return Promise.all([walkErrors(metadataWalk, headErrorOwner === owner ? [metadataHeadError] : []), walkErrors(viewportWalk, [])]).then(() => null);
+	};
+	const hiddenErrors = errorsOf("slot");
+	hiddenErrors.catch(() => null);
+	const routeErrors = errorsOf("route");
+	routeErrors.catch(() => null);
 	return {
 		hasDynamicMetadata,
 		hasSearchParams,
+		hiddenErrors,
 		metadata,
 		pageSearchParams,
+		routeErrors,
 		viewport
 	};
 }
 //#endregion
-export { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveOrderedAppPageMetadata };
+export { collectAppPageSearchParams, hasAppPageDynamicMetadata, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveInterceptLayoutsBesidePage, resolveOrderedAppPageMetadata, slotInterceptKeepsSourceHead };