vinext 0.0.55 → 0.1.1

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

@@ -1,4 +1,5 @@
 import { ValidFileMatcher } from "./file-matcher.js";
+import { isInvisibleSegment } from "./utils.js";
 
 //#region src/routing/app-route-graph.d.ts
 type InterceptingRoute = {
@@ -23,6 +24,11 @@ type InterceptingRoute = {
   pagePath: string; /** Absolute layout paths inside the intercepting route tree, outermost to innermost */
   layoutPaths: string[]; /** Parameter names for dynamic segments */
   params: string[];
+  /**
+   * Synthetic page-carrier slot id for sibling (slot-less) interception.
+   * Set only when the marker has no `@slot` wrapper; undefined for slot intercepts.
+   */
+  slotId?: string;
 };
 type ParallelSlot = {
   /** Graph-owned semantic slot identity. Required on AppRouteGraphParallelSlot. */id?: string; /** Stable slot identity (name + owning directory), used for route serialization keys. */
@@ -72,7 +78,13 @@ 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[]; /** Loading component path */
+  parallelSlots: ParallelSlot[];
+  /**
+   * Interception markers not wrapped in an `@slot` directory.
+   * On soft-nav, the intercepting page replaces the entire page response.
+   * Empty array when there are no sibling-style interception markers.
+   */
+  siblingIntercepts: InterceptingRoute[]; /** Loading component path */
   loadingPath: string | null; /** Error component path (leaf directory only) */
   errorPath: string | null;
   /**
@@ -264,13 +276,6 @@ declare function buildAppRouteGraph(appDir: string, matcher: ValidFileMatcher):
   routeManifest: RouteManifest;
 }>;
 declare function computeRootParamNames(routeSegments: readonly string[], layoutTreePositions: readonly number[]): string[];
-/**
- * Check whether a path segment is invisible in the URL (route groups, parallel slots, ".").
- *
- * Used by computeInterceptTarget, convertSegmentsToRouteParts, and
- * hasRemainingVisibleSegments — keep this the single source of truth.
- */
-declare function isInvisibleSegment(segment: string): boolean;
 /**
  * Convert filesystem path segments to URL route parts, skipping invisible segments
  * (route groups, @slots, ".") and converting dynamic segment syntax to Express-style
@@ -305,5 +310,4 @@ declare function computeAppRouteStaticSiblings(allRoutes: readonly {
   patternParts?: readonly string[] | null;
 }): string[];
 //#endregion
-export { AppRoute, AppRouteGraphParallelSlot, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, InterceptingRoute, ParallelSlot, RootBoundaryId, RouteManifest, RouteManifestBoundary, RouteManifestBoundaryOutcome, RouteManifestDefault, RouteManifestInterception, RouteManifestLayout, RouteManifestPage, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestRouteHandler, RouteManifestSlot, RouteManifestSlotBinding, RouteManifestSlotBindingState, RouteManifestTemplate, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
-//# sourceMappingURL=app-route-graph.d.ts.map
+export { AppRoute, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, RootBoundaryId, RouteManifest, RouteManifestInterception, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestSlotBinding, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };

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

@@ -1,6 +1,7 @@
-import { compareRoutes, decodeRouteSegment } from "./utils.js";
-import { scanWithExtensions } from "./file-matcher.js";
+import { compareRoutes, decodeRouteSegment, isInvisibleSegment } 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";
@@ -32,17 +33,17 @@ function createAppRouteGraphSlotId(slotName, ownerTreePath) {
 function createAppRouteGraphDefaultId(slotId) {
 	return `default:${slotId}`;
 }
+const SIBLING_INTERCEPT_SLOT_NAME = "__vinext_sibling_intercept";
+function createAppRouteGraphSiblingInterceptSlotId(sourcePattern) {
+	return createAppRouteGraphSlotId(SIBLING_INTERCEPT_SLOT_NAME, sourcePattern);
+}
 function createAppRouteGraphInterceptionId(slotId, sourcePattern, targetPattern) {
 	return `interception:${slotId}:${sourcePattern}->${targetPattern}`;
 }
 function createAppRouteGraphRootBoundaryId(treePath) {
 	return `root-boundary:${treePath}`;
 }
-function compareStableStrings(left, right) {
-	if (left < right) return -1;
-	if (left > right) return 1;
-	return 0;
-}
+const compareStableStrings = compareStrings;
 function sortedMapValues(map) {
 	return Array.from(map.entries()).sort(([left], [right]) => compareStableStrings(left, right)).map(([, value]) => value);
 }
@@ -185,6 +186,21 @@ function createStaticSegmentGraph(routes) {
 				slot
 			});
 		}
+		for (const ir of route.siblingIntercepts) {
+			if (!ir.slotId) continue;
+			const id = createAppRouteGraphInterceptionId(ir.slotId, ir.sourceMatchPattern, ir.targetPattern);
+			interceptions.set(id, {
+				id,
+				sourcePattern: ir.sourceMatchPattern,
+				sourcePatternParts: splitRouteManifestPatternParts(ir.sourceMatchPattern),
+				targetPattern: ir.targetPattern,
+				targetPatternParts: splitRouteManifestPatternParts(ir.targetPattern),
+				slotId: ir.slotId,
+				ownerLayoutId: null,
+				interceptingRouteId: routeIdByPattern.get(ir.sourceMatchPattern) ?? null,
+				targetRouteId: routeIdByPattern.get(ir.targetPattern) ?? null
+			});
+		}
 	}
 	return {
 		routes: routeEntries,
@@ -356,9 +372,10 @@ async function buildAppRouteGraph(appDir, matcher) {
 	}
 	const slotSubRoutes = discoverSlotSubRoutes(routes, matcher, ghostParentRoutes);
 	routes.push(...slotSubRoutes);
+	discoverSiblingInterceptingRoutes(routes, appDir, matcher);
 	validatePageRouteConflicts(routes, appDir);
 	validateRoutePatterns(routes.map((route) => route.pattern));
-	validateRoutePatterns([...new Set(routes.flatMap((route) => route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern))))]);
+	validateRoutePatterns([...new Set(routes.flatMap((route) => [...route.parallelSlots.flatMap((slot) => slot.interceptingRoutes.map((intercept) => intercept.targetPattern)), ...route.siblingIntercepts.map((intercept) => intercept.targetPattern)]))]);
 	routes.sort(compareRoutes);
 	return {
 		routes,
@@ -459,6 +476,8 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 		if (subPathMap.size === 0) continue;
 		const childrenDefault = findFile(parentPageDir, "default", matcher);
 		if (parentRoute.pagePath && !childrenDefault) continue;
+		const childrenCatchAll = childrenDefault ? null : findCatchAllPage(parentPageDir, matcher);
+		const childrenFallback = childrenDefault ?? childrenCatchAll;
 		for (const { rawSegments, converted: convertedSubRoute, slotPages } of subPathMap.values()) {
 			const { urlSegments: urlParts, params: subParams, isDynamic: subIsDynamic } = convertedSubRoute;
 			const subUrlPath = urlParts.join("/");
@@ -482,7 +501,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			const newRoute = {
 				ids: createAppRouteSemanticIds({
 					pattern,
-					pagePath: childrenDefault,
+					pagePath: childrenFallback,
 					routePath: null,
 					routeSegments: [...parentRoute.routeSegments, ...rawSegments],
 					layoutTreePositions: parentRoute.layoutTreePositions,
@@ -490,7 +509,7 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 					slots: subSlots
 				}),
 				pattern,
-				pagePath: childrenDefault,
+				pagePath: childrenFallback,
 				routePath: null,
 				layouts: parentRoute.layouts,
 				templates: parentRoute.templates,
@@ -510,7 +529,8 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 				isDynamic: parentRoute.isDynamic || subIsDynamic,
 				params: [...parentRoute.params, ...subParams],
 				rootParamNames: parentRoute.rootParamNames,
-				patternParts: [...parentRoute.patternParts, ...urlParts]
+				patternParts: [...parentRoute.patternParts, ...urlParts],
+				siblingIntercepts: []
 			};
 			syntheticRoutes.push(newRoute);
 			routesByPattern.set(pattern, newRoute);
@@ -552,6 +572,34 @@ function findSlotSubPages(slotDir, matcher) {
 	return results;
 }
 /**
+* Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
+* `[[...slug]]` directory that contains a `page` file. Returns the absolute
+* page path, or null when no catch-all sibling exists.
+*
+* Used as the children fallback for slot-only sub-routes (an explicit `@slot`
+* sub-page with no corresponding children page or `default.tsx`): Next.js
+* serves the children prop from the nearest catch-all, so `/baz` renders
+* `[...catchAll]/page.tsx` for children while `@slot/baz/page.tsx` fills the
+* slot. Optional catch-alls (`[[...slug]]`) qualify because they also match a
+* single extra segment.
+*/
+function findCatchAllPage(dir, matcher) {
+	let entries;
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const name = entry.name;
+		if (!(name.startsWith("[...") && name.endsWith("]") || name.startsWith("[[...") && name.endsWith("]]"))) continue;
+		const page = findFile(path.join(dir, name), "page", matcher);
+		if (page) return page;
+	}
+	return null;
+}
+/**
 * Convert a file path relative to app/ into an AppRoute.
 */
 function fileToAppRoute(file, appDir, type, matcher) {
@@ -623,7 +671,8 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 		isDynamic,
 		params,
 		rootParamNames: computeRootParamNames(segments, layoutTreePositions),
-		patternParts: urlSegments
+		patternParts: urlSegments,
+		siblingIntercepts: []
 	};
 }
 function dynamicParamNameFromSegment(segment) {
@@ -1065,6 +1114,86 @@ function discoverInterceptingRoutes(slotDir, routeDir, appDir, matcher) {
 	return results;
 }
 /**
+* Discover sibling-style interception markers — interception marker directories
+* (e.g. `(..)showcase`, `(..)(..)hoge`) that are NOT wrapped inside an `@slot`
+* directory. Mutates each matching route's `siblingIntercepts` array.
+*
+* 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.
+*/
+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.dirname(filePath);
+		if (!routesByDir.has(routeDir)) routesByDir.set(routeDir, route);
+	}
+	function walk(dir) {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			if (entry.name.startsWith("_")) continue;
+			if (entry.name.startsWith("@")) continue;
+			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);
+				for (const ir of results) {
+					ir.slotId = createAppRouteGraphSiblingInterceptSlotId(ir.sourceMatchPattern);
+					const owner = findOwnerRouteForDir(parentDir, appDir, routes, routesByDir);
+					if (owner) owner.siblingIntercepts.push(ir);
+				}
+				continue;
+			}
+			walk(childDir);
+		}
+	}
+	walk(appDir);
+}
+/**
+* Find the best route to attach a sibling intercept to, given the directory
+* that contains the interception marker.
+*
+* 1. Exact hit: a route whose page/handler lives directly in `dir`.
+* 2. Subtree hit: shallowest route whose page lives anywhere under `dir`
+*    (handles catch-all routes like `/templates/:catchAll+`).
+* 3. Ancestor walk: walk up the directory tree toward `appDir` looking for
+*    any of the above. This handles the case where the marker directory has
+*    no sibling pages at all (e.g. `deep/path/(...)target` with no
+*    `deep/path/page.tsx`).
+*/
+function findOwnerRouteForDir(dir, appDir, routes, routesByDir) {
+	let current = dir;
+	while (true) {
+		const exact = routesByDir.get(current);
+		if (exact) return exact;
+		const currentWithSep = current + path.sep;
+		let best = null;
+		for (const route of routes) {
+			const filePath = route.pagePath ?? route.routePath;
+			if (!filePath) continue;
+			if (!filePath.startsWith(currentWithSep)) continue;
+			if (!best || route.patternParts.length < best.patternParts.length) best = route;
+		}
+		if (best) return best;
+		if (current === appDir) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+}
+/**
 * Recursively scan a directory tree for page.tsx files that are inside
 * intercepting route directories.
 */
@@ -1140,18 +1269,6 @@ function computeInterceptSourceMatchPattern(interceptParentDir, appDir) {
 	return "/" + urlSegments.join("/");
 }
 /**
-* Check whether a path segment is invisible in the URL (route groups, parallel slots, ".").
-*
-* Used by computeInterceptTarget, convertSegmentsToRouteParts, and
-* hasRemainingVisibleSegments — keep this the single source of truth.
-*/
-function isInvisibleSegment(segment) {
-	if (segment === ".") return true;
-	if (segment.startsWith("(") && segment.endsWith(")")) return true;
-	if (segment.startsWith("@")) return true;
-	return false;
-}
-/**
 * Compute the target URL pattern for an intercepting route.
 *
 * Interception conventions (..), (..)(..)" climb by *visible route segments*
@@ -1167,9 +1284,11 @@ function computeInterceptTarget(convention, interceptSegment, currentDir, interc
 	const routeSegments = path.relative(appDir, routeDir).split(path.sep).filter(Boolean);
 	let baseParts;
 	switch (convention) {
-		case ".":
-			baseParts = routeSegments;
+		case ".": {
+			const interceptParentDir = path.dirname(interceptRoot);
+			baseParts = path.relative(appDir, interceptParentDir).split(path.sep).filter(Boolean);
 			break;
+		}
 		case "..":
 		case "../..": {
 			const levelsToClimb = convention === ".." ? 1 : 2;
@@ -1229,13 +1348,7 @@ function markerForInterceptionConvention(convention) {
 * Find a file by name (without extension) in a directory.
 * Checks configured pageExtensions.
 */
-function findFile(dir, name, matcher) {
-	for (const ext of matcher.dottedExtensions) {
-		const filePath = path.join(dir, name + ext);
-		if (fs.existsSync(filePath)) return filePath;
-	}
-	return null;
-}
+const findFile = findFileWithExts;
 /**
 * Convert filesystem path segments to URL route parts, skipping invisible segments
 * (route groups, @slots, ".") and converting dynamic segment syntax to Express-style
@@ -1334,5 +1447,3 @@ function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
 }
 //#endregion
 export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
-
-//# sourceMappingURL=app-route-graph.js.map

package/dist/routing/app-router.d.ts

@@ -27,5 +27,4 @@ declare function matchAppRoute(url: string, routes: AppRoute[]): {
   params: Record<string, string | string[]>;
 } | null;
 //#endregion
-export { type AppRoute, appRouteGraph, appRouter, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, invalidateAppRouteCache, matchAppRoute };
-//# sourceMappingURL=app-router.d.ts.map
+export { type AppRoute, appRouteGraph, appRouter, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, invalidateAppRouteCache, matchAppRoute };

package/dist/routing/app-router.js

@@ -57,5 +57,3 @@ function matchAppRoute(url, routes) {
 }
 //#endregion
 export { appRouteGraph, appRouter, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, invalidateAppRouteCache, matchAppRoute };
-
-//# sourceMappingURL=app-router.js.map

package/dist/routing/file-matcher.d.ts

@@ -18,6 +18,11 @@ type ValidFileMatcher = {
 declare function createValidFileMatcher(pageExtensions?: readonly string[] | null): ValidFileMatcher;
 /** Check if a file exists with any configured page extension. */
 declare function findFileWithExtensions(basePath: string, matcher: ValidFileMatcher): boolean;
+/**
+ * Find a file by basename and configured page extension in a directory.
+ * Returns the first matching absolute path, or null if not found.
+ */
+declare function findFileWithExts(dir: string, name: string, matcher: ValidFileMatcher): string | null;
 /**
  * Vite's default `resolve.extensions` covers `.tsx/.ts/.jsx/.js/.json` (and
  * `.mjs/.mts`). When the user configures `pageExtensions` with values Vite
@@ -43,5 +48,4 @@ declare function buildViteResolveExtensions(pageExtensions?: readonly string[] |
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion
-export { ValidFileMatcher, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, normalizePageExtensions, scanWithExtensions };
-//# sourceMappingURL=file-matcher.d.ts.map
+export { ValidFileMatcher, buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, scanWithExtensions };

package/dist/routing/file-matcher.js

@@ -1,4 +1,6 @@
+import { escapeRegExp } from "../utils/regex.js";
 import { existsSync } from "node:fs";
+import path from "node:path";
 import { glob } from "node:fs/promises";
 //#region src/routing/file-matcher.ts
 const DEFAULT_PAGE_EXTENSIONS = [
@@ -7,9 +9,6 @@ const DEFAULT_PAGE_EXTENSIONS = [
 	"jsx",
 	"js"
 ];
-function escapeRegex(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function normalizePageExtensions(pageExtensions) {
 	if (!Array.isArray(pageExtensions) || pageExtensions.length === 0) return [...DEFAULT_PAGE_EXTENSIONS];
 	const filtered = pageExtensions.filter((ext) => typeof ext === "string").map((ext) => ext.trim().replace(/^\.+/, "")).filter((ext) => ext.length > 0);
@@ -26,7 +25,7 @@ function buildExtensionGlob(stem, extensions) {
 function createValidFileMatcher(pageExtensions) {
 	const extensions = normalizePageExtensions(pageExtensions);
 	const dottedExtensions = extensions.map((ext) => `.${ext}`);
-	const extPattern = `(?:${extensions.map((ext) => escapeRegex(ext)).join("|")})`;
+	const extPattern = `(?:${extensions.map((ext) => escapeRegExp(ext)).join("|")})`;
 	const extensionRegex = new RegExp(`\\.${extPattern}$`);
 	const createLeafPattern = (fileNames) => {
 		const names = fileNames.length === 1 ? fileNames[0] : `(${fileNames.join("|")})`;
@@ -65,6 +64,17 @@ function findFileWithExtensions(basePath, matcher) {
 	return matcher.dottedExtensions.some((ext) => existsSync(basePath + ext));
 }
 /**
+* Find a file by basename and configured page extension in a directory.
+* Returns the first matching absolute path, or null if not found.
+*/
+function findFileWithExts(dir, name, matcher) {
+	for (const ext of matcher.dottedExtensions) {
+		const filePath = path.join(dir, name + ext);
+		if (existsSync(filePath)) return filePath;
+	}
+	return null;
+}
+/**
 * Vite's default `resolve.extensions` covers `.tsx/.ts/.jsx/.js/.json` (and
 * `.mjs/.mts`). When the user configures `pageExtensions` with values Vite
 * does not know about — e.g. `["platform.tsx", "tsx", "mdx"]` from the
@@ -113,6 +123,4 @@ async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	})) yield file;
 }
 //#endregion
-export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, normalizePageExtensions, scanWithExtensions };
-
-//# sourceMappingURL=file-matcher.js.map
+export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, scanWithExtensions };

package/dist/routing/pages-router.d.ts

@@ -45,5 +45,4 @@ declare function matchRoute(url: string, routes: Route[]): {
  */
 declare function apiRouter(pagesDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<Route[]>;
 //#endregion
-export { Route, apiRouter, invalidateRouteCache, matchRoute, pagesRouter, patternToNextFormat };
-//# sourceMappingURL=pages-router.d.ts.map
+export { Route, apiRouter, invalidateRouteCache, matchRoute, pagesRouter, patternToNextFormat };

package/dist/routing/pages-router.js

@@ -161,5 +161,3 @@ async function scanApiRoutes(pagesDir, matcher) {
 }
 //#endregion
 export { apiRouter, invalidateRouteCache, matchRoute, pagesRouter, patternToNextFormat };
-
-//# sourceMappingURL=pages-router.js.map

package/dist/routing/route-matching.d.ts

@@ -24,5 +24,4 @@ declare function matchRouteWithTrie<R extends {
   params: Record<string, string | string[]>;
 } | null;
 //#endregion
-export { createRouteTrieCache, matchRouteWithTrie };
-//# sourceMappingURL=route-matching.d.ts.map
+export { createRouteTrieCache, matchRouteWithTrie };

package/dist/routing/route-matching.js

@@ -40,5 +40,3 @@ function matchRouteWithTrie(url, routes, cache) {
 }
 //#endregion
 export { createRouteTrieCache, matchRouteWithTrie };
-
-//# sourceMappingURL=route-matching.js.map

package/dist/routing/route-pattern.d.ts

@@ -5,6 +5,7 @@ declare function routePattern(pathname: string): string;
 declare function fillRoutePatternSegments(pathname: string, params: RoutePatternParams): string | null;
 declare function matchRoutePattern(urlParts: readonly string[], patternParts: readonly string[]): RoutePatternParams | null;
 declare function matchRoutePatternPrefix(pathParts: readonly string[], patternParts: readonly string[]): boolean;
+declare function matchRoutePatternWithOptionalDynamicSegments(pathParts: readonly string[], patternParts: readonly string[]): boolean;
 /**
  * A single entry from `getStaticPaths().paths`.
  *
@@ -60,5 +61,4 @@ declare function normalizeStaticPathname(pathname: string): string;
  */
 declare function normalizeStaticPathsEntry(entry: StaticPathsEntry, routePattern: string): NormalizedStaticPathsEntry;
 //#endregion
-export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
-//# sourceMappingURL=route-pattern.d.ts.map
+export { RoutePatternParams, StaticPathsEntry, fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/routing/route-pattern.js

@@ -104,6 +104,21 @@ function matchRoutePatternPrefix(pathParts, patternParts) {
 	}
 	return true;
 }
+function matchRoutePatternWithOptionalDynamicSegments(pathParts, patternParts) {
+	function matchFrom(pathIndex, patternIndex) {
+		if (patternIndex === patternParts.length) return pathIndex === pathParts.length;
+		const patternPart = patternParts[patternIndex];
+		if (patternPart.startsWith(":") && (patternPart.endsWith("+") || patternPart.endsWith("*"))) {
+			const minLength = patternPart.endsWith("+") ? 1 : 0;
+			for (let endIndex = pathIndex + minLength; endIndex <= pathParts.length; endIndex++) if (matchFrom(endIndex, patternIndex + 1)) return true;
+			return false;
+		}
+		if (patternPart.startsWith(":")) return matchFrom(pathIndex, patternIndex + 1) || pathIndex < pathParts.length && matchFrom(pathIndex + 1, patternIndex + 1);
+		if (pathIndex >= pathParts.length || pathParts[pathIndex] !== patternPart) return false;
+		return matchFrom(pathIndex + 1, patternIndex + 1);
+	}
+	return matchFrom(0, 0);
+}
 /**
 * Strip query string and a single trailing slash from a pathname.
 *
@@ -147,6 +162,4 @@ function normalizeStaticPathsEntry(entry, routePattern) {
 	return { params };
 }
 //#endregion
-export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };
-
-//# sourceMappingURL=route-pattern.js.map
+export { fillRoutePatternSegments, matchRoutePattern, matchRoutePatternPrefix, matchRoutePatternWithOptionalDynamicSegments, normalizeStaticPathname, normalizeStaticPathsEntry, routePattern, routePatternParts };

package/dist/routing/route-trie.d.ts

@@ -64,5 +64,4 @@ declare function trieMatch<R>(root: TrieNode<R>, urlParts: string[]): {
   params: Record<string, string | string[]>;
 } | null;
 //#endregion
-export { TrieNode, buildRouteTrie, trieMatch };
-//# sourceMappingURL=route-trie.d.ts.map
+export { TrieNode, buildRouteTrie, trieMatch };

package/dist/routing/route-trie.js

@@ -141,5 +141,3 @@ function match(node, urlParts, index, entries) {
 }
 //#endregion
 export { buildRouteTrie, trieMatch };
-
-//# sourceMappingURL=route-trie.js.map

package/dist/routing/route-validation.d.ts

@@ -7,5 +7,4 @@
 declare function patternToNextFormat(pattern: string): string;
 declare function validateRoutePatterns(patterns: readonly string[]): void;
 //#endregion
-export { patternToNextFormat, validateRoutePatterns };
-//# sourceMappingURL=route-validation.d.ts.map
+export { patternToNextFormat, validateRoutePatterns };

package/dist/routing/route-validation.js

@@ -99,5 +99,3 @@ function validateRoutePatterns(patterns) {
 }
 //#endregion
 export { patternToNextFormat, validateRoutePatterns };
-
-//# sourceMappingURL=route-validation.js.map

package/dist/routing/utils.d.ts

@@ -41,6 +41,48 @@ declare function buildParams(entries: Array<[string, string | string[]]>): Recor
  * strict normalization layer rejects them at the request boundary).
  */
 declare function decodeMatchedParams(params: Record<string, string | string[]>): void;
+/**
+ * Check whether a path segment is invisible in the URL (route groups, parallel
+ * slots, "."). Single source of truth shared by the route graph (Node) and
+ * browser-side bfcache identity logic. Lives in this browser-safe utils module
+ * so importing it does not drag node:path/node:fs into the client bundle.
+ */
+declare function isInvisibleSegment(segment: string): boolean;
+/** Split a pathname into its non-empty segments without decoding. */
+declare function splitPathSegments(pathname: string): string[];
+/**
+ * Catch-all filesystem segment, e.g. `[...slug]`. Browser-safe predicate shared
+ * with the route graph's segment parsing (dynamicParamNameFromSegment) so the
+ * bracket conventions live in one place. The length guard rejects empty names
+ * (`[...]`).
+ */
+declare function isCatchAllSegment(segment: string): boolean;
+/**
+ * Optional-catch-all filesystem segment, e.g. `[[...slug]]`. Unlike a catch-all,
+ * this matches zero or more URL segments.
+ */
+declare function isOptionalCatchAllSegment(segment: string): boolean;
+/**
+ * Count how many pathname segments a tree path's *visible* segments consume,
+ * given the total number of pathname segments available.
+ *
+ * This is the minimal pure slice of the canonical filesystem-segment →
+ * URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
+ * extracted here so browser-side bfcache identity logic can share it without
+ * importing the Node-bound route graph module. `convertSegmentsToRouteParts`
+ * remains the source of truth for how each segment kind maps to a URL part.
+ *
+ * Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
+ * segment. A catch-all (`[...x]`) is terminal and consumes every remaining
+ * pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
+ * match zero segments, so it consumes only the remaining pathname segments
+ * (which is zero once preceding segments have already consumed the pathname) —
+ * never more than are actually present.
+ *
+ * @param visibleTreePathSegments URL-visible tree-path segments (callers must
+ *   pre-filter invisible segments via `isInvisibleSegment`).
+ * @param pathnameSegmentCount Total number of pathname segments available.
+ */
+declare function countConsumedPathnameSegments(visibleTreePathSegments: readonly string[], pathnameSegmentCount: number): number;
 //#endregion
-export { buildParams, compareRoutes, decodeMatchedParams, decodeRouteSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathnameForRouteMatch };
-//# sourceMappingURL=utils.d.ts.map
+export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };

package/dist/routing/utils.js

@@ -125,7 +125,66 @@ function decodeMatchedParams(params) {
 		else params[key] = decodeMatchedParam(value);
 	}
 }
