vinext 0.0.47 → 0.0.49

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

@@ -3,6 +3,7 @@ import { scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import fs from "node:fs";
 import path from "node:path";
+import { createHash } from "node:crypto";
 //#region src/routing/app-route-graph.ts
 /**
 * App Router route graph construction.
@@ -10,6 +11,139 @@ import path from "node:path";
 * Scans app/ directories and materializes route metadata before the request-time
 * matcher consumes it. Keep request matching and cache ownership in app-router.ts.
 */
+function createAppRouteGraphRouteId(pattern) {
+	return `route:${pattern}`;
+}
+function createAppRouteGraphPageId(pattern) {
+	return `page:${pattern}`;
+}
+function createAppRouteGraphRouteHandlerId(pattern) {
+	return `route-handler:${pattern}`;
+}
+function createAppRouteGraphLayoutId(treePath) {
+	return `layout:${treePath}`;
+}
+function createAppRouteGraphTemplateId(treePath) {
+	return `template:${treePath}`;
+}
+function createAppRouteGraphSlotId(slotName, ownerTreePath) {
+	return `slot:${slotName}:${ownerTreePath}`;
+}
+function createAppRouteGraphRootBoundaryId(treePath) {
+	return `root-boundary:${treePath}`;
+}
+function compareStableStrings(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function sortedMapValues(map) {
+	return Array.from(map.entries()).sort(([left], [right]) => compareStableStrings(left, right)).map(([, value]) => value);
+}
+function createRouteManifest(routes) {
+	const segmentGraph = createStaticSegmentGraph(routes);
+	return {
+		graphVersion: createRouteManifestGraphVersion(segmentGraph),
+		segmentGraph
+	};
+}
+function createStaticSegmentGraph(routes) {
+	const routeEntries = /* @__PURE__ */ new Map();
+	const pages = /* @__PURE__ */ new Map();
+	const routeHandlers = /* @__PURE__ */ new Map();
+	const layouts = /* @__PURE__ */ new Map();
+	const templates = /* @__PURE__ */ new Map();
+	const slots = /* @__PURE__ */ new Map();
+	const rootBoundaries = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		routeEntries.set(route.ids.route, {
+			id: route.ids.route,
+			pattern: route.pattern,
+			patternParts: [...route.patternParts],
+			isDynamic: route.isDynamic,
+			paramNames: [...route.params],
+			rootParamNames: [...route.rootParamNames],
+			rootBoundaryId: route.ids.rootBoundary,
+			pageId: route.ids.page,
+			routeHandlerId: route.ids.routeHandler,
+			layoutIds: [...route.ids.layouts],
+			templateIds: [...route.ids.templates],
+			slotIds: route.parallelSlots.map((slot) => slot.id).sort(compareStableStrings)
+		});
+		if (route.ids.page) pages.set(route.ids.page, {
+			id: route.ids.page,
+			routeId: route.ids.route,
+			pattern: route.pattern
+		});
+		if (route.ids.routeHandler) routeHandlers.set(route.ids.routeHandler, {
+			id: route.ids.routeHandler,
+			routeId: route.ids.route,
+			pattern: route.pattern
+		});
+		for (const [index, layoutId] of route.ids.layouts.entries()) {
+			const treePosition = route.layoutTreePositions[index];
+			assertRouteManifestTreePosition("layout", route, layoutId, treePosition);
+			const treePath = createAppRouteGraphTreePath(route.routeSegments, treePosition);
+			const existingLayout = layouts.get(layoutId);
+			if (existingLayout) assertRouteManifestRootBoundary("layout", route, layoutId, existingLayout.rootBoundaryId);
+			layouts.set(layoutId, {
+				id: layoutId,
+				treePath,
+				rootBoundaryId: route.ids.rootBoundary
+			});
+			if (index === 0 && route.ids.rootBoundary) rootBoundaries.set(route.ids.rootBoundary, {
+				id: route.ids.rootBoundary,
+				layoutId,
+				treePath
+			});
+		}
+		for (const [index, templateId] of route.ids.templates.entries()) {
+			const treePosition = route.templateTreePositions?.[index];
+			assertRouteManifestTreePosition("template", route, templateId, treePosition);
+			const existingTemplate = templates.get(templateId);
+			if (existingTemplate) assertRouteManifestRootBoundary("template", route, templateId, existingTemplate.rootBoundaryId);
+			templates.set(templateId, {
+				id: templateId,
+				treePath: createAppRouteGraphTreePath(route.routeSegments, treePosition),
+				rootBoundaryId: route.ids.rootBoundary
+			});
+		}
+		for (const slot of route.parallelSlots) slots.set(slot.id, {
+			id: slot.id,
+			key: slot.key,
+			name: slot.name
+		});
+	}
+	return {
+		routes: routeEntries,
+		pages,
+		routeHandlers,
+		layouts,
+		templates,
+		slots,
+		rootBoundaries
+	};
+}
+function assertRouteManifestTreePosition(kind, route, id, treePosition) {
+	if (treePosition !== void 0) return;
+	throw new Error(`[vinext] App route graph invariant violated: missing ${kind} tree position for ${id} on ${route.pattern}`);
+}
+function assertRouteManifestRootBoundary(kind, route, id, existingRootBoundaryId) {
+	if (existingRootBoundaryId === route.ids.rootBoundary) return;
+	throw new Error(`[vinext] App route graph invariant violated: ${kind} ${id} is shared across root boundaries (${existingRootBoundaryId ?? "none"} and ${route.ids.rootBoundary ?? "none"}) on ${route.pattern}`);
+}
+function createRouteManifestGraphVersion(segmentGraph) {
+	const stableShape = {
+		routes: sortedMapValues(segmentGraph.routes),
+		pages: sortedMapValues(segmentGraph.pages),
+		routeHandlers: sortedMapValues(segmentGraph.routeHandlers),
+		layouts: sortedMapValues(segmentGraph.layouts),
+		templates: sortedMapValues(segmentGraph.templates),
+		slots: sortedMapValues(segmentGraph.slots),
+		rootBoundaries: sortedMapValues(segmentGraph.rootBoundaries)
+	};
+	return `graph:${createHash("sha256").update(JSON.stringify(stableShape)).digest("hex")}`;
+}
 async function buildAppRouteGraph(appDir, matcher) {
 	const routes = [];
 	const excludeDir = (name) => name.startsWith("@") || name.startsWith("_");
@@ -38,7 +172,10 @@ async function buildAppRouteGraph(appDir, matcher) {
 	validateRoutePatterns(routes.map((route) => route.pattern));
 	validateRoutePatterns([...new Set(routes.flatMap((route) => route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern))))]);
 	routes.sort(compareRoutes);
-	return { routes };
+	return {
+		routes,
+		routeManifest: createRouteManifest(routes)
+	};
 }
 function hasParallelSlotDirectory(dir) {
 	try {
@@ -99,8 +236,9 @@ function discoverSlotSubRoutes(routes, matcher) {
 	};
 	for (const parentRoute of routes) {
 		if (parentRoute.parallelSlots.length === 0) continue;
-		if (!parentRoute.pagePath) continue;
-		const parentPageDir = path.dirname(parentRoute.pagePath);
+		const isLayoutOnlyUiRoute = !parentRoute.pagePath && !parentRoute.routePath && parentRoute.layouts.length > 0;
+		if (!parentRoute.pagePath && !isLayoutOnlyUiRoute) continue;
+		const parentPageDir = parentRoute.pagePath ? path.dirname(parentRoute.pagePath) : path.dirname(parentRoute.layouts[parentRoute.layouts.length - 1]);
 		const subPathMap = /* @__PURE__ */ new Map();
 		for (const slot of parentRoute.parallelSlots) {
 			if (path.dirname(slot.ownerDir) !== parentPageDir) continue;
@@ -131,7 +269,7 @@ function discoverSlotSubRoutes(routes, matcher) {
 		}
 		if (subPathMap.size === 0) continue;
 		const childrenDefault = findFile(parentPageDir, "default", matcher);
-		if (!childrenDefault) continue;
+		if (parentRoute.pagePath && !childrenDefault) continue;
 		for (const { rawSegments, converted: convertedSubRoute, slotPages } of subPathMap.values()) {
 			const { urlSegments: urlParts, params: subParams, isDynamic: subIsDynamic } = convertedSubRoute;
 			const subUrlPath = urlParts.join("/");
@@ -142,6 +280,8 @@ function discoverSlotSubRoutes(routes, matcher) {
 				applySlotSubPages(existingRoute, slotPages, rawSegments);
 				continue;
 			}
+			const syntheticParts = [...parentRoute.patternParts, ...urlParts];
+			if (Array.from(routesByPattern.values()).some((r) => patternsStructurallyEquivalent(r.patternParts, syntheticParts))) continue;
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
 				return {
@@ -151,6 +291,15 @@ function discoverSlotSubRoutes(routes, matcher) {
 				};
 			});
 			const newRoute = {
+				ids: createAppRouteSemanticIds({
+					pattern,
+					pagePath: childrenDefault,
+					routePath: null,
+					routeSegments: [...parentRoute.routeSegments, ...rawSegments],
+					layoutTreePositions: parentRoute.layoutTreePositions,
+					templateTreePositions: parentRoute.templateTreePositions,
+					slots: subSlots
+				}),
 				pattern,
 				pagePath: childrenDefault,
 				routePath: null,
@@ -245,6 +394,15 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
 	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher);
 	return {
+		ids: createAppRouteSemanticIds({
+			pattern: pattern === "/" ? "/" : pattern,
+			pagePath,
+			routePath,
+			routeSegments: segments,
+			layoutTreePositions,
+			templateTreePositions,
+			slots: parallelSlots
+		}),
 		pattern: pattern === "/" ? "/" : pattern,
 		pagePath,
 		routePath,
@@ -285,6 +443,29 @@ function computeRootParamNames(routeSegments, layoutTreePositions) {
 	}
 	return names;
 }
+function resolveRootBoundaryId(routeSegments, layoutTreePositions) {
+	const rootLayoutPosition = layoutTreePositions[0];
+	if (rootLayoutPosition === void 0) return null;
+	return createAppRouteGraphRootBoundaryId(createAppRouteGraphTreePath(routeSegments, rootLayoutPosition));
+}
+function createAppRouteSemanticIds(input) {
+	const slots = {};
+	for (const slot of input.slots) slots[slot.key] = slot.id;
+	return {
+		route: createAppRouteGraphRouteId(input.pattern),
+		page: input.pagePath ? createAppRouteGraphPageId(input.pattern) : null,
+		routeHandler: input.routePath ? createAppRouteGraphRouteHandlerId(input.pattern) : null,
+		rootBoundary: resolveRootBoundaryId(input.routeSegments, input.layoutTreePositions),
+		layouts: input.layoutTreePositions.map((treePosition) => createAppRouteGraphLayoutId(createAppRouteGraphTreePath(input.routeSegments, treePosition))),
+		templates: (input.templateTreePositions ?? []).map((treePosition) => createAppRouteGraphTemplateId(createAppRouteGraphTreePath(input.routeSegments, treePosition))),
+		slots
+	};
+}
+function createAppRouteGraphTreePath(routeSegments, treePosition) {
+	const treePathSegments = routeSegments.slice(0, treePosition);
+	if (treePathSegments.length === 0) return "/";
+	return `/${treePathSegments.join("/")}`;
+}
 /**
 * Compute the tree position (directory depth from app root) for each layout.
 * Root layout = 0, a layout at app/blog/ = 1, app/blog/(group)/ = 2.
@@ -545,6 +726,22 @@ function scoreSlotPattern(urlSegments) {
 	return score;
 }
 /**
+* Map a pattern segment to the tree-node type used by Next.js' route
+* validator. Two segments are structurally equivalent iff they share the
+* same tree-node type.
+*/
+function segmentTreeNodeType(seg) {
+	if (!seg.startsWith(":")) return `literal:${seg}`;
+	if (seg.endsWith("*")) return "optionalCatchAll";
+	if (seg.endsWith("+")) return "catchAll";
+	return "dynamic";
+}
+function patternsStructurallyEquivalent(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (segmentTreeNodeType(a[i]) !== segmentTreeNodeType(b[i])) return false;
+	return true;
+}
+/**
 * Discover parallel route slots (@team, @analytics, etc.) in a directory.
 * Returns a ParallelSlot for each @-prefixed subdirectory that has a page or default component.
 */
@@ -560,7 +757,10 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
 		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
+		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
+		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		slots.push({
+			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
 			name: slotName,
 			ownerDir: slotDir,
@@ -774,24 +974,27 @@ function convertSegmentsToRouteParts(segments) {
 	for (let i = 0; i < segments.length; i++) {
 		const segment = segments[i];
 		if (isInvisibleSegment(segment)) continue;
-		const catchAllMatch = segment.match(/^\[\.\.\.([\w-]+)\]$/);
+		const catchAllMatch = segment.match(/^\[\.\.\.([^\]]+)\]$/);
 		if (catchAllMatch) {
 			if (hasRemainingVisibleSegments(segments, i + 1)) return null;
+			if (catchAllMatch[1].endsWith("+") || catchAllMatch[1].endsWith("*")) return null;
 			isDynamic = true;
 			params.push(catchAllMatch[1]);
 			urlSegments.push(`:${catchAllMatch[1]}+`);
 			continue;
 		}
-		const optionalCatchAllMatch = segment.match(/^\[\[\.\.\.([\w-]+)\]\]$/);
+		const optionalCatchAllMatch = segment.match(/^\[\[\.\.\.([^\]]+)\]\]$/);
 		if (optionalCatchAllMatch) {
 			if (hasRemainingVisibleSegments(segments, i + 1)) return null;
+			if (optionalCatchAllMatch[1].endsWith("+") || optionalCatchAllMatch[1].endsWith("*")) return null;
 			isDynamic = true;
 			params.push(optionalCatchAllMatch[1]);
 			urlSegments.push(`:${optionalCatchAllMatch[1]}*`);
 			continue;
 		}
-		const dynamicMatch = segment.match(/^\[([\w-]+)\]$/);
+		const dynamicMatch = segment.match(/^\[([^\]]+)\]$/);
 		if (dynamicMatch) {
+			if (dynamicMatch[1].endsWith("+") || dynamicMatch[1].endsWith("*")) return null;
 			isDynamic = true;
 			params.push(dynamicMatch[1]);
 			urlSegments.push(`:${dynamicMatch[1]}`);