vinext 0.0.49 → 0.0.50

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

@@ -29,6 +29,9 @@ function createAppRouteGraphTemplateId(treePath) {
 function createAppRouteGraphSlotId(slotName, ownerTreePath) {
 	return `slot:${slotName}:${ownerTreePath}`;
 }
+function createAppRouteGraphDefaultId(slotId) {
+	return `default:${slotId}`;
+}
 function createAppRouteGraphRootBoundaryId(treePath) {
 	return `root-boundary:${treePath}`;
 }
@@ -54,6 +57,9 @@ function createStaticSegmentGraph(routes) {
 	const layouts = /* @__PURE__ */ new Map();
 	const templates = /* @__PURE__ */ new Map();
 	const slots = /* @__PURE__ */ new Map();
+	const defaults = /* @__PURE__ */ new Map();
+	const slotBindings = /* @__PURE__ */ new Map();
+	const boundaries = /* @__PURE__ */ new Map();
 	const rootBoundaries = /* @__PURE__ */ new Map();
 	for (const route of routes) {
 		routeEntries.set(route.ids.route, {
@@ -86,10 +92,18 @@ function createStaticSegmentGraph(routes) {
 			const treePath = createAppRouteGraphTreePath(route.routeSegments, treePosition);
 			const existingLayout = layouts.get(layoutId);
 			if (existingLayout) assertRouteManifestRootBoundary("layout", route, layoutId, existingLayout.rootBoundaryId);
-			layouts.set(layoutId, {
+			const layout = {
 				id: layoutId,
 				treePath,
 				rootBoundaryId: route.ids.rootBoundary
+			};
+			layouts.set(layoutId, layout);
+			addRouteManifestBoundaryFacts({
+				boundaries,
+				route,
+				layoutId,
+				treePath,
+				layoutIndex: index
 			});
 			if (index === 0 && route.ids.rootBoundary) rootBoundaries.set(route.ids.rootBoundary, {
 				id: route.ids.rootBoundary,
@@ -97,22 +111,51 @@ function createStaticSegmentGraph(routes) {
 				treePath
 			});
 		}
+		addRouteManifestSegmentErrorBoundaryFacts({
+			boundaries,
+			route
+		});
 		for (const [index, templateId] of route.ids.templates.entries()) {
 			const treePosition = route.templateTreePositions?.[index];
 			assertRouteManifestTreePosition("template", route, templateId, treePosition);
+			const treePath = createAppRouteGraphTreePath(route.routeSegments, 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
+				treePath,
+				rootBoundaryId: route.ids.rootBoundary,
+				ownerLayoutId: findRouteManifestOwnerLayoutId(route, treePosition),
+				reset: {
+					kind: "remountSubtree",
+					treePath
+				}
 			});
 		}
-		for (const slot of route.parallelSlots) slots.set(slot.id, {
-			id: slot.id,
-			key: slot.key,
-			name: slot.name
-		});
+		for (const slot of route.parallelSlots) {
+			const ownerLayoutId = findSlotOwnerLayoutId(route, slot);
+			const defaultId = slot.defaultPath ? createAppRouteGraphDefaultId(slot.id) : null;
+			slots.set(slot.id, {
+				id: slot.id,
+				key: slot.key,
+				name: slot.name,
+				ownerTreePath: slot.ownerTreePath,
+				ownerLayoutId,
+				rootBoundaryId: ownerLayoutId ? route.ids.rootBoundary : null,
+				defaultId,
+				hasDefault: slot.defaultPath !== null,
+				hasPage: slot.hasPage
+			});
+			if (defaultId) defaults.set(defaultId, {
+				id: defaultId,
+				slotId: slot.id,
+				ownerTreePath: slot.ownerTreePath,
+				ownerLayoutId,
+				rootBoundaryId: ownerLayoutId ? route.ids.rootBoundary : null
+			});
+			const binding = createRouteManifestSlotBinding(route, slot, ownerLayoutId, defaultId);
+			slotBindings.set(binding.id, binding);
+		}
 	}
 	return {
 		routes: routeEntries,
@@ -121,13 +164,80 @@ function createStaticSegmentGraph(routes) {
 		layouts,
 		templates,
 		slots,
+		defaults,
+		slotBindings,
+		boundaries,
 		rootBoundaries
 	};
 }
+function findRouteManifestOwnerLayoutId(route, treePosition) {
+	const layoutIndex = route.layoutTreePositions.indexOf(treePosition);
+	return route.ids.layouts[layoutIndex] ?? null;
+}
+function findSlotOwnerLayoutId(route, slot) {
+	if (slot.layoutIndex < 0) return null;
+	return route.ids.layouts[slot.layoutIndex] ?? null;
+}
+function createRouteManifestSlotBinding(route, slot, ownerLayoutId, defaultId) {
+	const state = getRouteManifestSlotBindingState(slot);
+	const binding = {
+		id: `${route.ids.route}::${slot.id}`,
+		routeId: route.ids.route,
+		slotId: slot.id,
+		ownerLayoutId,
+		state,
+		defaultId: state === "default" ? defaultId : null,
+		routeSegments: slot.routeSegments ? [...slot.routeSegments] : null
+	};
+	if (slot.slotPatternParts) binding.slotPatternParts = [...slot.slotPatternParts];
+	if (slot.slotParamNames) binding.slotParamNames = [...slot.slotParamNames];
+	return binding;
+}
+function getRouteManifestSlotBindingState(slot) {
+	if (slot.pagePath) return "active";
+	if (slot.defaultPath) return "default";
+	return "unmatched";
+}
+function addRouteManifestBoundaryFacts(input) {
+	addRouteManifestBoundaryFact(input, "error", input.route.layoutErrorPaths[input.layoutIndex]);
+	addRouteManifestBoundaryFact(input, "notFound", input.route.notFoundPaths[input.layoutIndex]);
+	addRouteManifestBoundaryFact(input, "forbidden", input.route.forbiddenPaths[input.layoutIndex]);
+	addRouteManifestBoundaryFact(input, "unauthorized", input.route.unauthorizedPaths[input.layoutIndex]);
+}
+function addRouteManifestSegmentErrorBoundaryFacts(input) {
+	for (const [index, boundaryPath] of (input.route.errorPaths ?? []).entries()) {
+		const treePosition = input.route.errorTreePositions?.[index];
+		assertRouteManifestBoundaryTreePosition(input.route, boundaryPath, treePosition);
+		const ownerLayoutId = findRouteManifestOwnerLayoutId(input.route, treePosition);
+		if (ownerLayoutId !== null) continue;
+		const treePath = createAppRouteGraphTreePath(input.route.routeSegments, treePosition);
+		addRouteManifestBoundaryFact({
+			boundaries: input.boundaries,
+			route: input.route,
+			layoutId: ownerLayoutId,
+			treePath
+		}, "error", boundaryPath);
+	}
+}
+function addRouteManifestBoundaryFact(input, outcome, boundaryPath) {
+	if (!boundaryPath) return;
+	const id = `boundary:${outcome}:${input.treePath}`;
+	input.boundaries.set(id, {
+		id,
+		outcome,
+		treePath: input.treePath,
+		ownerLayoutId: input.layoutId,
+		rootBoundaryId: input.route.ids.rootBoundary
+	});
+}
 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 assertRouteManifestBoundaryTreePosition(route, boundaryPath, treePosition) {
+	if (treePosition !== void 0) return;
+	throw new Error(`[vinext] App route graph invariant violated: missing boundary tree position for ${boundaryPath} 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}`);
@@ -140,6 +250,9 @@ function createRouteManifestGraphVersion(segmentGraph) {
 		layouts: sortedMapValues(segmentGraph.layouts),
 		templates: sortedMapValues(segmentGraph.templates),
 		slots: sortedMapValues(segmentGraph.slots),
+		defaults: sortedMapValues(segmentGraph.defaults),
+		slotBindings: sortedMapValues(segmentGraph.slotBindings),
+		boundaries: sortedMapValues(segmentGraph.boundaries),
 		rootBoundaries: sortedMapValues(segmentGraph.rootBoundaries)
 	};
 	return `graph:${createHash("sha256").update(JSON.stringify(stableShape)).digest("hex")}`;
@@ -383,6 +496,9 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const templateTreePositions = computeLayoutTreePositions(appDir, templates);
 	const layoutTreePositions = computeLayoutTreePositions(appDir, layouts);
 	const layoutErrorPaths = discoverLayoutAlignedErrors(segments, appDir, matcher);
+	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
+	const errorPaths = errorEntries.map((entry) => entry.path);
+	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
 	const routeDir = dir === "." ? appDir : path.join(appDir, dir);
 	const loadingPath = findFile(routeDir, "loading", matcher);
 	const errorPath = findFile(routeDir, "error", matcher);
@@ -412,6 +528,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 		loadingPath,
 		errorPath,
 		layoutErrorPaths,
+		errorPaths,
+		errorTreePositions,
 		notFoundPath,
 		notFoundPaths,
 		forbiddenPaths,
@@ -512,15 +630,39 @@ function discoverTemplates(segments, appDir, matcher) {
 	return templates;
 }
 /**
+* Discover error.tsx files by segment tree position.
+*
+* Next.js stores conventions on every loader-tree segment; a route-group
+* directory with error.tsx but no sibling layout.tsx must still wrap its
+* descendants. Keeping positions explicit avoids conflating segment boundaries
+* with layout component ownership.
+*/
+function discoverSegmentErrors(segments, appDir, matcher) {
+	const errors = [];
+	const rootError = findFile(appDir, "error", matcher);
+	if (rootError) errors.push({
+		path: rootError,
+		treePosition: 0
+	});
+	let currentDir = appDir;
+	for (let index = 0; index < segments.length; index++) {
+		const segment = segments[index];
+		currentDir = path.join(currentDir, segment);
+		const error = findFile(currentDir, "error", matcher);
+		if (error) errors.push({
+			path: error,
+			treePosition: index + 1
+		});
+	}
+	return errors;
+}
+/**
 * Discover error.tsx files aligned with the layouts array.
-* Walks the same directory levels as discoverLayouts and, for each level
-* that contributes a layout entry, checks whether error.tsx also exists.
-* Returns an array of the same length as discoverLayouts() would return,
-* with the error path (or null) at each corresponding layout level.
 *
-* This enables interleaving ErrorBoundary components with layouts in the
-* rendering tree, matching Next.js behavior where each segment independently
-* wraps its children with an error boundary.
+* Route manifests still model layout-owned boundary facts by layout index.
+* Keep this layout-aligned compatibility shape separate from segment-owned
+* error boundaries so route-group errors without layouts do not get attributed
+* to unrelated layouts.
 */
 function discoverLayoutAlignedErrors(segments, appDir, matcher) {
 	const errors = [];
@@ -764,6 +906,8 @@ function discoverParallelSlots(dir, appDir, matcher) {
 			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
 			name: slotName,
 			ownerDir: slotDir,
+			ownerTreePath,
+			hasPage: pagePath !== null,
 			pagePath,
 			defaultPath,
 			layoutPath: findFile(slotDir, "layout", matcher),