vinext 0.0.45 → 0.0.47

package/dist/routing/app-router.js

@@ -1,9 +1,7 @@
-import { compareRoutes, decodeRouteSegment, normalizePathnameForRouteMatch } from "./utils.js";
-import { createValidFileMatcher, scanWithExtensions } from "./file-matcher.js";
-import { validateRoutePatterns } from "./route-validation.js";
+import { normalizePathnameForRouteMatch } from "./utils.js";
+import { createValidFileMatcher } from "./file-matcher.js";
 import { buildRouteTrie, trieMatch } from "./route-trie.js";
-import fs from "node:fs";
-import path from "node:path";
+import { buildAppRouteGraph, computeRootParamNames } from "./app-route-graph.js";
 //#region src/routing/app-router.ts
 /**
 * App Router file-system routing.
@@ -28,13 +26,6 @@ function invalidateAppRouteCache() {
 	cachedAppDir = null;
 	cachedPageExtensionsKey = null;
 }
-function hasParallelSlotDirectory(dir) {
-	try {
-		return fs.readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isDirectory() && entry.name.startsWith("@"));
-	} catch {
-		return false;
-	}
-}
 /**
 * Scan the app/ directory and return a list of routes.
 */
@@ -42,612 +33,11 @@ async function appRouter(appDir, pageExtensions, matcher) {
 	matcher ??= createValidFileMatcher(pageExtensions);
 	const pageExtensionsKey = JSON.stringify(matcher.extensions);
 	if (cachedRoutes && cachedAppDir === appDir && cachedPageExtensionsKey === pageExtensionsKey) return cachedRoutes;
-	const routes = [];
-	const excludeDir = (name) => name.startsWith("@") || name.startsWith("_");
-	for await (const file of scanWithExtensions("**/page", appDir, matcher.extensions, excludeDir)) {
-		const route = fileToAppRoute(file, appDir, "page", matcher);
-		if (route) routes.push(route);
-	}
-	for await (const file of scanWithExtensions("**/route", appDir, matcher.extensions, excludeDir)) {
-		const route = fileToAppRoute(file, appDir, "route", matcher);
-		if (route) routes.push(route);
-	}
-	const routePatterns = new Set(routes.map((route) => route.pattern));
-	for await (const file of scanWithExtensions("**/layout", appDir, matcher.extensions, excludeDir)) {
-		const dir = path.dirname(file);
-		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
-		if (!hasParallelSlotDirectory(routeDir)) continue;
-		if (discoverParallelSlots(routeDir, appDir, matcher).length === 0) continue;
-		const route = directoryToAppRoute(dir, appDir, matcher, null, null);
-		if (!route || routePatterns.has(route.pattern)) continue;
-		routes.push(route);
-		routePatterns.add(route.pattern);
-	}
-	const slotSubRoutes = discoverSlotSubRoutes(routes, appDir, matcher);
-	routes.push(...slotSubRoutes);
-	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);
-	cachedRoutes = routes;
+	const graph = await buildAppRouteGraph(appDir, matcher);
+	cachedRoutes = graph.routes;
 	cachedAppDir = appDir;
 	cachedPageExtensionsKey = pageExtensionsKey;
