@timber-js/app 0.2.0-alpha.2 → 0.2.0-alpha.200

package/dist/_chunks/interception-DGDIjDbR.js

@@ -1,676 +0,0 @@
-import { a as isDynamicMetadataExtension, n as classifyMetadataRoute } from "./metadata-routes-CQCnF4VK.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();
-			const existing = node.metadataRoutes.get(name);
-			if (existing) {
-				const existingIsDynamic = isDynamicMetadataExtension(name, existing.extension);
-				if (isDynamicMetadataExtension(name, ext) || !existingIsDynamic) node.metadataRoutes.set(name, {
-					filePath: fullPath,
-					extension: ext
-				});
-			} else 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-js/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-js/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-js/app/server' {");
-		lines.push("  import type { Routes } from '@timber-js/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-js/app/client' {");
-		lines.push("  import type { SearchParamsDefinition, SetParams, QueryStatesOptions, SearchParamCodec } from '@timber-js/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-js/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-DGDIjDbR.js.map