@qzsy/vinext 0.1.12 → 0.1.81

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

@@ -23,7 +23,9 @@ type InterceptingRoute = {
   sourceMatchPattern: string; /** Absolute path to the intercepting page component */
   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 */
+  layoutPaths: string[]; /** Normalized branch segments accumulated at each intercept layout. */
+  layoutSegments?: string[][]; /** Full normalized interception branch segments through the page. */
+  branchSegments?: string[]; /** Parameter names for dynamic segments */
   params: string[];
   /**
    * Synthetic page-carrier slot id for sibling (slot-less) interception.
@@ -40,7 +42,9 @@ type ParallelSlot = {
   hasPage: boolean; /** Absolute path to the slot's page component */
   pagePath: string | null; /** Absolute path to the slot's default.tsx fallback */
   defaultPath: string | null; /** Absolute path to the slot's layout component (wraps slot content) */
-  layoutPath: string | null; /** Absolute path to the slot's loading component */
+  layoutPath: string | null; /** Nested active-branch layouts whose exports contribute route config. */
+  configLayoutPaths?: string[]; /** Tree positions of configLayoutPaths relative to the slot root. */
+  configLayoutTreePositions?: number[]; /** Absolute path to the slot's loading component */
   loadingPath: string | null; /** Absolute path to the slot's error component */
   errorPath: string | null; /** Intercepting routes within this slot */
   interceptingRoutes: InterceptingRoute[];
@@ -272,6 +276,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

@@ -1,5 +1,5 @@
-import { normalizePathSeparators } from "../utils/path.js";
 import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
@@ -344,6 +344,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 };
@@ -360,12 +367,16 @@ async function buildAppRouteGraph(appDir, matcher) {
 	const routePatterns = new Set(routes.map((route) => route.pattern));
 	const ghostParentRoutes = [];
 	for await (const file of scanWithExtensions("**/layout", appDir, scanMatcher.extensions, excludeDir)) {
-		const dir = path.dirname(file);
-		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+		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;
@@ -434,11 +445,16 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 	const applySlotSubPages = (route, slotPages, rawSegments) => {
 		route.parallelSlots = route.parallelSlots.map((slot) => {
 			const subPage = slotPages.get(slot.key);
-			if (subPage !== void 0) return {
-				...slot,
-				pagePath: subPage,
-				routeSegments: rawSegments
-			};
+			if (subPage !== void 0) {
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
+				return {
+					...slot,
+					pagePath: subPage,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					routeSegments: rawSegments
+				};
+			}
 			return slot;
 		});
 	};
@@ -495,9 +511,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			if (Array.from(routesByPattern.values()).some((r) => patternsStructurallyEquivalent(r.patternParts, syntheticParts))) continue;
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
 				return {
 					...slot,
 					pagePath: subPage || null,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 					routeSegments: subPage ? rawSegments : null
 				};
 			});
@@ -574,6 +593,23 @@ function findSlotSubPages(slotDir, matcher) {
 	perMatcher.set(slotDir, results);
 	return results;
 }
+function findSlotConfigLayoutPaths(slotDir, pagePath, matcher) {
+	if (!pagePath) return [];
+	const layouts = [];
+	let dir = path.dirname(pagePath);
+	while (dir !== slotDir && dir.startsWith(`${slotDir}${path.sep}`)) {
+		const layoutPath = findFile(dir, "layout", matcher);
+		if (layoutPath) layouts.unshift(layoutPath);
+		dir = path.dirname(dir);
+	}
+	return layouts;
+}
+function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
+	return layoutPaths.map((layoutPath) => {
+		const relativeDir = path.relative(slotDir, path.dirname(layoutPath));
+		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
+	});
+}
 /**
 * Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
 * `[[...slug]]` directory that contains a `page` file. Returns the absolute
@@ -604,17 +640,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);
 }
-function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
-	const segments = dir === "." ? [] : dir.split(path.sep);
+/**
+* `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, includeNestedOnlySlots = false) {
+	const segments = dir === "." ? [] : dir.split("/");
 	const params = [];
 	let isDynamic = false;
 	const convertedRoute = convertSegmentsToRouteParts(segments);
@@ -631,7 +679,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
-	const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+	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);
@@ -640,11 +689,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,
@@ -652,7 +701,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 			slots: parallelSlots
 		}),
 		pattern: pattern === "/" ? "/" : pattern,
-		pagePath,
+		pagePath: effectivePagePath,
 		routePath,
 		layouts,
 		templates,
@@ -863,8 +912,12 @@ function discoverBoundaryFilePerLayout(layouts, fileName, matcher) {
 * Walk from appDir through each segment to the route's directory. At each level
 * that has @slot dirs, collect them. Slots at the route's own directory level
 * use page.tsx; slots at ancestor levels use default.tsx only.
+*
+* `appDir` and `routeDir` must be forward-slash — `currentDir` descends from
+* `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 = [];
@@ -875,7 +928,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 		segmentIndex: 0
 	});
 	for (let i = 0; i < segments.length; i++) {
-		currentDir = path.join(currentDir, segments[i]);
+		currentDir = path.posix.join(currentDir, segments[i]);
 		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
 		dirsToCheck.push({
 			dir: currentDir,
@@ -887,9 +940,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);
@@ -902,9 +955,12 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 				slotPatternParts = [...ownerUrl?.urlSegments ?? [], ...mirror.slotUrlSegments];
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
+			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
 			const inheritedSlot = {
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
+				configLayoutPaths,
+				configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 				layoutIndex: slotLayoutIdx,
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
@@ -1035,6 +1091,9 @@ function patternsStructurallyEquivalent(a, b) {
 *
 * Returns the absolute page path, or null if no root-level page is found.
 *
+* `slotDir` must be forward-slash: the `path.posix.join` descent stays a
+* canonical id only when the base already is.
+*
 * Only descends into route-group directories (those whose name starts with `(`
 * and ends with `)`). Dynamic segments, regular named dirs, and `@slot` dirs
 * are not transparent and are therefore not searched.
@@ -1051,16 +1110,22 @@ function findSlotRootPage(slotDir, matcher) {
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
-		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
+		const found = findSlotRootPage(path.posix.join(slotDir, entry.name), matcher);
 		if (found) return found;
 	}
 	return null;
 }
 /**
 * Discover parallel route slots (@team, @analytics, etc.) in a directory.
-* Returns a ParallelSlot for each @-prefixed subdirectory that has a page or default component.
+* 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) {
+function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = false) {
 	if (!fs.existsSync(dir)) return [];
 	const entries = fs.readdirSync(dir, { withFileTypes: true });
 	const slots = [];
@@ -1068,16 +1133,18 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
-		const slotDir = path.join(dir, entry.name);
+		const slotDir = path.posix.join(dir, entry.name);
 		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,
@@ -1085,6 +1152,8 @@ function discoverParallelSlots(dir, appDir, matcher) {
 			pagePath,
 			defaultPath,
 			layoutPath: findFile(slotDir, "layout", matcher),
+			configLayoutPaths,
+			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
 			errorPath: findFile(slotDir, "error", matcher),
 			interceptingRoutes,
@@ -1134,6 +1203,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
@@ -1237,6 +1310,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;
@@ -1245,11 +1322,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);
 	}
 }
 /**
@@ -1272,8 +1349,12 @@ 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)],
 				convention,
 				layoutPaths: [...layoutPaths],
+				layoutSegments: layoutPaths.map((layoutPath) => {
+					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
+				}),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
@@ -1407,6 +1488,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/app-router.d.ts

@@ -12,11 +12,16 @@ declare function invalidateAppRouteCache(): void;
  * TODO(#726): Layer 4 should consume this read model directly once the
  * navigation planner owns route graph facts.
  *
+ * `appDir` must be forward-slash — callers normalize it at their entry, and it
+ * flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
+ *
  * @internal
  */
 declare function appRouteGraph(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraph>;
 /**
  * Scan the app/ directory and return a list of routes.
+ *
+ * `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
  */
 declare function appRouter(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraphRoute[]>;
 /**

package/dist/routing/app-router.js

@@ -30,6 +30,9 @@ function invalidateAppRouteCache() {
 * TODO(#726): Layer 4 should consume this read model directly once the
 * navigation planner owns route graph facts.
 *
+* `appDir` must be forward-slash — callers normalize it at their entry, and it
+* flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
+*
 * @internal
 */
 async function appRouteGraph(appDir, pageExtensions, matcher) {
@@ -44,6 +47,8 @@ async function appRouteGraph(appDir, pageExtensions, matcher) {
 }
 /**
 * Scan the app/ directory and return a list of routes.
+*
+* `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
 */
 async function appRouter(appDir, pageExtensions, matcher) {
 	return (await appRouteGraph(appDir, pageExtensions, matcher)).routes;

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;
 /**
@@ -54,6 +57,11 @@ declare function buildViteResolveExtensions(pageExtensions?: readonly string[] |
 declare function normalizeViteResolveExtensions(extensions: readonly string[]): string[];
 /**
  * Use function-form exclude for Node < 22.14 compatibility.
+ *
+ * Yields forward-slash relative paths: node's glob emits native (backslash)
+ * separators on Windows, so each match is normalized — this is the entry point
+ * that lets downstream consumers treat the scanned paths as canonical
+ * forward-slash ids.
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion

package/dist/routing/file-matcher.js

@@ -1,4 +1,5 @@
 import { escapeRegExp } from "../utils/regex.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { glob } from "node:fs/promises";
@@ -66,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) {
@@ -135,13 +139,18 @@ function normalizeViteResolveExtensions(extensions) {
 }
 /**
 * Use function-form exclude for Node < 22.14 compatibility.
+*
+* Yields forward-slash relative paths: node's glob emits native (backslash)
+* separators on Windows, so each match is normalized — this is the entry point
+* that lets downstream consumers treat the scanned paths as canonical
+* forward-slash ids.
 */
 async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	const pattern = buildExtensionGlob(stem, extensions);
 	for await (const file of glob(pattern, {
 		cwd,
 		...exclude ? { exclude } : {}
-	})) yield file;
+	})) yield normalizePathSeparators(file);
 }
 //#endregion
 export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

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/app-browser-action-result.d.ts

@@ -25,6 +25,7 @@ declare function isServerActionResult<TRoot>(value: unknown): value is AppBrowse
 declare function shouldClearClientNavigationCachesForServerActionResult<TRoot>(result: AppBrowserServerActionResult<TRoot> | TRoot, revalidation?: ServerActionRevalidationKind): boolean;
 declare function parseServerActionRevalidationHeader(headers: Pick<Headers, "get">): ServerActionRevalidationKind;
 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 +62,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, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction, shouldSyncServerActionHttpFallbackHead };