vinext 1.2.1 → 1.3.1

package/dist/plugins/worker-image-imports.js

@@ -42,7 +42,7 @@ function createWorkerImageImportsPlugin(options = {}) {
 				let dimensions = dimensionCache.get(imagePath);
 				if (!dimensions) {
 					try {
-						const { imageSize } = await import("../deps/.pnpm/image-size@2.0.2/deps/image-size/dist/index.js");
+						const { imageSize } = await import("../deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/index.js");
 						const result = imageSize(fs.readFileSync(imagePath));
 						dimensions = {
 							width: result.width ?? 0,
@@ -128,4 +128,4 @@ function createWorkerImageImportsPlugin(options = {}) {
 	};
 }
 //#endregion
-export { createWorkerImageImportsPlugin };
+export { WORKER_IMAGE_METADATA_PREFIX, createWorkerImageImportsPlugin };

package/dist/plugins/worker-use-server.d.ts

@@ -22,4 +22,5 @@ export declare function createWorkerUseServerPlugins(options: {
   rscPluginModule: Promise<RscPluginModule>;
   rscPluginPath: string;
 }): Promise<Plugin[]>;
-//#endregion
+//#endregion
+export {};

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

@@ -44,6 +44,30 @@ type InterceptingRoute = {
   notFoundBranchSegments?: string[];
   /** Tree position relative to the normalized interception branch. */
   notFoundTreePosition?: number | null;
+  /** Nearest forbidden convention inside the interception branch. */
+  forbiddenPath?: string | null;
+  /** Tree position relative to the normalized interception branch. */
+  forbiddenTreePosition?: number | null;
+  /** Nearest unauthorized convention inside the interception branch. */
+  unauthorizedPath?: string | null;
+  /** Tree position relative to the normalized interception branch. */
+  unauthorizedTreePosition?: number | null;
+  /** Every not-found convention inside the interception branch, outermost first. */
+  notFoundPaths?: string[];
+  /** Tree positions for notFoundPaths in the normalized interception branch. */
+  notFoundTreePositions?: number[];
+  /** Every forbidden convention inside the interception branch, outermost first. */
+  forbiddenPaths?: string[];
+  /** Tree positions for forbiddenPaths in the normalized interception branch. */
+  forbiddenTreePositions?: number[];
+  /** Every unauthorized convention inside the interception branch, outermost first. */
+  unauthorizedPaths?: string[];
+  /** Tree positions for unauthorizedPaths in the normalized interception branch. */
+  unauthorizedTreePositions?: number[];
+  /** Every error convention inside the interception branch, outermost first. */
+  errorPaths?: string[];
+  /** Tree positions for errorPaths in the normalized interception branch. */
+  errorTreePositions?: number[];
   /** Parameter names for dynamic segments */
   params: string[];
   /**
@@ -89,6 +113,10 @@ type ParallelSlot = {
   notFoundPath?: string | null;
   /** Tree position of that convention relative to the slot root. */
   notFoundTreePosition?: number | null;
+  /** Every not-found convention from the slot root to its active page, outermost first. */
+  notFoundPaths?: string[];
+  /** Slot-root-relative tree positions aligned with notFoundPaths. */
+  notFoundTreePositions?: number[];
   /** Intercepting routes within this slot */
   interceptingRoutes: InterceptingRoute[];
   /**
@@ -191,6 +219,18 @@ export type AppRoute = {
   unauthorizedTreePosition?: number | null;
   /** Unauthorized component paths per layout level (aligned with layouts array). */
   unauthorizedPaths: (string | null)[];
+  /**
+   * Not-found, forbidden and unauthorized component paths for every segment
+   * from app/ to the route's directory, including segments without a layout,
+   * aligned with the matching tree positions. A layout's notFound() is caught
+   * by the deepest of these above the layout's own segment.
+   */
+  segmentNotFoundPaths?: string[];
+  segmentNotFoundTreePositions?: number[];
+  segmentForbiddenPaths?: string[];
+  segmentForbiddenTreePositions?: number[];
+  segmentUnauthorizedPaths?: string[];
+  segmentUnauthorizedTreePositions?: number[];
   /**
    * Filesystem segments from app/ root to the route's directory.
    * Includes route groups and dynamic segments (as template strings like "[id]").
@@ -275,7 +315,7 @@ type RouteManifestRouteHandler = {
   routeId: string;
   pattern: string;
 };
-type RouteManifestLayout = {
+export type RouteManifestLayout = {
   id: string;
   treePath: string;
   patternParts: readonly string[];

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

@@ -131,7 +131,7 @@ function createStaticSegmentGraph(routes) {
 				treePath
 			});
 		}
-		addRouteManifestSegmentErrorBoundaryFacts({
+		addRouteManifestSegmentBoundaryFacts({
 			boundaries,
 			route
 		});
@@ -303,19 +303,42 @@ function addRouteManifestBoundaryFacts(input) {
 	addRouteManifestBoundaryFact(input, "forbidden", input.route.forbiddenPaths[input.layoutIndex]);
 	addRouteManifestBoundaryFact(input, "unauthorized", input.route.unauthorizedPaths[input.layoutIndex]);
 }
-function addRouteManifestSegmentErrorBoundaryFacts(input) {
-	for (const [index, boundaryPath] of (input.route.errorPaths ?? []).entries()) {
-		const treePosition = input.route.errorTreePositions?.[index];
-		assertRouteManifestBoundaryTreePosition(input.route, boundaryPath, treePosition);
-		const ownerLayoutId = findRouteManifestOwnerLayoutId(input.route, treePosition);
+function addRouteManifestSegmentBoundaryFacts(input) {
+	const { route } = input;
+	const segmentBoundaries = [
+		[
+			"error",
+			route.errorPaths,
+			route.errorTreePositions
+		],
+		[
+			"notFound",
+			route.segmentNotFoundPaths,
+			route.segmentNotFoundTreePositions
+		],
+		[
+			"forbidden",
+			route.segmentForbiddenPaths,
+			route.segmentForbiddenTreePositions
+		],
+		[
+			"unauthorized",
+			route.segmentUnauthorizedPaths,
+			route.segmentUnauthorizedTreePositions
+		]
+	];
+	for (const [outcome, boundaryPaths, treePositions] of segmentBoundaries) for (const [index, boundaryPath] of (boundaryPaths ?? []).entries()) {
+		const treePosition = treePositions?.[index];
+		assertRouteManifestBoundaryTreePosition(route, boundaryPath, treePosition);
+		const ownerLayoutId = findRouteManifestOwnerLayoutId(route, treePosition);
 		if (ownerLayoutId !== null) continue;
-		const treePath = createAppRouteGraphTreePath(input.route.routeSegments, treePosition);
+		const treePath = createAppRouteGraphTreePath(route.routeSegments, treePosition);
 		addRouteManifestBoundaryFact({
 			boundaries: input.boundaries,
-			route: input.route,
+			route,
 			layoutId: ownerLayoutId,
 			treePath
-		}, "error", boundaryPath);
+		}, outcome, boundaryPath);
 	}
 }
 function addRouteManifestBoundaryFact(input, outcome, boundaryPath) {
@@ -458,14 +481,11 @@ 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 withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
-					notFoundPath: notFoundBoundary.path,
-					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: rawSegments
 				}, subPage, matcher);
 			}
@@ -547,14 +567,11 @@ 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 withSlotLoadingEntries({
 					...slot,
 					pagePath: subPage || null,
 					configLayoutPaths,
 					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
-					notFoundPath: notFoundBoundary.path,
-					notFoundTreePosition: notFoundBoundary.treePosition,
 					routeSegments: subPage ? rawSegments : null
 				}, subPage ?? null, matcher);
 			});
@@ -593,6 +610,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				unauthorizedPath: parentRoute.unauthorizedPath,
 				unauthorizedTreePosition: parentRoute.unauthorizedTreePosition,
 				unauthorizedPaths: parentRoute.unauthorizedPaths,
+				segmentNotFoundPaths: parentRoute.segmentNotFoundPaths,
+				segmentNotFoundTreePositions: parentRoute.segmentNotFoundTreePositions,
+				segmentForbiddenPaths: parentRoute.segmentForbiddenPaths,
+				segmentForbiddenTreePositions: parentRoute.segmentForbiddenTreePositions,
+				segmentUnauthorizedPaths: parentRoute.segmentUnauthorizedPaths,
+				segmentUnauthorizedTreePositions: parentRoute.segmentUnauthorizedTreePositions,
 				routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 				childrenRouteSegments: childrenDefault ? parentRoute.routeSegments : void 0,
 				templateTreePositions: parentRoute.templateTreePositions,
@@ -680,52 +703,52 @@ function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
 	});
 }
 function findSlotLoadingEntries(slotDir, pagePath, matcher) {
+	return findSlotSegmentFileEntries(slotDir, pagePath, "loading", matcher);
+}
+/** Find a convention file in each directory from the slot root to the page, outermost first. */
+function findSlotSegmentFileEntries(slotDir, pagePath, fileName, matcher) {
 	const pageDir = pagePath ? path.dirname(pagePath) : slotDir;
 	if (pageDir !== slotDir && !pageDir.startsWith(`${slotDir}${path.sep}`)) return [];
 	const relativeDir = path.relative(slotDir, pageDir);
 	const segments = relativeDir ? relativeDir.split(path.sep).filter(Boolean) : [];
-	const loadings = [];
+	const entries = [];
 	let currentDir = slotDir;
-	const rootLoading = findFile(currentDir, "loading", matcher);
-	if (rootLoading) loadings.push({
-		path: rootLoading,
+	const rootEntry = findFile(currentDir, fileName, matcher);
+	if (rootEntry) entries.push({
+		path: rootEntry,
 		treePosition: 0
 	});
 	for (let index = 0; index < segments.length; index++) {
 		currentDir = path.join(currentDir, segments[index]);
-		const loading = findFile(currentDir, "loading", matcher);
-		if (loading) loadings.push({
-			path: loading,
+		const entry = findFile(currentDir, fileName, matcher);
+		if (entry) entries.push({
+			path: entry,
 			treePosition: index + 1
 		});
 	}
-	return loadings;
+	return entries;
 }
 function withSlotLoadingEntries(slot, pagePath, matcher) {
 	const loadingEntries = findSlotLoadingEntries(slot.ownerDir, pagePath, matcher);
 	return {
 		...slot,
 		loadingPaths: loadingEntries.map((entry) => entry.path),
-		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition)
+		loadingTreePositions: loadingEntries.map((entry) => entry.treePosition),
+		...findSlotNotFoundFields(slot.ownerDir, pagePath, matcher)
 	};
 }
-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);
-	}
+/**
+* Every not-found convention on the slot's active branch, plus the nearest one,
+* which supplies the slot's not-found metadata.
+*/
+function findSlotNotFoundFields(slotDir, pagePath, matcher) {
+	const entries = findSlotSegmentFileEntries(slotDir, pagePath, "not-found", matcher);
+	const nearest = entries.at(-1);
 	return {
-		path: null,
-		treePosition: null
+		notFoundPath: nearest?.path ?? null,
+		notFoundTreePosition: nearest?.treePosition ?? null,
+		notFoundPaths: entries.map((entry) => entry.path),
+		notFoundTreePositions: entries.map((entry) => entry.treePosition)
 	};
 }
 /**
@@ -801,6 +824,10 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 	const notFoundPaths = discoverBoundaryFilePerLayout(layouts, "not-found", matcher);
 	const forbiddenPaths = discoverBoundaryFilePerLayout(layouts, "forbidden", matcher);
 	const unauthorizedPaths = discoverBoundaryFilePerLayout(layouts, "unauthorized", matcher);
+	const discoverPageSegmentBoundaryFiles = (fileName) => pagePath === null && routePath !== null ? [] : discoverSegmentBoundaryFiles(segments, appDir, fileName, matcher);
+	const segmentNotFounds = discoverPageSegmentBoundaryFiles("not-found");
+	const segmentForbiddens = discoverPageSegmentBoundaryFiles("forbidden");
+	const segmentUnauthorizeds = discoverPageSegmentBoundaryFiles("unauthorized");
 	const parallelSlots = discoverInheritedParallelSlots(segments, appDir, routeDir, matcher, includeNestedOnlySlots);
 	return {
 		ids: createAppRouteSemanticIds({
@@ -833,6 +860,12 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath, includeN
 		forbiddenTreePosition: forbiddenEntry?.treePosition ?? null,
 		unauthorizedPath,
 		unauthorizedTreePosition: unauthorizedEntry?.treePosition ?? null,
+		segmentNotFoundPaths: segmentNotFounds.map((entry) => entry.path),
+		segmentNotFoundTreePositions: segmentNotFounds.map((entry) => entry.treePosition),
+		segmentForbiddenPaths: segmentForbiddens.map((entry) => entry.path),
+		segmentForbiddenTreePositions: segmentForbiddens.map((entry) => entry.treePosition),
+		segmentUnauthorizedPaths: segmentUnauthorizeds.map((entry) => entry.path),
+		segmentUnauthorizedTreePositions: segmentUnauthorizeds.map((entry) => entry.treePosition),
 		unauthorizedPaths,
 		routeSegments: segments,
 		templateTreePositions,
@@ -1034,6 +1067,24 @@ function discoverBoundaryFileEntry(segments, appDir, fileName, matcher) {
 	return null;
 }
 /**
+* Discover boundary files (not-found, forbidden, unauthorized) by segment tree
+* position. As with error.tsx, Next.js wraps each segment's children in its
+* boundary whether or not the segment has a layout.
+*/
+function discoverSegmentBoundaryFiles(segments, appDir, fileName, matcher) {
+	const boundaries = [];
+	let currentDir = appDir;
+	for (let index = 0; index <= segments.length; index++) {
+		if (index > 0) currentDir = path.join(currentDir, segments[index - 1]);
+		const boundary = findFile(currentDir, fileName, matcher);
+		if (boundary) boundaries.push({
+			path: boundary,
+			treePosition: index
+		});
+	}
+	return boundaries;
+}
+/**
 * Discover boundary files (not-found, forbidden, unauthorized) at each layout directory.
 * Returns an array aligned with the layouts array, where each entry is the boundary
 * file at that layout's directory, or null if none exists there.
@@ -1271,7 +1322,6 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
 		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		const loadingEntries = findSlotLoadingEntries(slotDir, pagePath, matcher);
-		const notFoundBoundary = findSlotNotFoundBoundary(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir)}`,
@@ -1289,8 +1339,7 @@ function discoverParallelSlots(dir, appDir, matcher, includeNestedOnlySlots = fa
 			loadingPaths: loadingEntries.map((loading) => loading.path),
 			loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 			errorPath: findFile(slotDir, "error", matcher),
-			notFoundPath: notFoundBoundary.path,
-			notFoundTreePosition: notFoundBoundary.treePosition,
+			...findSlotNotFoundFields(slotDir, pagePath, matcher),
 			interceptingRoutes,
 			layoutIndex: -1,
 			routeSegments: pagePath ? [] : null
@@ -1440,7 +1489,7 @@ function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
-function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = []) {
+function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, results, matcher, parentLoadingEntries = [], parentLayoutPaths = []) {
 	if (!fs.existsSync(currentDir)) return;
 	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
 	for (const entry of entries) {
@@ -1450,13 +1499,14 @@ function scanForInterceptingPages(currentDir, slotRootDir, routeDir, appDir, res
 		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, slotRootDir, results, matcher, [], parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
+			collectInterceptingPages(interceptDir, interceptDir, interceptMatch.convention, restOfName, routeDir, appDir, currentDir, slotRootDir, results, matcher, parentLayoutPaths, parentLoadingEntries, path.relative(slotRootDir, currentDir).split(path.sep).filter(Boolean).length);
 		} else {
+			const layout = findFile(interceptDir, "layout", matcher);
 			const loading = findFile(interceptDir, "loading", matcher);
 			scanForInterceptingPages(interceptDir, slotRootDir, routeDir, appDir, results, matcher, loading ? [...parentLoadingEntries, {
 				path: loading,
 				treePosition: path.relative(slotRootDir, interceptDir).split(path.sep).filter(Boolean).length
-			}] : parentLoadingEntries);
+			}] : parentLoadingEntries, layout ? [...parentLayoutPaths, layout] : parentLayoutPaths);
 		}
 	}
 }
@@ -1486,7 +1536,15 @@ 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 notFoundTreePositionOffset = slotRootDir ? 0 : 1;
+			const notFoundFields = findSlotNotFoundFields(slotRootDir ?? interceptRoot, page, matcher);
+			const findInterceptBoundaries = (fileName) => findSlotSegmentFileEntries(slotRootDir ?? interceptRoot, page, fileName, matcher).map((entry) => ({
+				path: entry.path,
+				treePosition: entry.treePosition + notFoundTreePositionOffset
+			}));
+			const forbiddenBoundaries = findInterceptBoundaries("forbidden");
+			const unauthorizedBoundaries = findInterceptBoundaries("unauthorized");
+			const errorBoundaries = findInterceptBoundaries("error");
 			const slotParentSegments = slotRootDir ? path.relative(slotRootDir, interceptParentDir).split(path.sep).filter(Boolean) : [];
 			const branchSegments = [
 				...slotParentSegments,
@@ -1498,7 +1556,9 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				convention,
 				layoutPaths: [...layoutPaths],
 				layoutSegments: layoutPaths.map((layoutPath) => {
-					const relativeDir = path.relative(interceptRoot, path.dirname(layoutPath));
+					const layoutDir = path.dirname(layoutPath);
+					if (slotRootDir && layoutDir !== interceptRoot && !layoutDir.startsWith(`${interceptRoot}${path.sep}`)) return path.relative(slotRootDir, layoutDir).split(path.sep).filter(Boolean);
+					const relativeDir = path.relative(interceptRoot, layoutDir);
 					return [
 						...slotParentSegments,
 						interceptSegment,
@@ -1508,8 +1568,20 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 				loadingPaths: loadingEntries.map((loading) => loading.path),
 				loadingTreePositions: loadingEntries.map((loading) => loading.treePosition),
 				notFoundBranchSegments: branchSegments,
-				notFoundPath: notFoundBoundary.path,
-				notFoundTreePosition: notFoundBoundary.treePosition === null ? null : slotRootDir ? notFoundBoundary.treePosition : notFoundBoundary.treePosition + 1,
+				notFoundPath: notFoundFields.notFoundPath,
+				notFoundTreePosition: notFoundFields.notFoundTreePosition == null ? null : notFoundFields.notFoundTreePosition + notFoundTreePositionOffset,
+				notFoundPaths: notFoundFields.notFoundPaths,
+				notFoundTreePositions: notFoundFields.notFoundTreePositions?.map((treePosition) => treePosition + notFoundTreePositionOffset),
+				forbiddenPath: forbiddenBoundaries.at(-1)?.path ?? null,
+				forbiddenTreePosition: forbiddenBoundaries.at(-1)?.treePosition ?? null,
+				forbiddenPaths: forbiddenBoundaries.map((boundary) => boundary.path),
+				forbiddenTreePositions: forbiddenBoundaries.map((boundary) => boundary.treePosition),
+				unauthorizedPath: unauthorizedBoundaries.at(-1)?.path ?? null,
+				unauthorizedTreePosition: unauthorizedBoundaries.at(-1)?.treePosition ?? null,
+				unauthorizedPaths: unauthorizedBoundaries.map((boundary) => boundary.path),
+				unauthorizedTreePositions: unauthorizedBoundaries.map((boundary) => boundary.treePosition),
+				errorPaths: errorBoundaries.map((boundary) => boundary.path),
+				errorTreePositions: errorBoundaries.map((boundary) => boundary.treePosition),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,

package/dist/routing/browser-route-manifest.d.ts

@@ -0,0 +1,44 @@
+import { GraphVersion, RouteManifest, RouteManifestInterception, RouteManifestLayout, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding } from "./app-route-graph.js";
+//#region src/routing/browser-route-manifest.d.ts
+export type BrowserRouteManifestRoute = Pick<RouteManifestRoute, "id" | "patternParts" | "isDynamic" | "paramNames" | "rootBoundaryId" | "pageId" | "layoutIds" | "slotIds">;
+type BrowserRouteManifestLayout = Pick<RouteManifestLayout, "id" | "patternParts" | "rootBoundaryId">;
+type BrowserRouteManifestSlotBinding = Pick<RouteManifestSlotBinding, "id" | "routeId" | "slotId" | "ownerLayoutId" | "state" | "routeSegments" | "slotPatternParts" | "slotParamNames">;
+export type BrowserRouteManifestInterception = Pick<RouteManifestInterception, "id" | "sourcePatternParts" | "targetPatternParts" | "slotId" | "ownerLayoutId" | "targetRouteId">;
+type BrowserRouteManifestRootBoundary = Pick<RouteManifestRootBoundary, "id" | "treePath">;
+/**
+ * The part of the RouteManifest the browser navigation runtime reads: the
+ * maps and fields the navigation planner, optimistic routing and interception
+ * context resolution use.
+ */
+export type BrowserRouteManifest = {
+  graphVersion: GraphVersion;
+  segmentGraph: {
+    routes: ReadonlyMap<string, BrowserRouteManifestRoute>;
+    layouts: ReadonlyMap<string, BrowserRouteManifestLayout>;
+    slotBindings: ReadonlyMap<string, BrowserRouteManifestSlotBinding>;
+    interceptions: ReadonlyMap<string, BrowserRouteManifestInterception>;
+    interceptionsBySlotId: ReadonlyMap<string, readonly BrowserRouteManifestInterception[]>;
+    rootBoundaries: ReadonlyMap<string, BrowserRouteManifestRootBoundary>;
+  };
+};
+/**
+ * JSON form of `BrowserRouteManifest`. Every map is keyed by its values' `id`,
+ * so maps travel as arrays of values in map order. A route omits `id` when it
+ * is `route:` plus its pattern, and `interceptionsBySlotId` lists interception
+ * ids instead of repeating the interceptions.
+ */
+export type BrowserRouteManifestWire = {
+  graphVersion: string;
+  routes: (Omit<BrowserRouteManifestRoute, "id"> & {
+    id?: string;
+  })[];
+  layouts: BrowserRouteManifestLayout[];
+  slotBindings: BrowserRouteManifestSlotBinding[];
+  interceptions: BrowserRouteManifestInterception[];
+  interceptionsBySlotId: [slotId: string, interceptionIds: string[]][];
+  rootBoundaries: BrowserRouteManifestRootBoundary[];
+};
+export declare function toBrowserRouteManifestWire(routeManifest: RouteManifest): BrowserRouteManifestWire;
+export declare function decodeBrowserRouteManifest(wire: BrowserRouteManifestWire): BrowserRouteManifest;
+//#endregion
+export {};

package/dist/routing/browser-route-manifest.js

@@ -0,0 +1,195 @@
+import { buildOptimisticRouteTrie } from "./optimistic-route-trie.js";
+//#region src/routing/browser-route-manifest.ts
+function createRouteIdFromPatternParts(patternParts) {
+	return `route:/${patternParts.join("/")}`;
+}
+/**
+* Route matching precedence of one pattern part, lower wins: the URL ending
+* here, then a static, dynamic, catch-all and optional catch-all part.
+*/
+function patternPartRank(part) {
+	if (part === void 0) return 0;
+	if (!part.startsWith(":")) return 1;
+	if (part.endsWith("+")) return 3;
+	if (part.endsWith("*")) return 4;
+	return 2;
+}
+/**
+* Whether the router sends a URL pathname that both patterns match to the
+* route handler: it wins at the first part whose kind differs. Two patterns
+* that never differ would be the same route shape, which cannot hold both a
+* handler and a page.
+*/
+function routeHandlerOutranks(handler, rendered) {
+	for (let index = 0;; index++) {
+		const handlerRank = patternPartRank(handler[index]);
+		const renderedRank = patternPartRank(rendered[index]);
+		if (handlerRank !== renderedRank) return handlerRank < renderedRank;
+		if (handlerRank === 0 || handlerRank >= 3) return false;
+	}
+}
+/**
+* Whether the optimistic trie of the rendered routes predicts a rendered
+* route that the route handler outranks for some URL pathname the handler
+* pattern matches. The trie match descends one path and only backtracks to a
+* catch-all on its way up, so this follows that path for every URL: a param
+* segment either names one of the node's static children or none of them,
+* and a catch-all takes any number of such segments.
+*/
+function triePredictsOutrankedRoute(trie, handler) {
+	const lastPart = handler.at(-1);
+	const isCatchAll = lastPart?.startsWith(":") === true && /[+*]$/.test(lastPart);
+	const fixedLength = isCatchAll ? handler.length - 1 : handler.length;
+	const minLength = lastPart?.endsWith("+") === true ? handler.length : fixedLength;
+	const predict = (route) => route === null ? {
+		outranked: false,
+		unmatched: true
+	} : {
+		outranked: routeHandlerOutranks(handler, route.patternParts),
+		unmatched: false
+	};
+	const afterOtherSegment = (node, depth) => {
+		const dynamic = node.dynamicChild ? predictFrom(node.dynamicChild.node, depth) : {
+			outranked: false,
+			unmatched: true
+		};
+		if (!dynamic.unmatched) return dynamic;
+		const fallback = predict(node.catchAllChild?.route ?? node.optionalCatchAllChild?.route ?? null);
+		return {
+			outranked: dynamic.outranked || fallback.outranked,
+			unmatched: fallback.unmatched
+		};
+	};
+	const predictFrom = (node, depth) => {
+		const predictions = {
+			outranked: false,
+			unmatched: false
+		};
+		const add = (more) => {
+			predictions.outranked ||= more.outranked;
+			predictions.unmatched ||= more.unmatched;
+		};
+		if (isCatchAll ? depth >= minLength : depth === fixedLength) add(predict(node.route ?? node.optionalCatchAllChild?.route ?? null));
+		if (depth < fixedLength && !handler[depth].startsWith(":")) {
+			const child = node.staticChildren.get(handler[depth]);
+			add(child ? predictFrom(child, depth + 1) : afterOtherSegment(node, depth + 1));
+		} else if (depth < fixedLength || isCatchAll) {
+			for (const child of node.staticChildren.values()) add(predictFrom(child, depth + 1));
+			add(afterOtherSegment(node, depth + 1));
+		}
+		return predictions;
+	};
+	return predictFrom(trie, 0).outranked;
+}
+/**
+* The browser only needs a route handler where the optimistic route trie of
+* the rendered routes would predict a route the handler outranks: the matcher
+* must find the handler there instead of rendering that route's shell. Any
+* other handler URL matches no rendered route on the client, or one the
+* router prefers, and its non-Flight response already turns the navigation
+* into a document load, so shipping its path would only publish the app's
+* API surface (issue #3624).
+*/
+function selectBrowserRoutes(routes) {
+	const allRoutes = [...routes];
+	const renderedTrie = buildOptimisticRouteTrie(allRoutes.filter((route) => route.routeHandlerId === null));
+	return allRoutes.filter((route) => route.routeHandlerId === null || triePredictsOutrankedRoute(renderedTrie, route.patternParts));
+}
+/**
+* The graph records the browser receives: the shipped routes, the rendered
+* routes' slot bindings, and the layouts and root boundaries those and the
+* interceptions reach. A shipped route handler only stops an optimistic
+* match, and its non-Flight response never renders a tree, so it ships as a
+* bare pattern; its layouts, slots and root boundary would only name its
+* directories.
+*/
+function selectBrowserGraph(graph) {
+	const routes = selectBrowserRoutes(graph.routes.values()).map((route) => route.routeHandlerId === null ? route : {
+		...route,
+		layoutIds: [],
+		rootBoundaryId: null,
+		slotIds: []
+	});
+	const renderedRouteIds = new Set(routes.filter((route) => route.routeHandlerId === null).map((route) => route.id));
+	const slotBindings = [...graph.slotBindings.values()].filter((binding) => renderedRouteIds.has(binding.routeId));
+	const layoutIds = /* @__PURE__ */ new Set([
+		...routes.flatMap((route) => route.layoutIds),
+		...slotBindings.flatMap((binding) => binding.ownerLayoutId ?? []),
+		...[...graph.interceptions.values()].flatMap((interception) => interception.ownerLayoutId ?? [])
+	]);
+	const layouts = [...graph.layouts.values()].filter((layout) => layoutIds.has(layout.id));
+	const rootBoundaryIds = new Set([...routes, ...layouts].flatMap((record) => record.rootBoundaryId ?? []));
+	return {
+		routes,
+		layouts,
+		slotBindings,
+		rootBoundaries: [...graph.rootBoundaries.values()].filter((rootBoundary) => rootBoundaryIds.has(rootBoundary.id))
+	};
+}
+function toBrowserRouteManifestWire(routeManifest) {
+	const graph = routeManifest.segmentGraph;
+	const browserGraph = selectBrowserGraph(graph);
+	return {
+		graphVersion: routeManifest.graphVersion,
+		routes: browserGraph.routes.map((route) => ({
+			...route.id === createRouteIdFromPatternParts(route.patternParts) ? {} : { id: route.id },
+			patternParts: route.patternParts,
+			isDynamic: route.isDynamic,
+			paramNames: route.paramNames,
+			rootBoundaryId: route.rootBoundaryId,
+			pageId: route.pageId,
+			layoutIds: route.layoutIds,
+			slotIds: route.slotIds
+		})),
+		layouts: browserGraph.layouts.map((layout) => ({
+			id: layout.id,
+			patternParts: layout.patternParts,
+			rootBoundaryId: layout.rootBoundaryId
+		})),
+		slotBindings: browserGraph.slotBindings.map((binding) => ({
+			id: binding.id,
+			routeId: binding.routeId,
+			slotId: binding.slotId,
+			ownerLayoutId: binding.ownerLayoutId,
+			state: binding.state,
+			routeSegments: binding.routeSegments,
+			slotPatternParts: binding.slotPatternParts,
+			slotParamNames: binding.slotParamNames
+		})),
+		interceptions: Array.from(graph.interceptions.values(), (interception) => ({
+			id: interception.id,
+			sourcePatternParts: interception.sourcePatternParts,
+			targetPatternParts: interception.targetPatternParts,
+			slotId: interception.slotId,
+			ownerLayoutId: interception.ownerLayoutId,
+			targetRouteId: interception.targetRouteId
+		})),
+		interceptionsBySlotId: Array.from(graph.interceptionsBySlotId, ([slotId, interceptions]) => [slotId, interceptions.map((interception) => interception.id)]),
+		rootBoundaries: browserGraph.rootBoundaries.map((rootBoundary) => ({
+			id: rootBoundary.id,
+			treePath: rootBoundary.treePath
+		}))
+	};
+}
+function mapById(values) {
+	return new Map(values.map((value) => [value.id, value]));
+}
+function decodeBrowserRouteManifest(wire) {
+	const interceptions = mapById(wire.interceptions);
+	return {
+		graphVersion: wire.graphVersion,
+		segmentGraph: {
+			routes: mapById(wire.routes.map((route) => ({
+				...route,
+				id: route.id ?? createRouteIdFromPatternParts(route.patternParts)
+			}))),
+			layouts: mapById(wire.layouts),
+			slotBindings: mapById(wire.slotBindings),
+			interceptions,
+			interceptionsBySlotId: new Map(wire.interceptionsBySlotId.map(([slotId, interceptionIds]) => [slotId, interceptionIds.flatMap((id) => interceptions.get(id) ?? [])])),
+			rootBoundaries: mapById(wire.rootBoundaries)
+		}
+	};
+}
+//#endregion
+export { decodeBrowserRouteManifest, toBrowserRouteManifestWire };

package/dist/routing/hashed-route-patterns.d.ts

@@ -0,0 +1,4 @@
+//#region src/routing/hashed-route-patterns.d.ts
+export declare function hashRoutePatternParts(patternParts: readonly string[]): string[];
+export declare function hashRoutePathname(pathname: string): string;
+//#endregion