@timber-js/app 0.2.0-alpha.90 → 0.2.0-alpha.92

package/dist/_chunks/interception-DSv3A2Zn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interception-DSv3A2Zn.js","names":[],"sources":["../../src/routing/types.ts","../../src/routing/scanner.ts","../../src/routing/codegen-shared.ts","../../src/routing/link-codegen.ts","../../src/routing/codegen.ts","../../src/routing/interception.ts"],"sourcesContent":["/**\n * Route tree types for timber.js file-system routing.\n *\n * The route tree is built by scanning the app/ directory and recognizing\n * file conventions (page.*, layout.*, middleware.ts, access.ts, route.ts, etc.).\n */\n\n/** Segment type classification */\nexport type SegmentType =\n  | 'static' // e.g. \"dashboard\"\n  | 'dynamic' // e.g. \"[id]\"\n  | 'catch-all' // e.g. \"[...slug]\"\n  | 'optional-catch-all' // e.g. \"[[...slug]]\"\n  | 'group' // e.g. \"(marketing)\"\n  | 'slot' // e.g. \"@sidebar\"\n  | 'intercepting' // e.g. \"(.)photo\", \"(..)photo\", \"(...)photo\"\n  | 'private'; // e.g. \"_components\", \"_lib\" — excluded from routing\n\n/**\n * Intercepting route marker — indicates how many levels up to resolve the\n * intercepted route from the intercepting route's location.\n *\n * See design/07-routing.md §\"Intercepting Routes\"\n */\nexport type InterceptionMarker = '(.)' | '(..)' | '(...)' | '(..)(..)';\n\n/** All recognized interception markers, ordered longest-first for parsing. */\nexport const INTERCEPTION_MARKERS: InterceptionMarker[] = ['(..)(..)', '(.)', '(..)', '(...)'];\n\n/** A single file discovered in a route segment */\nexport interface RouteFile {\n  /** Absolute path to the file */\n  filePath: string;\n  /** File extension without leading dot (e.g. \"tsx\", \"ts\", \"mdx\") */\n  extension: string;\n}\n\n/** A node in the segment tree */\nexport interface SegmentNode {\n  /** The raw directory name (e.g. \"dashboard\", \"[id]\", \"(auth)\", \"@sidebar\") */\n  segmentName: string;\n  /** Classified segment type */\n  segmentType: SegmentType;\n  /** The dynamic param name, if dynamic (e.g. \"id\" for \"[id]\", \"slug\" for \"[...slug]\") */\n  paramName?: string;\n  /** The URL path prefix at this segment level (e.g. \"/dashboard\") */\n  urlPath: string;\n  /** For intercepting segments: the marker used, e.g. \"(.)\". */\n  interceptionMarker?: InterceptionMarker;\n  /**\n   * For intercepting segments: the segment name after stripping the marker.\n   * E.g., for \"(.)photo\" this is \"photo\".\n   */\n  interceptedSegmentName?: string;\n\n  // --- File conventions ---\n  page?: RouteFile;\n  layout?: RouteFile;\n  middleware?: RouteFile;\n  access?: RouteFile;\n  route?: RouteFile;\n  /**\n   * params.ts — isomorphic convention file exporting segmentParams and/or searchParams.\n   * Discovered by the scanner like middleware.ts and access.ts.\n   * See design/07-routing.md §\"params.ts Convention File\"\n   */\n  params?: RouteFile;\n  error?: RouteFile;\n  default?: RouteFile;\n  /** Status-code files: 4xx.tsx, 5xx.tsx, {status}.tsx (component format) */\n  statusFiles?: Map<string, RouteFile>;\n  /** JSON status-code files: 4xx.json, 5xx.json, {status}.json */\n  jsonStatusFiles?: Map<string, RouteFile>;\n  /** denied.tsx — slot-only denial rendering */\n  denied?: RouteFile;\n  /** Legacy compat: not-found.tsx (maps to 404), forbidden.tsx (403), unauthorized.tsx (401) */\n  legacyStatusFiles?: Map<string, RouteFile>;\n\n  /** Metadata route files (sitemap.ts, robots.ts, icon.tsx, etc.) keyed by base name */\n  metadataRoutes?: Map<string, RouteFile>;\n\n  // --- Children ---\n  children: SegmentNode[];\n  /** Parallel route slots (keyed by slot name without @) */\n  slots: Map<string, SegmentNode>;\n}\n\n/** The full route tree output from the scanner */\nexport interface RouteTree {\n  /** The root segment node (representing app/) */\n  root: SegmentNode;\n  /** All discovered proxy.ts files (should be at most one, in app/) */\n  proxy?: RouteFile;\n  /**\n   * Global error page: app/global-error.{tsx,ts,jsx,js}\n   *\n   * Rendered as a standalone full-page replacement (no layout wrapping)\n   * when no segment-level error file is found. SSR-only render path.\n   * Must provide its own <html> and <body>.\n   *\n   * See design/10-error-handling.md §\"Tier 2 — Global Error Page\"\n   */\n  globalError?: RouteFile;\n}\n\n/** Configuration passed to the scanner */\nexport interface ScannerConfig {\n  /** Recognized page/layout extensions (without dots). Default: ['tsx', 'ts', 'jsx', 'js'] */\n  pageExtensions?: string[];\n}\n\n/** Default page extensions */\nexport const DEFAULT_PAGE_EXTENSIONS = ['tsx', 'ts', 'jsx', 'js'];\n","/**\n * Route discovery scanner.\n *\n * Pure function: (appDir, config) → RouteTree\n *\n * Scans the app/ directory and builds a segment tree recognizing all\n * timber.js file conventions. Does NOT handle request matching — this\n * is discovery only.\n */\n\nimport { readdirSync, statSync } from 'node:fs';\nimport { join, extname, basename } from 'node:path';\nimport type {\n  RouteTree,\n  SegmentNode,\n  SegmentType,\n  RouteFile,\n  ScannerConfig,\n  InterceptionMarker,\n} from './types.js';\nimport { classifyUrlSegment } from './segment-classify.js';\nimport { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS } from './types.js';\nimport { classifyMetadataRoute, isDynamicMetadataExtension } from '../server/metadata-routes.js';\n\n/**\n * Pattern matching encoded path delimiters that must be rejected during route discovery.\n * %2F / %2f (forward slash) and %5C / %5c (backslash) can cause route collisions\n * when decoded. See design/13-security.md §\"Encoded separators rejected\".\n */\nconst ENCODED_SEPARATOR_PATTERN = /%(?:2[fF]|5[cC])/;\n\n/**\n * Pattern matching encoded null bytes (%00) that must be rejected.\n * See design/13-security.md §\"Null bytes rejected\".\n */\nconst ENCODED_NULL_PATTERN = /%00/;\n\n/**\n * File convention names that use pageExtensions (can be .tsx, .ts, .jsx, .js, .mdx, etc.)\n */\nconst PAGE_EXT_CONVENTIONS = new Set(['page', 'layout', 'error', 'default', 'denied']);\n\n/**\n * Legacy compat status-code files.\n * Maps legacy file name → HTTP status code for the fallback chain.\n * See design/10-error-handling.md §\"Fallback Chain\".\n */\nconst LEGACY_STATUS_FILES: Record<string, number> = {\n  'not-found': 404,\n  'forbidden': 403,\n  'unauthorized': 401,\n};\n\n/**\n * File convention names that are always .ts/.tsx (never .mdx etc.)\n */\nconst FIXED_CONVENTIONS = new Set(['middleware', 'access', 'route', 'params']);\n\n/**\n * Status-code file patterns:\n * - Exact 3-digit codes: 401.tsx, 429.tsx, 503.tsx\n * - Category catch-alls: 4xx.tsx, 5xx.tsx\n */\nconst STATUS_CODE_PATTERN = /^(\\d{3}|[45]xx)$/;\n\n/**\n * Scan the app/ directory and build the route tree.\n *\n * @param appDir - Absolute path to the app/ directory\n * @param config - Scanner configuration\n * @returns The complete route tree\n */\nexport function scanRoutes(appDir: string, config: ScannerConfig = {}): RouteTree {\n  const pageExtensions = config.pageExtensions ?? DEFAULT_PAGE_EXTENSIONS;\n  const extSet = new Set(pageExtensions);\n\n  const tree: RouteTree = {\n    root: createSegmentNode('', 'static', '/'),\n  };\n\n  // Check for proxy.ts at app root\n  const proxyFile = findFixedFile(appDir, 'proxy');\n  if (proxyFile) {\n    tree.proxy = proxyFile;\n  }\n\n  // Check for global-error.{tsx,ts,jsx,js} at app root.\n  // Tier 2 error page — renders standalone (no layouts) when no segment-level\n  // error file is found. See design/10-error-handling.md §\"Tier 2\".\n  const globalErrorFile = findPageExtFile(appDir, 'global-error', extSet);\n  if (globalErrorFile) {\n    tree.globalError = globalErrorFile;\n  }\n\n  // Scan the root directory's files\n  scanSegmentFiles(appDir, tree.root, extSet);\n\n  // Scan children recursively\n  scanChildren(appDir, tree.root, extSet);\n\n  // Validate: detect route group collisions (different groups producing pages at the same URL)\n  validateRouteGroupCollisions(tree.root);\n\n  // Validate: detect duplicate param names in nested dynamic segments\n  // e.g., /[id]/items/[id] — same param name in ancestor and descendant\n  validateDuplicateParamNames(tree.root);\n\n  return tree;\n}\n\n/**\n * Create an empty segment node.\n */\nfunction createSegmentNode(\n  segmentName: string,\n  segmentType: SegmentType,\n  urlPath: string,\n  paramName?: string,\n  interceptionMarker?: InterceptionMarker,\n  interceptedSegmentName?: string\n): SegmentNode {\n  return {\n    segmentName,\n    segmentType,\n    urlPath,\n    paramName,\n    interceptionMarker,\n    interceptedSegmentName,\n    children: [],\n    slots: new Map(),\n  };\n}\n\n/**\n * Classify a directory name into its segment type.\n */\nexport function classifySegment(dirName: string): {\n  type: SegmentType;\n  paramName?: string;\n  interceptionMarker?: InterceptionMarker;\n  interceptedSegmentName?: string;\n} {\n  // Private folder: _name (excluded from routing)\n  if (dirName.startsWith('_')) {\n    return { type: 'private' };\n  }\n\n  // Parallel route slot: @name\n  if (dirName.startsWith('@')) {\n    return { type: 'slot' };\n  }\n\n  // Intercepting routes: (.)name, (..)name, (...)name, (..)(..)name\n  // Check before route groups since intercepting markers also start with (\n  const interception = parseInterceptionMarker(dirName);\n  if (interception) {\n    return {\n      type: 'intercepting',\n      interceptionMarker: interception.marker,\n      interceptedSegmentName: interception.segmentName,\n    };\n  }\n\n  // Route group: (name)\n  if (dirName.startsWith('(') && dirName.endsWith(')')) {\n    return { type: 'group' };\n  }\n\n  // Bracket-syntax segments: [param], [...param], [[...param]]\n  // Delegated to the shared character-based classifier. If you change\n  // bracket syntax, update segment-classify.ts — not here.\n  const urlSeg = classifyUrlSegment(dirName);\n  if (urlSeg.kind !== 'static') {\n    return { type: urlSeg.kind, paramName: urlSeg.name };\n  }\n\n  return { type: 'static' };\n}\n\n/**\n * Parse an interception marker from a directory name.\n *\n * Returns the marker and the remaining segment name, or null if not an\n * intercepting route. Markers are checked longest-first to avoid (..)\n * matching before (..)(..).\n *\n * Examples:\n *   \"(.)photo\"      → { marker: \"(.)\", segmentName: \"photo\" }\n *   \"(..)feed\"      → { marker: \"(..)\", segmentName: \"feed\" }\n *   \"(...)photos\"   → { marker: \"(...)\", segmentName: \"photos\" }\n *   \"(..)(..)admin\" → { marker: \"(..)(..)\", segmentName: \"admin\" }\n *   \"(marketing)\"   → null (route group, not interception)\n */\nfunction parseInterceptionMarker(\n  dirName: string\n): { marker: InterceptionMarker; segmentName: string } | null {\n  for (const marker of INTERCEPTION_MARKERS) {\n    if (dirName.startsWith(marker)) {\n      const rest = dirName.slice(marker.length);\n      // Must have a segment name after the marker, and the rest must not\n      // be empty or end with ) (which would be a route group like \"(auth)\")\n      if (rest.length > 0 && !rest.endsWith(')')) {\n        return { marker, segmentName: rest };\n      }\n    }\n  }\n  return null;\n}\n\n/**\n * Compute the URL path for a child segment given its parent's URL path.\n * Route groups, slots, and intercepting routes do NOT add URL depth.\n */\nfunction computeUrlPath(parentUrlPath: string, dirName: string, segmentType: SegmentType): string {\n  // Groups, slots, and intercepting routes don't add to URL path\n  if (segmentType === 'group' || segmentType === 'slot' || segmentType === 'intercepting') {\n    return parentUrlPath;\n  }\n\n  const parentPath = parentUrlPath === '/' ? '' : parentUrlPath;\n  return `${parentPath}/${dirName}`;\n}\n\n/**\n * Scan a directory for file conventions and populate the segment node.\n */\nfunction scanSegmentFiles(dirPath: string, node: SegmentNode, extSet: Set<string>): void {\n  let entries: string[];\n  try {\n    entries = readdirSync(dirPath);\n  } catch {\n    return;\n  }\n\n  for (const entry of entries) {\n    const fullPath = join(dirPath, entry);\n\n    // Skip directories — handled by scanChildren\n    try {\n      if (statSync(fullPath).isDirectory()) continue;\n    } catch {\n      continue;\n    }\n\n    const ext = extname(entry).slice(1); // remove leading dot\n    const name = basename(entry, `.${ext}`);\n\n    // Page-extension conventions (page, layout, error, default, denied)\n    if (PAGE_EXT_CONVENTIONS.has(name) && extSet.has(ext)) {\n      const file: RouteFile = { filePath: fullPath, extension: ext };\n      switch (name) {\n        case 'page':\n          node.page = file;\n          break;\n        case 'layout':\n          node.layout = file;\n          break;\n        case 'error':\n          node.error = file;\n          break;\n        case 'default':\n          node.default = file;\n          break;\n        case 'denied':\n          node.denied = file;\n          break;\n      }\n      continue;\n    }\n\n    // Fixed conventions (middleware, access, route) — always .ts or .tsx\n    if (FIXED_CONVENTIONS.has(name) && /\\.?[jt]sx?$/.test(ext)) {\n      const file: RouteFile = { filePath: fullPath, extension: ext };\n      switch (name) {\n        case 'middleware':\n          node.middleware = file;\n          break;\n        case 'access':\n          node.access = file;\n          break;\n        case 'route':\n          node.route = file;\n          break;\n        case 'params':\n          node.params = file;\n          break;\n      }\n      continue;\n    }\n\n    // JSON status-code files (401.json, 4xx.json, 503.json, 5xx.json)\n    // Recognized regardless of pageExtensions — .json is a data format, not a page extension.\n    if (STATUS_CODE_PATTERN.test(name) && ext === 'json') {\n      if (!node.jsonStatusFiles) {\n        node.jsonStatusFiles = new Map();\n      }\n      node.jsonStatusFiles.set(name, { filePath: fullPath, extension: ext });\n      continue;\n    }\n\n    // Status-code files (401.tsx, 4xx.tsx, 503.tsx, 5xx.tsx)\n    if (STATUS_CODE_PATTERN.test(name) && extSet.has(ext)) {\n      if (!node.statusFiles) {\n        node.statusFiles = new Map();\n      }\n      node.statusFiles.set(name, { filePath: fullPath, extension: ext });\n      continue;\n    }\n\n    // Legacy compat files (not-found.tsx, forbidden.tsx, unauthorized.tsx)\n    if (name in LEGACY_STATUS_FILES && extSet.has(ext)) {\n      if (!node.legacyStatusFiles) {\n        node.legacyStatusFiles = new Map();\n      }\n      node.legacyStatusFiles.set(name, { filePath: fullPath, extension: ext });\n      continue;\n    }\n\n    // Metadata route files (sitemap.ts, robots.ts, icon.tsx, opengraph-image.tsx, etc.)\n    // Both static (.xml, .txt, .png, .ico, etc.) and dynamic (.ts, .tsx) files are recognized.\n    // When both exist for the same base name, dynamic takes precedence.\n    // See design/16-metadata.md §\"Metadata Routes\"\n    const metaInfo = classifyMetadataRoute(entry);\n    if (metaInfo) {\n      if (!node.metadataRoutes) {\n        node.metadataRoutes = new Map();\n      }\n      const existing = node.metadataRoutes.get(name);\n      if (existing) {\n        // Dynamic > static precedence: only overwrite if the new file is dynamic\n        // or the existing file is static (dynamic always wins).\n        const existingIsDynamic = isDynamicMetadataExtension(name, existing.extension);\n        const newIsDynamic = isDynamicMetadataExtension(name, ext);\n        if (newIsDynamic || !existingIsDynamic) {\n          node.metadataRoutes.set(name, { filePath: fullPath, extension: ext });\n        }\n      } else {\n        node.metadataRoutes.set(name, { filePath: fullPath, extension: ext });\n      }\n    }\n  }\n\n  // Validate: route.ts + page.* is a hard build error\n  if (node.route && node.page) {\n    throw new Error(\n      `Build error: route.ts and page.* cannot coexist in the same segment.\\n` +\n        `  route.ts: ${node.route.filePath}\\n` +\n        `  page:     ${node.page.filePath}\\n` +\n        `A URL is either an API endpoint or a rendered page, not both.`\n    );\n  }\n}\n\n/**\n * Recursively scan child directories and build the segment tree.\n */\nfunction scanChildren(dirPath: string, parentNode: SegmentNode, extSet: Set<string>): void {\n  let entries: string[];\n  try {\n    entries = readdirSync(dirPath);\n  } catch {\n    return;\n  }\n\n  for (const entry of entries) {\n    const fullPath = join(dirPath, entry);\n\n    try {\n      if (!statSync(fullPath).isDirectory()) continue;\n    } catch {\n      continue;\n    }\n\n    // Reject directories with encoded path delimiters or null bytes.\n    // These can cause route collisions when decoded at the URL boundary.\n    // See design/13-security.md §\"Encoded separators rejected\" and §\"Null bytes rejected\".\n    if (ENCODED_SEPARATOR_PATTERN.test(entry)) {\n      throw new Error(\n        `Build error: directory name contains an encoded path delimiter (%%2F or %%5C).\\n` +\n          `  Directory: ${fullPath}\\n` +\n          `Encoded separators in directory names cause route collisions when decoded. ` +\n          `Rename the directory to remove the encoded delimiter.`\n      );\n    }\n    if (ENCODED_NULL_PATTERN.test(entry)) {\n      throw new Error(\n        `Build error: directory name contains an encoded null byte (%%00).\\n` +\n          `  Directory: ${fullPath}\\n` +\n          `Encoded null bytes in directory names are not allowed. ` +\n          `Rename the directory to remove the null byte encoding.`\n      );\n    }\n\n    const { type, paramName, interceptionMarker, interceptedSegmentName } = classifySegment(entry);\n\n    // Skip private folders — underscore-prefixed dirs are excluded from routing\n    if (type === 'private') continue;\n\n    const urlPath = computeUrlPath(parentNode.urlPath, entry, type);\n    const childNode = createSegmentNode(\n      entry,\n      type,\n      urlPath,\n      paramName,\n      interceptionMarker,\n      interceptedSegmentName\n    );\n\n    // Scan this segment's files\n    scanSegmentFiles(fullPath, childNode, extSet);\n\n    // Recurse into subdirectories\n    scanChildren(fullPath, childNode, extSet);\n\n    // Attach to parent: slots go into slots map, everything else is a child\n    if (type === 'slot') {\n      const slotName = entry.slice(1); // remove @\n      parentNode.slots.set(slotName, childNode);\n    } else {\n      parentNode.children.push(childNode);\n    }\n  }\n}\n\n/**\n * Validate that route groups don't produce conflicting pages/routes at the same URL path.\n *\n * Two route groups like (auth)/login/page.tsx and (marketing)/login/page.tsx both claim\n * /login — the scanner must detect and reject this at build time.\n *\n * Parallel slots are excluded from collision detection — they intentionally coexist at\n * the same URL path as their parent (that's the whole point of parallel routes).\n */\nfunction validateRouteGroupCollisions(root: SegmentNode): void {\n  // Map from urlPath → { filePath, source } for the first page/route seen at that path\n  const seen = new Map<string, { filePath: string; segmentPath: string }>();\n  collectRoutableLeaves(root, seen, '', false);\n}\n\n/**\n * Walk the segment tree and collect all routable leaves (page or route files),\n * throwing on collision. Slots are tracked in their own collision space since\n * they are parallel routes that intentionally share URL paths with their parent.\n */\nfunction collectRoutableLeaves(\n  node: SegmentNode,\n  seen: Map<string, { filePath: string; segmentPath: string }>,\n  segmentPath: string,\n  insideSlot: boolean\n): void {\n  const currentPath = segmentPath\n    ? `${segmentPath}/${node.segmentName}`\n    : node.segmentName || '(root)';\n\n  // Only check collisions for non-slot pages — slots intentionally share URL paths\n  if (!insideSlot) {\n    const routableFile = node.page ?? node.route;\n    if (routableFile) {\n      const existing = seen.get(node.urlPath);\n      if (existing) {\n        throw new Error(\n          `Build error: route collision — multiple route groups produce a page/route at the same URL path.\\n` +\n            `  URL path: ${node.urlPath}\\n` +\n            `  File 1:   ${existing.filePath} (via ${existing.segmentPath})\\n` +\n            `  File 2:   ${routableFile.filePath} (via ${currentPath})\\n` +\n            `Each URL path must map to exactly one page or route handler. ` +\n            `Rename or move one of the conflicting files.`\n        );\n      }\n      seen.set(node.urlPath, { filePath: routableFile.filePath, segmentPath: currentPath });\n    }\n  }\n\n  // Recurse into children\n  for (const child of node.children) {\n    collectRoutableLeaves(child, seen, currentPath, insideSlot);\n  }\n\n  // Recurse into slots — each slot is its own parallel route space\n  for (const [, slotNode] of node.slots) {\n    collectRoutableLeaves(slotNode, seen, currentPath, true);\n  }\n}\n\n/**\n * Validate that no route chain contains duplicate dynamic param names.\n *\n * Example violation:\n *   app/[id]/items/[id]/page.tsx — 'id' appears twice in the ancestor chain.\n *\n * Route groups are transparent — params accumulate through them.\n * Slots are independent — duplicate detection does NOT cross slot boundaries.\n *\n * See design/07-routing.md §\"Duplicate Param Name Detection\"\n */\nfunction validateDuplicateParamNames(root: SegmentNode): void {\n  walkForDuplicateParams(root, new Map());\n}\n\n/**\n * Recursively walk the segment tree, tracking seen param names → segment paths.\n * Throws on the first duplicate found.\n */\nfunction walkForDuplicateParams(node: SegmentNode, seen: Map<string, string>): void {\n  // If this node introduces a param name, check for duplicates\n  if (node.paramName) {\n    const existing = seen.get(node.paramName);\n    if (existing) {\n      throw new Error(\n        `[timber] Duplicate param name '${node.paramName}' in route chain.\\n` +\n          `  First defined at: ${existing}\\n` +\n          `  Duplicate at: ${node.urlPath || '/'}\\n` +\n          `  Rename one of the segments to avoid ambiguity.`\n      );\n    }\n    // Add to seen for descendants (use a new Map to avoid polluting siblings)\n    seen = new Map(seen);\n    seen.set(node.paramName, node.urlPath || '/');\n  }\n\n  // Recurse into children (they inherit the accumulated params)\n  for (const child of node.children) {\n    walkForDuplicateParams(child, seen);\n  }\n\n  // Slots are independent parallel routes — start fresh param tracking\n  // (a slot's params don't conflict with the main route's params)\n  for (const [, slotNode] of node.slots) {\n    walkForDuplicateParams(slotNode, new Map(seen));\n  }\n}\n\n/**\n * Find a fixed-extension file (proxy.ts) in a directory.\n */\nfunction findFixedFile(dirPath: string, name: string): RouteFile | undefined {\n  for (const ext of ['ts', 'tsx']) {\n    const fullPath = join(dirPath, `${name}.${ext}`);\n    try {\n      if (statSync(fullPath).isFile()) {\n        return { filePath: fullPath, extension: ext };\n      }\n    } catch {\n      // File doesn't exist\n    }\n  }\n  return undefined;\n}\n\n/**\n * Find a file using the configured page extensions (tsx, ts, jsx, js, mdx, etc.).\n * Used for app-root conventions like global-error that aren't per-segment.\n */\nfunction findPageExtFile(\n  dirPath: string,\n  name: string,\n  extSet: Set<string>\n): RouteFile | undefined {\n  for (const ext of extSet) {\n    const fullPath = join(dirPath, `${name}.${ext}`);\n    try {\n      if (statSync(fullPath).isFile()) {\n        return { filePath: fullPath, extension: ext };\n      }\n    } catch {\n      // File doesn't exist\n    }\n  }\n  return undefined;\n}\n","/**\n * Shared codegen helpers — import-path computation, codec chain type\n * builder, and searchParams type formatter.\n *\n * Extracted from `codegen.ts` so `link-codegen.ts` can use the same\n * helpers without a cyclic import.\n */\n\nimport { relative, posix } from 'node:path';\nimport type { ParamEntry, RouteEntry } from './codegen-types.js';\n\n/**\n * Compute a relative import specifier for a codec/page file, stripping\n * the .ts/.tsx extension and resolving against the codegen output dir.\n */\nexport function codecImportPath(codecFilePath: string, importBase: string | undefined): string {\n  const absPath = codecFilePath.replace(/\\.(ts|tsx)$/, '');\n  if (importBase) {\n    return './' + relative(importBase, absPath).replace(/\\\\/g, '/');\n  }\n  return './' + posix.basename(absPath);\n}\n\n/** Name of the shared helper type emitted at the top of the .d.ts. */\nexport const RESOLVE_SEGMENT_FIELD_TYPE_NAME = '_TimberResolveSegmentField';\n\n/**\n * Helper type emitted once at the top of the generated `.d.ts` and\n * referenced by every codec-chain conditional. Without this shared\n * helper, the inline expansion would duplicate the fallback branch on\n * every step and grow O(2^N) in chain depth (a single deep nested route\n * could blow up the file size and TS performance). With the helper,\n * each step reuses the named type and growth is O(N).\n *\n * The helper is a 2-arg conditional: given a typeof import expression\n * (`Def`), a key (`K`), and a fallback (`F`), it returns `T[K]` if\n * `Def extends ParamsDefinition<T>` and `K extends keyof T`, otherwise\n * `F`. The codec chain composes calls to this helper.\n */\nexport function emitResolveSegmentFieldHelper(): string {\n  return [\n    `type ${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<Def, K extends string, F> =`,\n    `  Def extends import('@timber-js/app/segment-params').ParamsDefinition<infer T>`,\n    `    ? K extends keyof T ? T[K] : F`,\n    `    : F;`,\n  ].join('\\n');\n}\n\n/**\n * Build a TypeScript type expression that resolves a single param's\n * codec by walking a chain of params.ts files in priority order.\n *\n * Each entry in the chain emits one application of the shared\n * `_TimberResolveSegmentField` helper type. Composing N applications\n * grows linearly with chain depth (O(N) characters), unlike an inline\n * conditional that would duplicate the fallback in each branch and\n * grow O(2^N).\n *\n * The closest match (position 0 in the chain) is checked first; if its\n * `segmentParams` definition declares the key, its inferred type wins.\n * Otherwise we fall through to the next entry, and finally to the\n * provided fallback. See TIM-834.\n */\nexport function buildCodecChainType(\n  p: ParamEntry,\n  importBase: string | undefined,\n  fallback: string\n): string {\n  const files = p.codecFilePaths;\n  if (!files || files.length === 0) return fallback;\n  const key = JSON.stringify(p.name);\n  // Compose helper applications inside-out so the closest entry\n  // (files[0]) ends up as the OUTERMOST application. Each application\n  // adds a constant-size wrapper around the running fallback.\n  let inner = fallback;\n  for (let i = files.length - 1; i >= 0; i--) {\n    const importPath = codecImportPath(files[i], importBase);\n    inner = `${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<(typeof import('${importPath}'))['segmentParams'], ${key}, ${inner}>`;\n  }\n  return inner;\n}\n\n/**\n * Format the searchParams type for a route entry.\n *\n * When a page.tsx (or params.ts) exports searchParams, we reference its\n * inferred type via an import type. The import path is relative to\n * `importBase` (the directory where the .d.ts will be written). When\n * importBase is undefined, falls back to a bare relative path.\n */\nexport function formatSearchParamsType(route: RouteEntry, importBase?: string): string {\n  if (route.hasSearchParams && route.searchParamsPagePath) {\n    const importPath = codecImportPath(route.searchParamsPagePath, importBase);\n    // Extract the type from the named 'searchParams' export of the page module.\n    return `(typeof import('${importPath}'))['searchParams'] extends import('@timber-js/app/search-params').SearchParamsDefinition<infer T> ? T : never`;\n  }\n  return '{}';\n}\n","/**\n * Typed `<Link>` codegen — interface augmentation generation.\n *\n * Extracted from `codegen.ts` to keep that file under the project's\n * 500-line cap. This module owns everything that emits the\n * `interface LinkFunction { ... }` augmentation blocks in the generated\n * `.timber/timber-routes.d.ts`.\n *\n * Two augmentation blocks are emitted:\n *\n * 1. **Per-route discriminated union** (`formatTypedLinkOverloads`) —\n *    one call signature whose props is a union keyed on `href`. TS\n *    narrows by literal href and reports prop errors against the\n *    matched variant. See TIM-835 and `design/09-typescript.md`.\n *\n * 2. **Catch-all overloads** (`formatLinkCatchAllOverloads`) — external\n *    href literals (`http://`, `mailto:`, etc.) and a computed-string\n *    `<H extends string>` signature for runtime-computed paths.\n *\n * Block ordering is critical for error UX: per-route is emitted FIRST\n * so that, after TS's \"later overload set ordered first\" merge rule,\n * the discriminated union ends up LAST in resolution order — the\n * overload TS reports against on failure.\n */\n\nimport type { ParamEntry, RouteEntry } from './codegen-types.js';\nimport { buildCodecChainType, formatSearchParamsType } from './codegen-shared.js';\n\n/** Shared Link base-props type literal used in every emitted call signature. */\nexport const LINK_BASE_PROPS_TYPE =\n  \"Omit<import('react').AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> & { prefetch?: boolean; scroll?: boolean; preserveSearchParams?: true | string[]; onNavigate?: import('./client/link.js').OnNavigateHandler; children?: import('react').ReactNode }\";\n\n/**\n * Build a TypeScript template literal pattern for a dynamic route.\n * e.g. '/products/[id]'        → '/products/${string}'\n *      '/blog/[...slug]'       → '/blog/${string}'\n *      '/docs/[[...path]]'     → '/docs/${string}' (also matches /docs)\n *      '/[org]/[repo]'         → '/${string}/${string}'\n */\nexport function buildResolvedPattern(route: RouteEntry): string | null {\n  const parts = route.urlPath.split('/');\n  const templateParts = parts.map((part) => {\n    if (part.startsWith('[[...') && part.endsWith(']]')) {\n      // Optional catch-all — matches any trailing path\n      return '${string}';\n    }\n    if (part.startsWith('[...') && part.endsWith(']')) {\n      // Catch-all — matches one or more segments\n      return '${string}';\n    }\n    if (part.startsWith('[') && part.endsWith(']')) {\n      // Dynamic segment\n      return '${string}';\n    }\n    return part;\n  });\n  return templateParts.join('/');\n}\n\n/**\n * Format the segmentParams type for Link overloads.\n *\n * Link params accept `string | number` for single dynamic segments\n * (convenience — values are stringified at runtime). Catch-all and\n * optional catch-all remain `string[]` / `string[] | undefined`.\n *\n * When the segment's params chain (TIM-834) declares a typed codec, the\n * inferred type from the codec wins via a nested conditional.\n */\nexport function formatLinkParamsType(params: ParamEntry[], importBase?: string): string {\n  if (params.length === 0) {\n    return '{}';\n  }\n\n  const fields = params.map((p) => {\n    const fallback = p.type === 'string' ? 'string | number' : p.type;\n    const codecType = buildCodecChainType(p, importBase, fallback);\n    return `${p.name}: ${codecType}`;\n  });\n  return `{ ${fields.join('; ')} }`;\n}\n\n/**\n * Catch-all call signatures for `<Link>` — external hrefs and computed\n * `string` variables. Emitted from codegen in a SEPARATE\n * `declare module` block (declared AFTER the per-route block) so the TS\n * \"later overload set ordered first\" rule places these catch-all\n * signatures ahead of per-route in resolution order, leaving per-route\n * as the final overload whose error message is reported on failure.\n *\n * The conditional `string extends H ? ... : never` protection preserves\n * TIM-624's guarantee that unknown internal path literals don't match\n * the catch-all — typos like `<Link href=\"/typo\" />` still error.\n */\nexport function formatLinkCatchAllOverloads(): string[] {\n  const lines: string[] = [];\n  const baseProps = LINK_BASE_PROPS_TYPE;\n\n  // TIM-830: the catch-all signatures accept EITHER the legacy\n  // `{ definition, values }` wrapper OR a flat `Record<string, unknown>`\n  // values object. External/computed hrefs can't be looked up in the\n  // runtime registry, so the wrapped form is still the reliable path;\n  // the flat form is kept permissive for callers migrating from typed-\n  // route hrefs to computed strings. `resolveHref` discriminates at\n  // runtime via the presence of a `definition` key.\n  const catchAllSearchParams =\n    '{ definition: SearchParamsDefinition<Record<string, unknown>>; values: Record<string, unknown> } | Record<string, unknown>';\n\n  // ExternalHref inlined here rather than referenced as an exported\n  // alias so the generated .d.ts stands alone without source imports.\n  const externalHref =\n    '`http://${string}` | `https://${string}` | `mailto:${string}` | `tel:${string}` | `ftp://${string}` | `//${string}` | `#${string}` | `?${string}`';\n\n  lines.push('  // Typed Link overloads — catch-all (block 2 / emitted second)');\n  lines.push('  interface LinkFunction {');\n\n  // (1) External/literal-protocol hrefs.\n  lines.push(`    (props: ${baseProps} & {`);\n  lines.push(`      href: ${externalHref}`);\n  lines.push(`      segmentParams?: never`);\n  lines.push(`      searchParams?: ${catchAllSearchParams}`);\n  lines.push(`    }): import('react').JSX.Element`);\n\n  // (2) Computed/variable href — non-literal `string` only.\n  // `string extends H` is true only when H is the wide `string` type,\n  // not a specific literal. Literal internal paths (typos) that don't\n  // match any per-route signature collapse to `never` here, but since\n  // this block is NOT the \"last overload\" at resolution time, TS\n  // instead reports the error from the per-route block — which now\n  // says `Type '\"/typo\"' is not assignable to type '\"/products/[id]\"'`\n  // or similar per-route-specific guidance.\n  lines.push(`    <H extends string>(`);\n  lines.push(`      props: string extends H`);\n  lines.push(`        ? ${baseProps} & {`);\n  lines.push(`            href: H`);\n  lines.push(`            segmentParams?: Record<string, string | number | string[]>`);\n  lines.push(`            searchParams?: ${catchAllSearchParams}`);\n  lines.push(`          }`);\n  lines.push(`        : never`);\n  lines.push(`    ): import('react').JSX.Element`);\n\n  lines.push('  }');\n  return lines;\n}\n\n/**\n * Generate typed per-route Link call signatures via LinkFunction\n * interface merging.\n *\n * TIM-835: This emits a SINGLE call signature whose props is a\n * discriminated union keyed on `href`. TypeScript narrows the union by\n * the literal `href` at the call site, then checks the rest of the\n * props against the matched variant. When `segmentParams` or\n * `searchParams` is wrong, TS reports the error against the matched\n * variant — naming the user's actual `href` and the offending field.\n *\n * Before TIM-835, this function emitted N separate per-route overloads\n * (one per route, sometimes two for dynamic routes). When ALL overloads\n * failed, TS would pick an arbitrary failed overload (heuristically the\n * \"last tried\") to render the diagnostic, often pointing at a route\n * completely unrelated to the one the user wrote. The discriminated\n * union sidesteps overload-resolution heuristics entirely.\n *\n * Open property shapes (`Record<string, unknown>` instead of `never`)\n * for `segmentParams` on routes that don't declare them keep generic\n * `LinkProps`-spreading wrappers compiling. (Aligned with TIM-833.)\n *\n * TIM-832: this function still emits the per-route block FIRST and the\n * catch-all block follows, so per-route remains the LAST overload set in\n * resolution order — the one TS reports against on failure. With a\n * discriminated union there is only one call signature in this block,\n * so the resolved-template-vs-pattern ordering reduces to placing the\n * pattern variant before the resolved-template variant inside the union.\n */\nexport function formatTypedLinkOverloads(routes: RouteEntry[], importBase?: string): string[] {\n  const lines: string[] = [];\n  const baseProps = LINK_BASE_PROPS_TYPE;\n\n  // Build the union variants. Each route contributes one variant for the\n  // pattern href (e.g. '/products/[id]') and, for dynamic routes, an\n  // additional variant for the resolved-template href (e.g.\n  // `/products/${string}`).\n  //\n  // The PATTERN variant must be listed BEFORE the resolved-template\n  // variant for the same route so that when the user writes the literal\n  // pattern href (`<Link href=\"/products/[id]\" />`), TS narrows to the\n  // pattern variant (which carries the typed `segmentParams` shape)\n  // rather than the looser resolved-template variant. Without this\n  // ordering, TS would silently match the resolved-template variant\n  // first — swallowing typed-segmentParams type errors.\n  const variants: string[] = [];\n  for (const route of routes) {\n    const hasDynamicParams = route.params.length > 0;\n    // For routes with no dynamic params, accept an absent OR open-shape\n    // segmentParams. `Record<string, unknown>` keeps generic spreads\n    // compiling and gives a readable error if a non-object is passed.\n    const paramsProp = hasDynamicParams\n      ? `segmentParams: ${formatLinkParamsType(route.params, importBase)}`\n      : 'segmentParams?: Record<string, unknown>';\n\n    const searchParamsType = route.hasSearchParams\n      ? formatSearchParamsType(route, importBase)\n      : null;\n    // TIM-830: pattern href uses the FLAT `Partial<T>` shape — the\n    // runtime registry is keyed by the un-interpolated pattern.\n    //\n    // TIM-835: when the route has NO searchParams definition, use\n    // `Record<string, never>` (forbids any keys) instead of\n    // `Record<string, unknown>` so passing unexpected query params is a\n    // type error. Generic-spread compatibility is preserved by the\n    // matching open shape on `segmentParams` (which is the prop users\n    // typically forward through wrapper components).\n    const patternSearchParamsProp = searchParamsType\n      ? `searchParams?: Partial<${searchParamsType}>`\n      : 'searchParams?: Record<string, never>';\n\n    // Pattern variant FIRST (more specific).\n    variants.push(\n      `${baseProps} & { href: '${route.urlPath}'; ${paramsProp}; ${patternSearchParamsProp} }`\n    );\n\n    // Resolved-template variant SECOND (looser, matches interpolated hrefs).\n    if (hasDynamicParams) {\n      const templatePattern = buildResolvedPattern(route);\n      if (templatePattern) {\n        // TIM-830: resolved-template href keeps the WRAPPED\n        // `{ definition, values }` shape — the registry can't be looked\n        // up by an already-interpolated href.\n        const resolvedSearchParamsProp = searchParamsType\n          ? `searchParams?: { definition: SearchParamsDefinition<${searchParamsType}>; values: Partial<${searchParamsType}> }`\n          : 'searchParams?: Record<string, never>';\n        // TIM-835: `Record<string, never>` for segmentParams forbids ANY\n        // provided keys on the resolved-template variant. Without this,\n        // the resolved-template would shadow the pattern variant for\n        // literal pattern hrefs (`<Link href=\"/products/[id]\" segmentParams={...} />`)\n        // because both variants accept the literal `'/products/[id]'`\n        // and the looser variant would silently swallow segmentParams\n        // type errors.\n        variants.push(\n          `${baseProps} & { href: \\`${templatePattern}\\`; segmentParams?: Record<string, never>; ${resolvedSearchParamsProp} }`\n        );\n      }\n    }\n  }\n\n  lines.push('  interface LinkFunction {');\n  if (variants.length === 0) {\n    // No page routes — emit nothing. The catch-all block in the second\n    // augmentation still provides external/computed-string signatures.\n    lines.push('  }');\n    return lines;\n  }\n  lines.push('    (');\n  lines.push('      props:');\n  for (const variant of variants) {\n    lines.push(`        | (${variant})`);\n  }\n  lines.push(`    ): import('react').JSX.Element`);\n  lines.push('  }');\n\n  return lines;\n}\n","/**\n * Route map codegen.\n *\n * Walks the scanned RouteTree and generates a TypeScript declaration file\n * mapping every route to its params and searchParams shapes.\n *\n * This runs at build time and in dev (regenerated on file changes).\n * No runtime overhead — purely static type generation.\n */\n\nimport { existsSync, readFileSync } from 'node:fs';\nimport type { RouteTree, SegmentNode } from './types.js';\nimport type { ParamEntry, RouteEntry } from './codegen-types.js';\nimport {\n  buildCodecChainType,\n  emitResolveSegmentFieldHelper,\n  formatSearchParamsType,\n} from './codegen-shared.js';\nimport { formatLinkCatchAllOverloads, formatTypedLinkOverloads } from './link-codegen.js';\n\n/** Options for route map generation. */\nexport interface CodegenOptions {\n  /** Absolute path to the app/ directory. Required for page searchParams detection. */\n  appDir?: string;\n  /**\n   * Absolute path to the directory where the .d.ts file will be written.\n   * Used to compute correct relative import paths for page files.\n   * Defaults to appDir when not provided (preserves backward compat for tests).\n   */\n  outputDir?: string;\n}\n\n/**\n * Generate a TypeScript declaration file string from a scanned route tree.\n *\n * The output is a `declare module '@timber-js/app'` block containing the Routes\n * interface that maps every route path to its params and searchParams shape.\n */\nexport function generateRouteMap(tree: RouteTree, options: CodegenOptions = {}): string {\n  const routes: RouteEntry[] = [];\n  collectRoutes(tree.root, [], [], routes);\n\n  // Sort routes alphabetically for deterministic output\n  routes.sort((a, b) => a.urlPath.localeCompare(b.urlPath));\n\n  // When outputDir differs from appDir, import paths must be relative to outputDir\n  const importBase = options.outputDir ?? options.appDir;\n\n  return formatDeclarationFile(routes, importBase);\n}\n\n/**\n * Recursively walk the segment tree and collect route entries.\n *\n * A route entry is created for any segment that has a `page` or `route` file.\n * Params accumulate from ancestor dynamic segments.\n */\nfunction collectRoutes(\n  node: SegmentNode,\n  ancestorParams: ParamEntry[],\n  ancestorParamsFiles: string[],\n  routes: RouteEntry[]\n): void {\n  // TIM-834: Identify this segment's own params.ts (if it has a\n  // segmentParams export). The full chain of params.ts files in the\n  // route ancestry is threaded down via `ancestorParamsFiles`; codec\n  // resolution for each ParamEntry is deferred until leaf time so that\n  // descendant params.ts files can override ancestor codecs (closest-\n  // to-leaf wins, matching the runtime semantics of\n  // coerceSegmentParams which walks segments top-down and overwrites\n  // earlier coercions).\n  const ownParamsFile =\n    node.params && fileHasExport(node.params.filePath, 'segmentParams')\n      ? node.params.filePath\n      : undefined;\n\n  // Accumulate params from this segment. We attach `codecFilePaths`\n  // later (at leaf time) using the FULL chain so descendant overrides\n  // are visible. The legacy layout/page fallback is recorded now\n  // because it is per-segment (and does not participate in inheritance).\n  const params = [...ancestorParams];\n  if (node.paramName) {\n    const legacyFallback = ownParamsFile ? undefined : findLegacyParamsExport(node);\n    params.push({\n      name: node.paramName,\n      type: paramTypeForSegment(node.segmentType),\n      // Codec chain populated at leaf time. We carry the per-segment\n      // legacy fallback (if any) so leaf-time resolution can fall back\n      // to it when no params.ts in the chain declares this key.\n      legacyCodecFilePath: legacyFallback,\n    });\n  }\n\n  // Extend the chain for descendants of this segment.\n  const nextAncestorFiles = ownParamsFile\n    ? [...ancestorParamsFiles, ownParamsFile]\n    : ancestorParamsFiles;\n\n  // Check if this segment is a leaf route (has page or route file)\n  const isPage = !!node.page;\n  const isApiRoute = !!node.route;\n\n  if (isPage || isApiRoute) {\n    // TIM-834 P1 fix: at LEAF time, the full chain of params.ts files\n    // (root-to-leaf) is known. Resolve every ParamEntry's\n    // `codecFilePaths` to the chain in LEAF-FIRST order so the\n    // closest-to-leaf entry is checked first — matching runtime\n    // closest-wins semantics. The chain is shared by all params in the\n    // route, so we compute it once.\n    const leafFirstChain = nextAncestorFiles.length > 0 ? [...nextAncestorFiles].reverse() : [];\n    const resolvedParams: ParamEntry[] = params.map((p) => {\n      const codecFilePaths =\n        leafFirstChain.length > 0\n          ? leafFirstChain\n          : p.legacyCodecFilePath\n            ? [p.legacyCodecFilePath]\n            : undefined;\n      return {\n        name: p.name,\n        type: p.type,\n        codecFilePaths,\n      };\n    });\n\n    const entry: RouteEntry = {\n      urlPath: node.urlPath,\n      params: resolvedParams,\n      hasSearchParams: false,\n      isApiRoute,\n    };\n\n    // Detect searchParams export from params.ts (primary) or page.tsx (fallback)\n    if (isPage) {\n      if (node.params && fileHasExport(node.params.filePath, 'searchParams')) {\n        entry.hasSearchParams = true;\n        entry.searchParamsPagePath = node.params.filePath;\n      } else if (node.page && fileHasExport(node.page.filePath, 'searchParams')) {\n        entry.hasSearchParams = true;\n        entry.searchParamsPagePath = node.page.filePath;\n      }\n    }\n\n    routes.push(entry);\n  }\n\n  // Recurse into children\n  for (const child of node.children) {\n    collectRoutes(child, params, nextAncestorFiles, routes);\n  }\n\n  // Recurse into slots (they share the parent's URL path, but may have their own pages)\n  for (const [, slot] of node.slots) {\n    collectRoutes(slot, params, nextAncestorFiles, routes);\n  }\n}\n\n/**\n * Determine the TypeScript type for a segment's param.\n */\nfunction paramTypeForSegment(segmentType: string): ParamEntry['type'] {\n  switch (segmentType) {\n    case 'catch-all':\n      return 'string[]';\n    case 'optional-catch-all':\n      return 'string[] | undefined';\n    default:\n      return 'string';\n  }\n}\n\n/**\n * Check if a file exports a specific named export.\n *\n * Uses a lightweight regex check — not full AST parsing. The actual type\n * extraction happens via the TypeScript compiler in the generated .d.ts.\n */\nfunction fileHasExport(filePath: string, exportName: string): boolean {\n  if (!existsSync(filePath)) return false;\n  try {\n    const content = readFileSync(filePath, 'utf-8');\n    const e = exportName.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n    return (\n      new RegExp(`export\\\\s+(const|let|var)\\\\s+${e}\\\\b`).test(content) ||\n      new RegExp(`export\\\\s*\\\\{[^}]*\\\\b${e}\\\\b[^}]*\\\\}`).test(content)\n    );\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Find a legacy `segmentParams` export on layout.tsx or page.tsx.\n *\n * Backward-compat shim: TIM-508 made params.ts the canonical location\n * for `segmentParams`. Layout/page exports are still accepted for the\n * OWN segment only (not inherited by descendants — see TIM-834).\n */\nfunction findLegacyParamsExport(node: SegmentNode): string | undefined {\n  if (node.layout && fileHasExport(node.layout.filePath, 'segmentParams')) {\n    return node.layout.filePath;\n  }\n  if (node.page && fileHasExport(node.page.filePath, 'segmentParams')) {\n    return node.page.filePath;\n  }\n  return undefined;\n}\n\n/**\n * Format the collected routes into a TypeScript declaration file.\n */\nfunction formatDeclarationFile(routes: RouteEntry[], importBase?: string): string {\n  const lines: string[] = [];\n\n  lines.push('// This file is auto-generated by timber.js route map codegen.');\n  lines.push('// Do not edit manually. Regenerated on build and in dev mode.');\n  lines.push('');\n  // export {} makes this file a module, so all declare module blocks are\n  // augmentations rather than ambient replacements. Without this, the\n  // declare module blocks would replace the original module types entirely\n  // (removing exports like bindUseQueryStates that aren't listed here).\n  lines.push('export {};');\n  lines.push('');\n\n  // TIM-834 P2: emit the shared codec-resolution helper type ONCE so the\n  // per-param chain conditionals reference it instead of inlining the\n  // fallback in both branches (which grows O(2^N) in chain depth).\n  lines.push(emitResolveSegmentFieldHelper());\n  lines.push('');\n  lines.push(\"declare module '@timber-js/app' {\");\n  lines.push('  interface Routes {');\n\n  for (const route of routes) {\n    const paramsType = formatParamsType(route.params, importBase);\n    const searchParamsType = formatSearchParamsType(route, importBase);\n\n    lines.push(`    '${route.urlPath}': {`);\n    lines.push(`      segmentParams: ${paramsType}`);\n    lines.push(`      searchParams: ${searchParamsType}`);\n    lines.push(`    }`);\n  }\n\n  lines.push('  }');\n  lines.push('}');\n  lines.push('');\n\n  // Generate @timber-js/app/server augmentation — typed searchParams() generic\n  const pageRoutes = routes.filter((r) => !r.isApiRoute);\n\n  // Note: searchParams() always returns Promise<URLSearchParams>.\n  // Typed parsing is done via definition.parse(searchParams()).\n  // No module augmentation needed for @timber-js/app/server.\n\n  // Generate overloads for @timber-js/app/client\n  const dynamicRoutes = routes.filter((r) => r.params.length > 0);\n\n  if (dynamicRoutes.length > 0 || pageRoutes.length > 0) {\n    lines.push(\"declare module '@timber-js/app/client' {\");\n    lines.push(\n      \"  import type { SearchParamsDefinition, SetParams, QueryStatesOptions, SearchParamCodec } from '@timber-js/app/search-params'\"\n    );\n    lines.push('');\n\n    // useParams overloads\n    if (dynamicRoutes.length > 0) {\n      for (const route of dynamicRoutes) {\n        const paramsType = formatParamsType(route.params, importBase);\n        lines.push(`  export function useSegmentParams(route: '${route.urlPath}'): ${paramsType}`);\n      }\n      lines.push('  export function useSegmentParams(): Record<string, string | string[]>');\n      lines.push('');\n    }\n\n    // useQueryStates overloads\n    if (pageRoutes.length > 0) {\n      lines.push(...formatUseQueryStatesOverloads(pageRoutes, importBase));\n      lines.push('');\n    }\n\n    // Typed Link overloads — per-route with DIRECT types (no conditionals).\n    // Direct types preserve TypeScript's excess property checking.\n    //\n    // TIM-832: per-route and catch-all are emitted as TWO separate\n    // augmentation blocks. Per TS's merging rule \"later overload sets\n    // ordered first\", the catch-all block (declared SECOND in this file)\n    // ends up FIRST in the merged call-signature list at resolution time,\n    // which puts the per-route block LAST — so its error message is the\n    // one TypeScript reports when no overload matches. This gives users a\n    // clear prop-mismatch error (e.g. \"'string | undefined' is not\n    // assignable to 'string | number' on id\") instead of the old\n    // confusing \"Type 'string' is not assignable to type 'never'\" cascade.\n    if (pageRoutes.length > 0) {\n      lines.push('  // Typed Link overloads — per-route (block 1 / emitted first)');\n      lines.push(...formatTypedLinkOverloads(pageRoutes, importBase));\n      lines.push('');\n    }\n\n    lines.push('}');\n    lines.push('');\n  }\n\n  // TIM-832: catch-all block — emitted as a SEPARATE `declare module`\n  // augmentation so TS's \"later overload set first\" rule orders it ahead\n  // of the per-route block above at resolution time, leaving per-route as\n  // the \"last overload\" whose error TypeScript reports.\n  lines.push(\"declare module '@timber-js/app/client' {\");\n  lines.push(\"  import type { SearchParamsDefinition } from '@timber-js/app/search-params'\");\n  lines.push('');\n  lines.push(...formatLinkCatchAllOverloads());\n  lines.push('}');\n  lines.push('');\n\n  return lines.join('\\n');\n}\n\n/**\n * Format the params type for a route entry.\n */\nfunction formatParamsType(params: ParamEntry[], importBase?: string): string {\n  if (params.length === 0) {\n    return '{}';\n  }\n\n  const fields = params.map((p) => {\n    const codecType = buildCodecChainType(p, importBase, p.type);\n    return `${p.name}: ${codecType}`;\n  });\n  return `{ ${fields.join('; ')} }`;\n}\n\n/**\n * Generate useQueryStates overloads.\n *\n * For each page route:\n * - Routes with search-params.ts get a typed overload returning the inferred T\n * - Routes without search-params.ts get an overload returning [{}, SetParams<{}>]\n *\n * A fallback overload for standalone codecs (existing API) is emitted last.\n */\nfunction formatUseQueryStatesOverloads(routes: RouteEntry[], importBase?: string): string[] {\n  const lines: string[] = [];\n\n  for (const route of routes) {\n    const searchParamsType = route.hasSearchParams\n      ? formatSearchParamsType(route, importBase)\n      : '{}';\n    lines.push(\n      `  export function useQueryStates<R extends '${route.urlPath}'>(route: R, options?: QueryStatesOptions): [${searchParamsType}, SetParams<${searchParamsType}>]`\n    );\n  }\n\n  // Fallback: standalone codecs (existing API)\n  lines.push(\n    '  export function useQueryStates<T extends Record<string, unknown>>(codecs: { [K in keyof T]: SearchParamCodec<T[K]> }, options?: QueryStatesOptions): [T, SetParams<T>]'\n  );\n\n  return lines;\n}\n\n// Link overload formatters and helpers (`formatTypedLinkOverloads`,\n// `formatLinkCatchAllOverloads`, `formatLinkParamsType`,\n// `buildResolvedPattern`, `LINK_BASE_PROPS_TYPE`) were extracted to\n// `./link-codegen.ts` (TIM-835) to keep this file under the 500-line\n// cap. They are imported at the top of this file.\n","/**\n * Intercepting route utilities.\n *\n * Computes rewrite rules from the route tree that enable intercepting routes\n * to conditionally render when navigating via client-side (soft) navigation.\n *\n * The mechanism: at build time, each intercepting route directory generates a\n * conditional rewrite. On soft navigation, the client sends an `X-Timber-URL`\n * header with the current pathname. The server checks if any rewrite's source\n * (the intercepted URL) matches the target pathname AND the header matches\n * the intercepting route's parent URL. If both match, the intercepting route\n * renders instead of the normal route.\n *\n * On hard navigation (no header), no rewrite matches, and the normal route\n * renders.\n *\n * See design/07-routing.md §\"Intercepting Routes\"\n */\n\nimport type { SegmentNode, InterceptionMarker } from './types.js';\n\n/** A conditional rewrite rule generated from an intercepting route. */\nexport interface InterceptionRewrite {\n  /**\n   * The URL pattern that this rewrite intercepts (the target of navigation).\n   * E.g., \"/photo/[id]\" for a (.)photo/[id] interception.\n   */\n  interceptedPattern: string;\n  /**\n   * The URL prefix that the client must be navigating FROM for this rewrite\n   * to apply. Matched against the X-Timber-URL header.\n   * E.g., \"/feed\" for a (.)photo/[id] inside /feed/@modal/.\n   */\n  interceptingPrefix: string;\n  /**\n   * Segments chain from root → intercepting leaf. Used to build the element\n   * tree when the interception is active.\n   */\n  segmentPath: SegmentNode[];\n}\n\n/**\n * Collect all interception rewrite rules from the route tree.\n *\n * Walks the tree recursively. For each intercepting segment, computes the\n * intercepted URL based on the marker and the segment's position.\n */\nexport function collectInterceptionRewrites(root: SegmentNode): InterceptionRewrite[] {\n  const rewrites: InterceptionRewrite[] = [];\n  walkForInterceptions(root, [root], rewrites);\n  return rewrites;\n}\n\n/**\n * Recursively walk the segment tree to find intercepting routes.\n */\nfunction walkForInterceptions(\n  node: SegmentNode,\n  ancestors: SegmentNode[],\n  rewrites: InterceptionRewrite[]\n): void {\n  // Check children\n  for (const child of node.children) {\n    if (child.segmentType === 'intercepting' && child.interceptionMarker) {\n      // Found an intercepting route — collect rewrites from its sub-tree\n      collectFromInterceptingNode(child, ancestors, rewrites);\n    } else {\n      walkForInterceptions(child, [...ancestors, child], rewrites);\n    }\n  }\n\n  // Check slots (intercepting routes are typically inside slots like @modal)\n  for (const [, slot] of node.slots) {\n    walkForInterceptions(slot, ancestors, rewrites);\n  }\n}\n\n/**\n * For an intercepting segment, find all leaf pages in its sub-tree and\n * generate rewrite rules for each.\n */\nfunction collectFromInterceptingNode(\n  interceptingNode: SegmentNode,\n  ancestors: SegmentNode[],\n  rewrites: InterceptionRewrite[]\n): void {\n  const marker = interceptingNode.interceptionMarker!;\n  const segmentName = interceptingNode.interceptedSegmentName!;\n\n  // Compute the intercepted URL base based on the marker\n  const parentUrlPath = ancestors[ancestors.length - 1].urlPath;\n  const interceptedBase = computeInterceptedBase(parentUrlPath, marker);\n  const interceptedUrlBase =\n    interceptedBase === '/' ? `/${segmentName}` : `${interceptedBase}/${segmentName}`;\n\n  // Find all leaf pages in the intercepting sub-tree\n  collectLeavesWithRewrites(\n    interceptingNode,\n    interceptedUrlBase,\n    parentUrlPath,\n    [...ancestors, interceptingNode],\n    rewrites\n  );\n}\n\n/**\n * Recursively find leaf pages in an intercepting sub-tree and generate\n * rewrite rules for each.\n */\nfunction collectLeavesWithRewrites(\n  node: SegmentNode,\n  interceptedUrlPath: string,\n  interceptingPrefix: string,\n  segmentPath: SegmentNode[],\n  rewrites: InterceptionRewrite[]\n): void {\n  if (node.page) {\n    rewrites.push({\n      interceptedPattern: interceptedUrlPath,\n      interceptingPrefix,\n      segmentPath: [...segmentPath],\n    });\n  }\n\n  for (const child of node.children) {\n    const childUrl =\n      child.segmentType === 'group'\n        ? interceptedUrlPath\n        : `${interceptedUrlPath}/${child.segmentName}`;\n    collectLeavesWithRewrites(\n      child,\n      childUrl,\n      interceptingPrefix,\n      [...segmentPath, child],\n      rewrites\n    );\n  }\n}\n\n/**\n * Compute the base URL that an intercepting route intercepts, given the\n * parent's URL path and the interception marker.\n *\n * - (.)  — same level: parent's URL path\n * - (..) — one level up: parent's parent URL path\n * - (...) — root level: /\n * - (..)(..) — two levels up: parent's grandparent URL path\n *\n * Level counting operates on URL path segments, NOT filesystem directories.\n * Route groups and parallel slots are already excluded from urlPath (they\n * don't add URL depth), so (..) correctly climbs visible segments. This\n * avoids the Vinext bug where path.dirname() on filesystem paths would\n * waste climbs on invisible route groups.\n */\nfunction computeInterceptedBase(parentUrlPath: string, marker: InterceptionMarker): string {\n  switch (marker) {\n    case '(.)':\n      return parentUrlPath;\n    case '(..)': {\n      const parts = parentUrlPath.split('/').filter(Boolean);\n      parts.pop();\n      return parts.length === 0 ? '/' : `/${parts.join('/')}`;\n    }\n    case '(...)':\n      return '/';\n    case '(..)(..)': {\n      const parts = parentUrlPath.split('/').filter(Boolean);\n      parts.pop();\n      parts.pop();\n      return parts.length === 0 ? '/' : `/${parts.join('/')}`;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/index.js

