vinext 0.0.30 → 0.0.31

package/dist/routing/app-router.js

@@ -1,748 +1,638 @@
-/**
- * App Router file-system routing.
- *
- * Scans the app/ directory following Next.js App Router conventions:
- * - app/page.tsx -> /
- * - app/about/page.tsx -> /about
- * - app/blog/[slug]/page.tsx -> /blog/:slug
- * - app/[...catchAll]/page.tsx -> /:catchAll+
- * - app/route.ts -> / (API route)
- * - app/(group)/page.tsx -> / (route groups are transparent)
- * - Layouts: app/layout.tsx wraps all children
- * - Loading: app/loading.tsx -> Suspense fallback
- * - Error: app/error.tsx -> ErrorBoundary
- * - Not Found: app/not-found.tsx
- */
-import path from "node:path";
-import fs from "node:fs";
 import { compareRoutes, decodeRouteSegment, normalizePathnameForRouteMatch } from "./utils.js";
-import { createValidFileMatcher, scanWithExtensions, } from "./file-matcher.js";
+import { createValidFileMatcher, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { buildRouteTrie, trieMatch } from "./route-trie.js";
-// Cache for app routes
+import fs from "node:fs";
+import path from "node:path";
+//#region src/routing/app-router.ts
+/**
+* App Router file-system routing.
+*
+* Scans the app/ directory following Next.js App Router conventions:
+* - app/page.tsx -> /
+* - app/about/page.tsx -> /about
+* - app/blog/[slug]/page.tsx -> /blog/:slug
+* - app/[...catchAll]/page.tsx -> /:catchAll+
+* - app/route.ts -> / (API route)
+* - app/(group)/page.tsx -> / (route groups are transparent)
+* - Layouts: app/layout.tsx wraps all children
+* - Loading: app/loading.tsx -> Suspense fallback
+* - Error: app/error.tsx -> ErrorBoundary
+* - Not Found: app/not-found.tsx
+*/
 let cachedRoutes = null;
 let cachedAppDir = null;
 let cachedPageExtensionsKey = null;
-export function invalidateAppRouteCache() {
-    cachedRoutes = null;
-    cachedAppDir = null;
-    cachedPageExtensionsKey = null;
+function invalidateAppRouteCache() {
+	cachedRoutes = null;
+	cachedAppDir = null;
+	cachedPageExtensionsKey = null;
 }
 /**
- * Scan the app/ directory and return a list of routes.
- */
-export async function appRouter(appDir, pageExtensions, matcher) {
-    matcher ??= createValidFileMatcher(pageExtensions);
-    const pageExtensionsKey = JSON.stringify(matcher.extensions);
-    if (cachedRoutes && cachedAppDir === appDir && cachedPageExtensionsKey === pageExtensionsKey) {
-        return cachedRoutes;
-    }
-    // Find all page.tsx and route.ts files, excluding @slot directories
-    // (slot pages are not standalone routes — they're rendered as props of their parent layout)
-    // and _private folders (Next.js convention for colocated non-route files).
-    const routes = [];
-    const excludeDir = (name) => name.startsWith("@") || name.startsWith("_");
-    // Process page files in a single pass
-    // Use function form of exclude for Node < 22.14 compatibility (string arrays require >= 22.14)
-    for await (const file of scanWithExtensions("**/page", appDir, matcher.extensions, excludeDir)) {
-        const route = fileToAppRoute(file, appDir, "page", matcher);
-        if (route)
-            routes.push(route);
-    }
-    // Process route handler files (API routes) in a single pass
-    for await (const file of scanWithExtensions("**/route", appDir, matcher.extensions, excludeDir)) {
-        const route = fileToAppRoute(file, appDir, "route", matcher);
-        if (route)
-            routes.push(route);
-    }
-    // Discover sub-routes created by nested pages within parallel slots.
-    // In Next.js, pages nested inside @slot directories create additional URL routes.
-    // For example, @audience/demographics/page.tsx at app/parallel-routes/ creates
-    // a route at /parallel-routes/demographics.
-    const slotSubRoutes = discoverSlotSubRoutes(routes, appDir, matcher);
-    routes.push(...slotSubRoutes);
-    validateRoutePatterns(routes.map((route) => route.pattern));
-    validateRoutePatterns(routes.flatMap((route) => route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern))));
-    // Sort: static routes first, then dynamic, then catch-all
-    routes.sort(compareRoutes);
-    cachedRoutes = routes;
-    cachedAppDir = appDir;
-    cachedPageExtensionsKey = pageExtensionsKey;
-    return routes;
+* Scan the app/ directory and return a list of routes.
+*/
+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 slotSubRoutes = discoverSlotSubRoutes(routes, appDir, matcher);
+	routes.push(...slotSubRoutes);
+	validateRoutePatterns(routes.map((route) => route.pattern));
+	validateRoutePatterns(routes.flatMap((route) => route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern))));
+	routes.sort(compareRoutes);
+	cachedRoutes = 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)
- */
+* 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 = [];
-    // O(1) lookup for existing routes by pattern — avoids O(n) routes.find() per sub-path per parent.
-    // Updated as new synthetic routes are pushed so that later parents can see earlier synthetic entries.
-    const routesByPattern = new Map(routes.map((r) => [r.pattern, r]));
-    const slotKey = (slotName, ownerDir) => `${slotName}\u0000${ownerDir}`;
-    const applySlotSubPages = (route, slotPages) => {
-        route.parallelSlots = route.parallelSlots.map((slot) => ({
-            ...slot,
-            pagePath: slotPages.get(slotKey(slot.name, slot.ownerDir)) ?? slot.pagePath,
-        }));
-    };
-    for (const parentRoute of routes) {
-        if (parentRoute.parallelSlots.length === 0)
-            continue;
-        if (!parentRoute.pagePath)
-            continue;
-        const parentPageDir = path.dirname(parentRoute.pagePath);
-        // Collect sub-paths from all slots.
-        // Map: normalized visible sub-path -> slot pages, raw filesystem segments (for routeSegments),
-        // and the pre-computed convertedSubRoute (to avoid a redundant re-conversion in the merge loop).
-        const subPathMap = new Map();
-        for (const slot of parentRoute.parallelSlots) {
-            const slotDir = path.join(parentPageDir, `@${slot.name}`);
-            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: new Map(),
-                    };
-                    subPathMap.set(normalizedSubPath, subPathEntry);
-                }
-                const slotId = slotKey(slot.name, slot.ownerDir);
-                const existingSlotPage = subPathEntry.slotPages.get(slotId);
-                if (existingSlotPage) {
-                    const pattern = joinRoutePattern(parentRoute.pattern, normalizedSubPath);
-                    throw new Error(`You cannot have two routes that resolve to the same path ("${pattern}").`);
-                }
-                subPathEntry.slotPages.set(slotId, pagePath);
-            }
-        }
-        if (subPathMap.size === 0)
-            continue;
-        // Find the default.tsx for the children slot at the parent directory
-        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);
-                continue;
-            }
-            // Build parallel slots for this sub-route: matching slots get the sub-page,
-            // non-matching slots get null pagePath (rendering falls back to defaultPath)
-            const subSlots = parentRoute.parallelSlots.map((slot) => ({
-                ...slot,
-                pagePath: slotPages.get(slotKey(slot.name, slot.ownerDir)) || null,
-            }));
-            const newRoute = {
-                pattern,
-                pagePath: childrenDefault, // children slot uses parent's default.tsx as page
-                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],
-                layoutTreePositions: parentRoute.layoutTreePositions,
-                isDynamic: parentRoute.isDynamic || subIsDynamic,
-                params: [...parentRoute.params, ...subParams],
-                patternParts: [...parentRoute.patternParts, ...urlParts],
-            };
-            syntheticRoutes.push(newRoute);
-            routesByPattern.set(pattern, newRoute);
-        }
-    }
-    return syntheticRoutes;
+	const syntheticRoutes = [];
+	const routesByPattern = new Map(routes.map((r) => [r.pattern, r]));
+	const slotKey = (slotName, ownerDir) => `${slotName}\u0000${ownerDir}`;
+	const applySlotSubPages = (route, slotPages) => {
+		route.parallelSlots = route.parallelSlots.map((slot) => ({
+			...slot,
+			pagePath: slotPages.get(slotKey(slot.name, slot.ownerDir)) ?? slot.pagePath
+		}));
+	};
+	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) {
+			const slotDir = path.join(parentPageDir, `@${slot.name}`);
+			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);
+				}
+				const slotId = slotKey(slot.name, slot.ownerDir);
+				if (subPathEntry.slotPages.get(slotId)) {
+					const pattern = joinRoutePattern(parentRoute.pattern, normalizedSubPath);
+					throw new Error(`You cannot have two routes that resolve to the same path ("${pattern}").`);
+				}
+				subPathEntry.slotPages.set(slotId, 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);
+				continue;
+			}
+			const subSlots = parentRoute.parallelSlots.map((slot) => ({
+				...slot,
+				pagePath: slotPages.get(slotKey(slot.name, slot.ownerDir)) || 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],
+				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.
- */
+* 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;
-            // Skip intercepting route directories
-            if (matchInterceptConvention(entry.name))
-                continue;
-            // Skip private folders (prefixed with _)
-            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 });
-            }
-            // Continue scanning deeper for nested sub-pages
-            scan(subDir);
-        }
-    }
-    scan(slotDir);
-    return results;
+	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.
- */
+* Convert a file path relative to app/ into an AppRoute.
+*/
 function fileToAppRoute(file, appDir, type, matcher) {
-    // Remove the filename (page.tsx or route.ts)
-    const dir = path.dirname(file);
-    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("/");
-    // Discover layouts and templates from root to leaf
-    const layouts = discoverLayouts(segments, appDir, matcher);
-    const templates = discoverTemplates(segments, appDir, matcher);
-    // Compute the tree position (directory depth) for each layout.
-    const layoutTreePositions = computeLayoutTreePositions(appDir, layouts);
-    // Discover per-layout error boundaries (aligned with layouts array).
-    // In Next.js, each segment independently wraps its children with an ErrorBoundary.
-    // This array enables interleaving error boundaries with layouts in the rendering.
-    const layoutErrorPaths = discoverLayoutAlignedErrors(segments, appDir, matcher);
-    // Discover loading, error in the route's directory
-    const routeDir = dir === "." ? appDir : path.join(appDir, dir);
-    const loadingPath = findFile(routeDir, "loading", matcher);
-    const errorPath = findFile(routeDir, "error", matcher);
-    // Discover not-found/forbidden/unauthorized: walk from route directory up to root (nearest wins).
-    const notFoundPath = discoverBoundaryFile(segments, appDir, "not-found", matcher);
-    const forbiddenPath = discoverBoundaryFile(segments, appDir, "forbidden", matcher);
-    const unauthorizedPath = discoverBoundaryFile(segments, appDir, "unauthorized", matcher);
-    // Discover per-layout not-found files (one per layout directory).
-    // These are used for per-layout NotFoundBoundary to match Next.js behavior where
-    // notFound() thrown from a layout is caught by the parent layout's boundary.
-    const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
-    // Discover parallel slots (@team, @analytics, etc.).
-    // Slots at the route's own directory use page.tsx; slots at ancestor directories
-    // (inherited from parent layouts) use default.tsx as fallback.
-    const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher);
-    return {
-        pattern: pattern === "/" ? "/" : pattern,
-        pagePath: type === "page" ? path.join(appDir, file) : null,
-        routePath: type === "route" ? path.join(appDir, file) : null,
-        layouts,
-        templates,
-        parallelSlots,
-        loadingPath,
-        errorPath,
-        layoutErrorPaths,
-        notFoundPath,
-        notFoundPaths,
-        forbiddenPath,
-        unauthorizedPath,
-        routeSegments: segments,
-        layoutTreePositions,
-        isDynamic,
-        params,
-        patternParts: urlSegments,
-    };
+	const dir = path.dirname(file);
+	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 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: type === "page" ? path.join(appDir, file) : null,
+		routePath: type === "route" ? path.join(appDir, file) : null,
+		layouts,
+		templates,
+		parallelSlots,
+		loadingPath,
+		errorPath,
+		layoutErrorPaths,
+		notFoundPath,
+		notFoundPaths,
+		forbiddenPath,
+		unauthorizedPath,
+		routeSegments: segments,
+		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.
- */
+* 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;
-        const relative = path.relative(appDir, layoutDir);
-        return relative.split(path.sep).length;
-    });
+	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.
- */
+* 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 = [];
-    // Check root layout
-    const rootLayout = findFile(appDir, "layout", matcher);
-    if (rootLayout)
-        layouts.push(rootLayout);
-    // Check each directory level
-    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;
+	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.
- */
+* 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 = [];
-    // Check root template
-    const rootTemplate = findFile(appDir, "template", matcher);
-    if (rootTemplate)
-        templates.push(rootTemplate);
-    // Check each directory level
-    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;
+	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.
- */
+* 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 = [];
-    // Root level (only if root has a layout — matching discoverLayouts logic)
-    const rootLayout = findFile(appDir, "layout", matcher);
-    if (rootLayout) {
-        errors.push(findFile(appDir, "error", matcher));
-    }
-    // Check each directory level
-    let currentDir = appDir;
-    for (const segment of segments) {
-        currentDir = path.join(currentDir, segment);
-        const layout = findFile(currentDir, "layout", matcher);
-        if (layout) {
-            errors.push(findFile(currentDir, "error", matcher));
-        }
-    }
-    return errors;
+	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.
- */
+* 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) {
-    // Build all directory paths from leaf to root
-    const dirs = [];
-    let dir = appDir;
-    dirs.push(dir);
-    for (const segment of segments) {
-        dir = path.join(dir, segment);
-        dirs.push(dir);
-    }
-    // Walk from leaf (last) to root (first)
-    for (let i = dirs.length - 1; i >= 0; i--) {
-        const f = findFile(dirs[i], fileName, matcher);
-        if (f)
-            return f;
-    }
-    return null;
+	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.
- */
+* 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) => {
-        const layoutDir = path.dirname(layoutPath);
-        return findFile(layoutDir, 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.
- */
+* 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 = new Map();
-    // Walk from appDir through each segment, tracking layout indices.
-    // layoutIndex tracks which position in the route's layouts[] array corresponds
-    // to a given directory. Only directories with a layout.tsx file increment.
-    let currentDir = appDir;
-    const dirsToCheck = [];
-    let layoutIdx = findFile(appDir, "layout", matcher) ? 0 : -1;
-    dirsToCheck.push({ dir: appDir, layoutIdx: Math.max(layoutIdx, 0) });
-    for (const segment of segments) {
-        currentDir = path.join(currentDir, segment);
-        if (findFile(currentDir, "layout", matcher)) {
-            layoutIdx++;
-        }
-        dirsToCheck.push({ dir: currentDir, layoutIdx: Math.max(layoutIdx, 0) });
-    }
-    for (const { dir, layoutIdx: lvlLayoutIdx } of dirsToCheck) {
-        const isOwnDir = dir === routeDir;
-        const slotsAtLevel = discoverParallelSlots(dir, appDir, matcher);
-        for (const slot of slotsAtLevel) {
-            if (isOwnDir) {
-                // At the route's own directory: use page.tsx (normal behavior)
-                slot.layoutIndex = lvlLayoutIdx;
-                slotMap.set(slot.name, slot);
-            }
-            else {
-                // At an ancestor directory: use default.tsx as the page, not page.tsx
-                // (the slot's page.tsx is for the parent route, not this child route)
-                const inheritedSlot = {
-                    ...slot,
-                    pagePath: null, // Don't use ancestor's page.tsx
-                    layoutIndex: lvlLayoutIdx,
-                    // defaultPath, loadingPath, errorPath, interceptingRoutes remain
-                };
-                // Only inherit if we haven't seen this slot at a closer level
-                if (!slotMap.has(slot.name)) {
-                    slotMap.set(slot.name, inheritedSlot);
-                }
-            }
-        }
-    }
-    return Array.from(slotMap.values());
+	const slotMap = /* @__PURE__ */ new Map();
+	let currentDir = appDir;
+	const dirsToCheck = [];
+	let layoutIdx = findFile(appDir, "layout", matcher) ? 0 : -1;
+	dirsToCheck.push({
+		dir: appDir,
+		layoutIdx: Math.max(layoutIdx, 0)
+	});
+	for (const segment of segments) {
+		currentDir = path.join(currentDir, segment);
+		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
+		dirsToCheck.push({
+			dir: currentDir,
+			layoutIdx: Math.max(layoutIdx, 0)
+		});
+	}
+	for (const { dir, layoutIdx: lvlLayoutIdx } of dirsToCheck) {
+		const isOwnDir = dir === routeDir;
+		const slotsAtLevel = discoverParallelSlots(dir, appDir, matcher);
+		for (const slot of slotsAtLevel) if (isOwnDir) {
+			slot.layoutIndex = lvlLayoutIdx;
+			slotMap.set(slot.name, slot);
+		} else {
+			const inheritedSlot = {
+				...slot,
+				pagePath: null,
+				layoutIndex: lvlLayoutIdx
+			};
+			slotMap.set(slot.name, 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.
- */
+* 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); // "@team" -> "team"
-        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);
-        // Only include slots that have at least a page, default, or intercepting route
-        if (!pagePath && !defaultPath && interceptingRoutes.length === 0)
-            continue;
-        slots.push({
-            name: slotName,
-            ownerDir: slotDir,
-            pagePath,
-            defaultPath,
-            layoutPath: findFile(slotDir, "layout", matcher),
-            loadingPath: findFile(slotDir, "loading", matcher),
-            errorPath: findFile(slotDir, "error", matcher),
-            interceptingRoutes,
-            layoutIndex: -1, // Will be set by discoverInheritedParallelSlots
-        });
-    }
-    return slots;
+	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({
+			name: slotName,
+			ownerDir: slotDir,
+			pagePath,
+			defaultPath,
+			layoutPath: findFile(slotDir, "layout", matcher),
+			loadingPath: findFile(slotDir, "loading", matcher),
+			errorPath: findFile(slotDir, "error", matcher),
+			interceptingRoutes,
+			layoutIndex: -1
+		});
+	}
+	return slots;
 }
 /**
- * The interception convention prefix patterns.
- * (.) — same level, (..) — one level up, (..)(..)" — two levels up, (...) — root
- */
+* 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: "." },
+	{
+		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
- */
+* 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 = [];
-    // Recursively scan for page files inside intercepting directories
-    scanForInterceptingPages(slotDir, routeDir, appDir, results, matcher);
-    return results;
+	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.
- */
+* 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;
-        // Skip private folders (prefixed with _)
-        if (entry.name.startsWith("_"))
-            continue;
-        // Check if this directory name starts with an interception convention
-        const interceptMatch = matchInterceptConvention(entry.name);
-        if (interceptMatch) {
-            // This directory is the start of an intercepting route
-            // e.g. "(.)photos" means intercept same-level "photos" route
-            const restOfName = entry.name.slice(interceptMatch.prefix.length);
-            const interceptDir = path.join(currentDir, entry.name);
-            // Find page files within this intercepting directory tree
-            collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, results, matcher);
-        }
-        else {
-            // Regular subdirectory — keep scanning for intercepting dirs
-            scanForInterceptingPages(path.join(currentDir, entry.name), 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.
- */
+* 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;
+	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.
- */
+* 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) {
-    // Check for page.tsx in current directory
-    const page = findFile(currentDir, "page", matcher);
-    if (page) {
-        const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
-        if (targetPattern) {
-            results.push({
-                convention,
-                targetPattern: targetPattern.pattern,
-                pagePath: page,
-                params: targetPattern.params,
-            });
-        }
-    }
-    // Recurse into subdirectories for nested intercepting routes
-    if (!fs.existsSync(currentDir))
-        return;
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        // Skip private folders (prefixed with _)
-        if (entry.name.startsWith("_"))
-            continue;
-        collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, results, matcher);
-    }
+	const page = findFile(currentDir, "page", matcher);
+	if (page) {
+		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
+		if (targetPattern) results.push({
+			convention,
+			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);
+	}
 }
 /**
- * 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.
- */
+* 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;
+	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
- */
+* 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) {
-    // Determine the base segments for target resolution.
-    // We work on route segments (not filesystem paths) so that route groups
-    // and parallel slots are properly skipped when climbing.
-    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;
-    }
-    // Add the intercept segment and any nested path segments
-    const nestedParts = path.relative(interceptRoot, currentDir).split(path.sep).filter(Boolean);
-    const allSegments = [...baseParts, interceptSegment, ...nestedParts];
-    const convertedTarget = convertSegmentsToRouteParts(allSegments);
-    if (!convertedTarget)
-        return null;
-    const { urlSegments, params } = convertedTarget;
-    const pattern = "/" + urlSegments.join("/");
-    return { pattern: pattern === "/" ? "/" : pattern, params };
+	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.
- */
+* 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;
+	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+").
- */
+* 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;
-        // Catch-all segments are only valid in terminal URL position.
-        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 };
+	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;
+	for (let i = startIndex; i < segments.length; i++) if (!isInvisibleSegment(segments[i])) return true;
+	return false;
 }
