vinext 0.1.2 → 0.1.3

package/dist/plugins/extensionless-dynamic-import.js

@@ -0,0 +1,152 @@
+import { forEachAstChild, hasRange, isAstRecord, nodeArray } from "./ast-utils.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/extensionless-dynamic-import.ts
+const MODULE_EXTENSIONS = [
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".json"
+];
+const TRANSFORMABLE_EXTENSIONS = new Set([
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".cjs",
+	".cts"
+]);
+function createExtensionlessDynamicImportPlugin() {
+	let moduleExtensions = MODULE_EXTENSIONS;
+	return {
+		name: "vinext:extensionless-dynamic-import",
+		enforce: "pre",
+		configResolved(config) {
+			moduleExtensions = getModuleExtensions(config);
+		},
+		transform(code, id) {
+			if (!/\bimport\s*\(/.test(code)) return null;
+			if (isDependencyId(id)) return null;
+			const lang = langForId(id);
+			if (!lang) return null;
+			let ast;
+			try {
+				ast = parseAst(code, { lang });
+			} catch {
+				return null;
+			}
+			const imports = collectExtensionlessImports(ast, code, moduleExtensions);
+			if (imports.length === 0) return null;
+			const output = new MagicString(code);
+			for (const dynamicImport of imports) {
+				const source = code.slice(dynamicImport.sourceStart, dynamicImport.sourceEnd);
+				output.overwrite(dynamicImport.start, dynamicImport.end, buildReplacement(source, dynamicImport.globPattern, dynamicImport.moduleExtensions));
+			}
+			return {
+				code: output.toString(),
+				map: output.generateMap({ hires: "boundary" })
+			};
+		}
+	};
+}
+function langForId(id) {
+	const clean = id.split("?", 1)[0];
+	const dot = clean.lastIndexOf(".");
+	if (dot < 0) return null;
+	const ext = clean.slice(dot).toLowerCase();
+	if (!TRANSFORMABLE_EXTENSIONS.has(ext)) return null;
+	if (ext === ".ts" || ext === ".mts" || ext === ".cts") return "ts";
+	if (ext === ".tsx") return "tsx";
+	return "jsx";
+}
+function isDependencyId(id) {
+	return id.split("?", 1)[0].replaceAll("\\", "/").includes("/node_modules/");
+}
+function collectExtensionlessImports(ast, code, moduleExtensions) {
+	const imports = [];
+	function visit(value) {
+		if (!isAstRecord(value)) return;
+		const parsed = parseExtensionlessImport(value, code, moduleExtensions);
+		if (parsed) {
+			imports.push(parsed);
+			return;
+		}
+		forEachAstChild(value, visit);
+	}
+	visit(ast);
+	return imports;
+}
+function parseExtensionlessImport(node, code, moduleExtensions) {
+	if (node.type !== "ImportExpression" || !hasRange(node)) return null;
+	if (node.options != null) return null;
+	const source = node.source;
+	if (!isAstRecord(source) || source.type !== "TemplateLiteral" || !hasRange(source)) return null;
+	if (nodeArray(source.expressions).length === 0) return null;
+	const quasiTexts = nodeArray(source.quasis).map(templateElementText);
+	if (quasiTexts.some((text) => text == null)) return null;
+	const texts = quasiTexts;
+	const first = texts[0];
+	if (!isImportPrefix(code.slice(node.start, source.start))) return null;
+	if (!(first.startsWith("./") || first.startsWith("../"))) return null;
+	if (texts.some((text) => /[*?[\]{}()!?#]/.test(text))) return null;
+	if (texts.slice(1).some((text) => text.includes("."))) return null;
+	const directoryEnd = first.lastIndexOf("/") + 1;
+	const directory = first.slice(0, directoryEnd);
+	const filenamePrefix = first.slice(directoryEnd);
+	if (filenamePrefix.includes(".")) return null;
+	return {
+		start: node.start,
+		end: node.end,
+		sourceStart: source.start,
+		sourceEnd: source.end,
+		globPattern: filenamePrefix.length > 0 ? [`${first}*`, `${first}*/**/*`] : `${directory}**/*`,
+		moduleExtensions
+	};
+}
+function isImportPrefix(value) {
+	const prefix = value.match(/^import\s*\(/)?.[0];
+	if (!prefix) return false;
+	let index = prefix.length;
+	while (index < value.length) {
+		const char = value[index];
+		if (/\s/.test(char)) {
+			index += 1;
+			continue;
+		}
+		if (value.startsWith("/*", index)) {
+			const commentEnd = value.indexOf("*/", index + 2);
+			if (commentEnd < 0) return false;
+			index = commentEnd + 2;
+			continue;
+		}
+		if (value.startsWith("//", index)) {
+			const lineEnd = value.indexOf("\n", index + 2);
+			if (lineEnd < 0) return true;
+			index = lineEnd + 1;
+			continue;
+		}
+		return false;
+	}
+	return true;
+}
+function templateElementText(value) {
+	if (!isAstRecord(value) || value.type !== "TemplateElement") return null;
+	const templateValue = value.value;
+	if (typeof templateValue !== "object" || templateValue === null) return null;
+	const cooked = Reflect.get(templateValue, "cooked");
+	return typeof cooked === "string" ? cooked : null;
+}
+function getModuleExtensions(config) {
+	return config.resolve.extensions.filter((extension) => extension !== ".node");
+}
+function buildReplacement(source, globPattern, moduleExtensions) {
+	const extensions = JSON.stringify(moduleExtensions);
+	return `((__vinextPath, __vinextModules = import.meta.glob(${JSON.stringify(globPattern)}), __vinextExtensions = ${extensions}) => { const __vinextLoader = __vinextModules[__vinextPath] ?? __vinextExtensions.map((__vinextExtension) => __vinextModules[__vinextPath + __vinextExtension]).find(Boolean) ?? __vinextExtensions.map((__vinextExtension) => __vinextModules[__vinextPath + "/index" + __vinextExtension]).find(Boolean); return __vinextLoader ? __vinextLoader() : Promise.reject(new Error("Cannot find module '" + __vinextPath + "'")); })(${source})`;
+}
+//#endregion
+export { createExtensionlessDynamicImportPlugin };

package/dist/plugins/optimize-imports.d.ts

@@ -14,6 +14,7 @@ type BarrelExportMap = Map<string, BarrelExportEntry>;
  * @see https://github.com/vercel/next.js/blob/9c31bbdaa/packages/next/src/server/config.ts#L1301
  */
 declare const DEFAULT_OPTIMIZE_PACKAGES: string[];
+declare function createOptimizedImportSourceMatcher(packages: Iterable<string>): (code: string) => boolean;
 /**
  * Build a map of exported names → source sub-module for a barrel package.
  *
@@ -38,4 +39,4 @@ declare function buildBarrelExportMap(entryPath: string | null, readFile: (filep
  */
 declare function createOptimizeImportsPlugin(getNextConfig: () => ResolvedNextConfig | undefined, getRoot: () => string): Plugin;
 //#endregion
-export { DEFAULT_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin };
+export { DEFAULT_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin, createOptimizedImportSourceMatcher };

package/dist/plugins/optimize-imports.js

@@ -1,4 +1,5 @@
 import { normalizePathSeparators } from "../utils/path.js";
+import { escapeRegExp } from "../utils/regex.js";
 import { getAstName } from "./ast-utils.js";
 import { createRequire } from "node:module";
 import path from "node:path";
@@ -100,6 +101,12 @@ const DEFAULT_OPTIMIZE_PACKAGES = [
 	"react-icons/wi",
 	"radix-ui"
 ];
+function createOptimizedImportSourceMatcher(packages) {
+	const pattern = [...packages].map(escapeRegExp).join("|");
+	if (!pattern) return () => false;
+	const importFromPattern = new RegExp(String.raw`(?:^|[;}\n\r])\s*import(?!\s*\()(?:(?!\bfrom\b)[\s\S])*?\bfrom\s*["'](?:${pattern})["']`, "m");
+	return (code) => code.includes("import") && code.includes("from") && importFromPattern.test(code);
+}
 /**
 * Resolve a package.json exports value to a string entry path.
 * Prefers node → import → module → default conditions, recursing into nested objects.
@@ -417,14 +424,14 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 	};
 	const entryPathCache = /* @__PURE__ */ new Map();
 	let optimizedPackages = /* @__PURE__ */ new Set();
-	let quotedPackages = [];
+	let hasOptimizedImportSource = () => false;
 	const registeredBarrels = /* @__PURE__ */ new Set();
 	return {
 		name: "vinext:optimize-imports",
 		buildStart() {
 			const nextConfig = getNextConfig();
 			optimizedPackages = new Set([...DEFAULT_OPTIMIZE_PACKAGES, ...nextConfig?.optimizePackageImports ?? []]);
-			quotedPackages = [...optimizedPackages].flatMap((pkg) => [`"${pkg}"`, `'${pkg}'`]);
+			hasOptimizedImportSource = createOptimizedImportSourceMatcher(optimizedPackages);
 			entryPathCache.clear();
 			barrelCaches.exportMapCache.clear();
 			barrelCaches.subpkgOrigin.clear();
@@ -445,12 +452,7 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 				const preferReactServer = env?.name === "rsc";
 				if (id.startsWith("\0")) return null;
 				const packages = optimizedPackages;
-				let hasBarrelImport = false;
-				for (const quoted of quotedPackages) if (code.includes(quoted)) {
-					hasBarrelImport = true;
-					break;
-				}
-				if (!hasBarrelImport) return null;
+				if (!hasOptimizedImportSource(code)) return null;
 				let ast;
 				try {
 					ast = parseAst(code);
@@ -576,4 +578,4 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 	};
 }
 //#endregion
-export { DEFAULT_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin };
+export { DEFAULT_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin, createOptimizedImportSourceMatcher };

package/dist/plugins/postcss.js

@@ -1,8 +1,11 @@
+import { importExportWithCommonJsFallback } from "../utils/commonjs-loader.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
 //#region src/plugins/postcss.ts
+async function loadPluginExport(resolvedPath) {
+	return importExportWithCommonJsFallback(resolvedPath);
+}
 /**
 * PostCSS config file names to search for, in priority order.
 * Matches the same search order as postcss-load-config / lilconfig.
@@ -65,8 +68,7 @@ async function resolvePostcssStringPluginsUncached(projectRoot) {
 		if (configPath.endsWith(".postcssrc")) {
 			if (fs.readFileSync(configPath, "utf-8").trim().startsWith("{")) return;
 		}
-		const mod = await import(pathToFileURL(configPath).href);
-		config = mod.default ?? mod;
+		config = await importExportWithCommonJsFallback(configPath);
 	} catch {
 		return;
 	}
@@ -76,14 +78,12 @@ async function resolvePostcssStringPluginsUncached(projectRoot) {
 	try {
 		return { plugins: await Promise.all(config.plugins.filter(Boolean).map(async (plugin) => {
 			if (typeof plugin === "string") {
-				const mod = await import(pathToFileURL(req.resolve(plugin)).href);
-				const fn = mod.default ?? mod;
+				const fn = await loadPluginExport(req.resolve(plugin));
 				return typeof fn === "function" ? fn() : fn;
 			}
 			if (Array.isArray(plugin) && typeof plugin[0] === "string") {
 				const [name, options] = plugin;
-				const mod = await import(pathToFileURL(req.resolve(name)).href);
-				const fn = mod.default ?? mod;
+				const fn = await loadPluginExport(req.resolve(name));
 				return typeof fn === "function" ? fn(options) : fn;
 			}
 			return plugin;

package/dist/plugins/typeof-window.d.ts

@@ -0,0 +1,14 @@
+//#region src/plugins/typeof-window.d.ts
+type WindowType = "object" | "undefined";
+type EnvironmentLike = {
+  config: {
+    consumer: "client" | "server";
+  };
+};
+declare function getTypeofWindowReplacement(environment: EnvironmentLike): WindowType;
+declare function replaceTypeofWindow(code: string, replacement: WindowType): {
+  code: string;
+  map: import("magic-string").SourceMap;
+} | null;
+//#endregion
+export { getTypeofWindowReplacement, replaceTypeofWindow };

package/dist/plugins/typeof-window.js

@@ -0,0 +1,150 @@
+import { collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, nodeArray } from "./ast-utils.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/typeof-window.ts
+function createScope(parent) {
+	return {
+		parent,
+		bindings: /* @__PURE__ */ new Set()
+	};
+}
+function hasBinding(scope, name) {
+	for (let current = scope; current; current = current.parent) if (current.bindings.has(name)) return true;
+	return false;
+}
+function collectScopeBindings(node, scope) {
+	forEachAstChild(node, (child) => {
+		if (child.type === "ExportNamedDeclaration" || child.type === "ExportDefaultDeclaration") {
+			if (isAstRecord(child.declaration)) collectScopeBindings(child, scope);
+			return;
+		}
+		if (child.type === "FunctionDeclaration" || child.type === "ClassDeclaration") {
+			collectBindingNames(child.id, scope.bindings);
+			return;
+		}
+		if (child.type === "VariableDeclaration") {
+			for (const declaration of nodeArray(child.declarations)) if (isAstRecord(declaration)) collectBindingNames(declaration.id, scope.bindings);
+			return;
+		}
+		if (child.type === "ImportDeclaration") {
+			for (const specifier of nodeArray(child.specifiers)) if (isAstRecord(specifier)) collectBindingNames(specifier.local, scope.bindings);
+		}
+	});
+}
+function collectVarBindings(node, scope, isRoot = true) {
+	if (!isRoot && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")) return;
+	if (node.type === "VariableDeclaration" && node.kind === "var") {
+		for (const declaration of nodeArray(node.declarations)) if (isAstRecord(declaration)) collectBindingNames(declaration.id, scope.bindings);
+	}
+	forEachAstChild(node, (child) => collectVarBindings(child, scope, false));
+}
+function isFunctionNode(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function createChildScope(node, parent) {
+	if (node.type !== "Program" && node.type !== "BlockStatement" && node.type !== "StaticBlock" && node.type !== "SwitchStatement" && node.type !== "CatchClause" && node.type !== "ForStatement" && node.type !== "ForInStatement" && node.type !== "ForOfStatement" && node.type !== "ClassDeclaration" && node.type !== "ClassExpression") return null;
+	const scope = createScope(parent);
+	if (node.type === "ClassDeclaration" || node.type === "ClassExpression") collectBindingNames(node.id, scope.bindings);
+	else if (node.type === "CatchClause") collectBindingNames(node.param, scope.bindings);
+	collectScopeBindings(node, scope);
+	if (node.type === "SwitchStatement") {
+		for (const switchCase of nodeArray(node.cases)) if (isAstRecord(switchCase)) collectScopeBindings(switchCase, scope);
+	}
+	return scope;
+}
+function getTypeofWindowReplacement(environment) {
+	return environment.config.consumer === "client" ? "object" : "undefined";
+}
+function stringLiteralValue(node) {
+	if (!isAstRecord(node)) return null;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+function evaluateTypeofWindowComparison(node, replacement, scope) {
+	if (!isAstRecord(node) || node.type !== "BinaryExpression") return null;
+	if (![
+		"==",
+		"===",
+		"!=",
+		"!=="
+	].includes(String(node.operator))) return null;
+	const left = isAstRecord(node.left) ? node.left : null;
+	const right = isAstRecord(node.right) ? node.right : null;
+	const leftIsTypeofWindow = left?.type === "UnaryExpression" && left.operator === "typeof" && isIdentifierNamed(left.argument, "window") && !hasBinding(scope, "window");
+	const rightIsTypeofWindow = right?.type === "UnaryExpression" && right.operator === "typeof" && isIdentifierNamed(right.argument, "window") && !hasBinding(scope, "window");
+	const comparedValue = leftIsTypeofWindow ? stringLiteralValue(right) : rightIsTypeofWindow ? stringLiteralValue(left) : null;
+	if (comparedValue === null) return null;
+	const equal = replacement === comparedValue;
+	return node.operator === "==" || node.operator === "===" ? equal : !equal;
+}
+function replaceTypeofWindow(code, replacement) {
+	if (!/typeof\s+window/.test(code)) return null;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return null;
+	}
+	const output = new MagicString(code);
+	let changed = false;
+	if (!isAstRecord(ast)) return null;
+	const rootScope = createScope(null);
+	collectScopeBindings(ast, rootScope);
+	collectVarBindings(ast, rootScope);
+	function visit(node, parentScope) {
+		if (isFunctionNode(node)) {
+			const parameterScope = createScope(parentScope);
+			collectBindingNames(node.id, parameterScope.bindings);
+			for (const parameter of nodeArray(node.params)) {
+				collectBindingNames(parameter, parameterScope.bindings);
+				if (isAstRecord(parameter)) visit(parameter, parameterScope);
+			}
+			if (isAstRecord(node.body)) if (node.body.type === "BlockStatement") {
+				const bodyScope = createScope(parameterScope);
+				collectVarBindings(node.body, bodyScope);
+				visit(node.body, bodyScope);
+			} else visit(node.body, parameterScope);
+			return;
+		}
+		const scope = createChildScope(node, parentScope) ?? parentScope;
+		if (node.type === "IfStatement" && hasRange(node)) {
+			const result = evaluateTypeofWindowComparison(node.test, replacement, scope);
+			if (result !== null) {
+				const selected = result ? node.consequent : node.alternate;
+				if (isAstRecord(selected) && hasRange(selected)) {
+					output.remove(node.start, selected.start);
+					output.remove(selected.end, node.end);
+					visit(selected, scope);
+				} else output.overwrite(node.start, node.end, ";");
+				changed = true;
+				return;
+			}
+		}
+		if (node.type === "ConditionalExpression" && hasRange(node)) {
+			const result = evaluateTypeofWindowComparison(node.test, replacement, scope);
+			const selected = result ? node.consequent : node.alternate;
+			if (result !== null && isAstRecord(selected) && hasRange(selected)) {
+				output.overwrite(node.start, selected.start, "(");
+				if (selected.end < node.end) output.overwrite(selected.end, node.end, ")");
+				else output.appendLeft(selected.end, ")");
+				visit(selected, scope);
+				changed = true;
+				return;
+			}
+		}
+		if (node.type === "UnaryExpression" && node.operator === "typeof" && isIdentifierNamed(node.argument, "window") && !hasBinding(scope, "window") && hasRange(node)) {
+			output.overwrite(node.start, node.end, JSON.stringify(replacement));
+			changed = true;
+			return;
+		}
+		forEachAstChild(node, (child) => visit(child, scope));
+	}
+	for (const node of ast.body) if (isAstRecord(node)) visit(node, rootScope);
+	if (!changed) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+//#endregion
+export { getTypeofWindowReplacement, replaceTypeofWindow };

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

@@ -21,7 +21,8 @@ type InterceptingRoute = {
    * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/interception-routes.ts
    */
   sourceMatchPattern: string; /** Absolute path to the intercepting page component */
-  pagePath: string; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
+  pagePath: string; /** Filesystem segments from app/ root to the intercepting page directory. */
+  sourcePageSegments?: string[]; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Parameter names for dynamic segments */
   params: string[];
   /**

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

@@ -1,5 +1,5 @@
 import { normalizePathSeparators } from "../utils/path.js";
-import { compareRoutes, decodeRouteSegment, isInvisibleSegment } from "./utils.js";
+import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
@@ -346,23 +346,25 @@ function createRouteManifestGraphVersion(segmentGraph) {
 }
 async function buildAppRouteGraph(appDir, matcher) {
 	const routes = [];
+	const scanMatcher = { ...matcher };
+	findFileProbeCache.set(scanMatcher, /* @__PURE__ */ new Map());
 	const excludeDir = (name) => name.startsWith("@") && name !== "@children" || name.startsWith("_") || isInterceptionMarkerDir(name);
-	for await (const file of scanWithExtensions("**/page", appDir, matcher.extensions, excludeDir)) {
-		const route = fileToAppRoute(file, appDir, "page", matcher);
+	for await (const file of scanWithExtensions("**/page", appDir, scanMatcher.extensions, excludeDir)) {
+		const route = fileToAppRoute(file, appDir, "page", scanMatcher);
 		if (route) routes.push(route);
 	}
-	for await (const file of scanWithExtensions("**/route", appDir, matcher.extensions, excludeDir)) {
-		const route = fileToAppRoute(file, appDir, "route", matcher);
+	for await (const file of scanWithExtensions("**/route", appDir, scanMatcher.extensions, excludeDir)) {
+		const route = fileToAppRoute(file, appDir, "route", scanMatcher);
 		if (route) routes.push(route);
 	}
 	const routePatterns = new Set(routes.map((route) => route.pattern));
 	const ghostParentRoutes = [];
-	for await (const file of scanWithExtensions("**/layout", appDir, matcher.extensions, excludeDir)) {
+	for await (const file of scanWithExtensions("**/layout", appDir, scanMatcher.extensions, excludeDir)) {
 		const dir = path.dirname(file);
 		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
-		if (discoverParallelSlots(routeDir, appDir, matcher).length === 0) continue;
-		const route = directoryToAppRoute(dir, appDir, matcher, null, null);
+		if (discoverParallelSlots(routeDir, appDir, scanMatcher).length === 0) continue;
+		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null);
 		if (!route) continue;
 		if (routePatterns.has(route.pattern)) {
 			ghostParentRoutes.push(route);
@@ -371,13 +373,13 @@ async function buildAppRouteGraph(appDir, matcher) {
 		routes.push(route);
 		routePatterns.add(route.pattern);
 	}
-	const slotSubRoutes = discoverSlotSubRoutes(routes, matcher, ghostParentRoutes);
+	const slotSubRoutes = discoverSlotSubRoutes(routes, scanMatcher, ghostParentRoutes);
 	routes.push(...slotSubRoutes);
-	discoverSiblingInterceptingRoutes(routes, appDir, matcher);
+	discoverSiblingInterceptingRoutes(routes, appDir, scanMatcher);
 	validatePageRouteConflicts(routes, appDir);
 	validateRoutePatterns(routes.map((route) => route.pattern));
 	validateRoutePatterns([...new Set(routes.flatMap((route) => [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern)), ...route.siblingIntercepts.map((intercept) => intercept.targetPattern)]))]);
-	routes.sort(compareRoutes);
+	sortRoutes(routes);
 	return {
 		routes,
 		routeManifest: createRouteManifest(routes)
@@ -1275,6 +1277,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
+				sourcePageSegments: normalizePathSeparators(path.relative(appDir, path.dirname(page))).split("/").filter(Boolean),
 				params: targetPattern.params
 			});
 		}
@@ -1384,10 +1387,37 @@ function markerForInterceptionConvention(convention) {
 	}
 }
 /**
-* Find a file by name (without extension) in a directory.
-* Checks configured pageExtensions.
+* Scan-scoped cache of convention-file probes, keyed by the per-scan matcher
+* created in `buildAppRouteGraph`. A single scan walks the appDir→leaf chain
+* separately for every route (layouts, templates, errors, boundaries, slots),
+* so shared ancestor directories — the `app/` root above all — get re-probed
+* once per descendant route. The probe result is deterministic within one scan
+* (the filesystem does not change mid-build), so memoizing it removes the
+* dominant cross-route redundancy.
+*
+* Keyed by matcher so the cache lifetime is exactly one `buildAppRouteGraph`
+* call: the scan registers a fresh matcher clone, and the entry is unreachable
+* (and GC-eligible) once the scan returns. A fresh key per scan is also what
+* makes this concurrency-safe — overlapping builds never share probe state.
+*/
+const findFileProbeCache = /* @__PURE__ */ new WeakMap();
+/**
+* Find a file by name (without extension) in a directory, checking configured
+* pageExtensions. Memoizes through `findFileProbeCache` when the matcher has a
+* registered per-scan cache; otherwise falls back to a direct probe (identical
+* result). The `null` "not found" outcome is cached too, so repeated misses on
+* shared ancestors cost a single set of `existsSync` calls per scan.
 */
-const findFile = findFileWithExts;
+function findFile(dir, name, matcher) {
+	const cache = findFileProbeCache.get(matcher);
+	if (!cache) return findFileWithExts(dir, name, matcher);
+	const key = `${dir}\0${name}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	const result = findFileWithExts(dir, name, matcher);
+	cache.set(key, result);
+	return result;
+}
 /**
 * Convert filesystem path segments to URL route parts, skipping invisible segments
 * (route groups, @slots, ".") and converting dynamic segment syntax to Express-style

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

@@ -43,9 +43,18 @@ declare function findFileWithExts(dir: string, name: string, matcher: ValidFileM
  * See: cloudflare/vinext#1502
  */
 declare function buildViteResolveExtensions(pageExtensions?: readonly string[] | null, viteDefaults?: readonly string[]): string[];
+/**
+ * Normalize an explicit Next.js resolver extension list for Vite.
+ *
+ * Unlike `pageExtensions`, both Turbopack's `resolveExtensions` and webpack's
+ * `resolve.extensions` replace their resolver defaults. The empty string is a
+ * webpack/Turbopack convention for trying the import exactly as written; Vite
+ * already does that before appending extensions, so it must be omitted here.
+ */
+declare function normalizeViteResolveExtensions(extensions: readonly string[]): string[];
 /**
  * Use function-form exclude for Node < 22.14 compatibility.
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion
-export { ValidFileMatcher, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, scanWithExtensions };
+export { ValidFileMatcher, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

package/dist/routing/file-matcher.js

@@ -113,6 +113,27 @@ function buildViteResolveExtensions(pageExtensions, viteDefaults = [
 	return result;
 }
 /**
+* Normalize an explicit Next.js resolver extension list for Vite.
+*
+* Unlike `pageExtensions`, both Turbopack's `resolveExtensions` and webpack's
+* `resolve.extensions` replace their resolver defaults. The empty string is a
+* webpack/Turbopack convention for trying the import exactly as written; Vite
+* already does that before appending extensions, so it must be omitted here.
+*/
+function normalizeViteResolveExtensions(extensions) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const extension of extensions) {
+		const trimmed = extension.trim();
+		if (!trimmed) continue;
+		const dotted = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+		if (seen.has(dotted)) continue;
+		seen.add(dotted);
+		result.push(dotted);
+	}
+	return result;
+}
+/**
 * Use function-form exclude for Node < 22.14 compatibility.
 */
 async function* scanWithExtensions(stem, cwd, extensions, exclude) {
@@ -123,4 +144,4 @@ async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	})) yield file;
 }
 //#endregion
-export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, scanWithExtensions };
+export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

package/dist/routing/pages-router.js

@@ -1,4 +1,4 @@
-import { compareRoutes, decodeRouteSegment } from "./utils.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";
@@ -54,7 +54,7 @@ async function scanPageRoutes(pagesDir, matcher) {
 		if (route) routes.push(route);
 	}
 	validateRoutePatterns(routes.map((route) => route.pattern));
-	routes.sort(compareRoutes);
+	sortRoutes(routes);
 	return routes;
 }
 /**
@@ -156,7 +156,7 @@ async function scanApiRoutes(pagesDir, matcher) {
 		if (route) routes.push(route);
 	}
 	validateRoutePatterns(routes.map((route) => route.pattern));
-	routes.sort(compareRoutes);
+	sortRoutes(routes);
 	return routes;
 }
 //#endregion