vinext 1.0.0-beta.1 → 1.0.0-beta.3

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

@@ -26,35 +26,60 @@ function resolveActiveParallelRouteHeadInputs(options) {
 	return Object.entries(options.slots ?? {}).map(([slotKey, slot]) => {
 		const ownerTreePosition = options.layoutTreePositions?.[slot.layoutIndex ?? 0] ?? 0;
 		const ownerParams = resolveAppPageSegmentParams(options.routeSegments, ownerTreePosition, options.params);
+		const slotParams = options.slotParams?.[slotKey] ?? options.params;
+		const notFoundParams = slot.notFound ? {
+			...ownerParams,
+			...resolveParallelLayoutParams(slot.routeSegments ?? options.routeSegments, slot.notFoundTreePosition ?? 0, slotParams)
+		} : null;
 		if (options.interceptSlotKey === slotKey && options.interceptPage) {
 			const interceptLayouts = options.interceptLayouts ?? [];
+			const inheritedSlotNotFound = slot.notFoundTreePosition === 0 ? slot.notFound ?? null : null;
+			const interceptNotFound = options.interceptNotFound ?? inheritedSlotNotFound;
+			const interceptNotFoundParams = interceptNotFound ? {
+				...ownerParams,
+				...resolveParallelLayoutParams(options.interceptNotFoundBranchSegments ?? options.interceptBranchSegments ?? options.routeSegments, options.interceptNotFound ? options.interceptNotFoundTreePosition ?? 0 : slot.notFoundTreePosition ?? 0, options.interceptParams ?? options.params)
+			} : null;
 			return {
-				layoutModules: [slot.layout, ...interceptLayouts].filter(isPresent),
-				layoutParams: [...slot.layout ? [ownerParams] : [], ...interceptLayouts.filter(isPresent).map((_, index) => {
-					const segments = options.interceptLayoutSegments?.[index] ?? [];
-					return {
-						...ownerParams,
-						...resolveParallelLayoutParams(options.interceptBranchSegments ?? segments, segments.length, options.interceptParams ?? options.params)
-					};
-				})],
-				layoutTreePositions: [...slot.layout ? [0] : [], ...interceptLayouts.filter(isPresent).map(() => options.routeSegments.length)],
-				pageModule: options.interceptPage,
-				params: options.interceptParams ?? options.params,
-				routeSegments: options.routeSegments
+				head: {
+					layoutModules: [slot.layout, ...interceptLayouts].filter(isPresent),
+					layoutParams: [...slot.layout ? [ownerParams] : [], ...interceptLayouts.filter(isPresent).map((_, index) => {
+						const segments = options.interceptLayoutSegments?.[index] ?? [];
+						return {
+							...ownerParams,
+							...resolveParallelLayoutParams(options.interceptBranchSegments ?? segments, segments.length, options.interceptParams ?? options.params)
+						};
+					})],
+					layoutTreePositions: [...slot.layout ? [0] : [], ...interceptLayouts.filter(isPresent).map(() => options.routeSegments.length)],
+					pageModule: options.interceptPage,
+					params: options.interceptParams ?? options.params,
+					routeSegments: options.interceptSourcePageSegments ?? options.routeSegments
+				},
+				...interceptNotFound ? {
+					notFoundModule: interceptNotFound,
+					notFoundParams: interceptNotFoundParams
+				} : {},
+				ownerTreePosition
 			};
 		}
 		return {
-			layoutModules: [slot.layout, ...slot.configLayouts ?? []].filter(isPresent),
-			layoutParams: [...slot.layout ? [ownerParams] : [], ...(slot.configLayoutTreePositions ?? []).map((treePosition) => ({
-				...ownerParams,
-				...resolveParallelLayoutParams(slot.routeSegments ?? options.routeSegments, treePosition, options.slotParams?.[slotKey] ?? options.params)
-			}))],
-			layoutTreePositions: [...slot.layout ? [0] : [], ...slot.configLayoutTreePositions ?? []],
-			pageModule: slot.page,
-			params: options.slotParams?.[slotKey] ?? options.params,
-			routeSegments: slot.routeSegments ?? options.routeSegments
+			head: {
+				layoutModules: [slot.layout, ...slot.configLayouts ?? []].filter(isPresent),
+				layoutParams: [...slot.layout ? [ownerParams] : [], ...(slot.configLayoutTreePositions ?? []).map((treePosition) => ({
+					...ownerParams,
+					...resolveParallelLayoutParams(slot.routeSegments ?? options.routeSegments, treePosition, options.slotParams?.[slotKey] ?? options.params)
+				}))],
+				layoutTreePositions: [...slot.layout ? [0] : [], ...slot.configLayoutTreePositions ?? []],
+				pageModule: slot.page,
+				params: slotParams,
+				routeSegments: slot.routeSegments ?? options.routeSegments
+			},
+			...slot.notFound ? {
+				notFoundModule: slot.notFound,
+				notFoundParams
+			} : {},
+			ownerTreePosition
 		};
-	});
+	}).sort((left, right) => right.ownerTreePosition - left.ownerTreePosition);
 }
 function isPresent(value) {
 	return value !== null && value !== void 0;
@@ -97,6 +122,20 @@ function createMetadataSources(metadataResults, routeSegments, layoutTreePositio
 	});
 	return metadataSources;
 }
