vinext 1.0.0-beta.1 → 1.0.0-beta.3

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

@@ -459,13 +459,16 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subPage = slotPages.get(slot.key);
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
-				return {
+				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
+				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					notFoundPath: notFoundBoundary.path,
+					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
-				};
+				}, subPage, matcher);
 			}
 			return slot;
 		});
@@ -545,13 +548,16 @@ 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);
-				return {
+				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
+				return withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					notFoundPath: notFoundBoundary.path,
+					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
-				};
+				}, subPage ?? null, matcher);
 			});
 			const newRoute = {
 				ids: createAppRouteSemanticIds({
@@ -574,14 +580,19 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					ownerTreePath: childrenOwnerTreePath,
 					state: childrenDefault ? "default" : childrenCatchAll ? "active" : "unmatched"
 				},
-				loadingPath: parentRoute.loadingPath,
+				loadingPath: null,
+				loadingPaths: parentRoute.loadingPaths,
+				loadingTreePositions: parentRoute.loadingTreePositions,
 				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 +680,55 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
 	});
 }
+function findSlotLoadingEntries(slotDir, pagePath, matcher) {
+	const pageDir = pagePath ? path.dirname(pagePath) : slotDir;
+	if (pageDir !== slotDir && !pageDir.startsWith(`${slotDir}${path.sep}`)) return [];
+	const relativeDir = path.relative(slotDir, pageDir);
+	const segments = relativeDir ? relativeDir.split(path.sep).filter(Boolean) : [];
+	const loadings = [];
+	let currentDir = slotDir;
+	const rootLoading = findFile(currentDir, "loading", matcher);
+	if (rootLoading) loadings.push({
+		path: rootLoading,
+		treePosition: 0
+	});
+	for (let index = 0; index < segments.length; index++) {
+		currentDir = path.join(currentDir, segments[index]);
+		const loading = findFile(currentDir, "loading", matcher);
+		if (loading) loadings.push({
+			path: loading,
+			treePosition: index + 1
+		});
+	}
+	return loadings;
+}
+function withSlotLoadingEntries(slot, pagePath, matcher) {
+	const loadingEntries = findSlotLoadingEntries(slot.ownerDir, pagePath, matcher);
+	return {
+		...slot,
+		loadingPaths: loadingEntries.map((entry) => entry.path),
+		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition)
+	};
+}
+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
@@ -723,6 +783,9 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const templateTreePositions = computeLayoutTreePositions(appDir, templates);
 	const layoutTreePositions = computeLayoutTreePositions(appDir, layouts);
 	const layoutErrorPaths = discoverLayoutAlignedErrors(segments, appDir, matcher);
+	const loadingEntries = discoverSegmentLoadings(segments, appDir, matcher);
+	const loadingPaths = loadingEntries.map((entry) => entry.path);
+	const loadingTreePositions = loadingEntries.map((entry) => entry.treePosition);
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
@@ -730,9 +793,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);
@@ -754,15 +820,20 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		templates,
 		parallelSlots,
 		loadingPath,
+		loadingPaths,
+		loadingTreePositions,
 		errorPath,
 		layoutErrorPaths,
 		errorPaths,
 		errorTreePositions,
 		notFoundPath,
+		notFoundTreePosition: notFoundEntry?.treePosition ?? null,
 		notFoundPaths,
 		forbiddenPaths,
 		forbiddenPath,
+		forbiddenTreePosition: forbiddenEntry?.treePosition ?? null,
 		unauthorizedPath,
+		unauthorizedTreePosition: unauthorizedEntry?.treePosition ?? null,
 		unauthorizedPaths,
 		routeSegments: segments,
 		templateTreePositions,
