vinext 0.1.1 → 0.1.3

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/plugins/wasm-module-import.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/wasm-module-import.d.ts
+/**
+ * vinext:wasm-module-import — handle `import x from '*.wasm?module'`.
+ *
+ * Resolutions marked external by Vite or a target adapter are preserved. For
+ * non-external resolutions, this plugin reads the WASM file, inlines it as
+ * base64, and exports a compiled WebAssembly.Module.
+ *
+ * Fixes #1351.
+ */
+declare function createWasmModuleImportPlugin(): Plugin;
+//#endregion
+export { createWasmModuleImportPlugin };

package/dist/plugins/wasm-module-import.js

@@ -0,0 +1,50 @@
+import { stripViteModuleQuery } from "../utils/path.js";
+import fs from "node:fs";
+//#region src/plugins/wasm-module-import.ts
+/**
+* vinext:wasm-module-import — handle `import x from '*.wasm?module'`.
+*
+* Resolutions marked external by Vite or a target adapter are preserved. For
+* non-external resolutions, this plugin reads the WASM file, inlines it as
+* base64, and exports a compiled WebAssembly.Module.
+*
+* Fixes #1351.
+*/
+function createWasmModuleImportPlugin() {
+	return {
+		name: "vinext:wasm-module-import",
+		enforce: "pre",
+		resolveId: {
+			filter: { id: /\.wasm\?module$/ },
+			async handler(source, importer) {
+				if (this.environment?.name === "client") return null;
+				if ((importer ? (importer.startsWith("\0") ? importer.slice(1) : importer).split("?")[0] : "").includes("@vercel/og")) return null;
+				const resolved = await this.resolve(source, importer, { skipSelf: true });
+				if (!resolved) return null;
+				if (resolved.external) return resolved;
+				return `\0vinext-wasm-module:${stripViteModuleQuery(resolved.id)}`;
+			}
+		},
+		load: {
+			filter: { id: /^\u0000vinext-wasm-module:/ },
+			handler(id) {
+				const filePath = id.replace(/^\u0000vinext-wasm-module:/, "");
+				this.addWatchFile(filePath);
+				let bytes;
+				try {
+					bytes = fs.readFileSync(filePath);
+				} catch {
+					return this.error(`[vinext] Could not read WASM file: ${filePath}`);
+				}
+				const base64 = bytes.toString("base64");
+				return [
+					`const _b64 = ${JSON.stringify(base64)};`,
+					`const _buf = Uint8Array.from(atob(_b64), c => c.charCodeAt(0));`,
+					`export default await WebAssembly.compile(_buf.buffer);`
+				].join("\n");
+			}
+		}
+	};
+}
+//#endregion
+export { createWasmModuleImportPlugin };

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[];
   /**
@@ -276,6 +277,28 @@ declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher):
   routeManifest: RouteManifest;
 }>;
 declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
+/**
+ * Find the best route to attach a sibling intercept to, given the directory
+ * that contains the interception marker.
+ *
+ * 1. Exact hit: a route whose page/handler lives directly in `dir`.
+ * 2. Subtree hit: shallowest route whose page lives anywhere under `dir`
+ *    (handles catch-all routes like `/templates/:catchAll+`).
+ * 3. Ancestor walk: walk up the directory tree toward `appDir` looking for
+ *    any of the above. This handles the case where the marker directory has
+ *    no sibling pages at all (e.g. `deep/path/(...)target` with no
+ *    `deep/path/page.tsx`).
+ *
+ * All comparisons happen in forward-slash space: `appDir` is forward-slash
+ * (normalized once in the config hook), but `dir` and route file paths
+ * descend through native `path.join`/`path.dirname`, which reintroduce
+ * backslashes on Windows. Without normalizing, the `current === appDir`
+ * termination never fires there and the walk overshoots the app root.
+ * `routesByDir` keys must be forward-slash dirnames of the route file paths.
+ *
+ * Exported for tests.
+ */
+declare function findOwnerRouteForDir(dir: string, appDir: string, routes: readonly AppRouteGraphRoute[], routesByDir: Map<string, AppRouteGraphRoute>): AppRouteGraphRoute | null;
 /**
  * Convert filesystem path segments to URL route parts, skipping invisible segments
  * (route groups, @slots, ".") and converting dynamic segment syntax to Express-style
@@ -310,4 +333,4 @@ declare function computeAppRouteStaticSiblings(allRoutes: readonly {
   patternParts?: readonly string[] | null;
 }): string[];
 //#endregion
-export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
+export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };

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

@@ -1,4 +1,5 @@
-import { compareRoutes, decodeRouteSegment, isInvisibleSegment } from "./utils.js";
+import { normalizePathSeparators } from "../utils/path.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";
@@ -345,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);
@@ -370,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)
@@ -485,7 +488,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const existingRoute = routesByPattern.get(pattern);
 			if (existingRoute) {
 				if (existingRoute.routePath && !existingRoute.pagePath) throw new Error(`You cannot have two routes that resolve to the same path ("${pattern}").`);
-				applySlotSubPages(existingRoute, slotPages, rawSegments);
+				if (urlParts.length > 0) applySlotSubPages(existingRoute, slotPages, rawSegments);
 				continue;
 			}
 			const syntheticParts = [...parentRoute.patternParts, ...urlParts];
@@ -1026,6 +1029,34 @@ function patternsStructurallyEquivalent(a, b) {
 	return true;
 }
 /**
+* Find a page file at the root URL level of a parallel slot directory, including
+* through transparent route-group subdirectories (e.g. `@slot/(group)/page.tsx`
+* is equivalent to `@slot/page.tsx` since `(group)` is invisible in the URL).
+*
+* Returns the absolute page path, or null if no root-level page is found.
+*
+* Only descends into route-group directories (those whose name starts with `(`
+* and ends with `)`). Dynamic segments, regular named dirs, and `@slot` dirs
+* are not transparent and are therefore not searched.
+*/
+function findSlotRootPage(slotDir, matcher) {
+	const directPage = findFile(slotDir, "page", matcher);
+	if (directPage) return directPage;
+	let entries;
+	try {
+		entries = fs.readdirSync(slotDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
+		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
+		if (found) return found;
+	}
+	return null;
+}
+/**
 * Discover parallel route slots (@team, @analytics, etc.) in a directory.
 * Returns a ParallelSlot for each @-prefixed subdirectory that has a page or default component.
 */
@@ -1038,7 +1069,7 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
 		const slotDir = path.join(dir, entry.name);
-		const pagePath = findFile(slotDir, "page", matcher);
+		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
 		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
@@ -1127,7 +1158,7 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 	for (const route of routes) {
 		const filePath = route.pagePath ?? route.routePath;
 		if (!filePath) continue;
-		const routeDir = path.dirname(filePath);
+		const routeDir = normalizePathSeparators(path.dirname(filePath));
 		if (!routesByDir.has(routeDir)) routesByDir.set(routeDir, route);
 	}
 	function walk(dir) {
@@ -1171,22 +1202,32 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 *    any of the above. This handles the case where the marker directory has
 *    no sibling pages at all (e.g. `deep/path/(...)target` with no
 *    `deep/path/page.tsx`).
+*
+* All comparisons happen in forward-slash space: `appDir` is forward-slash
+* (normalized once in the config hook), but `dir` and route file paths
+* descend through native `path.join`/`path.dirname`, which reintroduce
+* backslashes on Windows. Without normalizing, the `current === appDir`
+* termination never fires there and the walk overshoots the app root.
+* `routesByDir` keys must be forward-slash dirnames of the route file paths.
+*
+* Exported for tests.
 */
 function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
-	let current = dir;
+	const appRoot = normalizePathSeparators(appDir);
+	let current = normalizePathSeparators(dir);
 	while (true) {
 		const exact = routesByDir.get(current);
 		if (exact) return exact;
-		const currentWithSep = current + path.sep;
+		const currentWithSep = current + "/";
 		let best = null;
 		for (const route of routes) {
 			const filePath = route.pagePath ?? route.routePath;
 			if (!filePath) continue;
-			if (!filePath.startsWith(currentWithSep)) continue;
+			if (!normalizePathSeparators(filePath).startsWith(currentWithSep)) continue;
 			if (!best || route.patternParts.length < best.patternParts.length) best = route;
 		}
 		if (best) return best;
-		if (current === appDir) break;
+		if (current === appRoot) break;
 		const parent = path.dirname(current);
 		if (parent === current) break;
 		current = parent;
@@ -1236,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
 			});
 		}