@@ -1,6 +1,6 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./_chunks/chunk-BYIpzuS7.js";
 import { n as setViteServer } from "./_chunks/dev-warnings-DpGRGoDi.js";
-import { i as scanRoutes, n as generateRouteMap, t as collectInterceptionRewrites } from "./_chunks/interception-DRlhJWbu.js";
+import { i as scanRoutes, n as generateRouteMap, t as collectInterceptionRewrites } from "./_chunks/interception-DSv3A2Zn.js";
 import { t as formatSize } from "./_chunks/format-CYBGxKtc.js";
 import { dirname, extname, join, normalize, resolve } from "node:path";
 import { createRequire } from "node:module";

package/dist/routing/codegen-shared.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+import type { ParamEntry, RouteEntry } from './codegen-types.js';
+/**
+ * Compute a relative import specifier for a codec/page file, stripping
+ * the .ts/.tsx extension and resolving against the codegen output dir.
+ */
+export declare function codecImportPath(codecFilePath: string, importBase: string | undefined): string;
+/** Name of the shared helper type emitted at the top of the .d.ts. */
+export declare const RESOLVE_SEGMENT_FIELD_TYPE_NAME = "_TimberResolveSegmentField";
+/**
+ * Helper type emitted once at the top of the generated `.d.ts` and
+ * referenced by every codec-chain conditional. Without this shared
+ * helper, the inline expansion would duplicate the fallback branch on
+ * every step and grow O(2^N) in chain depth (a single deep nested route
+ * could blow up the file size and TS performance). With the helper,
+ * each step reuses the named type and growth is O(N).
+ *
+ * The helper is a 2-arg conditional: given a typeof import expression
+ * (`Def`), a key (`K`), and a fallback (`F`), it returns `T[K]` if
+ * `Def extends ParamsDefinition<T>` and `K extends keyof T`, otherwise
+ * `F`. The codec chain composes calls to this helper.
+ */
+export declare function emitResolveSegmentFieldHelper(): string;
+/**
+ * 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 one application of the shared
+ * `_TimberResolveSegmentField` helper type. Composing N applications
+ * grows linearly with chain depth (O(N) characters), unlike an inline
+ * conditional that would duplicate the fallback in each branch and
+ * grow O(2^N).
+ *
+ * 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 entry, and finally to the
+ * provided fallback. See TIM-834.
+ */
+export declare function buildCodecChainType(p: ParamEntry, importBase: string | undefined, fallback: string): string;
+/**
+ * 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.
+ */
+export declare function formatSearchParamsType(route: RouteEntry, importBase?: string): string;
+//# sourceMappingURL=codegen-shared.d.ts.map

