vinext 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/plugins/sass.js

@@ -1,7 +1,7 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { markCssUrlAssetReferences, rebaseCssUrlAssetReferences } from "../build/css-url-assets.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
 import { preprocessCSS } from "vite";
 import { pathToFileURL } from "node:url";
 //#region src/plugins/sass.ts
@@ -98,7 +98,7 @@ function sassStylesheetCandidates(importPath) {
 	return candidates;
 }
 function deriveSassNamespace(importUrl) {
-	const parts = importUrl.replaceAll("\\", "/").replace(/\/$/, "").split("/");
+	const parts = toSlash(importUrl).replace(/\/$/, "").split("/");
 	let basename = parts.pop() ?? "stylesheet";
 	basename = basename.replace(/^_/, "").replace(/\..*$/, "");
 	if (basename === "index" && parts.length > 0) basename = (parts.pop() ?? basename).replace(/^_/, "").replace(/\..*$/, "");

package/dist/plugins/server-externals-manifest.js

@@ -1,6 +1,6 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { builtinModules } from "node:module";
 import fs from "node:fs";
-import path from "node:path";
 //#region src/plugins/server-externals-manifest.ts
 const BUILTIN_MODULES = new Set(builtinModules.flatMap((name) => name.startsWith("node:") ? [name, name.slice(5)] : [name, `node:${name}`]));
 /**

package/dist/plugins/strip-server-exports.js

@@ -1,7 +1,7 @@
 import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/strip-server-exports.ts
-const SERVER_EXPORTS = new Set([
+const SERVER_EXPORTS = /* @__PURE__ */ new Set([
 	"getServerSideProps",
 	"getStaticProps",
 	"getStaticPaths",

package/dist/plugins/styled-jsx.js

@@ -1,5 +1,5 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { createRequire } from "node:module";
-import path from "node:path";
 import { parseAst } from "vite";
 import { pathToFileURL } from "node:url";
 //#region src/plugins/styled-jsx.ts
@@ -75,7 +75,8 @@ function createStyledJsxPlugin(initialProjectRoot, options = {}) {
 		if (!compilerPromise) {
 			const requireFromNext = getNextRequire();
 			if (!requireFromNext) throw new Error("[vinext] styled-jsx requires an installed next package so vinext can use its matching compiler.");
-			compilerPromise = importModule(pathToFileURL(requireFromNext.resolve("next/dist/build/swc")).href).then(async (compiler) => {
+			const compilerPath = requireFromNext.resolve("next/dist/build/swc");
+			compilerPromise = importModule(pathToFileURL(compilerPath).href).then(async (compiler) => {
 				await compiler.loadBindings();
 				return compiler;
 			});

package/dist/plugins/typeof-window.js

@@ -1,6 +1,6 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 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

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

@@ -25,7 +25,10 @@ type InterceptingRoute = {
   sourcePageSegments?: string[]; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   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 */
+  branchSegments?: string[]; /** Nearest not-found convention inside the interception branch. */
+  notFoundPath?: string | null; /** Slot-root-relative branch segments used to scope not-found params. */
+  notFoundBranchSegments?: string[]; /** Tree position relative to the normalized interception branch. */
+  notFoundTreePosition?: number | null; /** Parameter names for dynamic segments */
   params: string[];
   /**
    * Synthetic page-carrier slot id for sibling (slot-less) interception.
@@ -46,7 +49,9 @@ type ParallelSlot = {
   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 */
+  errorPath: string | null; /** Nearest not-found convention for the slot's active branch. */
+  notFoundPath?: string | null; /** Tree position of that convention relative to the slot root. */
+  notFoundTreePosition?: number | null; /** Intercepting routes within this slot */
   interceptingRoutes: InterceptingRoute[];
   /**
    * The layout index (0-based, in route.layouts[]) that this slot belongs to.
@@ -105,7 +110,8 @@ type AppRoute = {
   layoutErrorPaths: (string | null)[]; /** Per-segment error boundary paths, aligned with errorTreePositions. */
   errorPaths?: string[]; /** Tree position (directory depth from app/ root) for each error boundary. */
   errorTreePositions?: number[]; /** Not-found component path (nearest, walking up from page dir) */
-  notFoundPath: string | null;
+  notFoundPath: string | null; /** Tree position of the nearest not-found component's owning segment. */
+  notFoundTreePosition?: number | null;
   /**
    * Not-found component paths per layout level (aligned with layouts array).
    * Each entry is the not-found.tsx at that layout's directory, or null.
@@ -119,8 +125,10 @@ type AppRoute = {
    * Used to create per-layout ForbiddenBoundary.
    */
   forbiddenPaths: (string | null)[]; /** Forbidden component path (403) at the route's directory level */
-  forbiddenPath: string | null; /** Unauthorized component path (401) at the route's directory level */
-  unauthorizedPath: string | null; /** Unauthorized component paths per layout level (aligned with layouts array). */
+  forbiddenPath: string | null; /** Tree position of the nearest forbidden component's owning segment. */
+  forbiddenTreePosition?: number | null; /** Unauthorized component path (401) at the route's directory level */
+  unauthorizedPath: string | null; /** Tree position of the nearest unauthorized component's owning segment. */
+  unauthorizedTreePosition?: number | null; /** Unauthorized component paths per layout level (aligned with layouts array). */
   unauthorizedPaths: (string | null)[];
   /**
    * Filesystem segments from app/ root to the route's directory.
@@ -292,10 +300,6 @@ type RouteManifest = {
 };
 /**
  * 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[];
@@ -314,12 +318,9 @@ declare function computeRootParamNames(routeSegments: readonly string[], layoutT
  *    no sibling pages at all (e.g. `deep/path/(...)target` with no
  *    `deep/path/page.tsx`).
  *
- * All comparisons happen in forward-slash space: `appDir` is forward-slash
- * (normalized once in the config hook), but `dir` and route file paths
- * descend through native `path.join`/`path.dirname`, which reintroduce
- * backslashes on Windows. Without normalizing, the `current === appDir`
- * termination never fires there and the walk overshoots the app root.
- * `routesByDir` keys must be forward-slash dirnames of the route file paths.
+ * Comparisons happen in forward-slash space — inputs go through `toSlash` so
+ * callers still holding native-separator paths hit the `current === appDir`
+ * termination instead of overshooting the app root.
  *
  * Exported for tests.
  */

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

@@ -1,10 +1,9 @@
-import { normalizePathSeparators } from "../utils/path.js";
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { decodeRouteSegment, isInvisibleSegment, sortRoutes } from "./utils.js";
 import { findFileWithExts, scanWithExtensions } from "./file-matcher.js";
 import { validateRoutePatterns } from "./route-validation.js";
 import { compareStrings } from "../utils/compare.js";
 import fs from "node:fs";
-import path from "node:path";
 import { createHash } from "node:crypto";
 //#region src/routing/app-route-graph.ts
 /**
@@ -363,10 +362,6 @@ function createRouteManifestGraphVersion(segmentGraph) {
 }
 /**
 * 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 = [];
@@ -384,8 +379,8 @@ 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.posix.dirname(file);
-		const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
+		const dir = path.dirname(file);
+		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
 		if (discoverParallelSlots(routeDir, appDir, scanMatcher, true).length === 0) continue;
 		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null, true);
@@ -440,9 +435,9 @@ function validatePageRouteConflicts(routes, appDir) {
 	}
 }
 function formatAppFilePath(filePath, appDir) {
-	const relativePath = normalizePathSeparators(path.relative(appDir, filePath));
+	const relativePath = path.relative(appDir, filePath);
 	const parsedPath = path.parse(relativePath);
-	const withoutExtension = normalizePathSeparators(path.join(parsedPath.dir, parsedPath.name));
+	const withoutExtension = path.join(parsedPath.dir, parsedPath.name);
 	return withoutExtension.startsWith("/") ? withoutExtension : `/${withoutExtension}`;
 }
 /**
@@ -464,11 +459,14 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subPage = slotPages.get(slot.key);
 			if (subPage !== void 0) {
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
+				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage, matcher);
 				return {
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					notFoundPath: notFoundBoundary.path,
+					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
 				};
 			}
@@ -550,11 +548,14 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
 				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
+				const notFoundBoundary = findSlotNotFoundBoundary(slot.ownerDir, subPage ?? null, matcher);
 				return {
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					notFoundPath: notFoundBoundary.path,
+					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
 				};
 			});
@@ -583,10 +584,13 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				errorPath: parentRoute.errorPath,
 				layoutErrorPaths: parentRoute.layoutErrorPaths,
 				notFoundPath: parentRoute.notFoundPath,
+				notFoundTreePosition: parentRoute.notFoundTreePosition,
 				notFoundPaths: parentRoute.notFoundPaths,
 				forbiddenPaths: parentRoute.forbiddenPaths,
 				forbiddenPath: parentRoute.forbiddenPath,
+				forbiddenTreePosition: parentRoute.forbiddenTreePosition,
 				unauthorizedPath: parentRoute.unauthorizedPath,
+				unauthorizedTreePosition: parentRoute.unauthorizedTreePosition,
 				unauthorizedPaths: parentRoute.unauthorizedPaths,
 				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 				childrenRouteSegments: childrenDefault ? parentRoute.routeSegments : void 0,
@@ -674,6 +678,25 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
 	});
 }
+function findSlotNotFoundBoundary(slotDir, pagePath, matcher) {
+	let dir = pagePath ? path.dirname(pagePath) : slotDir;
+	while (dir === slotDir || dir.startsWith(`${slotDir}${path.sep}`)) {
+		const boundaryPath = findFile(dir, "not-found", matcher);
+		if (boundaryPath) {
+			const relativeDir = path.relative(slotDir, dir);
+			return {
+				path: boundaryPath,
+				treePosition: relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0
+			};
+		}
+		if (dir === slotDir) break;
+		dir = path.dirname(dir);
+	}
+	return {
+		path: null,
+		treePosition: null
+	};
+}
 /**
 * Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
 * `[[...slug]]` directory that contains a `page` file. Returns the absolute
@@ -704,27 +727,15 @@ 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.posix.dirname(file);
-	if (type === "page" && dir !== "." && path.posix.basename(dir) === "@children") {
-		const parent = path.posix.dirname(dir);
+	let dir = path.dirname(file);
+	if (type === "page" && dir !== "." && path.basename(dir) === "@children") {
+		const parent = path.dirname(dir);
 		dir = parent === "" || parent === "." ? "." : parent;
 	}
-	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.posix.join(appDir, file) : null, type === "route" ? path.posix.join(appDir, file) : null);
+	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
 }
-/**
-* `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 = [];
@@ -743,13 +754,16 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	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.posix.join(appDir, dir);
+	const routeDir = dir === "." ? appDir : path.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);
-	const forbiddenPath = discoverBoundaryFile(segments, appDir, "forbidden", matcher);
-	const unauthorizedPath = discoverBoundaryFile(segments, appDir, "unauthorized", matcher);
+	const notFoundEntry = discoverBoundaryFileEntry(segments, appDir, "not-found", matcher);
+	const notFoundPath = notFoundEntry?.path ?? null;
+	const forbiddenEntry = discoverBoundaryFileEntry(segments, appDir, "forbidden", matcher);
+	const forbiddenPath = forbiddenEntry?.path ?? null;
+	const unauthorizedEntry = discoverBoundaryFileEntry(segments, appDir, "unauthorized", matcher);
+	const unauthorizedPath = unauthorizedEntry?.path ?? null;
 	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
 	const forbiddenPaths = discoverBoundaryFilePerLayout(layouts, "forbidden", matcher);
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
@@ -776,10 +790,13 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		errorPaths,
 		errorTreePositions,
 		notFoundPath,
+		notFoundTreePosition: notFoundEntry?.treePosition ?? null,
 		notFoundPaths,
 		forbiddenPaths,
 		forbiddenPath,
+		forbiddenTreePosition: forbiddenEntry?.treePosition ?? null,
 		unauthorizedPath,
+		unauthorizedTreePosition: unauthorizedEntry?.treePosition ?? null,
 		unauthorizedPaths,
 		routeSegments: segments,
 		templateTreePositions,
@@ -850,8 +867,9 @@ function convertTreePathToRouteParts(treePath) {
 function computeLayoutTreePositions(appDir, layouts) {
 	return layouts.map((layoutPath) => {
 		const layoutDir = path.dirname(layoutPath);
-		if (layoutDir === appDir) return 0;
-		return path.relative(appDir, layoutDir).split(path.sep).length;
+		const relative = path.relative(appDir, layoutDir);
+		if (relative === "") return 0;
+		return relative.split(path.sep).length;
 	});
 }
 /**
@@ -937,7 +955,7 @@ function discoverLayoutAlignedErrors(segments, appDir, matcher) {
 * by walking from the route's directory up to the app root.
 * Returns the first (closest) file found, or null.
 */
-function discoverBoundaryFile(segments, appDir, fileName, matcher) {
+function discoverBoundaryFileEntry(segments, appDir, fileName, matcher) {
 	const dirs = [];
 	let dir = appDir;
 	dirs.push(dir);
@@ -947,7 +965,10 @@ function discoverBoundaryFile(segments, appDir, fileName, matcher) {
 	}
 	for (let i = dirs.length - 1; i >= 0; i--) {
 		const f = findFile(dirs[i], fileName, matcher);
-		if (f) return f;
+		if (f) return {
+			path: f,
+			treePosition: i
+		};
 	}
 	return null;
 }
@@ -976,10 +997,6 @@ 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, includeNestedOnlySlots = false) {
 	const slotMap = /* @__PURE__ */ new Map();
@@ -992,7 +1009,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, inc
 		segmentIndex: 0
 	});
 	for (let i = 0; i < segments.length; i++) {
-		currentDir = path.posix.join(currentDir, segments[i]);
+		currentDir = path.join(currentDir, segments[i]);
 		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
 		dirsToCheck.push({
 			dir: currentDir,
@@ -1155,9 +1172,6 @@ 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.
@@ -1169,7 +1183,7 @@ 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.posix.join(slotDir, entry.name), matcher);
+		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
 		if (found) return found;
 	}
 	return null;
@@ -1178,9 +1192,6 @@ 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,
 * default component, intercepting route, or nested page-backed sub-route.
-*
-* `dir` and `appDir` must be forward-slash. The slot directory is built from
-* `dir` with `path.posix.join`.
 */
 function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = false) {
 	const entries = readDirEntriesCached(dir, matcher);
@@ -1189,7 +1200,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
-		const slotDir = path.posix.join(dir, entry.name);
+		const slotDir = path.join(dir, entry.name);
 		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
@@ -1198,9 +1209,10 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
+		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
-			key: `${slotName}@${normalizePathSeparators(path.relative(appDir, slotDir))}`,
+			key: `${slotName}@${path.relative(appDir, slotDir)}`,
 			name: slotName,
 			ownerDir: slotDir,
 			ownerTreePath,
@@ -1212,6 +1224,8 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
 			errorPath: findFile(slotDir, "error", matcher),
+			notFoundPath: notFoundBoundary.path,
+			notFoundTreePosition: notFoundBoundary.treePosition,
 			interceptingRoutes,
 			layoutIndex: -1,
 			routeSegments: pagePath ? [] : null
@@ -1259,9 +1273,6 @@ function isInterceptionMarkerDir(name) {
 * Intercepting routes use conventions like (.)photo, (..)feed, (...), etc.
 * They intercept navigation to another route and render within the slot instead.
 *
-* `slotDir`, `routeDir`, and `appDir` must be forward-slash. They are passed
-* down to `path.posix.join` when building the intercept page paths.
-*
 * @param slotDir - The parallel slot directory (e.g. app/feed/@modal)
 * @param routeDir - The directory of the route that owns this slot (e.g. app/feed)
 * @param appDir - The root app directory
@@ -1269,7 +1280,7 @@ function isInterceptionMarkerDir(name) {
 function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 	if (!fs.existsSync(slotDir)) return [];
 	const results = [];
-	scanForInterceptingPages(slotDir, routeDir, appDir, results, matcher);
+	scanForInterceptingPages(slotDir, slotDir, routeDir, appDir, results, matcher);
 	return results;
 }
 /**
@@ -1280,17 +1291,13 @@ function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 * Sibling intercepts use the same conventions and target-computation logic as
 * slot intercepts, but their intercepting page replaces the full page response
 * (not a slot) during soft navigation.
-*
-* `appDir` and each route's `pagePath` / `routePath` must be forward-slash. The
-* owner directories are derived from `pagePath` / `routePath` and matched
-* against `appDir`-relative paths built with `path.posix.*`.
 */
 function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 	const routesByDir = /* @__PURE__ */ new Map();
 	for (const route of routes) {
 		const filePath = route.pagePath ?? route.routePath;
 		if (!filePath) continue;
-		const routeDir = path.posix.dirname(filePath);
+		const routeDir = path.dirname(filePath);
 		if (!routesByDir.has(routeDir)) routesByDir.set(routeDir, route);
 	}
 	function walk(dir) {
@@ -1304,13 +1311,13 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 			if (!entry.isDirectory()) continue;
 			if (entry.name.startsWith("_")) continue;
 			if (entry.name.startsWith("@")) continue;
-			const childDir = path.posix.join(dir, entry.name);
+			const childDir = path.join(dir, entry.name);
 			const marker = matchInterceptConvention(entry.name);
 			if (marker) {
 				const restOfName = entry.name.slice(marker.prefix.length);
 				const parentDir = dir;
 				const results = [];
-				collectInterceptingPages(childDir, childDir, marker.convention, restOfName, parentDir, appDir, parentDir, results, matcher);
+				collectInterceptingPages(childDir, childDir, marker.convention, restOfName, parentDir, appDir, parentDir, null, results, matcher);
 				for (const ir of results) {
 					ir.slotId = createAppRouteGraphSiblingInterceptSlotId(ir.sourceMatchPattern);
 					const owner = findOwnerRouteForDir(parentDir, appDir, routes, routesByDir);
@@ -1335,18 +1342,15 @@ function discoverSiblingInterceptingRoutes(routes, appDir, matcher) {
 *    no sibling pages at all (e.g. `deep/path/(...)target` with no
 *    `deep/path/page.tsx`).
 *
-* All comparisons happen in forward-slash space: `appDir` is forward-slash
-* (normalized once in the config hook), but `dir` and route file paths
-* descend through native `path.join`/`path.dirname`, which reintroduce
-* backslashes on Windows. Without normalizing, the `current === appDir`
-* termination never fires there and the walk overshoots the app root.
-* `routesByDir` keys must be forward-slash dirnames of the route file paths.
+* Comparisons happen in forward-slash space — inputs go through `toSlash` so
+* callers still holding native-separator paths hit the `current === appDir`
+* termination instead of overshooting the app root.
 *
 * Exported for tests.
 */
 function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
-	const appRoot = normalizePathSeparators(appDir);
-	let current = normalizePathSeparators(dir);
+	const appRoot = toSlash(appDir);
+	let current = toSlash(dir);
 	while (true) {
 		const exact = routesByDir.get(current);
 		if (exact) return exact;
@@ -1355,7 +1359,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 		for (const route of routes) {
 			const filePath = route.pagePath ?? route.routePath;
 			if (!filePath) continue;
-			if (!normalizePathSeparators(filePath).startsWith(currentWithSep)) continue;
+			if (!toSlash(filePath).startsWith(currentWithSep)) continue;
 			if (!best || route.patternParts.length < best.patternParts.length) best = route;
 		}
 		if (best) return best;
@@ -1369,22 +1373,19 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 /**
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
-*
-* `currentDir`, `routeDir`, and `appDir` must be forward-slash. `currentDir`
-* descends with `path.posix.join` when building the intercept page paths.
 */
-function scanForInterceptingPages(currentDir, routeDir, appDir, results, matcher) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
 		const interceptMatch = matchInterceptConvention(entry.name);
-		const interceptDir = path.posix.join(currentDir, entry.name);
+		const interceptDir = path.join(currentDir, entry.name);
 		if (interceptMatch) {
 			const restOfName = entry.name.slice(interceptMatch.prefix.length);
-			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, results, matcher);
-		} else scanForInterceptingPages(interceptDir, routeDir, appDir, results, matcher);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher);
+		} else scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher);
 	}
 }
 /**
@@ -1397,14 +1398,8 @@ function matchInterceptConvention(name) {
 /**
 * Collect page.tsx files inside an intercepting route directory tree
 * and compute their target URL patterns.
-*
-* `currentDir`, `interceptRoot`, `routeDir`, `appDir`, and `interceptParentDir`
-* must all be forward-slash. `currentDir` descends with `path.posix.join` and
-* its `findFile` results become the stored layout/page paths. The others are
-* relativized against `appDir` (and each other) to derive the intercept page
-* segments and URL patterns.
 */
-function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, parentLayoutPaths = []) {
+function collectInterceptingPages(currentDir, interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, parentLayoutPaths = []) {
 	const currentLayoutPath = findFile(currentDir, "layout", matcher);
 	const layoutPaths = currentLayoutPath ? [...parentLayoutPaths, currentLayoutPath] : parentLayoutPaths;
 	const page = findFile(currentDir, "page", matcher);
@@ -1412,17 +1407,23 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		const targetPattern = computeInterceptTarget(convention, interceptSegment, currentDir, interceptRoot, routeDir, appDir);
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
+			const notFoundBoundary = findSlotNotFoundBoundary(slotRootDir ?? interceptRoot, page, matcher);
+			const branchSegments = [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)];
+			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
 			results.push({
-				branchSegments: [interceptSegment, ...path.relative(interceptRoot, path.dirname(page)).split(path.sep).filter(Boolean)],
+				branchSegments,
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
 					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
 				}),
+				notFoundBranchSegments: [...slotParentSegments, ...branchSegments],
+				notFoundPath: notFoundBoundary.path,
+				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,
-				sourcePageSegments: normalizePathSeparators(path.relative(appDir, path.dirname(page))).split("/").filter(Boolean),
+				sourcePageSegments: path.relative(appDir, path.dirname(page)).split("/").filter(Boolean),
 				params: targetPattern.params
 			});
 		}
@@ -1432,7 +1433,7 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (entry.name.startsWith("_")) continue;
-		collectInterceptingPages(path.posix.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, results, matcher, layoutPaths);
+		collectInterceptingPages(path.join(currentDir, entry.name), interceptRoot, convention, interceptSegment, routeDir, appDir, interceptParentDir, slotRootDir, results, matcher, layoutPaths);
 	}
 }
 /**
@@ -1552,9 +1553,6 @@ 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,16 +12,11 @@ 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[]>;
 /**