@timber-js/app 0.2.0-alpha.9 → 0.2.0-alpha.91

package/dist/_chunks/{interception-BOoWmLUA.js → interception-ErnB33JX.js}

@@ -1,6 +1,7 @@
-import { a as isDynamicMetadataExtension, n as classifyMetadataRoute } from "./metadata-routes-Cjmvi3rQ.js";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { t as classifyUrlSegment } from "./segment-classify-BDNn6EzD.js";
+import { a as isDynamicMetadataExtension, n as classifyMetadataRoute } from "./metadata-routes-DS3eKNmf.js";
 import { basename, extname, join, posix, relative } from "node:path";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 //#region src/routing/types.ts
 /** All recognized interception markers, ordered longest-first for parsing. */
 var INTERCEPTION_MARKERS = [
@@ -65,8 +66,7 @@ var FIXED_CONVENTIONS = new Set([
 	"middleware",
 	"access",
 	"route",
-	"prerender",
-	"search-params"
+	"params"
 ]);
 /**
 * Status-code file patterns:
@@ -87,9 +87,12 @@ function scanRoutes(appDir, config = {}) {
 	const tree = { root: createSegmentNode("", "static", "/") };
 	const proxyFile = findFixedFile(appDir, "proxy");
 	if (proxyFile) tree.proxy = proxyFile;
+	const globalErrorFile = findPageExtFile(appDir, "global-error", extSet);
+	if (globalErrorFile) tree.globalError = globalErrorFile;
 	scanSegmentFiles(appDir, tree.root, extSet);
 	scanChildren(appDir, tree.root, extSet);
 	validateRouteGroupCollisions(tree.root);
+	validateDuplicateParamNames(tree.root);
 	return tree;
 }
 /**
@@ -120,17 +123,10 @@ function classifySegment(dirName) {
 		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)
+	const urlSeg = classifyUrlSegment(dirName);
+	if (urlSeg.kind !== "static") return {
+		type: urlSeg.kind,
+		paramName: urlSeg.name
 	};
 	return { type: "static" };
 }
@@ -224,11 +220,8 @@ function scanSegmentFiles(dirPath, node, extSet) {
 				case "route":
 					node.route = file;
 					break;
-				case "prerender":
-					node.prerender = file;
-					break;
-				case "search-params":
-					node.searchParams = file;
+				case "params":
+					node.params = file;
 					break;
 			}
 			continue;
@@ -338,6 +331,34 @@ function collectRoutableLeaves(node, seen, segmentPath, insideSlot) {
 	for (const [, slotNode] of node.slots) collectRoutableLeaves(slotNode, seen, currentPath, true);
 }
 /**
+* Validate that no route chain contains duplicate dynamic param names.
+*
+* Example violation:
+*   app/[id]/items/[id]/page.tsx — 'id' appears twice in the ancestor chain.
+*
+* Route groups are transparent — params accumulate through them.
+* Slots are independent — duplicate detection does NOT cross slot boundaries.
+*
+* See design/07-routing.md §"Duplicate Param Name Detection"
+*/
+function validateDuplicateParamNames(root) {
+	walkForDuplicateParams(root, /* @__PURE__ */ new Map());
+}
+/**
+* Recursively walk the segment tree, tracking seen param names → segment paths.
+* Throws on the first duplicate found.
+*/
+function walkForDuplicateParams(node, seen) {
+	if (node.paramName) {
+		const existing = seen.get(node.paramName);
+		if (existing) throw new Error(`[timber] Duplicate param name '${node.paramName}' in route chain.\n  First defined at: ${existing}\n  Duplicate at: ${node.urlPath || "/"}\n  Rename one of the segments to avoid ambiguity.`);
+		seen = new Map(seen);
+		seen.set(node.paramName, node.urlPath || "/");
+	}
+	for (const child of node.children) walkForDuplicateParams(child, seen);
+	for (const [, slotNode] of node.slots) walkForDuplicateParams(slotNode, new Map(seen));
+}
+/**
 * Find a fixed-extension file (proxy.ts) in a directory.
 */
 function findFixedFile(dirPath, name) {
@@ -351,6 +372,204 @@ function findFixedFile(dirPath, name) {
 		} catch {}
 	}
 }