-	return routes;
-}
-/**
-* Discover sub-routes created by nested pages within parallel slots.
-*
-* In Next.js, pages nested inside @slot directories create additional URL routes.
-* For example, given:
-*   app/parallel-routes/@audience/demographics/page.tsx
-* This creates a route at /parallel-routes/demographics where:
-* - children slot → parent's default.tsx
-* - @audience slot → @audience/demographics/page.tsx (matched)
-* - other slots → their default.tsx (fallback)
-*/
-function discoverSlotSubRoutes(routes, _appDir, matcher) {
-	const syntheticRoutes = [];
-	const routesByPattern = new Map(routes.map((r) => [r.pattern, r]));
-	const applySlotSubPages = (route, slotPages, rawSegments) => {
-		route.parallelSlots = route.parallelSlots.map((slot) => {
-			const subPage = slotPages.get(slot.key);
-			if (subPage !== void 0) return {
-				...slot,
-				pagePath: subPage,
-				routeSegments: rawSegments
-			};
-			return slot;
-		});
-	};
-	for (const parentRoute of routes) {
-		if (parentRoute.parallelSlots.length === 0) continue;
-		if (!parentRoute.pagePath) continue;
-		const parentPageDir = path.dirname(parentRoute.pagePath);
-		const subPathMap = /* @__PURE__ */ new Map();
-		for (const slot of parentRoute.parallelSlots) {
-			if (path.dirname(slot.ownerDir) !== parentPageDir) continue;
-			const slotDir = slot.ownerDir;
-			if (!fs.existsSync(slotDir)) continue;
-			const subPages = findSlotSubPages(slotDir, matcher);
-			for (const { relativePath, pagePath } of subPages) {
-				const subSegments = relativePath.split(path.sep);
-				const convertedSubRoute = convertSegmentsToRouteParts(subSegments);
-				if (!convertedSubRoute) continue;
-				const { urlSegments } = convertedSubRoute;
-				const normalizedSubPath = urlSegments.join("/");
-				let subPathEntry = subPathMap.get(normalizedSubPath);
-				if (!subPathEntry) {
-					subPathEntry = {
-						rawSegments: subSegments,
-						converted: convertedSubRoute,
-						slotPages: /* @__PURE__ */ new Map()
-					};
-					subPathMap.set(normalizedSubPath, subPathEntry);
-				}
-				if (subPathEntry.slotPages.get(slot.key)) {
-					const pattern = joinRoutePattern(parentRoute.pattern, normalizedSubPath);
-					throw new Error(`You cannot have two routes that resolve to the same path ("${pattern}").`);
-				}
-				subPathEntry.slotPages.set(slot.key, pagePath);
-			}
-		}
-		if (subPathMap.size === 0) continue;
-		const childrenDefault = findFile(parentPageDir, "default", matcher);
-		if (!childrenDefault) continue;
-		for (const { rawSegments, converted: convertedSubRoute, slotPages } of subPathMap.values()) {
-			const { urlSegments: urlParts, params: subParams, isDynamic: subIsDynamic } = convertedSubRoute;
-			const subUrlPath = urlParts.join("/");
-			const pattern = joinRoutePattern(parentRoute.pattern, subUrlPath);
-			const existingRoute = routesByPattern.get(pattern);
-			if (existingRoute) {
-				if (existingRoute.routePath && !existingRoute.pagePath) throw new Error(`You cannot have two routes that resolve to the same path ("${pattern}").`);
-				applySlotSubPages(existingRoute, slotPages, rawSegments);
-				continue;
-			}
-			const subSlots = parentRoute.parallelSlots.map((slot) => {
-				const subPage = slotPages.get(slot.key);
-				return {
-					...slot,
-					pagePath: subPage || null,
-					routeSegments: subPage ? rawSegments : null
-				};
-			});
-			const newRoute = {
-				pattern,
-				pagePath: childrenDefault,
-				routePath: null,
-				layouts: parentRoute.layouts,
-				templates: parentRoute.templates,
-				parallelSlots: subSlots,
-				loadingPath: parentRoute.loadingPath,
-				errorPath: parentRoute.errorPath,
-				layoutErrorPaths: parentRoute.layoutErrorPaths,
-				notFoundPath: parentRoute.notFoundPath,
-				notFoundPaths: parentRoute.notFoundPaths,
-				forbiddenPath: parentRoute.forbiddenPath,
-				unauthorizedPath: parentRoute.unauthorizedPath,
-				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
-				templateTreePositions: parentRoute.templateTreePositions,
-				layoutTreePositions: parentRoute.layoutTreePositions,
-				isDynamic: parentRoute.isDynamic || subIsDynamic,
-				params: [...parentRoute.params, ...subParams],
-				patternParts: [...parentRoute.patternParts, ...urlParts]
-			};
-			syntheticRoutes.push(newRoute);
-			routesByPattern.set(pattern, newRoute);
-		}
-	}
-	return syntheticRoutes;
-}
-/**
-* Find all page files in subdirectories of a parallel slot directory.
-* Returns relative paths (from the slot dir) and absolute page paths.
-* Skips the root page.tsx (already handled as the slot's main page)
-* and intercepting route directories.
-*/
-function findSlotSubPages(slotDir, matcher) {
-	const results = [];
-	function scan(dir) {
-		if (!fs.existsSync(dir)) return;
-		const entries = fs.readdirSync(dir, { withFileTypes: true });
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (matchInterceptConvention(entry.name)) continue;
-			if (entry.name.startsWith("_")) continue;
-			const subDir = path.join(dir, entry.name);
-			const page = findFile(subDir, "page", matcher);
-			if (page) {
-				const relativePath = path.relative(slotDir, subDir);
-				results.push({
-					relativePath,
-					pagePath: page
-				});
-			}
-			scan(subDir);
-		}
-	}
-	scan(slotDir);
-	return results;
-}
-/**
-* Convert a file path relative to app/ into an AppRoute.
-*/
-function fileToAppRoute(file, appDir, type, matcher) {
-	return directoryToAppRoute(path.dirname(file), appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
-}
-function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
-	const segments = dir === "." ? [] : dir.split(path.sep);
-	const params = [];
-	let isDynamic = false;
-	const convertedRoute = convertSegmentsToRouteParts(segments);
-	if (!convertedRoute) return null;
-	const { urlSegments, params: routeParams, isDynamic: routeIsDynamic } = convertedRoute;
-	params.push(...routeParams);
-	isDynamic = routeIsDynamic;
-	const pattern = "/" + urlSegments.join("/");
-	const layouts = discoverLayouts(segments, appDir, matcher);
-	const templates = discoverTemplates(segments, appDir, matcher);
-	const templateTreePositions = computeLayoutTreePositions(appDir, templates);
-	const layoutTreePositions = computeLayoutTreePositions(appDir, layouts);
-	const layoutErrorPaths = discoverLayoutAlignedErrors(segments, appDir, matcher);
-	const routeDir = dir === "." ? appDir : path.join(appDir, dir);
-	const loadingPath = findFile(routeDir, "loading", matcher);
-	const errorPath = findFile(routeDir, "error", matcher);
-	const notFoundPath = discoverBoundaryFile(segments, appDir, "not-found", matcher);
-	const forbiddenPath = discoverBoundaryFile(segments, appDir, "forbidden", matcher);
-	const unauthorizedPath = discoverBoundaryFile(segments, appDir, "unauthorized", matcher);
-	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
-	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher);
-	return {
-		pattern: pattern === "/" ? "/" : pattern,
-		pagePath,
-		routePath,
-		layouts,
-		templates,
-		parallelSlots,
-		loadingPath,
-		errorPath,
-		layoutErrorPaths,
-		notFoundPath,
-		notFoundPaths,
-		forbiddenPath,
-		unauthorizedPath,
-		routeSegments: segments,
-		templateTreePositions,
-		layoutTreePositions,
-		isDynamic,
-		params,
-		patternParts: urlSegments
-	};
-}
-/**
-* 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.
-* Counts ALL directory levels including route groups and parallel slots.
-*/
-function computeLayoutTreePositions(appDir, layouts) {
-	return layouts.map((layoutPath) => {
-		const layoutDir = path.dirname(layoutPath);
-		if (layoutDir === appDir) return 0;
-		return path.relative(appDir, layoutDir).split(path.sep).length;
-	});
-}
-/**
-* Discover all layout files from root to the given directory.
-* Each level of the directory tree may have a layout.tsx.
-*/
-function discoverLayouts(segments, appDir, matcher) {
-	const layouts = [];
-	const rootLayout = findFile(appDir, "layout", matcher);
-	if (rootLayout) layouts.push(rootLayout);
-	let currentDir = appDir;
-	for (const segment of segments) {
-		currentDir = path.join(currentDir, segment);
-		const layout = findFile(currentDir, "layout", matcher);
-		if (layout) layouts.push(layout);
-	}
-	return layouts;
-}
-/**
-* Discover all template files from root to the given directory.
-* Each level of the directory tree may have a template.tsx.
-* Templates are like layouts but re-mount on navigation.
-*/
-function discoverTemplates(segments, appDir, matcher) {
-	const templates = [];
-	const rootTemplate = findFile(appDir, "template", matcher);
-	if (rootTemplate) templates.push(rootTemplate);
-	let currentDir = appDir;
-	for (const segment of segments) {
-		currentDir = path.join(currentDir, segment);
-		const template = findFile(currentDir, "template", matcher);
-		if (template) templates.push(template);
-	}
-	return templates;
-}
-/**
-* 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.
-*/
-function discoverLayoutAlignedErrors(segments, appDir, matcher) {
-	const errors = [];
-	if (findFile(appDir, "layout", matcher)) errors.push(findFile(appDir, "error", matcher));
-	let currentDir = appDir;
-	for (const segment of segments) {
-		currentDir = path.join(currentDir, segment);
-		if (findFile(currentDir, "layout", matcher)) errors.push(findFile(currentDir, "error", matcher));
-	}
-	return errors;
-}
-/**
-* Discover the nearest boundary file (not-found, forbidden, unauthorized)
-* by walking from the route's directory up to the app root.
-* Returns the first (closest) file found, or null.
-*/
-function discoverBoundaryFile(segments, appDir, fileName, matcher) {
-	const dirs = [];
-	let dir = appDir;
-	dirs.push(dir);
-	for (const segment of segments) {
-		dir = path.join(dir, segment);
-		dirs.push(dir);
-	}
-	for (let i = dirs.length - 1; i >= 0; i--) {
-		const f = findFile(dirs[i], fileName, matcher);
-		if (f) return f;
-	}
-	return null;
-}
-/**
-* Discover boundary files (not-found, forbidden, unauthorized) at each layout directory.
-* Returns an array aligned with the layouts array, where each entry is the boundary
-* file at that layout's directory, or null if none exists there.
-*
-* This is used for per-layout error boundaries. In Next.js, each layout level
-* has its own boundary that wraps the layout's children. When notFound() is thrown
-* from a layout, it propagates up to the parent layout's boundary.
-*/
-function discoverBoundaryFilePerLayout(layouts, fileName, matcher) {
-	return layouts.map((layoutPath) => {
-		return findFile(path.dirname(layoutPath), fileName, matcher);
-	});
-}
-/**
-* Discover parallel slots inherited from ancestor directories.
-*
-* In Next.js, parallel slots belong to the layout that defines them. When a
-* child route is rendered, its parent layout's slots must still be present.
-* If the child doesn't have matching content in a slot, the slot's default.tsx
-* is rendered instead.
-*
-* Walk from appDir through each segment to the route's directory. At each level
-* that has @slot dirs, collect them. Slots at the route's own directory level
-* use page.tsx; slots at ancestor levels use default.tsx only.
-*/
-function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
-	const slotMap = /* @__PURE__ */ new Map();
-	let currentDir = appDir;
-	const dirsToCheck = [];
-	let layoutIdx = findFile(appDir, "layout", matcher) ? 0 : -1;
-	dirsToCheck.push({
-		dir: appDir,
-		layoutIdx
-	});
-	for (const segment of segments) {
-		currentDir = path.join(currentDir, segment);
-		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
-		dirsToCheck.push({
-			dir: currentDir,
-			layoutIdx
-		});
-	}
-	const routeHasLayout = layoutIdx >= 0;
-	for (const { dir, layoutIdx: lvlLayoutIdx } of dirsToCheck) {
-		if (lvlLayoutIdx < 0 && routeHasLayout) continue;
-		const isOwnDir = dir === routeDir;
-		const slotLayoutIdx = Math.max(lvlLayoutIdx, 0);
-		const slotsAtLevel = discoverParallelSlots(dir, appDir, matcher);
-		for (const slot of slotsAtLevel) if (isOwnDir) {
-			slot.layoutIndex = slotLayoutIdx;
-			slotMap.set(slot.key, slot);
-		} else {
-			const inheritedSlot = {
-				...slot,
-				pagePath: null,
-				layoutIndex: slotLayoutIdx,
-				routeSegments: null
-			};
-			slotMap.set(slot.key, inheritedSlot);
-		}
-	}
-	return Array.from(slotMap.values());
-}
-/**
-* Discover parallel route slots (@team, @analytics, etc.) in a directory.
-* Returns a ParallelSlot for each @-prefixed subdirectory that has a page or default component.
-*/
-function discoverParallelSlots(dir, appDir, matcher) {
-	if (!fs.existsSync(dir)) return [];
-	const entries = fs.readdirSync(dir, { withFileTypes: true });
-	const slots = [];
-	for (const entry of entries) {
-		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
-		const slotName = entry.name.slice(1);
-		const slotDir = path.join(dir, entry.name);
-		const pagePath = findFile(slotDir, "page", matcher);
-		const defaultPath = findFile(slotDir, "default", matcher);
-		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
-		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
-		slots.push({
-			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
-			name: slotName,
-			ownerDir: slotDir,
-			pagePath,
-			defaultPath,
-			layoutPath: findFile(slotDir, "layout", matcher),
-			loadingPath: findFile(slotDir, "loading", matcher),
-			errorPath: findFile(slotDir, "error", matcher),
-			interceptingRoutes,
-			layoutIndex: -1,
-			routeSegments: pagePath ? [] : null
-		});
-	}
-	return slots;
-}
-/**
-* The interception convention prefix patterns.
-* (.) — same level, (..) — one level up, (..)(..)" — two levels up, (...) — root
-*/
-const INTERCEPT_PATTERNS = [
-	{
-		prefix: "(...)",
-		convention: "..."
-	},
-	{
-		prefix: "(..)(..)",
-		convention: "../.."
-	},
-	{
-		prefix: "(..)",
-		convention: ".."
-	},
-	{
-		prefix: "(.)",
-		convention: "."
-	}
-];
-/**
-* Discover intercepting routes inside a parallel slot directory.
-*
-* Intercepting routes use conventions like (.)photo, (..)feed, (...), etc.
-* They intercept navigation to another route and render within the slot instead.
-*
-* @param slotDir - The parallel slot directory (e.g. app/feed/@modal)
-* @param routeDir - The directory of the route that owns this slot (e.g. app/feed)
-* @param appDir - The root app directory
-*/
-function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
-	if (!fs.existsSync(slotDir)) return [];
-	const results = [];
-	scanForInterceptingPages(slotDir, routeDir, appDir, results, matcher);
-	return results;
-}
-/**
-* Recursively scan a directory tree for page.tsx files that are inside
-* intercepting route directories.
-*/
-function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher) {
-	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;
-		const interceptMatch = matchInterceptConvention(entry.name);
-		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);
-		} else scanForInterceptingPages(path.join(currentDir, entry.name), routeDir, appDir, results, matcher);
-	}
-}
-/**
-* Match a directory name against interception convention prefixes.
-*/
-function matchInterceptConvention(name) {
-	for (const pattern of INTERCEPT_PATTERNS) if (name.startsWith(pattern.prefix)) return pattern;
-	return null;
-}
-/**
-* 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 = []) {
-	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 (!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);
-	}
-}
-/**
-* Check whether a path segment is invisible in the URL (route groups, parallel slots, ".").
-*
-* Used by computeInterceptTarget, convertSegmentsToRouteParts, and
-* hasRemainingVisibleSegments — keep this the single source of truth.
-*/
-function isInvisibleSegment(segment) {
-	if (segment === ".") return true;
-	if (segment.startsWith("(") && segment.endsWith(")")) return true;
-	if (segment.startsWith("@")) return true;
-	return false;
-}
-/**
-* Compute the target URL pattern for an intercepting route.
-*
-* Interception conventions (..), (..)(..)" climb by *visible route segments*
-* (not filesystem directories). Route groups like (marketing) and parallel
-* slots like @modal are invisible and must be skipped when counting levels.
-*
-* - (.) same level: resolve relative to routeDir
-* - (..) one level up: climb 1 visible segment
-* - (..)(..) two levels up: climb 2 visible segments
-* - (...) root: resolve from appDir
-*/
-function computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir) {
-	const routeSegments = path.relative(appDir, routeDir).split(path.sep).filter(Boolean);
-	let baseParts;
-	switch (convention) {
-		case ".":
-			baseParts = routeSegments;
-			break;
-		case "..":
-		case "../..": {
-			const levelsToClimb = convention === ".." ? 1 : 2;
-			let climbed = 0;
-			let cutIndex = routeSegments.length;
-			while (cutIndex > 0 && climbed < levelsToClimb) {
-				cutIndex--;
-				if (!isInvisibleSegment(routeSegments[cutIndex])) climbed++;
-			}
-			baseParts = routeSegments.slice(0, cutIndex);
-			break;
-		}
-		case "...":
-			baseParts = [];
-			break;
-		default: return null;
-	}
-	const nestedParts = path.relative(interceptRoot, currentDir).split(path.sep).filter(Boolean);
-	const convertedTarget = convertSegmentsToRouteParts([
-		...baseParts,
-		interceptSegment,
-		...nestedParts
-	]);
-	if (!convertedTarget) return null;
-	const { urlSegments, params } = convertedTarget;
-	const pattern = "/" + urlSegments.join("/");
-	return {
-		pattern: pattern === "/" ? "/" : pattern,
-		params
-	};
-}
-/**
-* Find a file by name (without extension) in a directory.
-* Checks configured pageExtensions.
-*/
-function findFile(dir, name, matcher) {
-	for (const ext of matcher.dottedExtensions) {
-		const filePath = path.join(dir, name + ext);
-		if (fs.existsSync(filePath)) return filePath;
-	}
-	return null;
-}
-/**
-* Convert filesystem path segments to URL route parts, skipping invisible segments
-* (route groups, @slots, ".") and converting dynamic segment syntax to Express-style
-* patterns (e.g. "[id]" → ":id", "[...slug]" → ":slug+").
-*/
-function convertSegmentsToRouteParts(segments) {
-	const urlSegments = [];
-	const params = [];
-	let isDynamic = false;
-	for (let i = 0; i < segments.length; i++) {
-		const segment = segments[i];
-		if (isInvisibleSegment(segment)) continue;
-		const catchAllMatch = segment.match(/^\[\.\.\.([\w-]+)\]$/);
-		if (catchAllMatch) {
-			if (hasRemainingVisibleSegments(segments, i + 1)) return null;
-			isDynamic = true;
-			params.push(catchAllMatch[1]);
-			urlSegments.push(`:${catchAllMatch[1]}+`);
-			continue;
-		}
-		const optionalCatchAllMatch = segment.match(/^\[\[\.\.\.([\w-]+)\]\]$/);
-		if (optionalCatchAllMatch) {
-			if (hasRemainingVisibleSegments(segments, i + 1)) return null;
-			isDynamic = true;
-			params.push(optionalCatchAllMatch[1]);
-			urlSegments.push(`:${optionalCatchAllMatch[1]}*`);
-			continue;
-		}
-		const dynamicMatch = segment.match(/^\[([\w-]+)\]$/);
-		if (dynamicMatch) {
-			isDynamic = true;
-			params.push(dynamicMatch[1]);
-			urlSegments.push(`:${dynamicMatch[1]}`);
-			continue;
-		}
-		urlSegments.push(decodeRouteSegment(segment));
-	}
-	return {
-		urlSegments,
-		params,
-		isDynamic
-	};
-}
-function hasRemainingVisibleSegments(segments, startIndex) {
-	for (let i = startIndex; i < segments.length; i++) if (!isInvisibleSegment(segments[i])) return true;
-	return false;
+	return graph.routes;
 }
 const appTrieCache = /* @__PURE__ */ new WeakMap();
 function getOrBuildAppTrie(routes) {
@@ -658,10 +48,6 @@ function getOrBuildAppTrie(routes) {
 	}
 	return trie;
 }
-function joinRoutePattern(basePattern, subPath) {
-	if (!subPath) return basePattern;
-	return basePattern === "/" ? `/${subPath}` : `${basePattern}/${subPath}`;
-}
 /**
 * Match a URL against App Router routes.
 */
@@ -673,6 +59,6 @@ function matchAppRoute(url, routes) {
 	return trieMatch(getOrBuildAppTrie(routes), urlParts);
 }
 //#endregion
-export { appRouter, invalidateAppRouteCache, matchAppRoute };
+export { appRouter, computeRootParamNames, invalidateAppRouteCache, matchAppRoute };
 
 //# sourceMappingURL=app-router.js.map