package/dist/routing/codegen-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-shared.d.ts","sourceRoot":"","sources":["../../src/routing/codegen-shared.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM7F;AAED,sEAAsE;AACtE,eAAO,MAAM,+BAA+B,+BAA+B,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,IAAI,MAAM,CAOtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,UAAU,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,GACf,MAAM,CAaR;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAOrF"}

package/dist/routing/codegen-types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared types for route codegen modules.
+ *
+ * Lives in its own file so `link-codegen.ts` and `codegen.ts` can import
+ * the same `RouteEntry` / `ParamEntry` shapes without a cyclic
+ * dependency between the two.
+ */
+/** A single route entry extracted from the segment tree. */
+export interface RouteEntry {
+    /** URL path pattern (e.g. "/products/[id]") */
+    urlPath: string;
+    /** Accumulated params from all ancestor dynamic segments */
+    params: ParamEntry[];
+    /** Whether the page.tsx exports searchParams */
+    hasSearchParams: boolean;
+    /** Absolute path to the page file that exports searchParams (for import paths) */
+    searchParamsPagePath?: string;
+    /** Whether this is an API route (route.ts) vs page route */
+    isApiRoute: boolean;
+}
+export interface ParamEntry {
+    name: string;
+    type: 'string' | 'string[]' | 'string[] | undefined';
+    /**
+     * Ordered list of params.ts files in the route chain that may declare
+     * a codec for this param, in priority order — **closest-to-leaf
+     * first**. The generated type emits a chain that picks the first
+     * entry whose `segmentParams` definition declares this param key.
+     *
+     * This array is the SAME for every param in a given route entry
+     * (it is the route's full ancestry of params.ts files in leaf-first
+     * order); the type-level conditional in `buildCodecChainType`
+     * narrows per-key. Sharing the array matches the runtime semantics
+     * of `coerceSegmentParams`, which walks segments top-down and lets
+     * later (deeper) coercions overwrite earlier ones — closest-to-leaf
+     * wins for both types and runtime.
+     *
+     * See TIM-834.
+     */
+    codecFilePaths?: string[];
+    /**
+     * Per-segment legacy fallback: a layout.tsx or page.tsx that exports
+     * `segmentParams` directly (pre-TIM-508 convention). Used only when
+     * the chain has no params.ts files at all. Does NOT participate in
+     * inheritance — a layout/page export is per-segment only.
+     *
+     * @internal Set during `collectRoutes`; consumed at leaf time when
+     *   building the final `codecFilePaths`.
+     */
+    legacyCodecFilePath?: string;
+}
+//# sourceMappingURL=codegen-types.d.ts.map