@@ -1345,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 findFile = findFileWithExts;
+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.
+*/
+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
@@ -1446,4 +1515,4 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 	return Array.from(siblings);
 }
 //#endregion
-export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, findOwnerRouteForDir, isInvisibleSegment };

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

@@ -69,7 +69,7 @@ function findFileWithExtensions(basePath, matcher) {
 */
 function findFileWithExts(dir, name, matcher) {
 	for (const ext of matcher.dottedExtensions) {
-		const filePath = path.join(dir, name + ext);
+		const filePath = path.posix.join(dir, name + ext);
 		if (existsSync(filePath)) return filePath;
 	}
 	return null;
@@ -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

package/dist/routing/utils.d.ts

@@ -1,13 +1,42 @@
 //#region src/routing/utils.d.ts
 /**
- * Sort comparator for routes — lower precedence score sorts first (higher priority).
- * Lexicographic tiebreaker on pattern for determinism.
+ * Sort routes by precedence — lower score sorts first (higher priority), with a
+ * lexicographic tiebreaker on the pattern for determinism. Sorts in place and
+ * returns the same array (mirrors `Array.prototype.sort`).
  *
- * Usage: routes.sort(compareRoutes)
+ * `routePrecedence` is a pure function of the pattern, so each pattern's score
+ * is computed exactly once up front (decorate-sort) instead of ~2·log n times
+ * by a comparator that re-parses on every comparison. The `localeCompare`
+ * tiebreaker already guarantees a total order, so the result is byte-identical
+ * to comparing precedence inline.
+ *
+ * Usage: sortRoutes(routes)
  */
-declare function compareRoutes<T extends {
+declare function sortRoutes<T extends {
   pattern: string;
-}>(a: T, b: T): number;
+}>(routes: T[]): T[];
+/**
+ * Single source of truth for hybrid App/Pages route ownership.
+ *
+ * Mirrors Next.js's DefaultRouteMatcherManager ordering: Pages providers
+ * are registered before App providers, then merged dynamic matchers sort
+ * together. Returns the router that should own a request/navigation to
+ * a URL that matched BOTH routers.
+ *
+ * Centralised so the server's request handling and the client's link /
+ * prefetch / programmatic-navigation paths all reach the same owner for
+ * the same (pages pattern, app pattern) pair. This intentionally implements
+ * Next.js's segment-tree ordering directly instead of vinext's broader
+ * `sortRoutes()` score heuristic. It only arbitrates two routes that already
+ * matched the same URL; each router's own trie ordering remains unchanged.
+ *
+ * Usage:
+ *   compareHybridRoutePatterns("/:slug", true, "/:slug", true)  // → "pages"
+ *   compareHybridRoutePatterns("/_sites/:slug*", true, "/:slug*", true)  // → "pages"
+ *   compareHybridRoutePatterns("/:path+", true, "/dashboard", false)  // → "app"
+ *   compareHybridRoutePatterns("/", false, "/", false)  // → "app"
+ */
+declare function compareHybridRoutePatterns(pagesPattern: string, pagesIsDynamic: boolean, appPattern: string, appIsDynamic: boolean): "app" | "pages";
 /**
  * Decode a filesystem or URL path segment while preserving encoded path delimiters.
  * Mirrors Next.js segment-wise decoding so "%5F" becomes "_" but "%2F" stays "%2F".
@@ -85,4 +114,4 @@ declare function isOptionalCatchAllSegment(segment: string): boolean;
  */
 declare function countConsumedPathnameSegments(visibleTreePathSegments: readonly string[], pathnameSegmentCount: number): number;
 //#endregion
-export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };
+export { buildParams, compareHybridRoutePatterns, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, sortRoutes, splitPathSegments, splitPathnameForRouteMatch };