vinext 1.2.1 → 1.3.1

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

@@ -1,8 +1,9 @@
+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 { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { createAppMetadataModuleRoute, traceGenerateMetadata } from "./app-metadata-tracing.js";
 //#region src/server/app-page-head.ts
 /**
@@ -25,7 +26,8 @@ async function resolveModuleMetadata(moduleRoute, ...args) {
 	}
 }
 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);
@@ -64,7 +66,8 @@ function resolveActiveParallelRouteHeadInputs(options) {
 					notFoundModuleRouteSegments: interceptNotFoundRouteSegments,
 					notFoundParams: interceptNotFoundParams
 				} : {},
-				ownerTreePosition
+				ownerTreePosition,
+				slotKey
 			};
 		}
 		const slotRouteSegments = slot.routeSegments ?? options.routeSegments;
@@ -83,14 +86,85 @@ function resolveActiveParallelRouteHeadInputs(options) {
 				...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
 		};
-	}).sort((left, right) => right.ownerTreePosition - left.ownerTreePosition);
+	}).map((input, index) => {
+		const [slotKey, slot] = slotEntries[index];
+		return {
+			directoryDepth: slot.ownerTreePosition ?? input.ownerTreePosition,
+			input,
+			name: slot.name ?? slotKey
+		};
+	}).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,113 +219,201 @@ 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);
-	}
+/** The walk's accumulated metadata, with its resolved title as the shown string. */
+function toShownMetadata(accumulated) {
+	const title = accumulated.title;
+	if (title === void 0 || typeof title === "string") return accumulated;
 	return {
-		resolvedViewport: accumulatedViewport,
-		viewportResults: Promise.all(viewportPromises)
+		...accumulated,
+		title: title.absolute || void 0
 	};
 }
-function mergeResolvedViewport(parent, viewport) {
-	return Promise.all([parent, viewport]).then(([resolvedParent, resolvedViewport]) => resolvedViewport ? mergeViewport([resolvedParent, resolvedViewport]) : resolvedParent);
-}
 function getParallelRouteModules(parallelRoute) {
 	return [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
 }
 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) => ({
+		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) => ({
+		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) {
+	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));
+	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 {
-		resolvedViewport: accumulatedViewport,
-		viewportResults: Promise.all(viewportPromises)
+		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 start = (segment, parent) => {
+		const item = startAppPageHeadItem(kind, segment, parent, !slotBranchParent && afterOutlet);
+		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) => {
+		const item = start(segment, resolved);
+		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 {
+		deferredErrors,
+		errors,
+		resolved,
+		route: routeResults,
+		slots: slotResults
 	};
 }
 /**
@@ -266,7 +428,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 +450,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 +462,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 +480,64 @@ 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) => {
+			try {
+				return mergeParentMetadataEntries([{ 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, resolveOrderedAppPageMetadata, slotInterceptKeepsSourceHead };

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

@@ -1,6 +1,6 @@
 import { MetadataFileRoute } from "./metadata-routes.js";
 import { AppPageParams } from "./app-page-boundary.js";
-import { Metadata, ResolvedViewport } from "../shims/metadata.js";
+import { Metadata, ResolvedViewport, Viewport } from "../shims/metadata.js";
 import { ActiveParallelRouteHeadInput, AppPageHeadModule, ApplyAppPageFileBasedMetadata, OrderedAppPageMetadataSource } from "./app-page-head.js";
 //#region src/server/app-page-http-access-fallback-metadata.d.ts
 type HttpAccessFallbackMetadataPlanOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = {
@@ -26,5 +26,51 @@ type ResolveHttpAccessFallbackMetadataOptions<TModule extends AppPageHeadModule
 };
 export declare function createHttpAccessFallbackMetadataPlan<TModule extends AppPageHeadModule>(options: HttpAccessFallbackMetadataPlanOptions<TModule>): OrderedAppPageMetadataSource<TModule>[];
 export declare function resolveHttpAccessFallbackMetadata<TModule extends AppPageHeadModule>(options: ResolveHttpAccessFallbackMetadataOptions<TModule>): Promise<Metadata | null>;
+type RouteNotFoundHeadPlanRoute<TModule extends AppPageHeadModule> = {
+  layouts?: readonly (TModule | null | undefined)[];
+  layoutTreePositions?: readonly number[] | null;
+  notFound?: TModule | null;
+  notFounds?: readonly (TModule | null | undefined)[] | null;
+  notFoundTreePosition?: number | null;
+  routeSegments?: readonly string[] | null;
+};
+/**
+ * The not-found head a route's own head falls back to. Like Next.js's
+ * metadata tree, every HTTP access signal from generateMetadata() or
+ * generateViewport() resolves through the not-found convention, whichever
+ * signal the route's render threw.
+ */
+export declare function createRouteNotFoundHeadPlanOptions<TModule extends AppPageHeadModule>(options: {
+  parallelBranches: readonly ActiveParallelRouteHeadInput<TModule>[];
+  params: AppPageParams;
+  primaryParallelBranch: ActiveParallelRouteHeadInput<TModule> | null;
+  rootNotFoundModule?: TModule | null;
+  route: RouteNotFoundHeadPlanRoute<TModule>;
+}): HttpAccessFallbackMetadataPlanOptions<TModule>;
+/**
+ * Settle each branch of a route's head on its own, as Next.js's MetadataTree
+ * and ViewportTree do: an HTTP access signal from generateMetadata() keeps the
+ * resolved viewport and resolves the metadata through the not-found
+ * convention, and the same holds the other way round. Any other error leaves
+ * that branch empty; the route's render reports it where it renders.
+ *
+ * A `dynamic = "error"` access error leaves its branch empty too, but
+ * `accessError` keeps it, whether the route's head or the not-found head it
+ * recovers through threw it: Next.js fails such a render even where its
+ * metadata trees drop the error, so a fallback without the route's outlet
+ * rethrows it.
+ */
+export declare function recoverAppPageRouteHead<TModule extends AppPageHeadModule>(head: {
+  metadata: Promise<Metadata | null>;
+  viewport: Promise<ResolvedViewport>;
+}, options: Omit<ResolveHttpAccessFallbackMetadataOptions<TModule>, keyof HttpAccessFallbackMetadataPlanOptions<TModule>> & {
+  resolvePlanOptions: () => HttpAccessFallbackMetadataPlanOptions<TModule>;
+}): {
+  accessError: Promise<Error | null>;
+  metadata: Promise<Metadata | null>;
+  /** `null` when the branch failed: like Next.js's, the head then has no viewport tags. */
+  viewport: Promise<Viewport | null>;
+};
 export declare function resolveHttpAccessFallbackViewport<TModule extends AppPageHeadModule>(options: HttpAccessFallbackMetadataPlanOptions<TModule>): Promise<ResolvedViewport>;
-//#endregion
+//#endregion
+export {};