package/dist/routing/codegen-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-types.d.ts","sourceRoot":"","sources":["../../src/routing/codegen-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4DAA4D;AAC5D,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,gDAAgD;IAChD,eAAe,EAAE,OAAO,CAAC;IACzB,kFAAkF;IAClF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,4DAA4D;IAC5D,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,sBAAsB,CAAC;IACrD;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;;;OAQG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B"}

package/dist/routing/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/routing/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AAuBzD,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,qFAAqF;IACrF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CAWtF"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/routing/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AASzD,wCAAwC;AACxC,MAAM,WAAW,cAAc;IAC7B,qFAAqF;IACrF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,MAAM,CAWtF"}

package/dist/routing/index.js

@@ -1,3 +1,3 @@
 import { t as classifyUrlSegment } from "../_chunks/segment-classify-BDNn6EzD.js";
-import { a as DEFAULT_PAGE_EXTENSIONS, i as scanRoutes, n as generateRouteMap, o as INTERCEPTION_MARKERS, r as classifySegment, t as collectInterceptionRewrites } from "../_chunks/interception-DRlhJWbu.js";
+import { a as DEFAULT_PAGE_EXTENSIONS, i as scanRoutes, n as generateRouteMap, o as INTERCEPTION_MARKERS, r as classifySegment, t as collectInterceptionRewrites } from "../_chunks/interception-DSv3A2Zn.js";
 export { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS, classifySegment, classifyUrlSegment, collectInterceptionRewrites, generateRouteMap, scanRoutes };

