vinext 0.1.8 → 0.2.0

package/dist/plugins/typeof-window.js

@@ -1,55 +1,17 @@
 import { collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, nodeArray } from "./ast-utils.js";
+import { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, createAstScope, hasAstBinding, isFunctionNode } from "./ast-scope.js";
+import path from "node:path";
 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 !== "Program" && node.type !== "BlockStatement" && node.type !== "StaticBlock" && node.type !== "TSModuleBlock" && node.type !== "CatchClause" && node.type !== "ForStatement" && node.type !== "ForInStatement" && node.type !== "ForOfStatement" && node.type !== "ClassDeclaration" && node.type !== "ClassExpression") return null;
+	const scope = createAstScope(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);
-	}
+	collectDirectScopeBindings(node, scope);
+	if (node.type === "StaticBlock" || node.type === "TSModuleBlock") collectVarScopeBindings(node, scope);
+	if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") collectLoopScopeBindings(node, scope);
 	return scope;
 }
 function getTypeofWindowReplacement(environment) {
@@ -70,42 +32,52 @@ function evaluateTypeofWindowComparison(node, replacement, scope) {
 	].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 leftIsTypeofWindow = left?.type === "UnaryExpression" && left.operator === "typeof" && isIdentifierNamed(left.argument, "window") && !hasAstBinding(scope, "window");
+	const rightIsTypeofWindow = right?.type === "UnaryExpression" && right.operator === "typeof" && isIdentifierNamed(right.argument, "window") && !hasAstBinding(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) {
+function replaceTypeofWindow(code, replacement, id = "file.js") {
 	if (!/typeof\s+window/.test(code)) return null;
+	const extension = path.extname(id.split("?", 1)[0]);
+	const lang = extension === ".ts" || extension === ".mts" || extension === ".cts" ? "ts" : extension === ".tsx" ? "tsx" : extension === ".jsx" ? "jsx" : "js";
 	let ast;
 	try {
-		ast = parseAst(code);
+		ast = parseAst(code, { lang });
 	} 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);
+	const rootScope = createAstScope(null);
+	collectDirectScopeBindings(ast, rootScope);
+	collectVarScopeBindings(ast, rootScope);
 	function visit(node, parentScope) {
 		if (isFunctionNode(node)) {
-			const parameterScope = createScope(parentScope);
+			const parameterScope = createAstScope(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);
+				const bodyScope = createAstScope(parameterScope);
+				collectDirectScopeBindings(node.body, bodyScope);
+				collectVarScopeBindings(node.body, bodyScope);
 				visit(node.body, bodyScope);
 			} else visit(node.body, parameterScope);
 			return;
 		}
+		if (node.type === "SwitchStatement") {
+			if (isAstRecord(node.discriminant)) visit(node.discriminant, parentScope);
+			const switchScope = createAstScope(parentScope);
+			collectSwitchScopeBindings(node, switchScope);
+			for (const switchCase of nodeArray(node.cases)) if (isAstRecord(switchCase)) visit(switchCase, switchScope);
+			return;
+		}
 		const scope = createChildScope(node, parentScope) ?? parentScope;
 		if (node.type === "IfStatement" && hasRange(node)) {
 			const result = evaluateTypeofWindowComparison(node.test, replacement, scope);
@@ -132,7 +104,7 @@ function replaceTypeofWindow(code, replacement) {
 				return;
 			}
 		}
-		if (node.type === "UnaryExpression" && node.operator === "typeof" && isIdentifierNamed(node.argument, "window") && !hasBinding(scope, "window") && hasRange(node)) {
+		if (node.type === "UnaryExpression" && node.operator === "typeof" && isIdentifierNamed(node.argument, "window") && !hasAstBinding(scope, "window") && hasRange(node)) {
 			output.overwrite(node.start, node.end, JSON.stringify(replacement));
 			changed = true;
 			return;

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

@@ -83,7 +83,12 @@ type AppRoute = {
   routePath: string | null; /** Ordered list of layout files from root to leaf */
   layouts: string[]; /** Ordered list of all discovered template files from root to leaf (not necessarily aligned 1:1 with layouts) */
   templates: string[]; /** Parallel route slots (from @slot directories at the route's directory level) */
-  parallelSlots: ParallelSlot[];
+  parallelSlots: ParallelSlot[]; /** Stable implicit children-slot identity for parallel-slot sub-route families. */
+  childrenSlot?: {
+    id: string;
+    ownerTreePath: string;
+    state: "active" | "default" | "unmatched";
+  };
   /**
    * Interception markers not wrapped in an `@slot` directory.
    * On soft-nav, the intercepting page replaces the entire page response.
@@ -122,7 +127,16 @@ type AppRoute = {
    * Includes route groups and dynamic segments (as template strings like "[id]").
    * Used at render time to compute the child segments for useSelectedLayoutSegments().
    */
-  routeSegments: string[]; /** Tree position (directory depth from app/ root) for each template. */
+  routeSegments: string[];
+  /**
+   * Active filesystem segments for the default `children` slot.
+   *
+   * Synthetic routes materialized only from named parallel-slot pages still
+   * use the full `routeSegments` for URL matching, params, and route identity,
+   * but their children slot renders the parent's default.tsx. In that case the
+   * active children segments remain at the parent route.
+   */
+  childrenRouteSegments?: string[]; /** Tree position (directory depth from app/ root) for each template. */
   templateTreePositions?: number[];
   /**
    * Tree position (directory depth from app/ root) for each layout.
@@ -276,6 +290,13 @@ type RouteManifest = {
   graphVersion: GraphVersion;
   segmentGraph: StaticSegmentGraph;
 };
+/**
+ * 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.
+ */
 declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher): Promise<{
   routes: AppRouteGraphRoute[];
   routeManifest: RouteManifest;

package/dist/routing/app-route-graph.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;
@@ -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,16 @@ 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`, and the owner segments and slot key come from
+* `path.posix.relative(appDir, …)`, which only yields a forward-slash relative
+* path when both operands already are.
 */
-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 +1195,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 ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
+		const hasNestedPages = includeNestedOnlySlots && findSlotSubPages(slotDir, matcher).length > 0;
+		if (!pagePath && !defaultPath && interceptingRoutes.length === 0 && !hasNestedPages) continue;
+		const ownerSegments = path.posix.relative(appDir, dir).split("/").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}@${path.posix.relative(appDir, slotDir)}`,
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
@@ -1178,6 +1261,10 @@ 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` and `path.posix.relative` when building the
+* intercept page paths and target patterns.
+*
 * @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
@@ -1281,6 +1368,10 @@ 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` and all three reach the `path.posix.join` /
+* `path.posix.relative` calls that build the intercept page paths and patterns.
 */
 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);
 	}
 }
 /**
@@ -1455,6 +1546,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;
 /**

package/dist/routing/file-matcher.js

@@ -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) {

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