vinext 0.1.8 → 0.2.1

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

@@ -1,5 +1,5 @@
-import { decodeRouteSegment, isInvisibleSegment, sortRoutes } 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";
@@ -83,6 +83,19 @@ function createStaticSegmentGraph(routes) {
 			templateIds: [...route.ids.templates],
 			slotIds: route.parallelSlots.map((slot) => slot.id).sort(compareStableStrings)
 		});
+		if (route.childrenSlot) {
+			const ownerLayoutId = findRouteManifestOwnerLayoutIdByTreePath(route, route.childrenSlot.ownerTreePath);
+			routeEntries.get(route.ids.route).slotIds = [...routeEntries.get(route.ids.route).slotIds, route.childrenSlot.id].sort(compareStableStrings);
+			slotBindings.set(`${route.ids.route}::${route.childrenSlot.id}`, {
+				id: `${route.ids.route}::${route.childrenSlot.id}`,
+				routeId: route.ids.route,
+				slotId: route.childrenSlot.id,
+				ownerLayoutId,
+				state: route.childrenSlot.state,
+				defaultId: null,
+				routeSegments: null
+			});
+		}
 		if (route.ids.page) pages.set(route.ids.page, {
 			id: route.ids.page,
 			routeId: route.ids.route,
@@ -225,6 +238,10 @@ function findRouteManifestOwnerLayoutId(route, treePosition) {
 	const layoutIndex = route.layoutTreePositions.indexOf(treePosition);
 	return route.ids.layouts[layoutIndex] ?? null;
 }
+function findRouteManifestOwnerLayoutIdByTreePath(route, treePath) {
+	const layoutIndex = route.layoutTreePositions.findIndex((treePosition) => createAppRouteGraphTreePath(route.routeSegments, treePosition) === treePath);
+	return route.ids.layouts[layoutIndex] ?? null;
+}
 function findSlotOwnerLayoutId(route, slot) {
 	if (slot.layoutIndex < 0) return null;
 	return route.ids.layouts[slot.layoutIndex] ?? null;
@@ -344,6 +361,13 @@ function createRouteManifestGraphVersion(segmentGraph) {
 	};
 	return `graph:${createHash("sha256").update(JSON.stringify(stableShape)).digest("hex")}`;
 }
+/**
+* Build the App Router route graph by scanning `appDir`.
+*
+* `appDir` must be forward-slash. Every path in the graph is derived from it
+* with `path.posix.*` and `findFile`, so a native appDir would produce mixed
+* separators on Windows. Production callers normalize it at their entry.
+*/
 async function buildAppRouteGraph(appDir, matcher) {
 	const routes = [];
 	const scanMatcher = { ...matcher };
@@ -363,9 +387,13 @@ async function buildAppRouteGraph(appDir, matcher) {
 		const dir = path.posix.dirname(file);
 		const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
-		if (discoverParallelSlots(routeDir, appDir, scanMatcher).length === 0) continue;
-		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null);
+		if (discoverParallelSlots(routeDir, appDir, scanMatcher, true).length === 0) continue;
+		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null, true);
 		if (!route) continue;
+		if (routes.some((candidate) => candidate.patternParts.length === route.patternParts.length + 1 && candidate.patternParts.at(-1)?.endsWith("*") && patternsStructurallyEquivalent(candidate.patternParts.slice(0, -1), route.patternParts))) {
+			ghostParentRoutes.push(route);
+			continue;
+		}
 		if (routePatterns.has(route.pattern)) {
 			ghostParentRoutes.push(route);
 			continue;
@@ -412,9 +440,9 @@ function validatePageRouteConflicts(routes, appDir) {
 	}
 }
 function formatAppFilePath(filePath, appDir) {
-	const relativePath = path.relative(appDir, filePath).replace(/\\/g, "/");
+	const relativePath = normalizePathSeparators(path.relative(appDir, filePath));
 	const parsedPath = path.parse(relativePath);
-	const withoutExtension = path.join(parsedPath.dir, parsedPath.name).replace(/\\/g, "/");
+	const withoutExtension = normalizePathSeparators(path.join(parsedPath.dir, parsedPath.name));
 	return withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
 }
 /**
@@ -482,8 +510,29 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			}
 		}
 		if (subPathMap.size === 0) continue;
+		const childrenOwnerTreePath = parentRoute.parallelSlots.find((slot) => path.dirname(slot.ownerDir) === parentPageDir)?.ownerTreePath;
+		if (!childrenOwnerTreePath) throw new Error(`[vinext] App route graph invariant violated: missing children slot owner for ${parentRoute.pattern}`);
 		const childrenDefault = findFile(parentPageDir, "default", matcher);
 		if (parentRoute.pagePath && !childrenDefault) continue;
+		const childrenSlotId = createAppRouteGraphSlotId("children", childrenOwnerTreePath);
+		if (parentRoute.pagePath) parentRoute.childrenSlot = {
+			id: childrenSlotId,
+			ownerTreePath: childrenOwnerTreePath,
+			state: "active"
+		};
+		for (const route of routes) {
+			if (!route.pagePath || route === parentRoute) continue;
+			const relativePageDir = path.relative(parentPageDir, path.dirname(route.pagePath));
+			if (relativePageDir === "" || relativePageDir === ".." || relativePageDir.startsWith(`..${path.sep}`) || path.isAbsolute(relativePageDir)) continue;
+			const existingOwnerDepth = route.childrenSlot?.ownerTreePath.split("/").filter(Boolean).length;
+			const candidateOwnerDepth = childrenOwnerTreePath.split("/").filter(Boolean).length;
+			if (existingOwnerDepth !== void 0 && existingOwnerDepth >= candidateOwnerDepth) continue;
+			route.childrenSlot = {
+				id: childrenSlotId,
+				ownerTreePath: childrenOwnerTreePath,
+				state: "active"
+			};
+		}
 		const childrenCatchAll = childrenDefault ? null : findCatchAllPage(parentPageDir, matcher);
 		const childrenFallback = childrenDefault ?? childrenCatchAll;
 		for (const { rawSegments, converted: convertedSubRoute, slotPages } of subPathMap.values()) {
@@ -525,6 +574,11 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				layouts: parentRoute.layouts,
 				templates: parentRoute.templates,
 				parallelSlots: subSlots,
+				childrenSlot: {
+					id: childrenSlotId,
+					ownerTreePath: childrenOwnerTreePath,
+					state: childrenDefault ? "default" : childrenCatchAll ? "active" : "unmatched"
+				},
 				loadingPath: parentRoute.loadingPath,
 				errorPath: parentRoute.errorPath,
 				layoutErrorPaths: parentRoute.layoutErrorPaths,
@@ -535,6 +589,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				unauthorizedPath: parentRoute.unauthorizedPath,
 				unauthorizedPaths: parentRoute.unauthorizedPaths,
 				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
+				childrenRouteSegments: childrenDefault ? parentRoute.routeSegments : void 0,
 				templateTreePositions: parentRoute.templateTreePositions,
 				layoutTreePositions: parentRoute.layoutTreePositions,
 				isDynamic: parentRoute.isDynamic || subIsDynamic,
@@ -549,6 +604,26 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 	}
 	return syntheticRoutes;
 }
+const dirEntriesCache = /* @__PURE__ */ new WeakMap();
+function readDirEntriesCached(dir, matcher) {
+	let perMatcher = dirEntriesCache.get(matcher);
+	if (!perMatcher) {
+		perMatcher = /* @__PURE__ */ new Map();
+		dirEntriesCache.set(matcher, perMatcher);
+	}
+	let entries = perMatcher.get(dir);
+	if (entries === void 0) {
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch (error) {
+			const code = error.code;
+			if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
+			entries = [];
+		}
+		perMatcher.set(dir, entries);
+	}
+	return entries;
+}
 const findSlotSubPagesCache = /* @__PURE__ */ new WeakMap();
 function findSlotSubPages(slotDir, matcher) {
 	let perMatcher = findSlotSubPagesCache.get(matcher);
@@ -629,23 +704,29 @@ function findCatchAllPage(dir, matcher) {
 }
 /**
 * Convert a file path relative to app/ into an AppRoute.
+*
+* `file` and `appDir` must be forward-slash. `file` comes from
+* `scanWithExtensions` (already forward-slash) and is joined onto `appDir` with
+* `path.posix.join` to form the page/route path, so a native input would
+* produce a mixed separator on Windows.
 */
 function fileToAppRoute(file, appDir, type, matcher) {
-	let dir = path.dirname(file);
-	if (type === "page" && dir !== "." && path.basename(dir) === "@children") {
-		const parent = path.dirname(dir);
+	let dir = path.posix.dirname(file);
+	if (type === "page" && dir !== "." && path.posix.basename(dir) === "@children") {
+		const parent = path.posix.dirname(dir);
 		dir = parent === "" || parent === "." ? "." : parent;
 	}
-	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
+	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.posix.join(appDir, file) : null, type === "route" ? path.posix.join(appDir, file) : null);
 }
 /**
-* `dir` and `appDir` must both be forward-slash. `dir` is split on
-* `path.posix.sep` and joined onto `appDir` with `path.posix.join`, and `appDir`
-* is threaded to the layout/slot/boundary discovery below, which build paths the
-* same way.
+* `dir`, `appDir`, `pagePath`, and `routePath` must all be forward-slash. `dir`
+* is split on `path.posix.sep` and joined onto `appDir` with `path.posix.join`.
+* `appDir` is threaded to the layout/slot/boundary discovery below, which builds
+* paths the same way. `pagePath` and `routePath` are stored on the route node as
+* canonical ids that get compared and re-joined downstream.
 */
-function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
-	const segments = dir === "." ? [] : dir.split(path.posix.sep);
+function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeNestedOnlySlots = false) {
+	const segments = dir === "." ? [] : dir.split("/");
 	const params = [];
 	let isDynamic = false;
 	const convertedRoute = convertSegmentsToRouteParts(segments);
@@ -663,6 +744,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
 	const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
+	const effectivePagePath = pagePath ?? (routePath ? null : findFile(routeDir, "default", matcher));
 	const loadingPath = findFile(routeDir, "loading", matcher);
 	const errorPath = findFile(routeDir, "error", matcher);
 	const notFoundPath = discoverBoundaryFile(segments, appDir, "not-found", matcher);
@@ -671,11 +753,11 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
 	const forbiddenPaths = discoverBoundaryFilePerLayout(layouts, "forbidden", matcher);
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
-	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher);
+	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, includeNestedOnlySlots);
 	return {
 		ids: createAppRouteSemanticIds({
 			pattern: pattern === "/" ? "/" : pattern,
-			pagePath,
+			pagePath: effectivePagePath,
 			routePath,
 			routeSegments: segments,
 			layoutTreePositions,
@@ -683,7 +765,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 			slots: parallelSlots
 		}),
 		pattern: pattern === "/" ? "/" : pattern,
-		pagePath,
+		pagePath: effectivePagePath,
 		routePath,
 		layouts,
 		templates,
@@ -899,7 +981,7 @@ function discoverBoundaryFilePerLayout(layouts, fileName, matcher) {
 * `appDir` via `path.posix.join`, and the `dir === routeDir` active-level test
 * below only matches when both share the canonical separator.
 */
-function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
+function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, includeNestedOnlySlots = false) {
 	const slotMap = /* @__PURE__ */ new Map();
 	let currentDir = appDir;
 	const dirsToCheck = [];
@@ -922,9 +1004,9 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 	for (const { dir, layoutIdx: lvlLayoutIdx, segmentIndex } of dirsToCheck) {
 		if (lvlLayoutIdx < 0 && routeHasLayout) continue;
 		const slotLayoutIdx = Math.max(lvlLayoutIdx, 0);
-		const slotsAtLevel = discoverParallelSlots(dir, appDir, matcher);
 		const segmentsBelow = segments.slice(segmentIndex);
 		const isActiveUrlLevel = dir === routeDir || segmentsBelow.every(isInvisibleSegment);
+		const slotsAtLevel = discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots && isActiveUrlLevel);
 		for (const slot of slotsAtLevel) if (isActiveUrlLevel) {
 			slot.layoutIndex = slotLayoutIdx;
 			slotMap.set(slot.key, slot);
@@ -1083,12 +1165,7 @@ function patternsStructurallyEquivalent(a, b) {
 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;
-	}
+	const entries = readDirEntriesCached(slotDir, matcher);
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
@@ -1099,11 +1176,14 @@ function findSlotRootPage(slotDir, matcher) {
 }
 /**
 * Discover parallel route slots (@team, @analytics, etc.) in a directory.
-* Returns a ParallelSlot for each @-prefixed subdirectory that has a page or default component.
+* Returns a ParallelSlot for each @-prefixed subdirectory that has a page,
+* default component, intercepting route, or nested page-backed sub-route.
+*
+* `dir` and `appDir` must be forward-slash. The slot directory is built from
+* `dir` with `path.posix.join`.
 */
-function discoverParallelSlots(dir, appDir, matcher) {
-	if (!fs.existsSync(dir)) return [];
-	const entries = fs.readdirSync(dir, { withFileTypes: true });
+function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = false) {
+	const entries = readDirEntriesCached(dir, matcher);
 	const slots = [];
 	for (const entry of entries) {
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
@@ -1113,13 +1193,14 @@ function discoverParallelSlots(dir, appDir, 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;
+		const hasNestedPages = includeNestedOnlySlots && findSlotSubPages(slotDir, matcher).length > 0;
+		if (!pagePath && !defaultPath && interceptingRoutes.length === 0 && !hasNestedPages) continue;
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
-			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
+			key: `${slotName}@${normalizePathSeparators(path.relative(appDir, slotDir))}`,
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
@@ -1178,6 +1259,9 @@ function isInterceptionMarkerDir(name) {
 * Intercepting routes use conventions like (.)photo, (..)feed, (...), etc.
 * They intercept navigation to another route and render within the slot instead.
 *
+* `slotDir`, `routeDir`, and `appDir` must be forward-slash. They are passed
+* down to `path.posix.join` when building the intercept page paths.
+*
 * @param slotDir - The parallel slot directory (e.g. app/feed/@modal)
 * @param routeDir - The directory of the route that owns this slot (e.g. app/feed)
 * @param appDir - The root app directory
@@ -1196,13 +1280,17 @@ function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 * Sibling intercepts use the same conventions and target-computation logic as
 * slot intercepts, but their intercepting page replaces the full page response
 * (not a slot) during soft navigation.
+*
+* `appDir` and each route's `pagePath` / `routePath` must be forward-slash. The
+* owner directories are derived from `pagePath` / `routePath` and matched
+* against `appDir`-relative paths built with `path.posix.*`.
 */
 function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 	const routesByDir = /* @__PURE__ */ new Map();
 	for (const route of routes) {
 		const filePath = route.pagePath ?? route.routePath;
 		if (!filePath) continue;
-		const routeDir = normalizePathSeparators(path.dirname(filePath));
+		const routeDir = path.posix.dirname(filePath);
 		if (!routesByDir.has(routeDir)) routesByDir.set(routeDir, route);
 	}
 	function walk(dir) {
@@ -1216,7 +1304,7 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 			if (!entry.isDirectory()) continue;
 			if (entry.name.startsWith("_")) continue;
 			if (entry.name.startsWith("@")) continue;
-			const childDir = path.join(dir, entry.name);
+			const childDir = path.posix.join(dir, entry.name);
 			const marker = matchInterceptConvention(entry.name);
 			if (marker) {
 				const restOfName = entry.name.slice(marker.prefix.length);
@@ -1281,6 +1369,9 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 /**
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
+*
+* `currentDir`, `routeDir`, and `appDir` must be forward-slash. `currentDir`
+* descends with `path.posix.join` when building the intercept page paths.
 */
 function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher) {
 	if (!fs.existsSync(currentDir)) return;
@@ -1289,11 +1380,11 @@ function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
 		const interceptMatch = matchInterceptConvention(entry.name);
+		const interceptDir = path.posix.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			const interceptDir = path.join(currentDir, entry.name);
 			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, results, matcher);
-		} else scanForInterceptingPages(path.join(currentDir, entry.name), routeDir, appDir, results, matcher);
+		} else scanForInterceptingPages(interceptDir, routeDir, appDir, results, matcher);
 	}
 }
 /**
@@ -1306,6 +1397,12 @@ function matchInterceptConvention(name) {
 /**
 * Collect page.tsx files inside an intercepting route directory tree
 * and compute their target URL patterns.
+*
+* `currentDir`, `interceptRoot`, `routeDir`, `appDir`, and `interceptParentDir`
+* must all be forward-slash. `currentDir` descends with `path.posix.join` and
+* its `findFile` results become the stored layout/page paths. The others are
+* relativized against `appDir` (and each other) to derive the intercept page
+* segments and URL patterns.
 */
 function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, parentLayoutPaths = []) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
@@ -1316,7 +1413,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
 			results.push({
-				branchSegments: [interceptSegment, ...normalizePathSeparators(path.relative(interceptRoot, path.dirname(page))).split("/").filter(Boolean)],
+				branchSegments: [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)],
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
@@ -1335,7 +1432,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
-		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.posix.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
 	}
 }
 /**
@@ -1455,6 +1552,9 @@ const findFileProbeCache = /* @__PURE__ */ new WeakMap();
 * 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.
+*
+* `dir` must be forward-slash. The returned path comes from `findFileWithExts`,
+* so it is forward-slash too.
 */
 function findFile(dir, name, matcher) {
 	const cache = findFileProbeCache.get(matcher);

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

@@ -21,6 +21,9 @@ declare function findFileWithExtensions(basePath: string, matcher: ValidFileMatc
 /**
  * Find a file by basename and configured page extension in a directory.
  * Returns the first matching absolute path, or null if not found.
+ *
+ * `dir` must be forward-slash. The returned path is built with `path.posix.join`,
+ * so it is forward-slash too.
  */
 declare function findFileWithExts(dir: string, name: string, matcher: ValidFileMatcher): string | null;
 /**
@@ -36,11 +39,18 @@ declare function findFileWithExts(dir: string, name: string, matcher: ValidFileM
  *  1. User-configured pageExtensions go first (each prefixed with `.`) so
  *     the user's priority wins. e.g. `.platform.tsx` resolves before `.tsx`.
  *  2. Vite's defaults follow, with duplicates removed.
+ *  3. `.cjs`/`.cts` go last (lowest priority). Neither Vite's defaults nor the
+ *     user's pageExtensions include them, but `vinext init` renames CJS config
+ *     files (e.g. `tailwind.config.js` → `tailwind.config.cjs`) when it adds
+ *     `"type": "module"`, and app code imports those extensionlessly
+ *     (`import cfg from "../tailwind.config"`). Without these, the bundle fails
+ *     with "[UNRESOLVED_IMPORT] Could not resolve '../tailwind.config'".
  *
  * The user's pageExtensions retain their relative order, which is what
  * Next.js / Turbopack do via the `resolveExtensions` config option.
  *
- * See: cloudflare/vinext#1502
+ * See: cloudflare/vinext#1502 for page-extension ordering, and
+ * cloudflare/vinext#2435 for extensionless `.cjs` config imports.
  */
 declare function buildViteResolveExtensions(pageExtensions?: readonly string[] | null, viteDefaults?: readonly string[]): string[];
 /**

package/dist/routing/file-matcher.js

@@ -1,5 +1,5 @@
-import { escapeRegExp } from "../utils/regex.js";
 import { normalizePathSeparators } from "../utils/path.js";
+import { escapeRegExp } from "../utils/regex.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { glob } from "node:fs/promises";
@@ -67,6 +67,9 @@ function findFileWithExtensions(basePath, matcher) {
 /**
 * Find a file by basename and configured page extension in a directory.
 * Returns the first matching absolute path, or null if not found.
+*
+* `dir` must be forward-slash. The returned path is built with `path.posix.join`,
+* so it is forward-slash too.
 */
 function findFileWithExts(dir, name, matcher) {
 	for (const ext of matcher.dottedExtensions) {
@@ -88,11 +91,18 @@ function findFileWithExts(dir, name, matcher) {
 *  1. User-configured pageExtensions go first (each prefixed with `.`) so
 *     the user's priority wins. e.g. `.platform.tsx` resolves before `.tsx`.
 *  2. Vite's defaults follow, with duplicates removed.
+*  3. `.cjs`/`.cts` go last (lowest priority). Neither Vite's defaults nor the
+*     user's pageExtensions include them, but `vinext init` renames CJS config
+*     files (e.g. `tailwind.config.js` → `tailwind.config.cjs`) when it adds
+*     `"type": "module"`, and app code imports those extensionlessly
+*     (`import cfg from "../tailwind.config"`). Without these, the bundle fails
+*     with "[UNRESOLVED_IMPORT] Could not resolve '../tailwind.config'".
 *
 * The user's pageExtensions retain their relative order, which is what
 * Next.js / Turbopack do via the `resolveExtensions` config option.
 *
-* See: cloudflare/vinext#1502
+* See: cloudflare/vinext#1502 for page-extension ordering, and
+* cloudflare/vinext#2435 for extensionless `.cjs` config imports.
 */
 function buildViteResolveExtensions(pageExtensions, viteDefaults = [
 	".mjs",
@@ -106,7 +116,12 @@ function buildViteResolveExtensions(pageExtensions, viteDefaults = [
 	const dotted = normalizePageExtensions(pageExtensions).map((ext) => `.${ext}`);
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
-	for (const ext of [...dotted, ...viteDefaults]) {
+	for (const ext of [
+		...dotted,
+		...viteDefaults,
+		".cjs",
+		".cts"
+	]) {
 		if (seen.has(ext)) continue;
 		seen.add(ext);
 		result.push(ext);

package/dist/routing/pages-router.js

@@ -63,7 +63,7 @@ async function scanPageRoutes(pagesDir, matcher) {
 function fileToRoute(file, pagesDir, matcher) {
 	const withoutExt = matcher.stripExtension(file);
 	if (withoutExt === file) return null;
-	const segments = withoutExt.split(path.sep);
+	const segments = withoutExt.split("/");
 	if (segments[segments.length - 1] === "index") segments.pop();
 	const params = [];
 	let isDynamic = false;
@@ -152,7 +152,7 @@ async function scanApiRoutes(pagesDir, matcher) {
 	}
 	const routes = [];
 	for (const file of files) {
-		const route = fileToRoute(path.join("api", file), pagesDir, matcher);
+		const route = fileToRoute(path.posix.join("api", file), pagesDir, matcher);
 		if (route) routes.push(route);
 	}
 	validateRoutePatterns(routes.map((route) => route.pattern));

package/dist/server/api-handler.js

@@ -1,15 +1,15 @@
 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, 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";
+import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-media-type.js";
 import { resolveRequestHost, resolveRequestProtocol } from "./proxy-trust.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
+import { attachPagesRequestCookies } from "./pages-node-compat.js";
+import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 import { decode } from "node:querystring";
 import { Buffer } from "node:buffer";
 //#region src/server/api-handler.ts
@@ -69,12 +69,6 @@ async function parseBody(req, sizeLimit = MAX_BODY_SIZE) {
 		});
 	});
 }
-/**
-* Parse cookies from the Cookie header.
-*/
-function parseCookies(req) {
-	return parseCookieHeader(req.headers.cookie);
-}
 function isEdgeApiRouteModule(module) {
 	if (typeof module.default !== "function") return false;
 	const bare = module.runtime;
@@ -167,12 +161,13 @@ async function writeEdgeApiResponseBody(res, body) {
 * Enhance a Node.js req/res pair with Next.js API route helpers.
 */
 function enhanceApiObjects(req, res, query, body) {
+	const apiReq = Object.assign(req, {
+		body,
+		query
+	});
+	attachPagesRequestCookies(apiReq);
 	return {
-		apiReq: Object.assign(req, {
-			body,
-			cookies: parseCookies(req),
-			query
-		}),
+		apiReq,
 		apiRes: Object.assign(res, {
 			status(code) {
 				this.statusCode = code;

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

@@ -1,3 +1,4 @@
+import { OperationLane } from "./operation-token.js";
 import { ServerActionResultFacts } from "./navigation-planner.js";
 
 //#region src/server/app-browser-action-result.d.ts
@@ -24,7 +25,9 @@ type ServerActionInitiationSnapshot<TRouterState> = {
 declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowserServerActionResult<TRoot>;
 declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
 declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
+declare function resolveServerActionOperationLane(revalidation: ServerActionRevalidationKind): Extract<OperationLane, "refresh" | "server-action">;
 declare function normalizeServerActionThrownValue(data: unknown, responseStatus: number): unknown;
+declare function shouldSyncServerActionHttpFallbackHead<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot): boolean;
 declare function readInvalidServerActionResponseError(response: Pick<Response, "headers" | "status" | "text">, hasRedirectLocation: boolean): Promise<Error | null>;
 type ServerActionResultResponseFactsInput = {
   actionRedirectHref: string | null;
@@ -61,4 +64,4 @@ type DiscardedServerActionRefreshSchedulerOptions = {
 };
 declare function createDiscardedServerActionRefreshScheduler(options: DiscardedServerActionRefreshSchedulerOptions): DiscardedServerActionRefreshScheduler;
 //#endregion
-export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
+export { AppBrowserServerActionResult, ServerActionResultResponseFactsInput, ServerActionRevalidationKind, createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionOperationLane, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction, shouldSyncServerActionHttpFallbackHead };

package/dist/server/app-browser-action-result.js

@@ -32,6 +32,9 @@ function parseServerActionRevalidationHeader(headers) {
 		default: return "none";
 	}
 }
+function resolveServerActionOperationLane(revalidation) {
+	return revalidation === "none" ? "server-action" : "refresh";
+}
 function createServerActionHttpFallbackError(status) {
 	if (status !== 401 && status !== 403 && status !== 404) return null;
 	const digest = status === 404 ? "NEXT_HTTP_ERROR_FALLBACK;404" : `NEXT_HTTP_ERROR_FALLBACK;${status}`;
@@ -41,6 +44,10 @@ function createServerActionHttpFallbackError(status) {
 function normalizeServerActionThrownValue(data, responseStatus) {
 	return createServerActionHttpFallbackError(responseStatus) ?? data;
 }
+function shouldSyncServerActionHttpFallbackHead(result) {
+	if (!isServerActionResult(result) || result.root !== void 0) return false;
+	return result.returnValue?.ok !== false;
+}
 async function readInvalidServerActionResponseError(response, hasRedirectLocation) {
 	const contentType = response.headers.get("content-type") ?? "";
 	if (contentType.startsWith("text/x-component") || hasRedirectLocation) return null;
@@ -108,4 +115,4 @@ function createDiscardedServerActionRefreshScheduler(options) {
 	};
 }
 //#endregion
-export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
+export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, resolveServerActionOperationLane, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction, shouldSyncServerActionHttpFallbackHead };