+async function finalizeAppPageMetadata(metadata, metadataSources, options) {
+	let resolvedMetadata = metadata;
+	if (options.applyFileBasedMetadata && options.metadataRoutes.length > 0) try {
+		resolvedMetadata = await options.applyFileBasedMetadata(metadata, options.routePath, options.params, options.metadataRoutes, {
+			routeSegments: options.routeSegments ?? [],
+			metadataSources,
+			basePath: options.basePath ?? ""
+		});
+	} catch (error) {
+		if (!options.fallbackOnFileMetadataError) throw error;
+		console.error(`[vinext] File-based metadata resolution failed while rendering error boundary for ${options.routePath}:`, error);
+	}
+	return resolvedMetadata ? postProcessMetadata(resolvedMetadata) : null;
+}
 function createLayoutInputs(layoutModules, layoutTreePositions) {
 	const layoutInputs = [];
 	for (let index = 0; index < layoutModules.length; index++) {
@@ -126,27 +165,41 @@ async function resolveLayoutMetadata(layoutInputs, params, routeSegments) {
 	}
 	return Promise.all(layoutMetadataPromises);
 }
-async function resolveLayoutViewport(layoutInputs, params, routeSegments) {
-	return Promise.all(layoutInputs.map((layoutInput) => {
+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);
-		return resolveModuleViewport(layoutInput.module, layoutParams);
-	}));
+		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)
+	};
+}
+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);
 }
-async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent, searchParamsObserver) {
+function parallelRouteHasDynamicMetadata(parallelRoute) {
+	return getParallelRouteModules(parallelRoute).some(hasGenerateMetadata) || hasGenerateMetadata(parallelRoute.pageModule);
+}
+async function resolveParallelRouteMetadata(parallelRoute, fallbackParams, fallbackRouteSegments, pageSearchParams, parent, searchParamsObserver) {
 	const params = parallelRoute.params ?? fallbackParams;
 	const routeSegments = parallelRoute.routeSegments ?? fallbackRouteSegments;
 	const metadataResults = [];
-	const viewportResults = [];
 	const metadataSources = [];
 	let accumulatedMetadata = parent;
-	const layoutModules = [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
+	const layoutModules = getParallelRouteModules(parallelRoute);
 	const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
 	const layoutParams = parallelRoute.layoutParams ?? [];
-	const hasDynamicMetadata = layoutModules.some(hasGenerateMetadata) || hasGenerateMetadata(parallelRoute.pageModule);
-	const layoutViewportPromises = layoutModules.map((layoutModule, index) => resolveModuleViewport(layoutModule, layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params)));
-	const pageViewportPromise = parallelRoute.pageModule ? resolveModuleViewport(parallelRoute.pageModule, params, pageSearchParams, searchParamsObserver) : Promise.resolve(null);
-	for (const layoutViewportPromise of layoutViewportPromises) layoutViewportPromise.catch(() => null);
-	pageViewportPromise.catch(() => null);
 	for (const [index, layoutModule] of layoutModules.entries()) {
 		const layoutMetadata = await resolveModuleMetadata(layoutModule, layoutParams[index] ?? resolveParallelLayoutParams(routeSegments, layoutTreePositions[index] ?? 0, params), void 0, accumulatedMetadata);
 		metadataResults.push(layoutMetadata);
@@ -167,20 +220,90 @@ async function resolveParallelRouteHead(parallelRoute, fallbackParams, fallbackR
 			routeSegments
 		});
 	}
-	viewportResults.push(...await Promise.all(layoutViewportPromises));
-	const pageViewport = await pageViewportPromise;
-	if (parallelRoute.pageModule) viewportResults.push(pageViewport);
 	return {
-		hasDynamicMetadata,
 		metadataResults,
-		metadataSources,
-		viewportResults
+		metadataSources
 	};
 }
