vinext 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/routing/app-route-graph.js

@@ -460,7 +460,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
 				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
-				return {
+				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
@@ -468,7 +468,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					notFoundPath: notFoundBoundary.path,
 					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
-				};
+				}, subPage, matcher);
 			}
 			return slot;
 		});
@@ -549,7 +549,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				const subPage = slotPages.get(slot.key);
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
 				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
-				return {
+				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
@@ -557,7 +557,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					notFoundPath: notFoundBoundary.path,
 					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
-				};
+				}, subPage ?? null, matcher);
 			});
 			const newRoute = {
 				ids: createAppRouteSemanticIds({
@@ -580,7 +580,9 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					ownerTreePath: childrenOwnerTreePath,
 					state: childrenDefault ? "default" : childrenCatchAll ? "active" : "unmatched"
 				},
-				loadingPath: parentRoute.loadingPath,
+				loadingPath: null,
+				loadingPaths: parentRoute.loadingPaths,
+				loadingTreePositions: parentRoute.loadingTreePositions,
 				errorPath: parentRoute.errorPath,
 				layoutErrorPaths: parentRoute.layoutErrorPaths,
 				notFoundPath: parentRoute.notFoundPath,
@@ -678,6 +680,36 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
 	});
 }
+function findSlotLoadingEntries(slotDir, pagePath, matcher) {
+	const pageDir = pagePath ? path.dirname(pagePath) : slotDir;
+	if (pageDir !== slotDir && !pageDir.startsWith(`${slotDir}${path.sep}`)) return [];
+	const relativeDir = path.relative(slotDir, pageDir);
+	const segments = relativeDir ? relativeDir.split(path.sep).filter(Boolean) : [];
+	const loadings = [];
+	let currentDir = slotDir;
+	const rootLoading = findFile(currentDir, "loading", matcher);
+	if (rootLoading) loadings.push({
+		path: rootLoading,
+		treePosition: 0
+	});
+	for (let index = 0; index < segments.length; index++) {
+		currentDir = path.join(currentDir, segments[index]);
+		const loading = findFile(currentDir, "loading", matcher);
+		if (loading) loadings.push({
+			path: loading,
+			treePosition: index + 1
+		});
+	}
+	return loadings;
+}
+function withSlotLoadingEntries(slot, pagePath, matcher) {
+	const loadingEntries = findSlotLoadingEntries(slot.ownerDir, pagePath, matcher);
+	return {
+		...slot,
+		loadingPaths: loadingEntries.map((entry) => entry.path),
+		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition)
+	};
+}
 function findSlotNotFoundBoundary(slotDir, pagePath, matcher) {
 	let dir = pagePath ? path.dirname(pagePath) : slotDir;
 	while (dir === slotDir || dir.startsWith(`${slotDir}${path.sep}`)) {
@@ -751,6 +783,9 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const templateTreePositions = computeLayoutTreePositions(appDir, templates);
 	const layoutTreePositions = computeLayoutTreePositions(appDir, layouts);
 	const layoutErrorPaths = discoverLayoutAlignedErrors(segments, appDir, matcher);
+	const loadingEntries = discoverSegmentLoadings(segments, appDir, matcher);
+	const loadingPaths = loadingEntries.map((entry) => entry.path);
+	const loadingTreePositions = loadingEntries.map((entry) => entry.treePosition);
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
@@ -785,6 +820,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		templates,
 		parallelSlots,
 		loadingPath,
+		loadingPaths,
+		loadingTreePositions,
 		errorPath,
 		layoutErrorPaths,
 		errorPaths,
@@ -933,6 +970,31 @@ function discoverSegmentErrors(segments, appDir, matcher) {
 	return errors;
 }
 /**
+* Discover loading.tsx files by segment tree position.
+*
+* Loading conventions belong to loader-tree segments rather than layouts. A
+* segment without layout.tsx can therefore provide the boundary that suspends
+* while its child layout renders.
+*/
+function discoverSegmentLoadings(segments, appDir, matcher) {
+	const loadings = [];
+	const rootLoading = findFile(appDir, "loading", matcher);
+	if (rootLoading) loadings.push({
+		path: rootLoading,
+		treePosition: 0
+	});
+	let currentDir = appDir;
+	for (let index = 0; index < segments.length; index++) {
+		currentDir = path.join(currentDir, segments[index]);
+		const loading = findFile(currentDir, "loading", matcher);
+		if (loading) loadings.push({
+			path: loading,
+			treePosition: index + 1
+		});
+	}
+	return loadings;
+}
+/**
 * Discover error.tsx files aligned with the layouts array.
 *
 * Route manifests still model layout-owned boundary facts by layout index.
@@ -1037,7 +1099,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
 			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
-			const inheritedSlot = {
+			const inheritedSlot = withSlotLoadingEntries({
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
 				configLayoutPaths,
@@ -1046,7 +1108,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
 				slotParamNames
-			};
+			}, mirror?.pagePath ?? null, matcher);
 			slotMap.set(slot.key, inheritedSlot);
 		}
 	}
@@ -1209,6 +1271,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
+		const loadingEntries = findSlotLoadingEntries(slotDir, pagePath, matcher);
 		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
@@ -1216,6 +1279,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
+			ownerTreePosition: ownerSegments.length,
 			hasPage: pagePath !== null,
 			pagePath,
 			defaultPath,
@@ -1223,6 +1287,8 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			configLayoutPaths,
 			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
+			loadingPaths: loadingEntries.map((loading) => loading.path),
+			loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 			errorPath: findFile(slotDir, "error", matcher),
 			notFoundPath: notFoundBoundary.path,
 			notFoundTreePosition: notFoundBoundary.treePosition,
@@ -1374,7 +1440,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
-function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = []) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1384,8 +1450,14 @@ function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, res
 		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher);
-		} else scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, [], parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
+		} else {
+			const loading = findFile(interceptDir, "loading", matcher);
+			scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher, loading ? [...parentLoadingEntries, {
+				path: loading,
+				treePosition: path.relative(slotRootDir, interceptDir).split(path.sep).filter(Boolean).length
+			}] : parentLoadingEntries);
+		}
 	}
 }
 /**
@@ -1399,25 +1471,43 @@ function matchInterceptConvention(name) {
 * Collect page.tsx files inside an intercepting route directory tree
 * and compute their target URL patterns.
 */
-function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, parentLayoutPaths = []) {
+function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, parentLayoutPaths = [], parentLoadingEntries = [], treePositionOffset = 0) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
+	const currentLoadingPath = findFile(currentDir, "loading", matcher);
+	const relativeCurrentDir = path.relative(interceptRoot, currentDir);
+	const currentTreePosition = treePositionOffset + 1 + (relativeCurrentDir ? relativeCurrentDir.split(path.sep).filter(Boolean).length : 0);
+	const loadingEntries = currentLoadingPath ? [...parentLoadingEntries, {
+		path: currentLoadingPath,
+		treePosition: currentTreePosition
+	}] : parentLoadingEntries;
 	const page = findFile(currentDir, "page", matcher);
 	if (page) {
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
 			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
-			const branchSegments = [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)];
 			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
+			const branchSegments = [
+				...slotParentSegments,
+				interceptSegment,
+				...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)
+			];
 			results.push({
 				branchSegments,
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
-					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
+					const relativeDir = path.relative(interceptRoot, path.dirname(layoutPath));
+					return [
+						...slotParentSegments,
+						interceptSegment,
+						...relativeDir.split(path.sep).filter(Boolean)
+					];
 				}),