+/**
+* Find a file using the configured page extensions (tsx, ts, jsx, js, mdx, etc.).
+* Used for app-root conventions like global-error that aren't per-segment.
+*/
+function findPageExtFile(dirPath, name, extSet) {
+	for (const ext of extSet) {
+		const fullPath = join(dirPath, `${name}.${ext}`);
+		try {
+			if (statSync(fullPath).isFile()) return {
+				filePath: fullPath,
+				extension: ext
+			};
+		} catch {}
+	}
+}
+//#endregion
+//#region src/routing/codegen-shared.ts
+/**
+* Shared codegen helpers — import-path computation, codec chain type
+* builder, and searchParams type formatter.
+*
+* Extracted from `codegen.ts` so `link-codegen.ts` can use the same
+* helpers without a cyclic import.
+*/
+/**
+* Compute a relative import specifier for a codec/page file, stripping
+* the .ts/.tsx extension and resolving against the codegen output dir.
+*/
+function codecImportPath(codecFilePath, importBase) {
+	const absPath = codecFilePath.replace(/\.(ts|tsx)$/, "");
+	if (importBase) return "./" + relative(importBase, absPath).replace(/\\/g, "/");
+	return "./" + posix.basename(absPath);
+}
+/**
+* Build a TypeScript type expression that resolves a single param's
+* codec by walking a chain of params.ts files in priority order.
+*
+* Each entry in the chain emits a conditional:
+*   `(typeof import(file))['segmentParams'] extends ParamsDefinition<infer T>
+*     ? K extends keyof T ? T[K] : <next>
+*     : <next>`
+*
+* The closest match (position 0 in the chain) is checked first; if its
+* `segmentParams` definition declares the key, its inferred type wins.
+* Otherwise we fall through to the next ancestor, and finally to the
+* provided fallback. See TIM-834.
+*/
+function buildCodecChainType(p, importBase, fallback) {
+	const files = p.codecFilePaths;
+	if (!files || files.length === 0) return fallback;
+	const key = JSON.stringify(p.name);
+	let inner = fallback;
+	for (let i = files.length - 1; i >= 0; i--) inner = `((typeof import('${codecImportPath(files[i], importBase)}'))['segmentParams'] extends import('@timber-js/app/segment-params').ParamsDefinition<infer T> ? (${key} extends keyof T ? T[${key}] : ${inner}) : ${inner})`;
+	return inner;
+}
+/**
+* Format the searchParams type for a route entry.
+*
+* When a page.tsx (or params.ts) exports searchParams, 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.searchParamsPagePath) return `(typeof import('${codecImportPath(route.searchParamsPagePath, importBase)}'))['searchParams'] extends import('@timber-js/app/search-params').SearchParamsDefinition<infer T> ? T : never`;
+	return "{}";
+}
+//#endregion
+//#region src/routing/link-codegen.ts
+/** Shared Link base-props type literal used in every emitted call signature. */
+var LINK_BASE_PROPS_TYPE = "Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & { prefetch?: boolean; scroll?: boolean; preserveSearchParams?: true | string[]; onNavigate?: import('./client/link.js').OnNavigateHandler; children?: import('react').ReactNode }";
+/**
+* Build a TypeScript template literal pattern for a dynamic route.
+* e.g. '/products/[id]'        → '/products/${string}'
+*      '/blog/[...slug]'       → '/blog/${string}'
+*      '/docs/[[...path]]'     → '/docs/${string}' (also matches /docs)
+*      '/[org]/[repo]'         → '/${string}/${string}'
+*/
+function buildResolvedPattern(route) {
+	return route.urlPath.split("/").map((part) => {
+		if (part.startsWith("[[...") && part.endsWith("]]")) return "${string}";
+		if (part.startsWith("[...") && part.endsWith("]")) return "${string}";
+		if (part.startsWith("[") && part.endsWith("]")) return "${string}";
+		return part;
+	}).join("/");
+}
+/**
+* Format the segmentParams type for Link overloads.
+*
+* 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`.
+*
+* When the segment's params chain (TIM-834) declares a typed codec, the
+* inferred type from the codec wins via a nested conditional.
+*/
+function formatLinkParamsType(params, importBase) {
+	if (params.length === 0) return "{}";
+	return `{ ${params.map((p) => {
+		const codecType = buildCodecChainType(p, importBase, p.type === "string" ? "string | number" : p.type);
+		return `${p.name}: ${codecType}`;
+	}).join("; ")} }`;
+}
+/**
+* Catch-all call signatures for `<Link>` — external hrefs and computed
+* `string` variables. Emitted from codegen in a SEPARATE
+* `declare module` block (declared AFTER the per-route block) so the TS
+* "later overload set ordered first" rule places these catch-all
+* signatures ahead of per-route in resolution order, leaving per-route
+* as the final overload whose error message is reported on failure.
+*
+* The conditional `string extends H ? ... : never` protection preserves
+* TIM-624's guarantee that unknown internal path literals don't match
+* the catch-all — typos like `<Link href="/typo" />` still error.
+*/
+function formatLinkCatchAllOverloads() {
+	const lines = [];
+	const baseProps = LINK_BASE_PROPS_TYPE;
+	const catchAllSearchParams = "{ definition: SearchParamsDefinition<Record<string, unknown>>; values: Record<string, unknown> } | Record<string, unknown>";
+	const externalHref = "`http://${string}` | `https://${string}` | `mailto:${string}` | `tel:${string}` | `ftp://${string}` | `//${string}` | `#${string}` | `?${string}`";
+	lines.push("  // Typed Link overloads — catch-all (block 2 / emitted second)");
+	lines.push("  interface LinkFunction {");
+	lines.push(`    (props: ${baseProps} & {`);
+	lines.push(`      href: ${externalHref}`);
+	lines.push(`      segmentParams?: never`);
+	lines.push(`      searchParams?: ${catchAllSearchParams}`);
+	lines.push(`    }): import('react').JSX.Element`);
+	lines.push(`    <H extends string>(`);
+	lines.push(`      props: string extends H`);
+	lines.push(`        ? ${baseProps} & {`);
+	lines.push(`            href: H`);
+	lines.push(`            segmentParams?: Record<string, string | number | string[]>`);
+	lines.push(`            searchParams?: ${catchAllSearchParams}`);
+	lines.push(`          }`);
+	lines.push(`        : never`);
+	lines.push(`    ): import('react').JSX.Element`);
+	lines.push("  }");
+	return lines;
+}
+/**
+* Generate typed per-route Link call signatures via LinkFunction
+* interface merging.
+*
+* TIM-835: This emits a SINGLE call signature whose props is a
+* discriminated union keyed on `href`. TypeScript narrows the union by
+* the literal `href` at the call site, then checks the rest of the
+* props against the matched variant. When `segmentParams` or
+* `searchParams` is wrong, TS reports the error against the matched
+* variant — naming the user's actual `href` and the offending field.
+*
+* Before TIM-835, this function emitted N separate per-route overloads
+* (one per route, sometimes two for dynamic routes). When ALL overloads
+* failed, TS would pick an arbitrary failed overload (heuristically the
+* "last tried") to render the diagnostic, often pointing at a route
+* completely unrelated to the one the user wrote. The discriminated
+* union sidesteps overload-resolution heuristics entirely.
+*
+* Open property shapes (`Record<string, unknown>` instead of `never`)
+* for `segmentParams` on routes that don't declare them keep generic
+* `LinkProps`-spreading wrappers compiling. (Aligned with TIM-833.)
+*
+* TIM-832: this function still emits the per-route block FIRST and the
+* catch-all block follows, so per-route remains the LAST overload set in
+* resolution order — the one TS reports against on failure. With a
+* discriminated union there is only one call signature in this block,
+* so the resolved-template-vs-pattern ordering reduces to placing the
+* pattern variant before the resolved-template variant inside the union.
+*/
+function formatTypedLinkOverloads(routes, importBase) {
+	const lines = [];
+	const baseProps = LINK_BASE_PROPS_TYPE;
+	const variants = [];
+	for (const route of routes) {
+		const hasDynamicParams = route.params.length > 0;
+		const paramsProp = hasDynamicParams ? `segmentParams: ${formatLinkParamsType(route.params, importBase)}` : "segmentParams?: Record<string, unknown>";
+		const searchParamsType = route.hasSearchParams ? formatSearchParamsType(route, importBase) : null;
+		const patternSearchParamsProp = searchParamsType ? `searchParams?: Partial<${searchParamsType}>` : "searchParams?: Record<string, never>";
+		variants.push(`${baseProps} & { href: '${route.urlPath}'; ${paramsProp}; ${patternSearchParamsProp} }`);
+		if (hasDynamicParams) {
+			const templatePattern = buildResolvedPattern(route);
+			if (templatePattern) {
+				const resolvedSearchParamsProp = searchParamsType ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }` : "searchParams?: Record<string, never>";
+				variants.push(`${baseProps} & { href: \`${templatePattern}\`; segmentParams?: Record<string, never>; ${resolvedSearchParamsProp} }`);
+			}
+		}
+	}
+	lines.push("  interface LinkFunction {");
+	if (variants.length === 0) {
+		lines.push("  }");
+		return lines;
+	}
+	lines.push("    (");
+	lines.push("      props:");
+	for (const variant of variants) lines.push(`        | (${variant})`);
+	lines.push(`    ): import('react').JSX.Element`);
+	lines.push("  }");
+	return lines;
+}
 //#endregion
 //#region src/routing/codegen.ts
 /**
@@ -370,7 +589,7 @@ function findFixedFile(dirPath, name) {
 */
 function generateRouteMap(tree, options = {}) {
 	const routes = [];
-	collectRoutes(tree.root, [], options.appDir, routes);
+	collectRoutes(tree.root, [], [], routes);
 	routes.sort((a, b) => a.urlPath.localeCompare(b.urlPath));
 	return formatDeclarationFile(routes, options.outputDir ?? options.appDir);
 }