+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);
+	}
+	return {
+		resolvedViewport: accumulatedViewport,
+		viewportResults: Promise.all(viewportPromises)
+	};
+}
+/**
+* Resolve an explicit metadata-source sequence.
+*
+* Route-specific conventions own source selection and ordering. This resolver
+* only supplies each source with its accumulated parent, merges the results,
+* and applies file-based metadata at the end.
+*/
+function resolveOrderedAppPageMetadata(options) {
+	return runWithFetchDedupe(async () => {
+		const metadataPromises = [];
+		let accumulatedEntriesPromise = Promise.resolve([]);
+		for (const source of options.sources) {
+			const parentPromise = accumulatedEntriesPromise.then((entries) => entries.length > 0 ? mergeMetadataEntries(entries) : {});
+			const metadataPromise = resolveModuleMetadata(source.module, source.params, source.searchParams, parentPromise, source.searchParamsObserver);
+			metadataPromises.push(metadataPromise);
+			metadataPromise.catch(() => null);
+			accumulatedEntriesPromise = Promise.all([accumulatedEntriesPromise, metadataPromise]).then(([entries, metadata]) => metadata ? [...entries, { metadata }] : entries);
+			accumulatedEntriesPromise.catch(() => null);
+		}
+		const [metadataEntries, metadataResults] = await Promise.all([accumulatedEntriesPromise, Promise.all(metadataPromises)]);
+		const metadataSources = options.sources.flatMap((source, index) => {
+			const metadata = metadataResults[index] ?? null;
+			return metadata || source.includeWhenEmpty ? [{
+				metadata,
+				routeSegments: source.routeSegments
+			}] : [];
+		});
+		return finalizeAppPageMetadata(metadataEntries.length > 0 ? mergeMetadataEntries(metadataEntries) : null, metadataSources, options);
+	});
+}
 async function resolveAppPageHead(options) {
-	return await runWithFetchDedupe(() => resolveAppPageHeadInner(options));
+	const prepared = prepareAppPageHead(options);
+	const [metadata, viewport] = await Promise.all([prepared.metadata, prepared.viewport]);
+	return {
+		...prepared,
+		metadata,
+		viewport
+	};
+}
+/**
+* Start metadata and viewport resolution without coupling their completion.
+*
+* Live document renders can place the metadata promise behind Suspense while
+* still waiting for viewport tags before the shell is emitted. Blocking
+* callers use {@link resolveAppPageHead} and observe the same result as before.
+*/
+function prepareAppPageHead(options) {
+	return runWithFetchDedupe(() => prepareAppPageHeadInner(options));
 }