-				notFoundBranchSegments: [...slotParentSegments, ...branchSegments],
+				loadingPaths: loadingEntries.map((loading) => loading.path),
+				loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
+				notFoundBranchSegments: branchSegments,
 				notFoundPath: notFoundBoundary.path,
 				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
 				targetPattern: targetPattern.pattern,
@@ -1433,7 +1523,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
-		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, layoutPaths, loadingEntries, treePositionOffset);
 	}
 }
 /**
@@ -1661,4 +1751,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };

package/dist/server/api-handler.d.ts

@@ -11,6 +11,8 @@ import { IncomingMessage, ServerResponse } from "node:http";
 declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
   basePath?: string;
   i18n?: NextI18nConfig | null;
+  trustedRevalidateOrigin?: string;
+  allowedRevalidateHeaderKeys?: readonly string[];
   trailingSlash?: boolean;
 }): Promise<boolean>;
 //#endregion

package/dist/server/api-handler.js

@@ -9,7 +9,7 @@ import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-medi
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { attachPagesPreviewApi, attachPagesRequestCookies } from "./pages-node-compat.js";
-import { isEdgeApiRuntime } from "./edge-api-runtime.js";
+import { finalizeEdgeApiResponse, isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { decode } from "node:querystring";
 import { Buffer } from "node:buffer";
 //#region src/server/api-handler.ts
@@ -160,7 +160,7 @@ async function writeEdgeApiResponseBody(res, body) {
 /**
 * Enhance a Node.js req/res pair with Next.js API route helpers.
 */
-function enhanceApiObjects(req, res, query, body) {
+function enhanceApiObjects(req, res, query, body, trustedRevalidateOrigin, allowedRevalidateHeaderKeys = [], dev = false) {
 	const apiReq = Object.assign(req, {
 		body,
 		query
@@ -202,7 +202,7 @@ function enhanceApiObjects(req, res, query, body) {
 			return this;
 		},
 		async revalidate(urlPath, opts) {
-			await performOnDemandRevalidate(req, urlPath, opts);
+			await performOnDemandRevalidate(req, urlPath, opts, trustedRevalidateOrigin, allowedRevalidateHeaderKeys, dev);
 		}
 	});
 	attachPagesPreviewApi(apiReq, apiRes);
@@ -227,8 +227,9 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 				i18n: nextConfig.i18n ?? void 0,
 				trailingSlash: nextConfig.trailingSlash
 			} } : void 0);