@@ -899,6 +970,31 @@ function discoverSegmentErrors(segments, appDir, matcher) {
 	return errors;
 }
 /**
+* Discover loading.tsx files by segment tree position.
+*
+* Loading conventions belong to loader-tree segments rather than layouts. A
+* segment without layout.tsx can therefore provide the boundary that suspends
+* while its child layout renders.
+*/
+function discoverSegmentLoadings(segments, appDir, matcher) {
+	const loadings = [];
+	const rootLoading = findFile(appDir, "loading", matcher);
+	if (rootLoading) loadings.push({
+		path: rootLoading,
+		treePosition: 0
+	});
+	let currentDir = appDir;
+	for (let index = 0; index < segments.length; index++) {
+		currentDir = path.join(currentDir, segments[index]);
+		const loading = findFile(currentDir, "loading", matcher);
+		if (loading) loadings.push({
+			path: loading,
+			treePosition: index + 1
+		});
+	}
+	return loadings;
+}
+/**
 * Discover error.tsx files aligned with the layouts array.
 *
 * Route manifests still model layout-owned boundary facts by layout index.
@@ -921,7 +1017,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 +1027,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;
 }
@@ -1000,7 +1099,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
 			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
-			const inheritedSlot = {
+			const inheritedSlot = withSlotLoadingEntries({
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
 				configLayoutPaths,
@@ -1009,7 +1108,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
 				slotParamNames
-			};
+			}, mirror?.pagePath ?? null, matcher);
 			slotMap.set(slot.key, inheritedSlot);
 		}
 	}
@@ -1172,12 +1271,15 @@ 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 loadingEntries = findSlotLoadingEntries(slotDir, pagePath, matcher);
+		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir)}`,
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
+			ownerTreePosition: ownerSegments.length,
 			hasPage: pagePath !== null,
 			pagePath,
 			defaultPath,
@@ -1185,7 +1287,11 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			configLayoutPaths,
 			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
+			loadingPaths: loadingEntries.map((loading) => loading.path),
+			loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 			errorPath: findFile(slotDir, "error", matcher),
+			notFoundPath: notFoundBoundary.path,
+			notFoundTreePosition: notFoundBoundary.treePosition,
 			interceptingRoutes,
 			layoutIndex: -1,
 			routeSegments: pagePath ? [] : null
@@ -1240,7 +1346,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 +1383,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 +1440,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, parentLoadingEntries = []) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1344,8 +1450,14 @@ 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, [], parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
+		} else {
+			const loading = findFile(interceptDir, "loading", matcher);
+			scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher, loading ? [...parentLoadingEntries, {
+				path: loading,
+				treePosition: path.relative(slotRootDir, interceptDir).split(path.sep).filter(Boolean).length
+			}] : parentLoadingEntries);
+		}
 	}
 }
 /**
@@ -1359,21 +1471,45 @@ 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 = [], parentLoadingEntries = [], treePositionOffset = 0) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
+	const currentLoadingPath = findFile(currentDir, "loading", matcher);
+	const relativeCurrentDir = path.relative(interceptRoot, currentDir);
+	const currentTreePosition = treePositionOffset + 1 + (relativeCurrentDir ? relativeCurrentDir.split(path.sep).filter(Boolean).length : 0);
+	const loadingEntries = currentLoadingPath ? [...parentLoadingEntries, {
+		path: currentLoadingPath,
+		treePosition: currentTreePosition
+	}] : parentLoadingEntries;
 	const page = findFile(currentDir, "page", matcher);
 	if (page) {
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
+			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
+			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
+			const branchSegments = [
+				...slotParentSegments,
+				interceptSegment,
+				...path.relative(interceptRoot, path.dirname(page)).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)];
+					const relativeDir = path.relative(interceptRoot, path.dirname(layoutPath));
+					return [
+						...slotParentSegments,
+						interceptSegment,
+						...relativeDir.split(path.sep).filter(Boolean)
+					];
 				}),
+				loadingPaths: loadingEntries.map((loading) => loading.path),
+				loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
+				notFoundBranchSegments: branchSegments,
+				notFoundPath: notFoundBoundary.path,
+				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
@@ -1387,7 +1523,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, loadingEntries, treePositionOffset);
 	}
 }
 /**
@@ -1615,4 +1751,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment, patternsStructurallyEquivalent };

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 };