vinext 0.0.49 → 0.0.51

package/dist/routing/app-route-graph.d.ts

@@ -3,7 +3,23 @@ import { ValidFileMatcher } from "./file-matcher.js";
 //#region src/routing/app-route-graph.d.ts
 type InterceptingRoute = {
   /** The interception convention: "." | ".." | "../.." | "..." */convention: string; /** The URL pattern this intercepts (e.g. "/photos/:id") */
-  targetPattern: string; /** Absolute path to the intercepting page component */
+  targetPattern: string;
+  /**
+   * URL pattern of the *intercepting route* — the path that owns the slot
+   * containing this interception marker, with route groups and `@slot`
+   * segments stripped. Mirrors Next.js' `interceptingRoute` from
+   * `extractInterceptionRouteInformation`.
+   *
+   * Used at request time to gate `findIntercept` against the Next-URL /
+   * interception-context header: an intercept only fires when the source
+   * pathname matches `^<sourceMatchPattern>(?:/.*)?$`. Without this gate
+   * a direct RSC fetch to the intercept target would render the modal
+   * instead of the underlying page.
+   *
+   * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/lib/generate-interception-routes-rewrites.ts
+   * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/interception-routes.ts
+   */
+  sourceMatchPattern: string; /** Absolute path to the intercepting page component */
   pagePath: string; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Parameter names for dynamic segments */
   params: string[];
@@ -12,7 +28,9 @@ type ParallelSlot = {
   /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */id?: string; /** Stable slot identity (name + owning directory), used for route serialization keys. */
   key: string; /** Slot name (e.g. "team" from @team) */
   name: string; /** Absolute path to the @slot directory that owns this slot. Internal routing metadata. */
-  ownerDir: string; /** Absolute path to the slot's page component */
+  ownerDir: string; /** Stable tree path for the directory whose layout owns this slot. */
+  ownerTreePath: string; /** Whether the slot owner directory declares its own page component. */
+  hasPage: boolean; /** Absolute path to the slot's page component */
   pagePath: string | null; /** Absolute path to the slot's default.tsx fallback */
   defaultPath: string | null; /** Absolute path to the slot's layout component (wraps slot content) */
   layoutPath: string | null; /** Absolute path to the slot's loading component */
@@ -61,10 +79,10 @@ type AppRoute = {
    * Per-layout error boundary paths, aligned with the layouts array.
    * Each entry is the error.tsx at the same directory level as the
    * corresponding layout (or null if that level has no error.tsx).
-   * Used to interleave ErrorBoundary components with layouts so that
-   * ancestor error boundaries catch errors from descendant segments.
    */
-  layoutErrorPaths: (string | null)[]; /** Not-found component path (nearest, walking up from page dir) */
+  layoutErrorPaths: (string | null)[]; /** Per-segment error boundary paths, aligned with errorTreePositions. */
+  errorPaths?: string[]; /** Tree position (directory depth from app/ root) for each error boundary. */
+  errorTreePositions?: number[]; /** Not-found component path (nearest, walking up from page dir) */
   notFoundPath: string | null;
   /**
    * Not-found component paths per layout level (aligned with layouts array).
@@ -161,11 +179,60 @@ type RouteManifestTemplate = {
   id: string;
   treePath: string;
   rootBoundaryId: RootBoundaryId | null;
+  ownerLayoutId: string | null;
+  reset: {
+    kind: "remountSubtree";
+    treePath: string;
+  };
 };
 type RouteManifestSlot = {
   id: string;
   key: string;
   name: string;
+  ownerTreePath: string;
+  ownerLayoutId: string | null;
+  rootBoundaryId: RootBoundaryId | null;
+  defaultId: string | null;
+  hasDefault: boolean;
+  hasPage: boolean;
+};
+type RouteManifestDefault = {
+  id: string;
+  slotId: string;
+  ownerTreePath: string;
+  ownerLayoutId: string | null;
+  rootBoundaryId: RootBoundaryId | null;
+};
+type RouteManifestSlotBindingState = "active" | "default" | "unmatched";
+type RouteManifestSlotBinding = {
+  id: string;
+  routeId: string;
+  slotId: string;
+  ownerLayoutId: string | null;
+  state: RouteManifestSlotBindingState;
+  defaultId: string | null;
+  routeSegments: readonly string[] | null;
+  slotPatternParts?: readonly string[];
+  slotParamNames?: readonly string[];
+};
+type RouteManifestInterception = {
+  id: string;
+  sourcePattern: string;
+  sourcePatternParts: readonly string[];
+  targetPattern: string;
+  targetPatternParts: readonly string[];
+  slotId: string;
+  ownerLayoutId: string | null;
+  interceptingRouteId: string | null;
+  targetRouteId: string | null;
+};
+type RouteManifestBoundaryOutcome = "error" | "forbidden" | "notFound" | "unauthorized";
+type RouteManifestBoundary = {
+  id: string;
+  outcome: RouteManifestBoundaryOutcome;
+  treePath: string;
+  ownerLayoutId: string | null;
+  rootBoundaryId: RootBoundaryId | null;
 };
 type RouteManifestRootBoundary = {
   id: RootBoundaryId;
@@ -179,6 +246,11 @@ type StaticSegmentGraph = {
   layouts: ReadonlyMap<string, RouteManifestLayout>;
   templates: ReadonlyMap<string, RouteManifestTemplate>;
   slots: ReadonlyMap<string, RouteManifestSlot>;
+  defaults: ReadonlyMap<string, RouteManifestDefault>;
+  slotBindings: ReadonlyMap<string, RouteManifestSlotBinding>;
+  interceptions: ReadonlyMap<string, RouteManifestInterception>;
+  interceptionsBySlotId: ReadonlyMap<string, readonly RouteManifestInterception[]>;
+  boundaries: ReadonlyMap<string, RouteManifestBoundary>;
   rootBoundaries: ReadonlyMap<RootBoundaryId, RouteManifestRootBoundary>;
 };
 type RouteManifest = {
@@ -191,5 +263,5 @@ declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher):
 }>;
 declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
 //#endregion
-export { AppRoute, AppRouteGraphParallelSlot, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, InterceptingRoute, ParallelSlot, RootBoundaryId, RouteManifest, RouteManifestLayout, RouteManifestPage, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestRouteHandler, RouteManifestSlot, RouteManifestTemplate, StaticSegmentGraph, buildAppRouteGraph, computeRootParamNames };
+export { AppRoute, AppRouteGraphParallelSlot, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, InterceptingRoute, ParallelSlot, RootBoundaryId, RouteManifest, RouteManifestBoundary, RouteManifestBoundaryOutcome, RouteManifestDefault, RouteManifestInterception, RouteManifestLayout, RouteManifestPage, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestRouteHandler, RouteManifestSlot, RouteManifestSlotBinding, RouteManifestSlotBindingState, RouteManifestTemplate, StaticSegmentGraph, buildAppRouteGraph, computeRootParamNames };
 //# sourceMappingURL=app-route-graph.d.ts.map

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

@@ -29,6 +29,12 @@ function createAppRouteGraphTemplateId(treePath) {
 function createAppRouteGraphSlotId(slotName, ownerTreePath) {
 	return `slot:${slotName}:${ownerTreePath}`;
 }
+function createAppRouteGraphDefaultId(slotId) {
+	return `default:${slotId}`;
+}
+function createAppRouteGraphInterceptionId(slotId, sourcePattern, targetPattern) {
+	return `interception:${slotId}:${sourcePattern}->${targetPattern}`;
+}
 function createAppRouteGraphRootBoundaryId(treePath) {
 	return `root-boundary:${treePath}`;
 }
@@ -54,7 +60,12 @@ 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 interceptions = /* @__PURE__ */ new Map();
+	const boundaries = /* @__PURE__ */ new Map();
 	const rootBoundaries = /* @__PURE__ */ new Map();
+	const routeIdByPattern = createRouteManifestRouteIdByPattern(routes);
 	for (const route of routes) {
 		routeEntries.set(route.ids.route, {
 			id: route.ids.route,
@@ -86,10 +97,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 +116,58 @@ 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) {
+			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);
+			addRouteManifestInterceptionFacts({
+				interceptions,
+				ownerLayoutId,
+				route,
+				routeIdByPattern,
+				slot
 			});
 		}
-		for (const slot of route.parallelSlots) slots.set(slot.id, {
-			id: slot.id,
-			key: slot.key,
-			name: slot.name
-		});
 	}
 	return {
 		routes: routeEntries,
@@ -121,13 +176,114 @@ function createStaticSegmentGraph(routes) {
 		layouts,
 		templates,
 		slots,
+		defaults,
+		slotBindings,
+		interceptions,
+		interceptionsBySlotId: createRouteManifestInterceptionsBySlotId(interceptions),
+		boundaries,
 		rootBoundaries
 	};
 }
+function createRouteManifestRouteIdByPattern(routes) {
+	return new Map(routes.map((route) => [route.pattern, route.ids.route]));
+}
+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 addRouteManifestInterceptionFacts(input) {
+	for (const interception of input.slot.interceptingRoutes) {
+		const id = createAppRouteGraphInterceptionId(input.slot.id, interception.sourceMatchPattern, interception.targetPattern);
+		input.interceptions.set(id, {
+			id,
+			sourcePattern: interception.sourceMatchPattern,
+			sourcePatternParts: splitRouteManifestPatternParts(interception.sourceMatchPattern),
+			targetPattern: interception.targetPattern,
+			targetPatternParts: splitRouteManifestPatternParts(interception.targetPattern),
+			slotId: input.slot.id,
+			ownerLayoutId: input.ownerLayoutId,
+			interceptingRouteId: input.routeIdByPattern.get(interception.sourceMatchPattern) ?? null,
+			targetRouteId: input.routeIdByPattern.get(interception.targetPattern) ?? null
+		});
+	}
+}
+function createRouteManifestInterceptionsBySlotId(interceptions) {
+	const interceptionsBySlotId = /* @__PURE__ */ new Map();
+	for (const interception of interceptions.values()) {
+		const existing = interceptionsBySlotId.get(interception.slotId);
+		if (existing) existing.push(interception);
+		else interceptionsBySlotId.set(interception.slotId, [interception]);
+	}
+	for (const slotInterceptions of interceptionsBySlotId.values()) slotInterceptions.sort((left, right) => compareStableStrings(left.id, right.id));
+	return new Map(Array.from(interceptionsBySlotId.entries()).sort(([left], [right]) => compareStableStrings(left, right)));
+}
+function splitRouteManifestPatternParts(pattern) {
+	return pattern.split("/").filter((part) => part.length > 0);
+}
+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 +296,11 @@ function createRouteManifestGraphVersion(segmentGraph) {
 		layouts: sortedMapValues(segmentGraph.layouts),
 		templates: sortedMapValues(segmentGraph.templates),
 		slots: sortedMapValues(segmentGraph.slots),
+		defaults: sortedMapValues(segmentGraph.defaults),
+		slotBindings: sortedMapValues(segmentGraph.slotBindings),
+		interceptions: sortedMapValues(segmentGraph.interceptions),
+		interceptionsBySlotId: sortedMapValues(segmentGraph.interceptionsBySlotId),
+		boundaries: sortedMapValues(segmentGraph.boundaries),
 		rootBoundaries: sortedMapValues(segmentGraph.rootBoundaries)
 	};
 	return `graph:${createHash("sha256").update(JSON.stringify(stableShape)).digest("hex")}`;
@@ -383,6 +544,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 +576,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 		loadingPath,
 		errorPath,
 		layoutErrorPaths,
+		errorPaths,
+		errorTreePositions,
 		notFoundPath,
 		notFoundPaths,
 		forbiddenPaths,
@@ -512,15 +678,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 +954,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),
@@ -828,7 +1020,7 @@ function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
 			const interceptDir = path.join(currentDir, entry.name);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, results, matcher);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, results, matcher);
 		} else scanForInterceptingPages(path.join(currentDir, entry.name), routeDir, appDir, results, matcher);
 	}
 }