package/dist/routing/link-codegen.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Typed `<Link>` codegen — interface augmentation generation.
+ *
+ * Extracted from `codegen.ts` to keep that file under the project's
+ * 500-line cap. This module owns everything that emits the
+ * `interface LinkFunction { ... }` augmentation blocks in the generated
+ * `.timber/timber-routes.d.ts`.
+ *
+ * Two augmentation blocks are emitted:
+ *
+ * 1. **Per-route discriminated union** (`formatTypedLinkOverloads`) —
+ *    one call signature whose props is a union keyed on `href`. TS
+ *    narrows by literal href and reports prop errors against the
+ *    matched variant. See TIM-835 and `design/09-typescript.md`.
+ *
+ * 2. **Catch-all overloads** (`formatLinkCatchAllOverloads`) — external
+ *    href literals (`http://`, `mailto:`, etc.) and a computed-string
+ *    `<H extends string>` signature for runtime-computed paths.
+ *
+ * Block ordering is critical for error UX: per-route is emitted FIRST
+ * so that, after TS's "later overload set ordered first" merge rule,
+ * the discriminated union ends up LAST in resolution order — the
+ * overload TS reports against on failure.
+ */
+import type { ParamEntry, RouteEntry } from './codegen-types.js';
+/** Shared Link base-props type literal used in every emitted call signature. */
+export declare const 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}'
+ */
+export declare function buildResolvedPattern(route: RouteEntry): string | null;
+/**
+ * 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.
+ */
+export declare function formatLinkParamsType(params: ParamEntry[], importBase?: string): string;
+/**
+ * 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.
+ */
+export declare function formatLinkCatchAllOverloads(): string[];
+/**
+ * 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.
+ */
+export declare function formatTypedLinkOverloads(routes: RouteEntry[], importBase?: string): string[];
+//# sourceMappingURL=link-codegen.d.ts.map