-// Trie cache — keyed by route array identity (same array = same trie)
-const appTrieCache = new WeakMap();
+const appTrieCache = /* @__PURE__ */ new WeakMap();
 function getOrBuildAppTrie(routes) {
-    let trie = appTrieCache.get(routes);
-    if (!trie) {
-        trie = buildRouteTrie(routes);
-        appTrieCache.set(routes, trie);
-    }
-    return trie;
+	let trie = appTrieCache.get(routes);
+	if (!trie) {
+		trie = buildRouteTrie(routes);
+		appTrieCache.set(routes, trie);
+	}
+	return trie;
 }
 function joinRoutePattern(basePattern, subPath) {
-    if (!subPath)
-        return basePattern;
-    return basePattern === "/" ? `/${subPath}` : `${basePattern}/${subPath}`;
+	if (!subPath) return basePattern;
+	return basePattern === "/" ? `/${subPath}` : `${basePattern}/${subPath}`;
 }
 /**
- * Match a URL against App Router routes.
- */
-export function matchAppRoute(url, routes) {
-    const pathname = url.split("?")[0];
-    let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\/$/, "");
-    normalizedUrl = normalizePathnameForRouteMatch(normalizedUrl);
-    // Split URL once, look up via trie
-    const urlParts = normalizedUrl.split("/").filter(Boolean);
-    const trie = getOrBuildAppTrie(routes);
-    return trieMatch(trie, urlParts);
+* Match a URL against App Router routes.
+*/
+function matchAppRoute(url, routes) {
+	const pathname = url.split("?")[0];
+	let normalizedUrl = pathname === "/" ? "/" : pathname.replace(/\/$/, "");
+	normalizedUrl = normalizePathnameForRouteMatch(normalizedUrl);
+	const urlParts = normalizedUrl.split("/").filter(Boolean);
+	return trieMatch(getOrBuildAppTrie(routes), urlParts);
 }
+//#endregion
+export { appRouter, invalidateAppRouteCache, matchAppRoute };
+
 //# sourceMappingURL=app-router.js.map