-			const response = await apiModule.default(nextRequest);
-			if (!(response instanceof Response)) throw new Error("Edge API route did not return a Response");
+			const handlerResponse = await apiModule.default(nextRequest);
+			if (!(handlerResponse instanceof Response)) throw new Error("Edge API route did not return a Response");
+			const response = finalizeEdgeApiResponse(handlerResponse, "node");
 			res.statusCode = response.status;
 			res.statusMessage = response.statusText;
 			const setCookieHeaders = response.headers.getSetCookie();
@@ -248,7 +249,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 		}
 		const query = mergeRouteParamsIntoQuery(parseQueryString(url), params);
 		const bodyParserConfig = resolveBodyParserConfig(apiModule.config);
-		const { apiReq, apiRes } = enhanceApiObjects(req, res, query, bodyParserConfig.enabled ? await parseBody(req, bodyParserConfig.sizeLimit) : void 0);
+		const { apiReq, apiRes } = enhanceApiObjects(req, res, query, bodyParserConfig.enabled ? await parseBody(req, bodyParserConfig.sizeLimit) : void 0, nextConfig?.trustedRevalidateOrigin, nextConfig?.allowedRevalidateHeaderKeys, true);
 		await handler(apiReq, apiRes);
 		return true;
 	} catch (e) {

package/dist/server/app-bfcache-identity.js

@@ -51,19 +51,45 @@ function createActiveSlotIdentity(id, parsed) {
 	if (interception?.slotId !== id) return null;
 	return `${id}@${interception.targetRouteId}`;
 }
+function getDirectMatchedRoutePathname(metadata) {
+	if (metadata?.metadata.interception != null || metadata?.metadata.sourcePage == null) return null;
+	const route = AppElementsWire.parseElementKey(metadata.metadata.routeId);
+	return route?.kind === "route" ? route.path : null;
+}
+function getPageMatchedUrl(parsed, metadata) {
+	const interception = metadata?.metadata.interception;
+	if (interception === null || interception === void 0) {
+		const matchedRoutePathname = getDirectMatchedRoutePathname(metadata);
+		return matchedRoutePathname === parsed.path ? matchedRoutePathname : null;
+	}
+	for (const [routeId, matchedUrl] of [[interception.sourceRouteId, interception.sourceMatchedUrl], [interception.targetRouteId, interception.targetMatchedUrl]]) {
+		const route = AppElementsWire.parseElementKey(routeId);
+		if (route?.kind === "route" && route.path === parsed.path) return matchedUrl;
+	}
+	return null;
+}
+function getTreePathname(treePath, metadata) {
+	const interception = metadata?.metadata.interception;
+	if (interception === null || interception === void 0) return getDirectMatchedRoutePathname(metadata);
+	const slot = AppElementsWire.parseElementKey(interception.slotId);
+	if (slot?.kind !== "slot") return interception.sourceMatchedUrl;
+	const treeSegments = splitPathSegments(treePath);
+	const ownerSegments = splitPathSegments(slot.treePath);
+	return treeSegments.length > ownerSegments.length && ownerSegments.every((segment, index) => treeSegments[index] === segment) && treeSegments[ownerSegments.length] === `@${slot.name}` ? interception.targetMatchedUrl : interception.sourceMatchedUrl;
+}
 /**
 * Derive BFCache identity from AppElements wire keys. Keep wire-key parsing
 * contained here until vinext has a route-manifest authority equivalent to
 * Next.js CacheNode or segment-cache state.
 */
 function createBfcacheSegmentIdentity(id, parsed, options) {
-	if (parsed.kind === "page") return `${id}@${options.pathname}`;
+	if (parsed.kind === "page") return `${id}@${getPageMatchedUrl(parsed, options.metadata) ?? options.pathname}`;
 	if (parsed.kind === "slot") {
 		const activeSlotIdentity = createActiveSlotIdentity(id, options.metadata);
 		if (activeSlotIdentity !== null) return activeSlotIdentity;
 		return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
 	}
-	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(options.pathname, parsed.treePath)}`;
+	if (parsed.kind === "layout" || parsed.kind === "template") return `${id}@${getTreePathIdentityPrefix(getTreePathname(parsed.treePath, options.metadata) ?? options.pathname, parsed.treePath)}`;
 	return null;
 }
 function collectBfcacheSegmentIdCandidates(elements, metadata = readAppElementsMetadata(elements)) {