package/dist/routing/link-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-codegen.d.ts","sourceRoot":"","sources":["../../src/routing/link-codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGjE,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,8PAC4N,CAAC;AAE9P;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAkBrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAWtF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,EAAE,CAiDtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAuF5F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timber-js/app",
-  "version": "0.2.0-alpha.90",
+  "version": "0.2.0-alpha.92",
   "description": "Vite-native React framework built for Servers and Serverless Platforms — correct HTTP semantics, real status codes, pages that work without JavaScript",
   "keywords": [
     "cloudflare-workers",

package/src/routing/codegen-shared.ts

@@ -0,0 +1,98 @@
+/**
+ * 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.
+ */
+
+import { relative, posix } from 'node:path';
+import type { ParamEntry, RouteEntry } from './codegen-types.js';
+
+/**
+ * Compute a relative import specifier for a codec/page file, stripping
+ * the .ts/.tsx extension and resolving against the codegen output dir.
+ */
+export function codecImportPath(codecFilePath: string, importBase: string | undefined): string {
+  const absPath = codecFilePath.replace(/\.(ts|tsx)$/, '');
+  if (importBase) {
+    return './' + relative(importBase, absPath).replace(/\\/g, '/');
+  }
+  return './' + posix.basename(absPath);
+}
+
+/** Name of the shared helper type emitted at the top of the .d.ts. */
+export const RESOLVE_SEGMENT_FIELD_TYPE_NAME = '_TimberResolveSegmentField';
+
+/**
+ * Helper type emitted once at the top of the generated `.d.ts` and
+ * referenced by every codec-chain conditional. Without this shared
+ * helper, the inline expansion would duplicate the fallback branch on
+ * every step and grow O(2^N) in chain depth (a single deep nested route
+ * could blow up the file size and TS performance). With the helper,
+ * each step reuses the named type and growth is O(N).
+ *
+ * The helper is a 2-arg conditional: given a typeof import expression
+ * (`Def`), a key (`K`), and a fallback (`F`), it returns `T[K]` if
+ * `Def extends ParamsDefinition<T>` and `K extends keyof T`, otherwise
+ * `F`. The codec chain composes calls to this helper.
+ */
+export function emitResolveSegmentFieldHelper(): string {
+  return [
+    `type ${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<Def, K extends string, F> =`,
+    `  Def extends import('@timber-js/app/segment-params').ParamsDefinition<infer T>`,
+    `    ? K extends keyof T ? T[K] : F`,
+    `    : F;`,
+  ].join('\n');
+}
+
+/**
+ * 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 one application of the shared
+ * `_TimberResolveSegmentField` helper type. Composing N applications
+ * grows linearly with chain depth (O(N) characters), unlike an inline
+ * conditional that would duplicate the fallback in each branch and
+ * grow O(2^N).
+ *
+ * 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 entry, and finally to the
+ * provided fallback. See TIM-834.
+ */
+export function buildCodecChainType(
+  p: ParamEntry,
+  importBase: string | undefined,
+  fallback: string
+): string {
+  const files = p.codecFilePaths;
+  if (!files || files.length === 0) return fallback;
+  const key = JSON.stringify(p.name);
+  // Compose helper applications inside-out so the closest entry
+  // (files[0]) ends up as the OUTERMOST application. Each application
+  // adds a constant-size wrapper around the running fallback.
+  let inner = fallback;
+  for (let i = files.length - 1; i >= 0; i--) {
+    const importPath = codecImportPath(files[i], importBase);
+    inner = `${RESOLVE_SEGMENT_FIELD_TYPE_NAME}<(typeof import('${importPath}'))['segmentParams'], ${key}, ${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.
+ */
+export function formatSearchParamsType(route: RouteEntry, importBase?: string): string {
+  if (route.hasSearchParams && route.searchParamsPagePath) {
+    const importPath = codecImportPath(route.searchParamsPagePath, importBase);
+    // Extract the type from the named 'searchParams' export of the page module.
+    return `(typeof import('${importPath}'))['searchParams'] extends import('@timber-js/app/search-params').SearchParamsDefinition<infer T> ? T : never`;
+  }
+  return '{}';
+}

package/src/routing/codegen-types.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared types for route codegen modules.
+ *
+ * Lives in its own file so `link-codegen.ts` and `codegen.ts` can import
+ * the same `RouteEntry` / `ParamEntry` shapes without a cyclic
+ * dependency between the two.
+ */
+
+/** A single route entry extracted from the segment tree. */
+export interface RouteEntry {
+  /** URL path pattern (e.g. "/products/[id]") */
+  urlPath: string;
+  /** Accumulated params from all ancestor dynamic segments */
+  params: ParamEntry[];
+  /** Whether the page.tsx exports searchParams */
+  hasSearchParams: boolean;
+  /** Absolute path to the page file that exports searchParams (for import paths) */
+  searchParamsPagePath?: string;
+  /** Whether this is an API route (route.ts) vs page route */
+  isApiRoute: boolean;
+}
+
+export interface ParamEntry {
+  name: string;
+  type: 'string' | 'string[]' | 'string[] | undefined';
+  /**
+   * Ordered list of params.ts files in the route chain that may declare
+   * a codec for this param, in priority order — **closest-to-leaf
+   * first**. The generated type emits a chain that picks the first
+   * entry whose `segmentParams` definition declares this param key.
+   *
+   * This array is the SAME for every param in a given route entry
+   * (it is the route's full ancestry of params.ts files in leaf-first
+   * order); the type-level conditional in `buildCodecChainType`
+   * narrows per-key. Sharing the array matches the runtime semantics
+   * of `coerceSegmentParams`, which walks segments top-down and lets
+   * later (deeper) coercions overwrite earlier ones — closest-to-leaf
+   * wins for both types and runtime.
+   *
+   * See TIM-834.
+   */
+  codecFilePaths?: string[];
+  /**
+   * Per-segment legacy fallback: a layout.tsx or page.tsx that exports
+   * `segmentParams` directly (pre-TIM-508 convention). Used only when
+   * the chain has no params.ts files at all. Does NOT participate in
+   * inheritance — a layout/page export is per-segment only.
+   *
+   * @internal Set during `collectRoutes`; consumed at leaf time when
+   *   building the final `codecFilePaths`.
+   */
+  legacyCodecFilePath?: string;
+}