vinext 1.0.0-beta.1 → 1.0.0-beta.2

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

@@ -25,7 +25,10 @@ type InterceptingRoute = {
   sourcePageSegments?: string[]; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Normalized branch segments accumulated at each intercept layout. */
   layoutSegments?: string[][]; /** Full normalized interception branch segments through the page. */
-  branchSegments?: string[]; /** Parameter names for dynamic segments */
+  branchSegments?: string[]; /** Nearest not-found convention inside the interception branch. */
+  notFoundPath?: string | null; /** Slot-root-relative branch segments used to scope not-found params. */
+  notFoundBranchSegments?: string[]; /** Tree position relative to the normalized interception branch. */
+  notFoundTreePosition?: number | null; /** Parameter names for dynamic segments */
   params: string[];
   /**
    * Synthetic page-carrier slot id for sibling (slot-less) interception.
@@ -46,7 +49,9 @@ type ParallelSlot = {
   configLayoutPaths?: string[]; /** Tree positions of configLayoutPaths relative to the slot root. */
   configLayoutTreePositions?: number[]; /** Absolute path to the slot's loading component */
   loadingPath: string | null; /** Absolute path to the slot's error component */
-  errorPath: string | null; /** Intercepting routes within this slot */
+  errorPath: string | null; /** Nearest not-found convention for the slot's active branch. */
+  notFoundPath?: string | null; /** Tree position of that convention relative to the slot root. */
+  notFoundTreePosition?: number | null; /** Intercepting routes within this slot */
   interceptingRoutes: InterceptingRoute[];
   /**
    * The layout index (0-based, in route.layouts[]) that this slot belongs to.
@@ -105,7 +110,8 @@ type AppRoute = {
   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;
+  notFoundPath: string | null; /** Tree position of the nearest not-found component's owning segment. */
+  notFoundTreePosition?: number | null;
   /**
    * Not-found component paths per layout level (aligned with layouts array).
    * Each entry is the not-found.tsx at that layout's directory, or null.
@@ -119,8 +125,10 @@ type AppRoute = {
    * Used to create per-layout ForbiddenBoundary.
    */
   forbiddenPaths: (string | null)[]; /** Forbidden component path (403) at the route's directory level */
-  forbiddenPath: string | null; /** Unauthorized component path (401) at the route's directory level */
-  unauthorizedPath: string | null; /** Unauthorized component paths per layout level (aligned with layouts array). */
+  forbiddenPath: string | null; /** Tree position of the nearest forbidden component's owning segment. */
+  forbiddenTreePosition?: number | null; /** Unauthorized component path (401) at the route's directory level */
+  unauthorizedPath: string | null; /** Tree position of the nearest unauthorized component's owning segment. */
+  unauthorizedTreePosition?: number | null; /** Unauthorized component paths per layout level (aligned with layouts array). */
   unauthorizedPaths: (string | null)[];
   /**
    * Filesystem segments from app/ root to the route's directory.

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

@@ -459,11 +459,14 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subPage = slotPages.get(slot.key);
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
+				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
 				return {
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					notFoundPath: notFoundBoundary.path,
+					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
 				};
 			}
@@ -545,11 +548,14 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
+				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
 				return {
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					notFoundPath: notFoundBoundary.path,
+					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
 				};
 			});
@@ -578,10 +584,13 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				errorPath: parentRoute.errorPath,
 				layoutErrorPaths: parentRoute.layoutErrorPaths,
 				notFoundPath: parentRoute.notFoundPath,
+				notFoundTreePosition: parentRoute.notFoundTreePosition,
 				notFoundPaths: parentRoute.notFoundPaths,
 				forbiddenPaths: parentRoute.forbiddenPaths,
 				forbiddenPath: parentRoute.forbiddenPath,
+				forbiddenTreePosition: parentRoute.forbiddenTreePosition,
 				unauthorizedPath: parentRoute.unauthorizedPath,
+				unauthorizedTreePosition: parentRoute.unauthorizedTreePosition,
 				unauthorizedPaths: parentRoute.unauthorizedPaths,
 				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 				childrenRouteSegments: childrenDefault ? parentRoute.routeSegments : void 0,
@@ -669,6 +678,25 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
 	});
 }
+function findSlotNotFoundBoundary(slotDir, pagePath, matcher) {
+	let dir = pagePath ? path.dirname(pagePath) : slotDir;
+	while (dir === slotDir || dir.startsWith(`${slotDir}${path.sep}`)) {
+		const boundaryPath = findFile(dir, "not-found", matcher);
+		if (boundaryPath) {
+			const relativeDir = path.relative(slotDir, dir);
+			return {
+				path: boundaryPath,
+				treePosition: relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0
+			};
+		}
+		if (dir === slotDir) break;
+		dir = path.dirname(dir);
+	}
+	return {
+		path: null,
+		treePosition: null
+	};
+}
 /**
 * Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
 * `[[...slug]]` directory that contains a `page` file. Returns the absolute
@@ -730,9 +758,12 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const effectivePagePath = pagePath ?? (routePath ? null : findFile(routeDir, "default", matcher));
 	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 notFoundEntry = discoverBoundaryFileEntry(segments, appDir, "not-found", matcher);
+	const notFoundPath = notFoundEntry?.path ?? null;
+	const forbiddenEntry = discoverBoundaryFileEntry(segments, appDir, "forbidden", matcher);
+	const forbiddenPath = forbiddenEntry?.path ?? null;
+	const unauthorizedEntry = discoverBoundaryFileEntry(segments, appDir, "unauthorized", matcher);
+	const unauthorizedPath = unauthorizedEntry?.path ?? null;
 	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
 	const forbiddenPaths = discoverBoundaryFilePerLayout(layouts, "forbidden", matcher);
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
@@ -759,10 +790,13 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		errorPaths,
 		errorTreePositions,
 		notFoundPath,
+		notFoundTreePosition: notFoundEntry?.treePosition ?? null,
 		notFoundPaths,
 		forbiddenPaths,
 		forbiddenPath,
+		forbiddenTreePosition: forbiddenEntry?.treePosition ?? null,
 		unauthorizedPath,
+		unauthorizedTreePosition: unauthorizedEntry?.treePosition ?? null,
 		unauthorizedPaths,
 		routeSegments: segments,
 		templateTreePositions,
@@ -921,7 +955,7 @@ function discoverLayoutAlignedErrors(segments, appDir, matcher) {
 * 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) {
+function discoverBoundaryFileEntry(segments, appDir, fileName, matcher) {
 	const dirs = [];
 	let dir = appDir;
 	dirs.push(dir);
@@ -931,7 +965,10 @@ function discoverBoundaryFile(segments, appDir, fileName, matcher) {
 	}
 	for (let i = dirs.length - 1; i >= 0; i--) {
 		const f = findFile(dirs[i], fileName, matcher);
-		if (f) return f;
+		if (f) return {
+			path: f,
+			treePosition: i
+		};
 	}
 	return null;
 }
@@ -1172,6 +1209,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
+		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir)}`,
@@ -1186,6 +1224,8 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
 			errorPath: findFile(slotDir, "error", matcher),
+			notFoundPath: notFoundBoundary.path,
+			notFoundTreePosition: notFoundBoundary.treePosition,
 			interceptingRoutes,
 			layoutIndex: -1,
 			routeSegments: pagePath ? [] : null
@@ -1240,7 +1280,7 @@ function isInterceptionMarkerDir(name) {
 function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 	if (!fs.existsSync(slotDir)) return [];
 	const results = [];
-	scanForInterceptingPages(slotDir, routeDir, appDir, results, matcher);
+	scanForInterceptingPages(slotDir, slotDir, routeDir, appDir, results, matcher);
 	return results;
 }
 /**
@@ -1277,7 +1317,7 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 				const restOfName = entry.name.slice(marker.prefix.length);
 				const parentDir = dir;
 				const results = [];
-				collectInterceptingPages(childDir, childDir, marker.convention, restOfName, parentDir, appDir, parentDir, results, matcher);
+				collectInterceptingPages(childDir, childDir, marker.convention, restOfName, parentDir, appDir, parentDir, null, results, matcher);
 				for (const ir of results) {
 					ir.slotId = createAppRouteGraphSiblingInterceptSlotId(ir.sourceMatchPattern);
 					const owner = findOwnerRouteForDir(parentDir, appDir, routes, routesByDir);
@@ -1334,7 +1374,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
-function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1344,8 +1384,8 @@ function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher
 		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, results, matcher);
-		} else scanForInterceptingPages(interceptDir, routeDir, appDir, results, matcher);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher);
+		} else scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher);
 	}
 }
 /**
@@ -1359,7 +1399,7 @@ 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, interceptParentDir, results, matcher, parentLayoutPaths = []) {
+function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, parentLayoutPaths = []) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
 	const page = findFile(currentDir, "page", matcher);
@@ -1367,13 +1407,19 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
+			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
+			const branchSegments = [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)];
+			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
 			results.push({
-				branchSegments: [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)],
+				branchSegments,
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
 					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
 				}),
+				notFoundBranchSegments: [...slotParentSegments, ...branchSegments],
+				notFoundPath: notFoundBoundary.path,
+				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
@@ -1387,7 +1433,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 	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, interceptParentDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, layoutPaths);
 	}
 }
 /**

package/dist/routing/app-router.js

@@ -20,7 +20,9 @@ import { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamName
 let cachedGraph = null;
 let cachedAppDir = null;
 let cachedPageExtensionsKey = null;
+let cacheGeneration = 0;
 function invalidateAppRouteCache() {
+	cacheGeneration++;
 	cachedGraph = null;
 	cachedAppDir = null;
 	cachedPageExtensionsKey = null;
@@ -35,12 +37,16 @@ function invalidateAppRouteCache() {
 async function appRouteGraph(appDir, pageExtensions, matcher) {
 	matcher ??= createValidFileMatcher(pageExtensions);
 	const pageExtensionsKey = JSON.stringify(matcher.extensions);
-	if (cachedGraph && cachedAppDir === appDir && cachedPageExtensionsKey === pageExtensionsKey) return cachedGraph;
-	const graph = await buildAppRouteGraph(appDir, matcher);
-	cachedGraph = graph;
-	cachedAppDir = appDir;
-	cachedPageExtensionsKey = pageExtensionsKey;
-	return graph;
+	while (true) {
+		if (cachedGraph && cachedAppDir === appDir && cachedPageExtensionsKey === pageExtensionsKey) return cachedGraph;
+		const scanGeneration = cacheGeneration;
+		const graph = await buildAppRouteGraph(appDir, matcher);
+		if (scanGeneration !== cacheGeneration) continue;
+		cachedGraph = graph;
+		cachedAppDir = appDir;
+		cachedPageExtensionsKey = pageExtensionsKey;
+		return graph;
+	}
 }
 /**
 * Scan the app/ directory and return a list of routes.

package/dist/routing/file-matcher.d.ts

@@ -24,32 +24,21 @@ declare function findFileWithExtensions(basePath: string, matcher: ValidFileMatc
  */
 declare function findFileWithExts(dir: string, name: string, matcher: ValidFileMatcher): string | null;
 /**
- * Vite's default `resolve.extensions` covers `.tsx/.ts/.jsx/.js/.json` (and
- * `.mjs/.mts`). When the user configures `pageExtensions` with values Vite
- * does not know about — e.g. `["platform.tsx", "tsx", "mdx"]` from the
- * Next.js `resolve-extensions` fixture — extensionless imports of those
- * files fail to resolve, and the build crashes with "Custom deploy script
- * failed: undefined (1)".
+ * Add the config extensions produced by `vinext init` to vinext's resolver.
  *
- * Build the merged extension list that Vite should use:
+ * `pageExtensions` is intentionally not part of module resolution. Next.js
+ * uses it to discover route files; custom module extensions are configured
+ * separately through `turbopack.resolveExtensions` or webpack
+ * `resolve.extensions`.
  *
- *  1. User-configured pageExtensions go first (each prefixed with `.`) so
- *     the user's priority wins. e.g. `.platform.tsx` resolves before `.tsx`.
- *  2. Vite's defaults follow, with duplicates removed.
- *  3. `.cjs`/`.cts` go last (lowest priority). Neither Vite's defaults nor the
- *     user's pageExtensions include them, but `vinext init` renames CJS config
- *     files (e.g. `tailwind.config.js` → `tailwind.config.cjs`) when it adds
- *     `"type": "module"`, and app code imports those extensionlessly
- *     (`import cfg from "../tailwind.config"`). Without these, the bundle fails
- *     with "[UNRESOLVED_IMPORT] Could not resolve '../tailwind.config'".
+ * The default order preserves vinext's existing module-resolution behavior
+ * and matches Next.js Turbopack for overlapping JavaScript and TypeScript
+ * extensions.
  *
- * The user's pageExtensions retain their relative order, which is what
- * Next.js / Turbopack do via the `resolveExtensions` config option.
- *
- * See: cloudflare/vinext#1502 for page-extension ordering, and
- * cloudflare/vinext#2435 for extensionless `.cjs` config imports.
+ * `.cjs`/`.cts` go last because `vinext init` renames CJS config files when it
+ * adds `"type": "module"`, and app code may import those files extensionlessly.
  */
-declare function buildViteResolveExtensions(pageExtensions?: readonly string[] | null, viteDefaults?: readonly string[]): string[];
+declare function buildViteResolveExtensions(viteExtensions?: readonly string[]): string[];
 /**
  * Normalize an explicit Next.js resolver extension list for Vite.
  *

package/dist/routing/file-matcher.js

@@ -9,6 +9,15 @@ const DEFAULT_PAGE_EXTENSIONS = [
 	"jsx",
 	"js"
 ];
+const DEFAULT_VINEXT_RESOLVE_EXTENSIONS = [
+	".tsx",
+	".ts",
+	".jsx",
+	".js",
+	".mjs",
+	".mts",
+	".json"
+];
 function normalizePageExtensions(pageExtensions) {
 	if (!Array.isArray(pageExtensions) || pageExtensions.length === 0) return [...DEFAULT_PAGE_EXTENSIONS];
 	const filtered = pageExtensions.filter((ext) => typeof ext === "string").map((ext) => ext.trim().replace(/^\.+/, "")).filter((ext) => ext.length > 0);
@@ -79,46 +88,25 @@ function findFileWithExts(dir, name, matcher) {
 	return null;
 }
 /**
-* Vite's default `resolve.extensions` covers `.tsx/.ts/.jsx/.js/.json` (and
-* `.mjs/.mts`). When the user configures `pageExtensions` with values Vite
-* does not know about — e.g. `["platform.tsx", "tsx", "mdx"]` from the
-* Next.js `resolve-extensions` fixture — extensionless imports of those
-* files fail to resolve, and the build crashes with "Custom deploy script
-* failed: undefined (1)".
+* Add the config extensions produced by `vinext init` to vinext's resolver.
 *
-* Build the merged extension list that Vite should use:
+* `pageExtensions` is intentionally not part of module resolution. Next.js
+* uses it to discover route files; custom module extensions are configured
+* separately through `turbopack.resolveExtensions` or webpack
+* `resolve.extensions`.
 *
-*  1. User-configured pageExtensions go first (each prefixed with `.`) so
-*     the user's priority wins. e.g. `.platform.tsx` resolves before `.tsx`.
-*  2. Vite's defaults follow, with duplicates removed.
-*  3. `.cjs`/`.cts` go last (lowest priority). Neither Vite's defaults nor the
-*     user's pageExtensions include them, but `vinext init` renames CJS config
-*     files (e.g. `tailwind.config.js` → `tailwind.config.cjs`) when it adds
-*     `"type": "module"`, and app code imports those extensionlessly
-*     (`import cfg from "../tailwind.config"`). Without these, the bundle fails
-*     with "[UNRESOLVED_IMPORT] Could not resolve '../tailwind.config'".
+* The default order preserves vinext's existing module-resolution behavior
+* and matches Next.js Turbopack for overlapping JavaScript and TypeScript
+* extensions.
 *
-* The user's pageExtensions retain their relative order, which is what
-* Next.js / Turbopack do via the `resolveExtensions` config option.
-*
-* See: cloudflare/vinext#1502 for page-extension ordering, and
-* cloudflare/vinext#2435 for extensionless `.cjs` config imports.
+* `.cjs`/`.cts` go last because `vinext init` renames CJS config files when it
+* adds `"type": "module"`, and app code may import those files extensionlessly.
 */
-function buildViteResolveExtensions(pageExtensions, viteDefaults = [
-	".mjs",
-	".js",
-	".mts",
-	".ts",
-	".jsx",
-	".tsx",
-	".json"
-]) {
-	const dotted = normalizePageExtensions(pageExtensions).map((ext) => `.${ext}`);
+function buildViteResolveExtensions(viteExtensions = DEFAULT_VINEXT_RESOLVE_EXTENSIONS) {
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
 	for (const ext of [
-		...dotted,
-		...viteDefaults,
+		...viteExtensions,
 		".cjs",
 		".cts"
 	]) {

package/dist/routing/pages-router.js

@@ -2,7 +2,7 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { decodeRouteSegment, sortRoutes } from "./utils.js";
 import { createValidFileMatcher, scanWithExtensions } from "./file-matcher.js";
 import { patternToNextFormat, validateRoutePatterns } from "./route-validation.js";
-import { createRouteTrieCache, matchRouteWithTrie } from "./route-matching.js";
+import { createRouteTrieCache, matchRouteWithTrieRawPathname } from "./route-matching.js";
 //#region src/routing/pages-router.ts
 /** Next.js special pages that should not produce routes. */
 const RESERVED_PAGE_NAMES = /* @__PURE__ */ new Set([
@@ -11,11 +11,13 @@ const RESERVED_PAGE_NAMES = /* @__PURE__ */ new Set([
 	"_error"
 ]);
 const routeCache = /* @__PURE__ */ new Map();
+let routeCacheGeneration = 0;
 /**
 * Invalidate cached routes for a given pages directory.
 * Called by the file watcher when pages are added/removed.
 */
 function invalidateRouteCache(pagesDir) {
+	routeCacheGeneration++;
 	for (const key of routeCache.keys()) if (key.startsWith(`pages:${pagesDir}:`) || key.startsWith(`api:${pagesDir}:`)) routeCache.delete(key);
 }
 /**
@@ -32,20 +34,7 @@ function invalidateRouteCache(pagesDir) {
 */
 async function pagesRouter(pagesDir, pageExtensions, matcher) {
 	matcher ??= createValidFileMatcher(pageExtensions);
-	const cacheKey = `pages:${pagesDir}:${JSON.stringify(matcher.extensions)}`;
-	const cached = routeCache.get(cacheKey);
-	if (cached) return cached.promise;
-	const promise = scanPageRoutes(pagesDir, matcher);
-	routeCache.set(cacheKey, {
-		routes: [],
-		promise
-	});
-	const routes = await promise;
-	routeCache.set(cacheKey, {
-		routes,
-		promise
-	});
-	return routes;
+	return getCachedRoutes(`pages:${pagesDir}:${JSON.stringify(matcher.extensions)}`, () => scanPageRoutes(pagesDir, matcher));
 }
 async function scanPageRoutes(pagesDir, matcher) {
 	const routes = [];
@@ -114,7 +103,7 @@ const trieCache = createRouteTrieCache();
 * Returns the matched params or null if no match.
 */
 function matchRoute(url, routes) {
-	return matchRouteWithTrie(url, routes, trieCache);
+	return matchRouteWithTrieRawPathname(url, routes, trieCache);
 }
 /**
 * Scan the pages/api/ directory and return API routes.
@@ -126,20 +115,25 @@ function matchRoute(url, routes) {
 */
 async function apiRouter(pagesDir, pageExtensions, matcher) {
 	matcher ??= createValidFileMatcher(pageExtensions);
-	const cacheKey = `api:${pagesDir}:${JSON.stringify(matcher.extensions)}`;
+	return getCachedRoutes(`api:${pagesDir}:${JSON.stringify(matcher.extensions)}`, () => scanApiRoutes(pagesDir, matcher));
+}
+async function getCachedRoutes(cacheKey, scan) {
 	const cached = routeCache.get(cacheKey);
-	if (cached) return cached.promise;
-	const promise = scanApiRoutes(pagesDir, matcher);
-	routeCache.set(cacheKey, {
-		routes: [],
-		promise
-	});
-	const routes = await promise;
-	routeCache.set(cacheKey, {
-		routes,
-		promise
-	});
-	return routes;
+	if (cached) return cached;
+	const promise = (async () => {
+		while (true) {
+			const scanGeneration = routeCacheGeneration;
+			const routes = await scan();
+			if (scanGeneration === routeCacheGeneration) return routes;
+		}
+	})();
+	routeCache.set(cacheKey, promise);
+	try {
+		return await promise;
+	} catch (error) {
+		if (routeCache.get(cacheKey) === promise) routeCache.delete(cacheKey);
+		throw error;
+	}
 }
 async function scanApiRoutes(pagesDir, matcher) {
 	const apiDir = path.join(pagesDir, "api");

package/dist/routing/route-matching.d.ts

@@ -23,5 +23,18 @@ declare function matchRouteWithTrie<R extends {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
+/**
+ * Match a filesystem route against the request's raw encoded pathname.
+ *
+ * Next.js compares static route identity before decoding, so `/%61bout` does
+ * not select the filesystem route `/about`. Dynamic captures are still decoded
+ * exactly once by `trieMatch`, matching `getRouteMatcher` upstream.
+ */
+declare function matchRouteWithTrieRawPathname<R extends {
+  patternParts: string[];
+}>(url: string, routes: R[], cache: RouteTrieCache<R>): {
+  route: R;
+  params: Record<string, string | string[]>;
+} | null;
 //#endregion
-export { createRouteTrieCache, matchRouteWithTrie };
+export { createRouteTrieCache, matchRouteWithTrie, matchRouteWithTrieRawPathname };

package/dist/routing/route-matching.js

@@ -38,5 +38,17 @@ function matchRouteWithTrie(url, routes, cache) {
 	const urlParts = normalizedUrl.split("/").filter(Boolean);
 	return trieMatch(getOrBuildTrie(cache, routes), urlParts);
 }
+/**
+* Match a filesystem route against the request's raw encoded pathname.
+*
+* Next.js compares static route identity before decoding, so `/%61bout` does
+* not select the filesystem route `/about`. Dynamic captures are still decoded
+* exactly once by `trieMatch`, matching `getRouteMatcher` upstream.
+*/
+function matchRouteWithTrieRawPathname(url, routes, cache) {
+	const pathname = url.split("?")[0];
+	const urlParts = (pathname === "/" ? "/" : pathname.replace(/\/$/, "")).split("/").filter(Boolean);
+	return trieMatch(getOrBuildTrie(cache, routes), urlParts);
+}
 //#endregion
-export { createRouteTrieCache, matchRouteWithTrie };
+export { createRouteTrieCache, matchRouteWithTrie, matchRouteWithTrieRawPathname };

package/dist/routing/route-pattern.d.ts

@@ -4,6 +4,7 @@ declare function routePatternParts(pathname: string): string[];
 declare function routePattern(pathname: string): string;
 declare function fillRoutePatternSegments(pathname: string, params: RoutePatternParams): string | null;
 declare function matchRoutePattern(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
+declare function matchRoutePatternRaw(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
 declare function matchRoutePatternPrefix(pathParts: readonly string[], patternParts: readonly string[]): boolean;
 declare function matchRoutePatternWithOptionalDynamicSegments(pathParts: readonly string[], patternParts: readonly string[]): boolean;
 /**
@@ -61,4 +62,4 @@ declare function normalizeStaticPathname(pathname: string): string;
  */
 declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
 //#endregion
-export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
+export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternRaw, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/routing/route-pattern.js

@@ -56,6 +56,11 @@ function fillRoutePatternSegments(pathname, params) {
 	return resolvedSegments.length > 0 ? `/${resolvedSegments.join("/")}` : "/";
 }
 function matchRoutePattern(urlParts, patternParts) {
+	const params = matchRoutePatternRaw(urlParts, patternParts);
+	if (params) decodeMatchedParams(params);
+	return params;
+}
+function matchRoutePatternRaw(urlParts, patternParts) {
 	const params = Object.create(null);
 	function matchFrom(urlIndex, patternIndex) {
 		if (patternIndex === patternParts.length) return urlIndex === urlParts.length;
@@ -83,9 +88,7 @@ function matchRoutePattern(urlParts, patternParts) {
 		if (urlIndex >= urlParts.length || urlParts[urlIndex] !== patternPart) return false;
 		return matchFrom(urlIndex + 1, patternIndex + 1);
 	}
-	if (!matchFrom(0, 0)) return null;
-	decodeMatchedParams(params);
-	return params;
+	return matchFrom(0, 0) ? params : null;
 }
 function matchRoutePatternPrefix(pathParts, patternParts) {
 	let pathIndex = 0;
@@ -162,4 +165,4 @@ function normalizeStaticPathsEntry(entry, routePattern) {
 	return { params };
 }
 //#endregion
-export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
+export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternRaw, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/routing/route-trie.d.ts

@@ -63,5 +63,9 @@ declare function trieMatch<R>(root: TrieNode<R>, urlParts: string[]): {
   route: R;
   params: Record<string, string | string[]>;
 } | null;
+declare function trieMatchRaw<R>(root: TrieNode<R>, urlParts: string[]): {
+  route: R;
+  params: Record<string, string | string[]>;
+} | null;
 //#endregion
-export { TrieNode, buildRouteTrie, trieMatch };
+export { TrieNode, buildRouteTrie, trieMatch, trieMatchRaw };

package/dist/routing/route-trie.js

@@ -92,10 +92,13 @@ function buildRouteTrie(routes) {
 * @returns Match result with route and extracted params, or null
 */
 function trieMatch(root, urlParts) {
-	const result = match(root, urlParts, 0, []);
+	const result = trieMatchRaw(root, urlParts);
 	if (result) decodeMatchedParams(result.params);
 	return result;
 }
+function trieMatchRaw(root, urlParts) {
+	return match(root, urlParts, 0, []);
+}
 function match(node, urlParts, index, entries) {
 	if (index === urlParts.length) {
 		if (node.route !== null) return {
@@ -140,4 +143,4 @@ function match(node, urlParts, index, entries) {
 	return null;
 }
 //#endregion
-export { buildRouteTrie, trieMatch };
+export { buildRouteTrie, trieMatch, trieMatchRaw };