+/**
+* Check whether a path segment is invisible in the URL (route groups, parallel
+* slots, "."). Single source of truth shared by the route graph (Node) and
+* browser-side bfcache identity logic. Lives in this browser-safe utils module
+* so importing it does not drag node:path/node:fs into the client bundle.
+*/
+function isInvisibleSegment(segment) {
+	if (segment === ".") return true;
+	if (segment.startsWith("(") && segment.endsWith(")")) return true;
+	if (segment.startsWith("@")) return true;
+	return false;
+}
+/** Split a pathname into its non-empty segments without decoding. */
+function splitPathSegments(pathname) {
+	return pathname.split("/").filter(Boolean);
+}
+/**
+* Catch-all filesystem segment, e.g. `[...slug]`. Browser-safe predicate shared
+* with the route graph's segment parsing (dynamicParamNameFromSegment) so the
+* bracket conventions live in one place. The length guard rejects empty names
+* (`[...]`).
+*/
+function isCatchAllSegment(segment) {
+	return segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5;
+}
+/**
+* Optional-catch-all filesystem segment, e.g. `[[...slug]]`. Unlike a catch-all,
+* this matches zero or more URL segments.
+*/
+function isOptionalCatchAllSegment(segment) {
+	return segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7;
+}
+/**
+* Count how many pathname segments a tree path's *visible* segments consume,
+* given the total number of pathname segments available.
+*
+* This is the minimal pure slice of the canonical filesystem-segment →
+* URL-segment mapping in `app-route-graph.ts` (`convertSegmentsToRouteParts`),
+* extracted here so browser-side bfcache identity logic can share it without
+* importing the Node-bound route graph module. `convertSegmentsToRouteParts`
+* remains the source of truth for how each segment kind maps to a URL part.
+*
+* Each ordinary visible segment (static or `[x]`) consumes exactly one pathname
+* segment. A catch-all (`[...x]`) is terminal and consumes every remaining
+* pathname segment. An optional-catch-all (`[[...x]]`) is also terminal but may
+* match zero segments, so it consumes only the remaining pathname segments
+* (which is zero once preceding segments have already consumed the pathname) —
+* never more than are actually present.
+*
+* @param visibleTreePathSegments URL-visible tree-path segments (callers must
+*   pre-filter invisible segments via `isInvisibleSegment`).
+* @param pathnameSegmentCount Total number of pathname segments available.
+*/
+function countConsumedPathnameSegments(visibleTreePathSegments, pathnameSegmentCount) {
+	let consumed = 0;
+	for (const segment of visibleTreePathSegments) {
+		if (isCatchAllSegment(segment) || isOptionalCatchAllSegment(segment)) return Math.max(consumed, pathnameSegmentCount);
+		consumed += 1;
+	}
+	return consumed;
+}
 //#endregion
-export { buildParams, compareRoutes, decodeMatchedParams, decodeRouteSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathnameForRouteMatch };
-
-//# sourceMappingURL=utils.js.map
+export { buildParams, compareRoutes, countConsumedPathnameSegments, decodeMatchedParams, decodeRouteSegment, isCatchAllSegment, isInvisibleSegment, isOptionalCatchAllSegment, normalizePathnameForRouteMatch, normalizePathnameForRouteMatchStrict, splitPathSegments, splitPathnameForRouteMatch };

package/dist/server/api-handler.d.ts

@@ -9,5 +9,4 @@ import { IncomingMessage, ServerResponse } from "node:http";
  */
 declare function handleApiRoute(runner: ModuleImporter, req: IncomingMessage, res: ServerResponse, url: string, apiRoutes: Route[]): Promise<boolean>;
 //#endregion
-export { handleApiRoute };
-//# sourceMappingURL=api-handler.d.ts.map
+export { handleApiRoute };