-async function resolveAppPageHeadInner(options) {
+function prepareAppPageHeadInner(options) {
 	const routeSegments = options.routeSegments ?? [];
 	const layoutTreePositions = options.layoutTreePositions ?? [];
 	const layoutInputs = createLayoutInputs(options.layoutModules, layoutTreePositions);
@@ -188,64 +311,72 @@ async function resolveAppPageHeadInner(options) {
 	const primaryHasDynamicMetadata = layoutInputs.some((input) => hasGenerateMetadata(input.module)) || hasGenerateMetadata(options.pageModule);
 	const { hasSearchParams, pageSearchParams } = collectAppPageSearchParams(options.searchParams);
 	const layoutMetadataPromise = resolveLayoutMetadata(layoutInputs, options.params, routeSegments);
-	const layoutViewportPromise = resolveLayoutViewport(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(options.pageModule, options.params, pageSearchParams, pageParentPromise, options.searchParamsObserver) : Promise.resolve(null);
-	const pageViewportPromise = options.pageModule ? resolveModuleViewport(options.pageModule, options.params, pageSearchParams, options.searchParamsObserver) : Promise.resolve(null);
-	const parallelRouteHeadPromise = Promise.all((options.parallelRoutes ?? []).map((parallelRoute) => resolveParallelRouteHead(parallelRoute, options.params, routeSegments, pageSearchParams, pageParentPromise, options.searchParamsObserver)));
-	const [layoutMetadataResults, layoutViewportResults, pageMetadata, pageViewport, parallelRouteHeads] = await Promise.all([
+	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 hasDynamicMetadata = primaryHasDynamicMetadata || parallelRoutes.some(parallelRouteHasDynamicMetadata);
+	const metadata = Promise.all([
 		layoutMetadataPromise,
-		layoutViewportPromise,
 		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 metadataSources = createMetadataSources(layoutMetadataResults, routeSegments, layoutSourcePositions, pageMetadata, Boolean(options.pageModule));
+		metadataSources.push(...parallelMetadataSources);
+		return finalizeAppPageMetadata(resolvedMetadataBase, metadataSources, options);
+	});
+	const viewport = Promise.all([
+		layoutViewportPromise,
 		pageViewportPromise,
-		parallelRouteHeadPromise
-	]);
-	const parallelMetadataResults = parallelRouteHeads.flatMap((head) => head.metadataResults);
-	const parallelViewportResults = parallelRouteHeads.flatMap((head) => head.viewportResults);
-	const parallelMetadataSources = parallelRouteHeads.flatMap((head) => head.metadataSources);
-	const hasDynamicMetadata = primaryHasDynamicMetadata || parallelRouteHeads.some((head) => head.hasDynamicMetadata);
-	const primaryPageHasTitle = pageMetadata != null && pageMetadata.title !== void 0;
-	const metadataEntries = [
-		...layoutMetadataResults.filter(isPresent).map((metadata) => ({ metadata })),
-		...pageMetadata ? [{
-			isPage: true,
-			metadata: pageMetadata
-		}] : [],
-		...parallelMetadataResults.filter(isPresent).map((metadata) => ({
-			contributesTitle: !primaryPageHasTitle,
-			metadata
-		}))
-	];
-	const viewportList = [
+		parallelRouteViewportPromise
+	]).then(([layoutViewportResults, pageViewport, parallelRouteViewports]) => mergeViewport([
 		...layoutViewportResults.filter(isPresent),
 		...pageViewport ? [pageViewport] : [],
-		...parallelViewportResults.filter(isPresent)
-	];
-	const resolvedMetadataBase = metadataEntries.length > 0 ? mergeMetadataEntries(metadataEntries) : null;
-	const metadataSources = createMetadataSources(layoutMetadataResults, routeSegments, layoutSourcePositions, pageMetadata, Boolean(options.pageModule));
-	metadataSources.push(...parallelMetadataSources);
-	let metadata = resolvedMetadataBase;
-	if (options.applyFileBasedMetadata && options.metadataRoutes.length > 0) try {
-		metadata = await options.applyFileBasedMetadata(resolvedMetadataBase, options.routePath, options.params, options.metadataRoutes, {
-			routeSegments,
-			metadataSources,
-			basePath: options.basePath ?? ""
-		});
-	} catch (error) {
-		if (!options.fallbackOnFileMetadataError) throw error;
-		console.error(`[vinext] File-based metadata resolution failed while rendering error boundary for ${options.routePath}:`, error);
-	}
-	if (metadata) metadata = postProcessMetadata(metadata);
+		...parallelRouteViewports.flat().filter(isPresent)
+	]));
+	metadata.catch(() => null);
+	viewport.catch(() => null);
 	return {
 		hasDynamicMetadata,
 		hasSearchParams,
 		metadata,
 		pageSearchParams,
-		viewport: mergeViewport(viewportList)
+		viewport
 	};
 }
 //#endregion
-export { collectAppPageSearchParams, resolveActiveParallelRouteHeadInputs, resolveAppPageHead };
+export { collectAppPageSearchParams, prepareAppPageHead, resolveActiveParallelRouteHeadInputs, resolveAppPageHead, resolveOrderedAppPageMetadata };

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

@@ -0,0 +1,29 @@
+import { MetadataFileRoute } from "./metadata-routes.js";
+import { AppPageParams } from "./app-page-boundary.js";
+import { Metadata, ResolvedViewport } 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> = {
+  boundaryModule?: TModule | null;
+  boundaryParams: AppPageParams; /** Whether active branches may replace the fallback with their local not-found convention. */
+  branchNotFoundConventions?: boolean;
+  layoutModules: readonly (TModule | null | undefined)[];
+  layoutTreePositions?: readonly number[] | null;
+  parallelBranches?: readonly ActiveParallelRouteHeadInput<TModule>[] | null;
+  params: AppPageParams;
+  primaryParallelBranch?: ActiveParallelRouteHeadInput<TModule> | null;
+  routeSegments?: readonly string[] | null;
+};
+type ResolveHttpAccessFallbackMetadataOptions<TModule extends AppPageHeadModule = AppPageHeadModule> = HttpAccessFallbackMetadataPlanOptions<TModule> & {
+  applyFileBasedMetadata?: ApplyAppPageFileBasedMetadata;
+  basePath?: string;
+  fallbackOnFileMetadataError?: boolean;
+  metadataRoutes: readonly MetadataFileRoute[];
+  routePath: string;
+};
+declare function createHttpAccessFallbackMetadataPlan<TModule extends AppPageHeadModule>(options: HttpAccessFallbackMetadataPlanOptions<TModule>): OrderedAppPageMetadataSource<TModule>[];
+declare function resolveHttpAccessFallbackMetadata<TModule extends AppPageHeadModule>(options: ResolveHttpAccessFallbackMetadataOptions<TModule>): Promise<Metadata | null>;
+declare function resolveHttpAccessFallbackViewport<TModule extends AppPageHeadModule>(options: HttpAccessFallbackMetadataPlanOptions<TModule>): Promise<ResolvedViewport>;
+//#endregion
+export { createHttpAccessFallbackMetadataPlan, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };

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

@@ -0,0 +1,114 @@
+import { mergeViewport, resolveModuleViewport } from "../shims/metadata.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveOrderedAppPageMetadata } from "./app-page-head.js";
+//#region src/server/app-page-http-access-fallback-metadata.ts
+function isPresent(value) {
+	return value !== null && value !== void 0;
+}
+/**
+* Translate HTTP-access boundary semantics into the exact metadata source
+* order used by Next.js's loader-tree walk.
+*
+* The not-found convention is appended at every active leaf. A sibling
+* intercept is the primary leaf and therefore precedes the ordinary slot
+* branches; otherwise the convention also represents the primary page leaf.
+*/
+function createHttpAccessFallbackPlan(options, fallbackLeafMode) {
+	const routeSegments = options.routeSegments ?? [];
+	const plan = [];
+	for (const [index, layoutModule] of options.layoutModules.entries()) {
+		if (!isPresent(layoutModule)) continue;
+		const treePosition = options.layoutTreePositions?.[index] ?? 0;
+		plan.push({
+			kind: "source",
+			source: {
+				includeWhenEmpty: true,
+				module: layoutModule,
+				params: resolveAppPageSegmentParams(routeSegments, treePosition, options.params),
+				routeSegments: routeSegments.slice(0, treePosition)
+			}
+		});
+	}
+	let activeBoundaryModule = options.boundaryModule;
+	let activeBoundaryParams = options.boundaryParams;
+	let activeBoundaryRouteSegments = routeSegments;
+	const appendFallbackLeaf = () => {
+		if (fallbackLeafMode === "final") {
+			plan.push({ kind: "fallback-leaf" });
+			return;
+		}
+		if (!activeBoundaryModule) return;
+		plan.push({
+			kind: "source",
+			source: {
+				includeWhenEmpty: true,
+				module: activeBoundaryModule,
+				params: activeBoundaryParams,
+				routeSegments: activeBoundaryRouteSegments
+			}
+		});
+	};
+	if (!options.primaryParallelBranch) appendFallbackLeaf();
+	const parallelBranches = [...options.primaryParallelBranch ? [options.primaryParallelBranch] : [], ...[...options.parallelBranches ?? []].sort((left, right) => right.ownerTreePosition - left.ownerTreePosition)];
+	for (const branch of parallelBranches) {
+		const parallelRoute = branch.head;
+		const parallelParams = parallelRoute.params ?? options.params;
+		const parallelRouteSegments = parallelRoute.routeSegments ?? routeSegments;
+		const layoutModules = [...parallelRoute.layoutModules ?? [], parallelRoute.layoutModule].filter(isPresent);
+		const layoutTreePositions = parallelRoute.layoutTreePositions ?? [];
+		const layoutParams = parallelRoute.layoutParams ?? [];
+		for (const [index, layoutModule] of layoutModules.entries()) plan.push({
+			kind: "source",
+			source: {
+				includeWhenEmpty: true,
+				module: layoutModule,
+				params: layoutParams[index] ?? resolveAppPageBranchParams(parallelRouteSegments, layoutTreePositions[index] ?? 0, parallelParams),
+				routeSegments: parallelRouteSegments
+			}
+		});
+		if (options.branchNotFoundConventions !== false && branch.notFoundModule) {
+			activeBoundaryModule = branch.notFoundModule;
+			activeBoundaryParams = branch.notFoundParams ?? parallelParams;
+			activeBoundaryRouteSegments = parallelRouteSegments;
+		}
+		appendFallbackLeaf();
+	}
+	return plan.flatMap((item) => {
+		if (item.kind === "source") return [item.source];
+		if (!activeBoundaryModule) return [];
+		return [{
+			includeWhenEmpty: true,
+			module: activeBoundaryModule,
+			params: activeBoundaryParams,
+			routeSegments: activeBoundaryRouteSegments
+		}];
+	});
+}
+function createHttpAccessFallbackMetadataPlan(options) {
+	return createHttpAccessFallbackPlan(options, "final");
+}
+function resolveHttpAccessFallbackMetadata(options) {
+	return resolveOrderedAppPageMetadata({
+		applyFileBasedMetadata: options.applyFileBasedMetadata,
+		basePath: options.basePath,
+		fallbackOnFileMetadataError: options.fallbackOnFileMetadataError,
+		metadataRoutes: options.metadataRoutes,
+		params: options.params,
+		routePath: options.routePath,
+		routeSegments: options.routeSegments,
+		sources: createHttpAccessFallbackMetadataPlan(options)
+	});
+}
+async function resolveHttpAccessFallbackViewport(options) {
+	let accumulatedViewport = Promise.resolve(mergeViewport([]));
+	for (const source of createHttpAccessFallbackPlan(options, "snapshot")) {
+		const parentForSource = accumulatedViewport;
+		const viewportPromise = resolveModuleViewport(source.module, source.params, void 0, parentForSource);
+		viewportPromise.catch(() => null);
+		accumulatedViewport = Promise.all([parentForSource, viewportPromise]).then(([parent, viewport]) => viewport ? mergeViewport([parent, viewport]) : parent);
+		accumulatedViewport.catch(() => null);
+	}
+	return accumulatedViewport;
+}
+//#endregion
+export { createHttpAccessFallbackMetadataPlan, resolveHttpAccessFallbackMetadata, resolveHttpAccessFallbackViewport };

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

@@ -40,12 +40,16 @@ type AppPageProbeModule = Readonly<{
 }> | null | undefined;
 type AppPageProbeSlot = Readonly<{
   page?: AppPageProbeModule;
+  loading?: AppPageProbeModule;
+  loadings?: readonly AppPageProbeModule[] | null;
+  loadingTreePositions?: readonly number[] | null;
 }> | null | undefined;
 type AppPageProbeRoute = Readonly<{
   slots?: Readonly<Record<string, AppPageProbeSlot>> | null;
 }>;
 type AppPageProbeIntercept = Readonly<{
   page?: AppPageProbeModule;
+  interceptLoadings?: readonly AppPageProbeModule[] | null;
   matchedParams?: unknown;
   /**
    * Key of the parallel-route slot this interception overrides. At render

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

@@ -1,6 +1,6 @@
-import { markAppPagePropsForUseCache } from "../shims/internal/app-page-props-cache-key.js";
 import { isNextRouterError } from "../shims/navigation-errors.js";
 import "../shims/navigation-server.js";
+import { markAppPagePropsForUseCache } from "../shims/internal/app-page-props-cache-key.js";
 import { isPromiseLike } from "../utils/promise.js";
 import { probeAppPageComponent, probeAppPageLayouts } from "./app-page-execution.js";
 import { collectAppPageSearchParams } from "./app-page-head.js";
@@ -218,13 +218,17 @@ function buildAppPageProbes(options) {
 	const overriddenSlotKey = intercept?.slotKey ?? null;
 	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
 		if (overriddenSlotKey !== null && slotKey === overriddenSlotKey) continue;
+		if (slot?.loading?.default || slot?.loadings?.some((loading) => loading?.default)) continue;
 		probes.push(probeAppPage({
 			pageComponent: slot?.page?.default,
 			asyncRouteParams,
 			searchParams
 		}));
 	}
-	if (intercept) probes.push(probeAppPage({
+	const interceptedSlot = intercept?.slotKey ? route.slots?.[intercept.slotKey] : null;
+	const interceptedSlotHasRootLoading = Boolean(interceptedSlot?.loading?.default || interceptedSlot?.loadings?.some((loading, index) => loading?.default && interceptedSlot.loadingTreePositions?.[index] === 0));
+	const interceptHasLoadingBoundary = Boolean(intercept?.interceptLoadings?.some((loading) => loading?.default) || interceptedSlotHasRootLoading);
+	if (intercept && !interceptHasLoadingBoundary) probes.push(probeAppPage({
 		pageComponent: intercept.page?.default,
 		asyncRouteParams: options.makeThenableParams(intercept.matchedParams ?? matchedParams),
 		searchParams

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

@@ -3,11 +3,11 @@ import { AppOutgoingElements } from "./app-elements-wire.js";
 import { NavigationContext } from "../shims/navigation-context-state.js";
 import { AppPageFontPreload, AppPageSpecialError, LayoutClassificationOptions } from "./app-page-execution.js";
 import { AppPageMiddlewareContext } from "./app-page-response.js";
+import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
+import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPageSsrHandler } from "./app-page-stream.js";
-import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { CachedAppPageValue } from "../shims/cache-handler.js";
-import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderObservationState } from "./app-page-render-observation.js";
 import { ReactNode } from "react";
 import { ReactFormState } from "react-dom/client";

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

@@ -11,10 +11,10 @@ import { DEFAULT_CACHE_VARIANT_BUDGET, buildCacheVariantWithRouteBudget, buildRe
 import { createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope, createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 import { finalizeAppPageHtmlCacheResponse, finalizeAppPageRscCacheResponse } from "./app-page-cache-finalizer.js";
 import { createStaticLayoutClientReuseArtifactCompatibility, createStaticLayoutClientReusePayloadHash, createStaticLayoutClientReuseRouteId } from "./static-layout-client-reuse-proof.js";
+import { hasDigest } from "./app-rsc-errors.js";
 import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery } from "./app-page-stream.js";
 import { getStaticLayoutObservationSkipRejection } from "./app-layout-param-observation.js";
-import { hasDigest } from "./app-rsc-errors.js";
 import { createClientReuseSkipTransportPlan, crossCheckClientReuseManifestEntryWithCache } from "./skip-cache-proof.js";
 //#region src/server/app-page-render.ts
 function buildResponseTiming(options) {

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

@@ -11,7 +11,13 @@ type GenerateStaticParamsModule = {
   generateStaticParams?: GenerateStaticParams | null;
 };
 type GenerateStaticParamsSource = {
+  /**
+   * Primary loader-tree sources execute top-down as one chain. Each source
+   * receives the complete params object produced by the sources before it.
+   */
+  chained?: true;
   generateStaticParams: GenerateStaticParams;
+  independentChain?: number;
   paramAliases?: Readonly<Record<string, string>>;
   paramPatternParts?: readonly string[];
   routePatternParts?: readonly string[];
@@ -56,14 +62,23 @@ type AppPageInterceptMatch<TPage = unknown> = {
   interceptLayouts?: readonly unknown[] | null;
   interceptLayoutSegments?: readonly (readonly string[])[] | null;
   interceptBranchSegments?: readonly string[] | null;
+  interceptLoadings?: readonly unknown[] | null;
+  interceptLoadingTreePositions?: readonly number[] | null;
+  interceptNotFoundBranchSegments?: readonly string[] | null;
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
   sourceMatchedParams?: AppPageParams;
   page: TPage;
   __pageLoader?: (() => Promise<TPage>) | null;
+  notFound?: unknown;
+  __loadNotFound?: (() => Promise<unknown>) | null;
+  notFoundTreePosition?: number | null;
   __loadState?: {
     page: TPage;
     pageLoading: Promise<TPage> | null;
+    notFound?: unknown;
+    notFoundLoading?: Promise<unknown> | null;
     interceptLayoutsLoading: Promise<readonly unknown[]> | null;
   };
   slotId?: string | null;