vinext 0.1.2 → 0.1.4

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)
@@ -884,11 +886,11 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 	const routeHasLayout = layoutIdx >= 0;
 	for (const { dir, layoutIdx: lvlLayoutIdx, segmentIndex } of dirsToCheck) {
 		if (lvlLayoutIdx < 0 && routeHasLayout) continue;
-		const isOwnDir = dir === routeDir;
 		const slotLayoutIdx = Math.max(lvlLayoutIdx, 0);
 		const slotsAtLevel = discoverParallelSlots(dir, appDir, matcher);
 		const segmentsBelow = segments.slice(segmentIndex);
-		for (const slot of slotsAtLevel) if (isOwnDir) {
+		const isActiveUrlLevel = dir === routeDir || segmentsBelow.every(isInvisibleSegment);
+		for (const slot of slotsAtLevel) if (isActiveUrlLevel) {
 			slot.layoutIndex = slotLayoutIdx;
 			slotMap.set(slot.key, slot);
 		} else {
@@ -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

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

package/dist/routing/utils.js

@@ -44,14 +44,66 @@ function routePrecedence(pattern) {
 	return score;
 }
 /**
-* 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)
+*/
+function sortRoutes(routes) {
+	const scores = /* @__PURE__ */ new Map();
+	for (const route of routes) if (!scores.has(route.pattern)) scores.set(route.pattern, routePrecedence(route.pattern));
+	return routes.sort((a, b) => {
+		const diff = (scores.get(a.pattern) ?? 0) - (scores.get(b.pattern) ?? 0);
+		return diff !== 0 ? diff : a.pattern.localeCompare(b.pattern);
+	});
+}
+/**
+* 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"
 */
-function compareRoutes(a, b) {
-	const diff = routePrecedence(a.pattern) - routePrecedence(b.pattern);
-	return diff !== 0 ? diff : a.pattern.localeCompare(b.pattern);
+function compareHybridRoutePatterns(pagesPattern, pagesIsDynamic, appPattern, appIsDynamic) {
+	if (pagesPattern === appPattern) throw new Error(`Conflicting app and page routes found for "${pagesPattern}"`);
+	if (!pagesIsDynamic) return appIsDynamic ? "pages" : "app";
+	if (!appIsDynamic) return "app";
+	const pagesSegments = pagesPattern.split("/").filter(Boolean);
+	const appSegments = appPattern.split("/").filter(Boolean);
+	const segmentRank = (segment) => {
+		if (!segment.startsWith(":")) return 0;
+		if (segment.endsWith("*")) return 3;
+		if (segment.endsWith("+")) return 2;
+		return 1;
+	};
+	for (let index = 0; index < Math.min(pagesSegments.length, appSegments.length); index++) {
+		const pagesRank = segmentRank(pagesSegments[index]);
+		const appRank = segmentRank(appSegments[index]);
+		if (pagesRank !== appRank) return pagesRank < appRank ? "pages" : "app";
+	}
+	if (pagesSegments.length !== appSegments.length) return pagesSegments.length < appSegments.length ? "pages" : "app";
+	return "pages";
 }
 const PATH_DELIMITER_REGEX = /([/#?\\]|%(2f|23|3f|5c))/gi;
 function encodePathDelimiters(segment) {
@@ -187,4 +239,4 @@ function countConsumedPathnameSegments(visibleTreePathSegments, pathnameSegmentC
 	return consumed;
 }
 //#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 };

package/dist/server/api-handler.d.ts

@@ -1,3 +1,4 @@
+import { NextI18nConfig } from "../config/next-config.js";
 import { Route } from "../routing/pages-router.js";
 import { ModuleImporter } from "./instrumentation.js";
 import { IncomingMessage, ServerResponse } from "node:http";
@@ -7,6 +8,10 @@ import { IncomingMessage, ServerResponse } from "node:http";
  * Handle an API route request.
  * Returns true if the request was handled, false if no API route matched.
  */
-declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[]): Promise<boolean>;
+declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[], nextConfig?: {
+  basePath?: string;
+  i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
+}): Promise<boolean>;
 //#endregion
 export { handleApiRoute };

package/dist/server/api-handler.js

@@ -1,8 +1,10 @@
+import { hasBasePath } from "../utils/base-path.js";
 import { matchRoute } from "../routing/pages-router.js";
 import "./server-globals.js";
+import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { NextRequest } from "../shims/server.js";
 import { importModule, reportRequestError } from "./instrumentation.js";
-import { mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { mergeRouteParamsIntoQuery, parseQueryString, urlQueryToSearchParams } from "../utils/query.js";
 import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT, resolveBodyParserConfig } from "./pages-body-parser-config.js";
@@ -71,13 +73,7 @@ async function parseBody(req, sizeLimit = MAX_BODY_SIZE) {
 * Parse cookies from the Cookie header.
 */
 function parseCookies(req) {
-	const header = req.headers.cookie ?? "";
-	const cookies = {};
-	for (const part of header.split(";")) {
-		const [key, ...rest] = part.split("=");
-		if (key) cookies[key.trim()] = rest.join("=").trim();
-	}
-	return cookies;
+	return parseCookieHeader(req.headers.cookie);
 }
 function isEdgeApiRouteModule(module) {
 	if (typeof module.default !== "function") return false;
@@ -98,13 +94,19 @@ function readEdgeRequestBody(req) {
 		req.on("error", (error) => controller.error(error));
 	} });
 }
-function createEdgeApiRequest(req, url) {
+function createEdgeApiRequest(req, url, params, nextConfig) {
 	const headers = new Headers();
-	for (const [name, value] of Object.entries(req.headers)) if (Array.isArray(value)) for (const item of value) headers.append(name, item);
-	else if (value !== void 0) headers.set(name, value);
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (name.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else if (value !== void 0) headers.set(name, value);
+	}
 	const proto = resolveRequestProtocol(req);
 	const host = resolveRequestHost(req, "localhost");
-	const requestUrl = new URL(url, `${proto}://${host}`);
+	const requestUrl = new URL(req.url ?? url, `${proto}://${host}`);
+	const basePath = nextConfig?.basePath;
+	if (basePath && !hasBasePath(requestUrl.pathname, basePath)) requestUrl.pathname = `${basePath}${requestUrl.pathname}`;
+	requestUrl.search = urlQueryToSearchParams(mergeRouteParamsIntoQuery(parseQueryString(url), params)).toString();
 	const body = readEdgeRequestBody(req);
 	const init = {
 		headers,
@@ -210,14 +212,18 @@ function enhanceApiObjects(req, res, query, body) {
 * Handle an API route request.
 * Returns true if the request was handled, false if no API route matched.
 */
-async function handleApiRoute(runner, req, res, url, apiRoutes) {
+async function handleApiRoute(runner, req, res, url, apiRoutes, nextConfig) {
 	const match = matchRoute(url, apiRoutes);
 	if (!match) return false;
 	const { route, params } = match;
 	try {
 		const apiModule = await importModule(runner, route.filePath);
 		if (isEdgeApiRouteModule(apiModule)) {
-			const nextRequest = new NextRequest(createEdgeApiRequest(req, url));
+			const nextRequest = new NextRequest(createEdgeApiRequest(req, url, params, nextConfig), nextConfig ? { nextConfig: {
+				basePath: nextConfig.basePath,
+				i18n: nextConfig.i18n ?? void 0,
+				trailingSlash: nextConfig.trailingSlash
+			} } : void 0);
 			const response = await apiModule.default(nextRequest);
 			if (!(response instanceof Response)) throw new Error("Edge API route did not return a Response");
 			res.statusCode = response.status;
@@ -253,7 +259,7 @@ async function handleApiRoute(runner, req, res, url, apiRoutes) {
 		reportRequestError(e instanceof Error ? e : new Error(String(e)), {
 			path: url,
 			method: req.method ?? "GET",
-			headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")]))
+			headers: Object.fromEntries(Object.entries(req.headers).filter(([k]) => !k.startsWith(":")).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : String(v ?? "")]))
 		}, {
 			routerKind: "Pages Router",
 			routePath: match.route.pattern,

package/dist/server/app-browser-action-result.d.ts

@@ -1,3 +1,5 @@
+import { ServerActionResultFacts } from "./navigation-planner.js";
+
 //#region src/server/app-browser-action-result.d.ts
 type AppBrowserServerActionResult<TRoot> = {
   root?: TRoot;
@@ -24,12 +26,23 @@ declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(r
 declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
 declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
 declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
-declare function shouldCheckRscCompatibilityForServerActionResponse(response: Pick<Response, "headers">): boolean;
-declare function resolveServerActionRedirectCompatibilityHardNavigationTarget(options: {
+type ServerActionResultResponseFactsInput = {
   actionRedirectHref: string | null;
-  clientCompatibilityId: string | null | undefined;
-  response: Pick<Response, "headers">;
-}): string | null;
+  actionRedirectType: string | null;
+  clientCompatibilityId: string | null;
+  contentTypeHeader: string | null;
+  compatibilityIdHeader: string | null;
+  currentHref: string;
+  origin: string;
+  responseUrl: string | null;
+};
+/**
+ * Converts raw browser response data into the narrow facts expected by the
+ * navigation planner. This is the single place where redirect-type
+ * normalisation and RSC content-type detection happen for server-action
+ * compatibility checks.
+ */
+declare function createServerActionResultFacts(input: ServerActionResultResponseFactsInput): ServerActionResultFacts;
 declare function shouldScheduleRefreshForDiscardedServerAction(revalidation: ServerActionRevalidationKind): boolean;
 declare function createServerActionInitiationSnapshot<TRouterState>(options: {
   href: string;
@@ -48,4 +61,4 @@ type DiscardedServerActionRefreshSchedulerOptions = {
 };
 declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
 //#endregion
-export { AppBrowserServerActionResult, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionRedirectCompatibilityHardNavigationTarget, shouldCheckRscCompatibilityForServerActionResponse, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
+export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };