vinext 0.1.7 → 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

@@ -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[];
@@ -79,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.
@@ -118,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.
@@ -272,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

@@ -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";
@@ -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 };
@@ -360,12 +384,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 +462,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;
 		});
 	};
@@ -477,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()) {
@@ -495,9 +549,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
 				};
 			});
@@ -517,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,
@@ -527,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,
@@ -541,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);
@@ -574,6 +657,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 +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);
 }
-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 +743,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 +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,
@@ -652,7 +765,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 			slots: parallelSlots
 		}),
 		pattern: pattern === "/" ? "/" : pattern,
-		pagePath,
+		pagePath: effectivePagePath,
 		routePath,
 		layouts,
 		templates,
@@ -863,8 +976,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 +992,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 +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);
@@ -902,9 +1019,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 +1155,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.
@@ -1042,42 +1165,44 @@ 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;
-		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) {
-	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;
 		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 +1210,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 +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
@@ -1237,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;
@@ -1245,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);
 	}
 }
 /**
@@ -1272,8 +1407,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 +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);