@timber-js/app 0.1.0

package/dist/_chunks/interception-DIaZN1bF.js

@@ -0,0 +1,669 @@
+import { n as classifyMetadataRoute } from "./metadata-routes-BDnswgRO.js";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, extname, join, posix, relative } from "node:path";
+//#region src/routing/types.ts
+/** All recognized interception markers, ordered longest-first for parsing. */
+var INTERCEPTION_MARKERS = [
+	"(..)(..)",
+	"(.)",
+	"(..)",
+	"(...)"
+];
+/** Default page extensions */
+var DEFAULT_PAGE_EXTENSIONS = [
+	"tsx",
+	"ts",
+	"jsx",
+	"js"
+];
+//#endregion
+//#region src/routing/scanner.ts
+/**
+* Route discovery scanner.
+*
+* Pure function: (appDir, config) → RouteTree
+*
+* Scans the app/ directory and builds a segment tree recognizing all
+* timber.js file conventions. Does NOT handle request matching — this
+* is discovery only.
+*/
+/**
+* Pattern matching encoded path delimiters that must be rejected during route discovery.
+* %2F / %2f (forward slash) and %5C / %5c (backslash) can cause route collisions
+* when decoded. See design/13-security.md §"Encoded separators rejected".
+*/
+var ENCODED_SEPARATOR_PATTERN = /%(?:2[fF]|5[cC])/;
+/**
+* Pattern matching encoded null bytes (%00) that must be rejected.
+* See design/13-security.md §"Null bytes rejected".
+*/
+var ENCODED_NULL_PATTERN = /%00/;
+/**
+* File convention names that use pageExtensions (can be .tsx, .ts, .jsx, .js, .mdx, etc.)
+*/
+var PAGE_EXT_CONVENTIONS = new Set([
+	"page",
+	"layout",
+	"error",
+	"default",
+	"denied"
+]);
+/**
+* Legacy compat status-code files.
+* Maps legacy file name → HTTP status code for the fallback chain.
+* See design/10-error-handling.md §"Fallback Chain".
+*/
+var LEGACY_STATUS_FILES = {
+	"not-found": 404,
+	"forbidden": 403,
+	"unauthorized": 401
+};
+/**
+* File convention names that are always .ts/.tsx (never .mdx etc.)
+*/
+var FIXED_CONVENTIONS = new Set([
+	"middleware",
+	"access",
+	"route",
+	"prerender",
+	"search-params"
+]);
+/**
+* Status-code file patterns:
+* - Exact 3-digit codes: 401.tsx, 429.tsx, 503.tsx
+* - Category catch-alls: 4xx.tsx, 5xx.tsx
+*/
+var STATUS_CODE_PATTERN = /^(\d{3}|[45]xx)$/;
+/**
+* Scan the app/ directory and build the route tree.
+*
+* @param appDir - Absolute path to the app/ directory
+* @param config - Scanner configuration
+* @returns The complete route tree
+*/
+function scanRoutes(appDir, config = {}) {
+	const pageExtensions = config.pageExtensions ?? DEFAULT_PAGE_EXTENSIONS;
+	const extSet = new Set(pageExtensions);
+	const tree = { root: createSegmentNode("", "static", "/") };
+	const proxyFile = findFixedFile(appDir, "proxy");
+	if (proxyFile) tree.proxy = proxyFile;
+	scanSegmentFiles(appDir, tree.root, extSet);
+	scanChildren(appDir, tree.root, extSet);
+	validateRouteGroupCollisions(tree.root);
+	return tree;
+}
+/**
+* Create an empty segment node.
+*/
+function createSegmentNode(segmentName, segmentType, urlPath, paramName, interceptionMarker, interceptedSegmentName) {
+	return {
+		segmentName,
+		segmentType,
+		urlPath,
+		paramName,
+		interceptionMarker,
+		interceptedSegmentName,
+		children: [],
+		slots: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* Classify a directory name into its segment type.
+*/
+function classifySegment(dirName) {
+	if (dirName.startsWith("_")) return { type: "private" };
+	if (dirName.startsWith("@")) return { type: "slot" };
+	const interception = parseInterceptionMarker(dirName);
+	if (interception) return {
+		type: "intercepting",
+		interceptionMarker: interception.marker,
+		interceptedSegmentName: interception.segmentName
+	};
+	if (dirName.startsWith("(") && dirName.endsWith(")")) return { type: "group" };
+	if (dirName.startsWith("[[...") && dirName.endsWith("]]")) return {
+		type: "optional-catch-all",
+		paramName: dirName.slice(5, -2)
+	};
+	if (dirName.startsWith("[...") && dirName.endsWith("]")) return {
+		type: "catch-all",
+		paramName: dirName.slice(4, -1)
+	};
+	if (dirName.startsWith("[") && dirName.endsWith("]")) return {
+		type: "dynamic",
+		paramName: dirName.slice(1, -1)
+	};
+	return { type: "static" };
+}
+/**
+* Parse an interception marker from a directory name.
+*
+* Returns the marker and the remaining segment name, or null if not an
+* intercepting route. Markers are checked longest-first to avoid (..)
+* matching before (..)(..).
+*
+* Examples:
+*   "(.)photo"      → { marker: "(.)", segmentName: "photo" }
+*   "(..)feed"      → { marker: "(..)", segmentName: "feed" }
+*   "(...)photos"   → { marker: "(...)", segmentName: "photos" }
+*   "(..)(..)admin" → { marker: "(..)(..)", segmentName: "admin" }
+*   "(marketing)"   → null (route group, not interception)
+*/
+function parseInterceptionMarker(dirName) {
+	for (const marker of INTERCEPTION_MARKERS) if (dirName.startsWith(marker)) {
+		const rest = dirName.slice(marker.length);
+		if (rest.length > 0 && !rest.endsWith(")")) return {
+			marker,
+			segmentName: rest
+		};
+	}
+	return null;
+}
+/**
+* Compute the URL path for a child segment given its parent's URL path.
+* Route groups, slots, and intercepting routes do NOT add URL depth.
+*/
+function computeUrlPath(parentUrlPath, dirName, segmentType) {
+	if (segmentType === "group" || segmentType === "slot" || segmentType === "intercepting") return parentUrlPath;
+	return `${parentUrlPath === "/" ? "" : parentUrlPath}/${dirName}`;
+}
+/**
+* Scan a directory for file conventions and populate the segment node.
+*/
+function scanSegmentFiles(dirPath, node, extSet) {
+	let entries;
+	try {
+		entries = readdirSync(dirPath);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dirPath, entry);
+		try {
+			if (statSync(fullPath).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const ext = extname(entry).slice(1);
+		const name = basename(entry, `.${ext}`);
+		if (PAGE_EXT_CONVENTIONS.has(name) && extSet.has(ext)) {
+			const file = {
+				filePath: fullPath,
+				extension: ext
+			};
+			switch (name) {
+				case "page":
+					node.page = file;
+					break;
+				case "layout":
+					node.layout = file;
+					break;
+				case "error":
+					node.error = file;
+					break;
+				case "default":
+					node.default = file;
+					break;
+				case "denied":
+					node.denied = file;
+					break;
+			}
+			continue;
+		}
+		if (FIXED_CONVENTIONS.has(name) && /\.?[jt]sx?$/.test(ext)) {
+			const file = {
+				filePath: fullPath,
+				extension: ext
+			};
+			switch (name) {
+				case "middleware":
+					node.middleware = file;
+					break;
+				case "access":
+					node.access = file;
+					break;
+				case "route":
+					node.route = file;
+					break;
+				case "prerender":
+					node.prerender = file;
+					break;
+				case "search-params":
+					node.searchParams = file;
+					break;
+			}
+			continue;
+		}
+		if (STATUS_CODE_PATTERN.test(name) && ext === "json") {
+			if (!node.jsonStatusFiles) node.jsonStatusFiles = /* @__PURE__ */ new Map();
+			node.jsonStatusFiles.set(name, {
+				filePath: fullPath,
+				extension: ext
+			});
+			continue;
+		}
+		if (STATUS_CODE_PATTERN.test(name) && extSet.has(ext)) {
+			if (!node.statusFiles) node.statusFiles = /* @__PURE__ */ new Map();
+			node.statusFiles.set(name, {
+				filePath: fullPath,
+				extension: ext
+			});
+			continue;
+		}
+		if (name in LEGACY_STATUS_FILES && extSet.has(ext)) {
+			if (!node.legacyStatusFiles) node.legacyStatusFiles = /* @__PURE__ */ new Map();
+			node.legacyStatusFiles.set(name, {
+				filePath: fullPath,
+				extension: ext
+			});
+			continue;
+		}
+		if (classifyMetadataRoute(entry)) {
+			if (!node.metadataRoutes) node.metadataRoutes = /* @__PURE__ */ new Map();
+			node.metadataRoutes.set(name, {
+				filePath: fullPath,
+				extension: ext
+			});
+		}
+	}
+	if (node.route && node.page) throw new Error(`Build error: route.ts and page.* cannot coexist in the same segment.\n  route.ts: ${node.route.filePath}\n  page:     ${node.page.filePath}\nA URL is either an API endpoint or a rendered page, not both.`);
+}
+/**
+* Recursively scan child directories and build the segment tree.
+*/
+function scanChildren(dirPath, parentNode, extSet) {
+	let entries;
+	try {
+		entries = readdirSync(dirPath);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dirPath, entry);
+		try {
+			if (!statSync(fullPath).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		if (ENCODED_SEPARATOR_PATTERN.test(entry)) throw new Error(`Build error: directory name contains an encoded path delimiter (%%2F or %%5C).\n  Directory: ${fullPath}\nEncoded separators in directory names cause route collisions when decoded. Rename the directory to remove the encoded delimiter.`);
+		if (ENCODED_NULL_PATTERN.test(entry)) throw new Error(`Build error: directory name contains an encoded null byte (%%00).\n  Directory: ${fullPath}\nEncoded null bytes in directory names are not allowed. Rename the directory to remove the null byte encoding.`);
+		const { type, paramName, interceptionMarker, interceptedSegmentName } = classifySegment(entry);
+		if (type === "private") continue;
+		const childNode = createSegmentNode(entry, type, computeUrlPath(parentNode.urlPath, entry, type), paramName, interceptionMarker, interceptedSegmentName);
+		scanSegmentFiles(fullPath, childNode, extSet);
+		scanChildren(fullPath, childNode, extSet);
+		if (type === "slot") {
+			const slotName = entry.slice(1);
+			parentNode.slots.set(slotName, childNode);
+		} else parentNode.children.push(childNode);
+	}
+}
+/**
+* Validate that route groups don't produce conflicting pages/routes at the same URL path.
+*
+* Two route groups like (auth)/login/page.tsx and (marketing)/login/page.tsx both claim
+* /login — the scanner must detect and reject this at build time.
+*
+* Parallel slots are excluded from collision detection — they intentionally coexist at
+* the same URL path as their parent (that's the whole point of parallel routes).
+*/
+function validateRouteGroupCollisions(root) {
+	collectRoutableLeaves(root, /* @__PURE__ */ new Map(), "", false);
+}
+/**
+* Walk the segment tree and collect all routable leaves (page or route files),
+* throwing on collision. Slots are tracked in their own collision space since
+* they are parallel routes that intentionally share URL paths with their parent.
+*/
+function collectRoutableLeaves(node, seen, segmentPath, insideSlot) {
+	const currentPath = segmentPath ? `${segmentPath}/${node.segmentName}` : node.segmentName || "(root)";
+	if (!insideSlot) {
+		const routableFile = node.page ?? node.route;
+		if (routableFile) {
+			const existing = seen.get(node.urlPath);
+			if (existing) throw new Error(`Build error: route collision — multiple route groups produce a page/route at the same URL path.\n  URL path: ${node.urlPath}\n  File 1:   ${existing.filePath} (via ${existing.segmentPath})\n  File 2:   ${routableFile.filePath} (via ${currentPath})\nEach URL path must map to exactly one page or route handler. Rename or move one of the conflicting files.`);
+			seen.set(node.urlPath, {
+				filePath: routableFile.filePath,
+				segmentPath: currentPath
+			});
+		}
+	}
+	for (const child of node.children) collectRoutableLeaves(child, seen, currentPath, insideSlot);
+	for (const [, slotNode] of node.slots) collectRoutableLeaves(slotNode, seen, currentPath, true);
+}
+/**
+* Find a fixed-extension file (proxy.ts) in a directory.
+*/
+function findFixedFile(dirPath, name) {
+	for (const ext of ["ts", "tsx"]) {
+		const fullPath = join(dirPath, `${name}.${ext}`);
+		try {
+			if (statSync(fullPath).isFile()) return {
+				filePath: fullPath,
+				extension: ext
+			};
+		} catch {}
+	}
+}
+//#endregion
+//#region src/routing/codegen.ts
+/**
+* Route map codegen.
+*
+* Walks the scanned RouteTree and generates a TypeScript declaration file
+* mapping every route to its params and searchParams shapes.
+*
+* This runs at build time and in dev (regenerated on file changes).
+* No runtime overhead — purely static type generation.
+*/
+/**
+* Generate a TypeScript declaration file string from a scanned route tree.
+*
+* The output is a `declare module '@timber/app'` block containing the Routes
+* interface that maps every route path to its params and searchParams shape.
+*/
+function generateRouteMap(tree, options = {}) {
+	const routes = [];
+	collectRoutes(tree.root, [], options.appDir, routes);
+	routes.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
+	return formatDeclarationFile(routes, options.outputDir ?? options.appDir);
+}
+/**
+* Recursively walk the segment tree and collect route entries.
+*
+* A route entry is created for any segment that has a `page` or `route` file.
+* Params accumulate from ancestor dynamic segments.
+*/
+function collectRoutes(node, ancestorParams, appDir, routes) {
+	const params = [...ancestorParams];
+	if (node.paramName) params.push({
+		name: node.paramName,
+		type: paramTypeForSegment(node.segmentType)
+	});
+	const isPage = !!node.page;
+	const isApiRoute = !!node.route;
+	if (isPage || isApiRoute) {
+		const entry = {
+			urlPath: node.urlPath,
+			params: [...params],
+			hasSearchParams: false,
+			isApiRoute
+		};
+		if (appDir && isPage) {
+			const searchParamsFile = findSearchParamsFile(resolveSegmentDir(appDir, node));
+			if (searchParamsFile) {
+				entry.hasSearchParams = true;
+				entry.searchParamsAbsPath = searchParamsFile;
+			}
+		}
+		routes.push(entry);
+	}
+	for (const child of node.children) collectRoutes(child, params, appDir, routes);
+	for (const [, slot] of node.slots) collectRoutes(slot, params, appDir, routes);
+}
+/**
+* Determine the TypeScript type for a segment's param.
+*/
+function paramTypeForSegment(segmentType) {
+	switch (segmentType) {
+		case "catch-all": return "string[]";
+		case "optional-catch-all": return "string[] | undefined";
+		default: return "string";
+	}
+}
+/**
+* Resolve the absolute directory path for a segment node.
+*
+* Reconstructs the filesystem path by walking from appDir through
+* the segment names encoded in the urlPath, accounting for groups and slots.
+*/
+function resolveSegmentDir(appDir, node) {
+	const file = node.page ?? node.route;
+	if (file) {
+		const parts = file.filePath.split("/");
+		parts.pop();
+		return parts.join("/");
+	}
+	return appDir;
+}
+/**
+* Find a search-params.ts file in a directory.
+*/
+function findSearchParamsFile(dirPath) {
+	for (const ext of ["ts", "tsx"]) {
+		const candidate = join(dirPath, `search-params.${ext}`);
+		if (existsSync(candidate)) return candidate;
+	}
+}
+/**
+* Format the collected routes into a TypeScript declaration file.
+*/
+function formatDeclarationFile(routes, importBase) {
+	const lines = [];
+	lines.push("// This file is auto-generated by timber.js route map codegen.");
+	lines.push("// Do not edit manually. Regenerated on build and in dev mode.");
+	lines.push("");
+	lines.push("export {};");
+	lines.push("");
+	lines.push("declare module '@timber/app' {");
+	lines.push("  interface Routes {");
+	for (const route of routes) {
+		const paramsType = formatParamsType(route.params);
+		const searchParamsType = formatSearchParamsType(route, importBase);
+		lines.push(`    '${route.urlPath}': {`);
+		lines.push(`      params: ${paramsType}`);
+		lines.push(`      searchParams: ${searchParamsType}`);
+		lines.push(`    }`);
+	}
+	lines.push("  }");
+	lines.push("}");
+	lines.push("");
+	const pageRoutes = routes.filter((r) => !r.isApiRoute);
+	if (pageRoutes.length > 0) {
+		lines.push("declare module '@timber/app/server' {");
+		lines.push("  import type { Routes } from '@timber/app'");
+		lines.push("  export function searchParams<R extends keyof Routes>(): Promise<Routes[R]['searchParams']>");
+		lines.push("}");
+		lines.push("");
+	}
+	const dynamicRoutes = routes.filter((r) => r.params.length > 0);
+	if (dynamicRoutes.length > 0 || pageRoutes.length > 0) {
+		lines.push("declare module '@timber/app/client' {");
+		lines.push("  import type { SearchParamsDefinition, SetParams, QueryStatesOptions, SearchParamCodec } from '@timber/app/search-params'");
+		lines.push("");
+		if (dynamicRoutes.length > 0) {
+			for (const route of dynamicRoutes) {
+				const paramsType = formatParamsType(route.params);
+				lines.push(`  export function useParams(route: '${route.urlPath}'): ${paramsType}`);
+			}
+			lines.push("  export function useParams(): Record<string, string | string[]>");
+			lines.push("");
+		}
+		if (pageRoutes.length > 0) {
+			lines.push(...formatUseQueryStatesOverloads(pageRoutes, importBase));
+			lines.push("");
+		}
+		if (pageRoutes.length > 0) {
+			lines.push("  // Typed Link props per route");
+			lines.push(...formatTypedLinkOverloads(pageRoutes, importBase));
+		}
+		lines.push("}");
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Format the params type for a route entry.
+*/
+function formatParamsType(params) {
+	if (params.length === 0) return "{}";
+	return `{ ${params.map((p) => `${p.name}: ${p.type}`).join("; ")} }`;
+}
+/**
+* Format the params type for Link props.
+*
+* Link params accept `string | number` for single dynamic segments
+* (convenience — values are stringified at runtime). Catch-all and
+* optional catch-all remain `string[]` / `string[] | undefined`.
+*
+* See design/07-routing.md §"Typed params and searchParams on <Link>"
+*/
+function formatLinkParamsType(params) {
+	if (params.length === 0) return "{}";
+	return `{ ${params.map((p) => {
+		const type = p.type === "string" ? "string | number" : p.type;
+		return `${p.name}: ${type}`;
+	}).join("; ")} }`;
+}
+/**
+* Format the searchParams type for a route entry.
+*
+* When a search-params.ts exists, we reference its inferred type via an import type.
+* The import path is relative to `importBase` (the directory where the .d.ts will be
+* written). When importBase is undefined, falls back to a bare relative path.
+*/
+function formatSearchParamsType(route, importBase) {
+	if (route.hasSearchParams && route.searchParamsAbsPath) {
+		const absPath = route.searchParamsAbsPath.replace(/\.(ts|tsx)$/, "");
+		let importPath;
+		if (importBase) importPath = "./" + relative(importBase, absPath).replace(/\\/g, "/");
+		else importPath = "./" + posix.basename(absPath);
+		return `(typeof import('${importPath}'))['default'] extends import('@timber/app/search-params').SearchParamsDefinition<infer T> ? T : never`;
+	}
+	return "{}";
+}
+/**
+* Generate useQueryStates overloads.
+*
+* For each page route:
+* - Routes with search-params.ts get a typed overload returning the inferred T
+* - Routes without search-params.ts get an overload returning [{}, SetParams<{}>]
+*
+* A fallback overload for standalone codecs (existing API) is emitted last.
+*/
+function formatUseQueryStatesOverloads(routes, importBase) {
+	const lines = [];
+	for (const route of routes) {
+		const searchParamsType = route.hasSearchParams ? formatSearchParamsType(route, importBase) : "{}";
+		lines.push(`  export function useQueryStates<R extends '${route.urlPath}'>(route: R, options?: QueryStatesOptions): [${searchParamsType}, SetParams<${searchParamsType}>]`);
+	}
+	lines.push("  export function useQueryStates<T extends Record<string, unknown>>(codecs: { [K in keyof T]: SearchParamCodec<T[K]> }, options?: QueryStatesOptions): [T, SetParams<T>]");
+	return lines;
+}
+/**
+* Generate typed Link overloads.
+*
+* For each page route, we generate a Link function overload that:
+* - Constrains href to the route pattern
+* - Types the params prop based on dynamic segments
+* - Types the searchParams prop based on search-params.ts (if present)
+*
+* Routes without dynamic segments accept href as a literal string with no params.
+* Routes with dynamic segments require a params prop.
+*/
+function formatTypedLinkOverloads(routes, importBase) {
+	const lines = [];
+	for (const route of routes) {
+		const hasDynamicParams = route.params.length > 0;
+		const paramsType = formatLinkParamsType(route.params);
+		const searchParamsType = route.hasSearchParams ? formatSearchParamsType(route, importBase) : null;
+		if (hasDynamicParams) {
+			const spProp = searchParamsType ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }` : `searchParams?: never`;
+			lines.push(`  export function Link(props: Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {`);
+			lines.push(`    href: '${route.urlPath}'`);
+			lines.push(`    params: ${paramsType}`);
+			lines.push(`    ${spProp}`);
+			lines.push(`    prefetch?: boolean; scroll?: boolean; children?: import('react').ReactNode`);
+			lines.push(`  }): import('react').JSX.Element`);
+		} else {
+			const spProp = searchParamsType ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }` : `searchParams?: never`;
+			lines.push(`  export function Link(props: Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & {`);
+			lines.push(`    href: '${route.urlPath}'`);
+			lines.push(`    params?: never`);
+			lines.push(`    ${spProp}`);
+			lines.push(`    prefetch?: boolean; scroll?: boolean; children?: import('react').ReactNode`);
+			lines.push(`  }): import('react').JSX.Element`);
+		}
+	}
+	lines.push(`  export function Link(props: import('./client/link.js').LinkProps): import('react').JSX.Element`);
+	return lines;
+}
+//#endregion
+//#region src/routing/interception.ts
+/**
+* Collect all interception rewrite rules from the route tree.
+*
+* Walks the tree recursively. For each intercepting segment, computes the
+* intercepted URL based on the marker and the segment's position.
+*/
+function collectInterceptionRewrites(root) {
+	const rewrites = [];
+	walkForInterceptions(root, [root], rewrites);
+	return rewrites;
+}
+/**
+* Recursively walk the segment tree to find intercepting routes.
+*/
+function walkForInterceptions(node, ancestors, rewrites) {
+	for (const child of node.children) if (child.segmentType === "intercepting" && child.interceptionMarker) collectFromInterceptingNode(child, ancestors, rewrites);
+	else walkForInterceptions(child, [...ancestors, child], rewrites);
+	for (const [, slot] of node.slots) walkForInterceptions(slot, ancestors, rewrites);
+}
+/**
+* For an intercepting segment, find all leaf pages in its sub-tree and
+* generate rewrite rules for each.
+*/
+function collectFromInterceptingNode(interceptingNode, ancestors, rewrites) {
+	const marker = interceptingNode.interceptionMarker;
+	const segmentName = interceptingNode.interceptedSegmentName;
+	const parentUrlPath = ancestors[ancestors.length - 1].urlPath;
+	const interceptedBase = computeInterceptedBase(parentUrlPath, marker);
+	collectLeavesWithRewrites(interceptingNode, interceptedBase === "/" ? `/${segmentName}` : `${interceptedBase}/${segmentName}`, parentUrlPath, [...ancestors, interceptingNode], rewrites);
+}
+/**
+* Recursively find leaf pages in an intercepting sub-tree and generate
+* rewrite rules for each.
+*/
+function collectLeavesWithRewrites(node, interceptedUrlPath, interceptingPrefix, segmentPath, rewrites) {
+	if (node.page) rewrites.push({
+		interceptedPattern: interceptedUrlPath,
+		interceptingPrefix,
+		segmentPath: [...segmentPath]
+	});
+	for (const child of node.children) collectLeavesWithRewrites(child, child.segmentType === "group" ? interceptedUrlPath : `${interceptedUrlPath}/${child.segmentName}`, interceptingPrefix, [...segmentPath, child], rewrites);
+}
+/**
+* Compute the base URL that an intercepting route intercepts, given the
+* parent's URL path and the interception marker.
+*
+* - (.)  — same level: parent's URL path
+* - (..) — one level up: parent's parent URL path
+* - (...) — root level: /
+* - (..)(..) — two levels up: parent's grandparent URL path
+*
+* Level counting operates on URL path segments, NOT filesystem directories.
+* Route groups and parallel slots are already excluded from urlPath (they
+* don't add URL depth), so (..) correctly climbs visible segments. This
+* avoids the Vinext bug where path.dirname() on filesystem paths would
+* waste climbs on invisible route groups.
+*/
+function computeInterceptedBase(parentUrlPath, marker) {
+	switch (marker) {
+		case "(.)": return parentUrlPath;
+		case "(..)": {
+			const parts = parentUrlPath.split("/").filter(Boolean);
+			parts.pop();
+			return parts.length === 0 ? "/" : `/${parts.join("/")}`;
+		}
+		case "(...)": return "/";
+		case "(..)(..)": {
+			const parts = parentUrlPath.split("/").filter(Boolean);
+			parts.pop();
+			parts.pop();
+			return parts.length === 0 ? "/" : `/${parts.join("/")}`;
+		}
+	}
+}
+//#endregion
+export { DEFAULT_PAGE_EXTENSIONS as a, scanRoutes as i, generateRouteMap as n, INTERCEPTION_MARKERS as o, classifySegment as r, collectInterceptionRewrites as t };
+
+//# sourceMappingURL=interception-DIaZN1bF.js.map