@@ -380,12 +599,24 @@ function generateRouteMap(tree, options = {}) {
 * 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) {
+function collectRoutes(node, ancestorParams, ancestorParamsFiles, routes) {
+	const ownParamsFile = node.params && fileHasExport(node.params.filePath, "segmentParams") ? node.params.filePath : void 0;
 	const params = [...ancestorParams];
-	if (node.paramName) params.push({
-		name: node.paramName,
-		type: paramTypeForSegment(node.segmentType)
-	});
+	if (node.paramName) {
+		const codecFilePaths = [];
+		if (ownParamsFile) codecFilePaths.push(ownParamsFile);
+		for (let i = ancestorParamsFiles.length - 1; i >= 0; i--) codecFilePaths.push(ancestorParamsFiles[i]);
+		if (codecFilePaths.length === 0) {
+			const legacy = findLegacyParamsExport(node);
+			if (legacy) codecFilePaths.push(legacy);
+		}
+		params.push({
+			name: node.paramName,
+			type: paramTypeForSegment(node.segmentType),
+			codecFilePaths: codecFilePaths.length > 0 ? codecFilePaths : void 0
+		});
+	}
+	const nextAncestorFiles = ownParamsFile ? [...ancestorParamsFiles, ownParamsFile] : ancestorParamsFiles;
 	const isPage = !!node.page;
 	const isApiRoute = !!node.route;
 	if (isPage || isApiRoute) {
@@ -395,17 +626,19 @@ function collectRoutes(node, ancestorParams, appDir, routes) {
 			hasSearchParams: false,
 			isApiRoute
 		};
-		if (appDir && isPage) {
-			const searchParamsFile = findSearchParamsFile(resolveSegmentDir(appDir, node));
-			if (searchParamsFile) {
+		if (isPage) {
+			if (node.params && fileHasExport(node.params.filePath, "searchParams")) {
 				entry.hasSearchParams = true;
-				entry.searchParamsAbsPath = searchParamsFile;
+				entry.searchParamsPagePath = node.params.filePath;
+			} else if (node.page && fileHasExport(node.page.filePath, "searchParams")) {
+				entry.hasSearchParams = true;
+				entry.searchParamsPagePath = node.page.filePath;
 			}
 		}
 		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);
+	for (const child of node.children) collectRoutes(child, params, nextAncestorFiles, routes);
+	for (const [, slot] of node.slots) collectRoutes(slot, params, nextAncestorFiles, routes);
 }
 /**
 * Determine the TypeScript type for a segment's param.
@@ -418,28 +651,31 @@ function paramTypeForSegment(segmentType) {
 	}
 }
 /**
-* Resolve the absolute directory path for a segment node.
+* Check if a file exports a specific named export.
 *
-* Reconstructs the filesystem path by walking from appDir through
-* the segment names encoded in the urlPath, accounting for groups and slots.
+* Uses a lightweight regex check — not full AST parsing. The actual type
+* extraction happens via the TypeScript compiler in the generated .d.ts.
 */
-function resolveSegmentDir(appDir, node) {
-	const file = node.page ?? node.route;
-	if (file) {
-		const parts = file.filePath.split("/");
-		parts.pop();
-		return parts.join("/");
+function fileHasExport(filePath, exportName) {
+	if (!existsSync(filePath)) return false;
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const e = exportName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		return new RegExp(`export\\s+(const|let|var)\\s+${e}\\b`).test(content) || new RegExp(`export\\s*\\{[^}]*\\b${e}\\b[^}]*\\}`).test(content);
+	} catch {
+		return false;
 	}
-	return appDir;
 }
 /**
-* Find a search-params.ts file in a directory.
+* Find a legacy `segmentParams` export on layout.tsx or page.tsx.
+*
+* Backward-compat shim: TIM-508 made params.ts the canonical location
+* for `segmentParams`. Layout/page exports are still accepted for the
+* OWN segment only (not inherited by descendants — see TIM-834).
 */
-function findSearchParamsFile(dirPath) {
-	for (const ext of ["ts", "tsx"]) {
-		const candidate = join(dirPath, `search-params.${ext}`);
-		if (existsSync(candidate)) return candidate;
-	}
+function findLegacyParamsExport(node) {
+	if (node.layout && fileHasExport(node.layout.filePath, "segmentParams")) return node.layout.filePath;
+	if (node.page && fileHasExport(node.page.filePath, "segmentParams")) return node.page.filePath;
 }
 /**
 * Format the collected routes into a TypeScript declaration file.
@@ -454,10 +690,10 @@ function formatDeclarationFile(routes, importBase) {
 	lines.push("declare module '@timber-js/app' {");
 	lines.push("  interface Routes {");
 	for (const route of routes) {
-		const paramsType = formatParamsType(route.params);
+		const paramsType = formatParamsType(route.params, importBase);
 		const searchParamsType = formatSearchParamsType(route, importBase);
 		lines.push(`    '${route.urlPath}': {`);
-		lines.push(`      params: ${paramsType}`);
+		lines.push(`      segmentParams: ${paramsType}`);
 		lines.push(`      searchParams: ${searchParamsType}`);
 		lines.push(`    }`);
 	}
@@ -465,13 +701,6 @@ function formatDeclarationFile(routes, importBase) {
 	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' {");
@@ -479,10 +708,10 @@ function formatDeclarationFile(routes, importBase) {
 		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}`);
+				const paramsType = formatParamsType(route.params, importBase);
+				lines.push(`  export function useSegmentParams(route: '${route.urlPath}'): ${paramsType}`);
 			}
-			lines.push("  export function useParams(): Record<string, string | string[]>");
+			lines.push("  export function useSegmentParams(): Record<string, string | string[]>");
 			lines.push("");
 		}
 		if (pageRoutes.length > 0) {
@@ -490,55 +719,32 @@ function formatDeclarationFile(routes, importBase) {
 			lines.push("");
 		}
 		if (pageRoutes.length > 0) {
-			lines.push("  // Typed Link props per route");
+			lines.push("  // Typed Link overloads — per-route (block 1 / emitted first)");
 			lines.push(...formatTypedLinkOverloads(pageRoutes, importBase));
+			lines.push("");
 		}
 		lines.push("}");
 		lines.push("");
 	}
+	lines.push("declare module '@timber-js/app/client' {");
+	lines.push("  import type { SearchParamsDefinition } from '@timber-js/app/search-params'");
+	lines.push("");
+	lines.push(...formatLinkCatchAllOverloads());
+	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) {
+function formatParamsType(params, importBase) {
 	if (params.length === 0) return "{}";
 	return `{ ${params.map((p) => {
-		const type = p.type === "string" ? "string | number" : p.type;
-		return `${p.name}: ${type}`;
+		const codecType = buildCodecChainType(p, importBase, p.type);
+		return `${p.name}: ${codecType}`;
 	}).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:
@@ -556,44 +762,6 @@ function formatUseQueryStatesOverloads(routes, importBase) {
 	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
 /**
@@ -673,4 +841,4 @@ function computeInterceptedBase(parentUrlPath, marker) {
 //#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-BOoWmLUA.js.map
+//# sourceMappingURL=interception-ErnB33JX.js.map