@@ -843,29 +1035,53 @@ 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, results, matcher, parentLayoutPaths = []) {
+function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, parentLayoutPaths = []) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
 	const page = findFile(currentDir, "page", matcher);
 	if (page) {
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
-		if (targetPattern) results.push({
-			convention,
-			layoutPaths: [...layoutPaths],
-			targetPattern: targetPattern.pattern,
-			pagePath: page,
-			params: targetPattern.params
-		});
+		if (targetPattern) {
+			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
+			results.push({
+				convention,
+				layoutPaths: [...layoutPaths],
+				targetPattern: targetPattern.pattern,
+				sourceMatchPattern,
+				pagePath: page,
+				params: targetPattern.params
+			});
+		}
 	}
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	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, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
 	}
 }
 /**
+* Compute the URL pattern for the *intercepting route* — the path that
+* owns the slot containing the interception marker. Route groups (`(name)`)
+* and parallel slots (`@slot`) are stripped because Next.js'
+* `normalizeAppPath` treats them as invisible in the URL.
+*
+* Mirrors Next.js' computation in `extractInterceptionRouteInformation`:
+* `interceptingRoute = normalizeAppPath(path.split(marker, 2)[0])`.
+*
+* Returns `/` for the app root.
+*
+* @see https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/interception-routes.ts
+*/
+function computeInterceptSourceMatchPattern(interceptParentDir, appDir) {
+	const segments = path.relative(appDir, interceptParentDir).split(path.sep).filter(Boolean);
+	const converted = convertSegmentsToRouteParts(segments);
+	const urlSegments = converted ? converted.urlSegments : segments.filter((segment) => !isInvisibleSegment(segment));
+	if (urlSegments.length === 0) return "/";
+	return "/" + urlSegments.join("/");
+}
+/**
 * Check whether a path segment is invisible in the URL (route groups, parallel slots, ".").
 *
 * Used by computeInterceptTarget, convertSegmentsToRouteParts, and