@timber-js/app 0.2.0-alpha.205 → 0.2.0-alpha.207

package/src/server/tree-match.ts

@@ -66,6 +66,27 @@ export function matchUrlParts<TFile>(
   return null;
 }
 
+/**
+ * Yield every match for the given URL parts, in priority order.
+ *
+ * Same matching semantics as `matchUrlParts` — static > affixed-dynamic >
+ * bare-dynamic > catch-all > optional-catch-all — but instead of returning
+ * the first match, it yields all of them. Used by the metadata route matcher,
+ * which needs to try alternate owner segments when the first match doesn't
+ * own the requested metadata file.
+ */
+export function* matchUrlPartsAll<TFile>(
+  root: SegmentNode<TFile>,
+  parts: string[],
+  options?: TreeMatchOptions
+): Generator<TreeMatchResult<TFile>> {
+  const chain: SegmentNode<TFile>[] = [];
+  const params: Record<string, string | string[]> = {};
+  const requireTerminal = options?.requireTerminal ?? true;
+
+  yield* matchNodeAll(root, parts, 0, chain, params, requireTerminal);
+}
+
 // ─── Internal ─────────────────────────────────────────────────────────────
 
 /**
@@ -107,6 +128,59 @@ function isTerminal<TFile>(node: SegmentNode<TFile>): boolean {
   return !!(node.page || node.route);
 }
 
+/**
+ * Specificity tier for a segment. Lower = more specific. Matches the
+ * priority order in `matchNode`: static > affixed-dynamic > bare-dynamic >
+ * catch-all > optional-catch-all.
+ */
+function segmentTier<TFile>(node: SegmentNode<TFile>): number {
+  if (node.segmentType === 'static') return 0;
+  if (node.segmentType === 'dynamic' && (node.paramPrefix || node.paramSuffix)) return 1;
+  if (node.segmentType === 'dynamic') return 2;
+  if (node.segmentType === 'catch-all') return 3;
+  if (node.segmentType === 'optional-catch-all') return 4;
+  return 2;
+}
+
+/**
+ * Score a bare-dynamic candidate by running `matchNode` against its subtree
+ * with the remaining URL parts, then reading the tier of each segment in
+ * the matched chain. Returns a tier array that is compared lexicographically
+ * — the candidate whose chain has a lower tier at the first differing
+ * position is more specific.
+ *
+ * Delegates entirely to `matchNode`, so every segment type and priority
+ * rule is inherited automatically — no second copy to drift.
+ */
+function subtreeMatchScore<TFile>(
+  node: SegmentNode<TFile>,
+  parts: string[],
+  index: number,
+  requireTerminal: boolean
+): number[] {
+  const chain: SegmentNode<TFile>[] = [];
+  const params: Record<string, string | string[]> = {};
+  if (!matchNode(node, parts, index, chain, params, requireTerminal)) return [];
+  // Skip the first entry (the candidate node itself — it's the bare-dynamic
+  // we're scoring, which is the same tier for all candidates).
+  return chain.slice(1).map((seg) => segmentTier(seg));
+}
+
+/**
+ * Compare two tier arrays lexicographically. Negative means `a` is more
+ * specific (should be tried first).
+ */
+function compareTierArrays(a: number[], b: number[]): number {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    // A shorter match is less specific — missing entries treated as worst tier.
+    const ta = i < a.length ? a[i] : 5;
+    const tb = i < b.length ? b[i] : 5;
+    if (ta !== tb) return ta - tb;
+  }
+  return 0;
+}
+
 /** Combined affix length for specificity ordering. */
 function affixLength<TFile>(node: SegmentNode<TFile>): number {
   return (node.paramPrefix?.length ?? 0) + (node.paramSuffix?.length ?? 0);
@@ -206,32 +280,177 @@ function matchNode<TFile>(
   }
 
   // 3. Bare dynamic segments ([param])
+  //    When multiple bare dynamics compete (common with route groups that
+  //    flatten into the same parent), sort by subtree specificity so a
+  //    branch containing a static match for the NEXT URL part is tried
+  //    first. Without this, the winner depends on children order and
+  //    renaming a route group can flip it — the exact shape the collision
+  //    validator exists to reject.
+  const bareDynamic = effective.filter(
+    ({ child }) =>
+      child.segmentType === 'dynamic' && child.paramName && !child.paramPrefix && !child.paramSuffix
+  );
+  if (bareDynamic.length > 1 && index + 1 < parts.length) {
+    const scores = new Map<SegmentNode<TFile>, number[]>();
+    for (const { child } of bareDynamic) {
+      scores.set(child, subtreeMatchScore(child, parts, index + 1, requireTerminal));
+    }
+    bareDynamic.sort((a, b) => compareTierArrays(scores.get(a.child)!, scores.get(b.child)!));
+  }
+  for (const { child, groupChain } of bareDynamic) {
+    chain.push(...groupChain);
+    const prev = params[child.paramName!];
+    params[child.paramName!] = part;
+    if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {
+      return true;
+    }
+    // Backtrack
+    chain.length -= groupChain.length;
+    if (prev !== undefined) {
+      params[child.paramName!] = prev;
+    } else {
+      delete params[child.paramName!];
+    }
+  }
+
+  // 4. Catch-all segments ([...param]) — must be terminal unless the
+  // caller passed requireTerminal:false (metadata route matching needs to
+  // find the owning segment even when it has no page).
   for (const { child, groupChain } of effective) {
     if (
-      child.segmentType === 'dynamic' &&
+      child.segmentType === 'catch-all' &&
       child.paramName &&
-      !child.paramPrefix &&
-      !child.paramSuffix
+      (!requireTerminal || isTerminal(child))
     ) {
-      chain.push(...groupChain);
-      const prev = params[child.paramName];
-      params[child.paramName] = part;
-      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {
-        return true;
+      chain.push(...groupChain, child);
+      params[child.paramName] = parts.slice(index);
+      return true;
+    }
+  }
+
+  // 5. Optional catch-all segments ([[...param]]) — same terminal rule
+  for (const { child, groupChain } of effective) {
+    if (
+      child.segmentType === 'optional-catch-all' &&
+      child.paramName &&
+      (!requireTerminal || isTerminal(child))
+    ) {
+      chain.push(...groupChain, child);
+      params[child.paramName] = parts.slice(index);
+      return true;
+    }
+  }
+
+  chain.pop();
+  return false;
+}
+
+/**
+ * Generator twin of `matchNode` — yields every match instead of returning
+ * the first. Each yield snapshots `chain` and `params` so the caller gets
+ * independent results. After yielding, backtracking continues to find the
+ * next match.
+ */
+function* matchNodeAll<TFile>(
+  node: SegmentNode<TFile>,
+  parts: string[],
+  index: number,
+  chain: SegmentNode<TFile>[],
+  params: Record<string, string | string[]>,
+  requireTerminal: boolean
+): Generator<TreeMatchResult<TFile>> {
+  chain.push(node);
+
+  if (index >= parts.length) {
+    if (!requireTerminal || isTerminal(node)) {
+      yield { chain: [...chain], params: { ...params } };
+    }
+
+    for (const child of node.children) {
+      if (child.segmentType === 'group') {
+        yield* matchNodeAll(child, parts, index, chain, params, requireTerminal);
       }
-      // Backtrack
+    }
+
+    const effective = collectEffectiveChildren(node);
+    for (const { child, groupChain } of effective) {
+      if (child.segmentType === 'optional-catch-all' && (!requireTerminal || isTerminal(child))) {
+        chain.push(...groupChain, child);
+        yield { chain: [...chain], params: { ...params } };
+        chain.length -= groupChain.length + 1;
+      }
+    }
+
+    chain.pop();
+    return;
+  }
+
+  const part = parts[index];
+  const effective = collectEffectiveChildren(node);
+
+  // 1. Static segments
+  for (const { child, groupChain } of effective) {
+    if (child.segmentType === 'static' && child.segmentName === part) {
+      chain.push(...groupChain);
+      yield* matchNodeAll(child, parts, index + 1, chain, params, requireTerminal);
+      chain.length -= groupChain.length;
+    }
+  }
+
+  // 2. Affixed dynamic segments
+  const affixed = effective.filter(
+    ({ child }) =>
+      child.segmentType === 'dynamic' && child.paramName && (child.paramPrefix || child.paramSuffix)
+  );
+  affixed.sort((a, b) => affixLength(b.child) - affixLength(a.child));
+  for (const { child, groupChain } of affixed) {
+    const prefix = child.paramPrefix ?? '';
+    const suffix = child.paramSuffix ?? '';
+    if (
+      part.length > prefix.length + suffix.length &&
+      (!prefix || part.startsWith(prefix)) &&
+      (!suffix || part.endsWith(suffix))
+    ) {
+      const value = part.slice(prefix.length, part.length - (suffix.length || 0));
+      chain.push(...groupChain);
+      const prev = params[child.paramName!];
+      params[child.paramName!] = value;
+      yield* matchNodeAll(child, parts, index + 1, chain, params, requireTerminal);
       chain.length -= groupChain.length;
       if (prev !== undefined) {
-        params[child.paramName] = prev;
+        params[child.paramName!] = prev;
       } else {
-        delete params[child.paramName];
+        delete params[child.paramName!];
       }
     }
   }
 
-  // 4. Catch-all segments ([...param]) — must be terminal unless the
-  // caller passed requireTerminal:false (metadata route matching needs to
-  // find the owning segment even when it has no page).
+  // 3. Bare dynamic segments
+  const bareDynamic = effective.filter(
+    ({ child }) =>
+      child.segmentType === 'dynamic' && child.paramName && !child.paramPrefix && !child.paramSuffix
+  );
+  if (bareDynamic.length > 1 && index + 1 < parts.length) {
+    const scores = new Map<SegmentNode<TFile>, number[]>();
+    for (const { child } of bareDynamic) {
+      scores.set(child, subtreeMatchScore(child, parts, index + 1, requireTerminal));
+    }
+    bareDynamic.sort((a, b) => compareTierArrays(scores.get(a.child)!, scores.get(b.child)!));
+  }
+  for (const { child, groupChain } of bareDynamic) {
+    chain.push(...groupChain);
+    const prev = params[child.paramName!];
+    params[child.paramName!] = part;
+    yield* matchNodeAll(child, parts, index + 1, chain, params, requireTerminal);
+    chain.length -= groupChain.length;
+    if (prev !== undefined) {
+      params[child.paramName!] = prev;
+    } else {
+      delete params[child.paramName!];
+    }
+  }
+
+  // 4. Catch-all segments
   for (const { child, groupChain } of effective) {
     if (
       child.segmentType === 'catch-all' &&
@@ -239,12 +458,19 @@ function matchNode<TFile>(
       (!requireTerminal || isTerminal(child))
     ) {
       chain.push(...groupChain, child);
+      const prev = params[child.paramName];
       params[child.paramName] = parts.slice(index);
-      return true;
+      yield { chain: [...chain], params: { ...params } };
+      chain.length -= groupChain.length + 1;
+      if (prev !== undefined) {
+        params[child.paramName] = prev;
+      } else {
+        delete params[child.paramName];
+      }
     }
   }
 
-  // 5. Optional catch-all segments ([[...param]]) — same terminal rule
+  // 5. Optional catch-all segments
   for (const { child, groupChain } of effective) {
     if (
       child.segmentType === 'optional-catch-all' &&
@@ -252,11 +478,17 @@ function matchNode<TFile>(
       (!requireTerminal || isTerminal(child))
     ) {
       chain.push(...groupChain, child);
+      const prev = params[child.paramName];
       params[child.paramName] = parts.slice(index);
-      return true;
+      yield { chain: [...chain], params: { ...params } };
+      chain.length -= groupChain.length + 1;
+      if (prev !== undefined) {
+        params[child.paramName] = prev;
+      } else {
+        delete params[child.paramName];
+      }
     }
   }
 
   chain.pop();
-  return false;
 }

package/dist/_chunks/convention-lint-BnO5TyHD.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"convention-lint-BnO5TyHD.js","names":[],"sources":["../../src/routing/segment-codegen.ts","../../src/routing/codegen-write.ts","../../src/routing/export-detect.ts","../../src/routing/convention-lint.ts"],"sourcesContent":["/**\n * $segment type generation and directory-to-route mapping.\n *\n * Generates per-route $segment.d.ts files in .timber/types/ that mirror\n * the app/ directory structure. TypeScript's rootDirs feature makes these\n * importable as './$segment' from route files.\n *\n * Design doc: design/41-global-params.md §The $segment Module\n */\n\nimport { writeFile, mkdir } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport type { RouteTree, SegmentNode } from './types.ts';\n\n/** Info carried per directory for type generation. */\nexport interface SegmentInfo {\n  /** The URL route pattern (groups and slots stripped). e.g. '/[artistSlug]/[year]' */\n  route: string;\n  /** The full tree path including groups and slots — uniquely identifies a segment.\n   *  e.g. '/(browse)/[artistSlug]/@shows/[year]' */\n  segmentPath: string;\n}\n\n/**\n * Build a map of absolute filesystem directory → segment info.\n * Used by resolveId to map a $segment import's importer to the correct route,\n * and by writeSegmentTypes to generate per-route $segment.d.ts files.\n *\n * Walks every segment (not just leaves) so layouts and middleware\n * at any depth can import $segment.\n */\nexport function buildDirToRouteMap(tree: RouteTree, appDir: string): Map<string, SegmentInfo> {\n  const map = new Map<string, SegmentInfo>();\n\n  function walk(node: SegmentNode, fsPath: string, treePath: string): void {\n    map.set(fsPath, {\n      route: node.urlPath || '/',\n      segmentPath: treePath || '/',\n    });\n\n    for (const child of node.children) {\n      const childDir = join(fsPath, child.segmentName);\n      const childTreePath = `${treePath}/${child.segmentName}`;\n      walk(child, childDir, childTreePath);\n    }\n    for (const [slotName, slotNode] of Object.entries(node.slots)) {\n      const slotDir = join(fsPath, `@${slotName}`);\n      const slotTreePath = `${treePath}/@${slotName}`;\n      walk(slotNode, slotDir, slotTreePath);\n    }\n  }\n\n  walk(tree.root, appDir, '');\n  return map;\n}\n\n/**\n * Generate the full $segment.d.ts content for a segment.\n */\nexport function generateSegmentDts(info: SegmentInfo): string {\n  return [\n    `export const ROUTE: '${info.route}';`,\n    `export const SEGMENT_PATH: '${info.segmentPath}';`,\n    '',\n  ].join('\\n');\n}\n\n/**\n * Generate per-route $segment.d.ts files in .timber/types/ mirroring\n * the app/ directory structure. These files are importable via TypeScript's\n * rootDirs feature.\n */\nexport async function writeSegmentTypes(\n  routeTree: RouteTree,\n  appDir: string,\n  root: string\n): Promise<void> {\n  // Compute the relative prefix from project root to appDir.\n  // e.g. if appDir is /project/src/app, relative is 'src/app'\n  const relative = appDir.slice(root.length + 1);\n  const typesBase = join(root, '.timber', 'types', relative);\n  const map = buildDirToRouteMap(routeTree, appDir);\n\n  const writes: Promise<void>[] = [];\n  for (const [fsDir, info] of map) {\n    // Mirror the app/ structure under .timber/types/\n    const relDir = fsDir.slice(appDir.length); // e.g. '/[artistSlug]/[year]'\n    const segmentDir = join(typesBase, relDir);\n    const segmentFile = join(segmentDir, '$segment.d.ts');\n    const content = generateSegmentDts(info);\n\n    writes.push(\n      mkdir(segmentDir, { recursive: true }).then(() => writeFile(segmentFile, content, 'utf-8'))\n    );\n  }\n\n  await Promise.all(writes);\n}\n","/**\n * Route-map codegen writer.\n *\n * Materializes the generated route types on disk: `.timber/timber-routes.d.ts`,\n * `.timber/segment-types.d.ts` (via `writeSegmentTypes`), and the root\n * `timber-env.d.ts` that references them.\n *\n * Lives outside `plugins/routing.ts` because it has two callers with two\n * different failure policies: the dev/build plugin starts the write off the hot\n * path and logs failures, while `timber check` awaits it and treats a failure as\n * fatal — a type check run against absent or stale route types reports errors\n * about code that is fine. One implementation, two policies, so the bytes on\n * disk cannot drift between the two commands.\n *\n * Design docs: 09-typescript.md §\"Typed Routes\", 18-build-system.md\n */\n\nimport { writeFile, mkdir } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { generateRouteMap } from './codegen.ts';\nimport { writeSegmentTypes } from './segment-codegen.ts';\nimport type { RouteTree } from './types.ts';\n\n/**\n * Path (relative to the project root) of the generated route map declaration\n * file, and the name of the root file that `/// <reference>`s it.\n *\n * Exported because `timber check` has to answer whether the user's tsconfig\n * pulls these into the program — a question about these exact paths. It derives\n * them from here rather than restating them, so a rename cannot leave the check\n * looking for a file nothing writes.\n */\nexport const CODEGEN_OUTPUT = '.timber/timber-routes.d.ts';\n\n/** Root-level file that references the generated declarations. */\nexport const ENV_DTS_FILENAME = 'timber-env.d.ts';\n\n/**\n * Content of the timber-env.d.ts file written to the project root.\n *\n * Uses a triple-slash reference so TypeScript auto-discovers the generated\n * route map without the user needing to edit tsconfig.json — same pattern\n * as Next.js's next-env.d.ts.\n *\n * Also references `vite/client` so side-effect imports like\n * `import './globals.css'` type-check without ts(2882), and so\n * `import.meta.env`, `import.meta.hot`, `import.meta.glob`, asset\n * imports (`*.png`, `*.svg`, …), CSS modules, and `?url`/`?raw`/\n * `?inline` query variants all resolve without the user editing\n * tsconfig.json themselves. Next.js's next-env.d.ts plays the same\n * role via `next/types/global`.\n *\n * `vite` is a peer dep of `@timber-js/app`, so the reference always\n * resolves in a correctly-installed project.\n */\nconst TIMBER_ENV_DTS = [\n  '// This file is auto-generated by timber.js. Do not edit.',\n  '// It ensures TypeScript picks up the generated route types and',\n  '// Vite-provided ambient types (CSS, assets, import.meta.env, HMR).',\n  '/* eslint-disable @typescript-eslint/triple-slash-reference */',\n  '/// <reference path=\".timber/timber-routes.d.ts\" />',\n  '/// <reference types=\"vite/client\" />',\n  '/// <reference types=\"react/canary\" />',\n  '/// <reference types=\"react-dom/canary\" />',\n  '',\n].join('\\n');\n\n/**\n * Codegen writes that have been started but have not yet landed on disk.\n *\n * `writeRouteCodegen` is deliberately unawaited on the dev/build hot path,\n * which leaves that caller no way to know the files exist yet. Anything that\n * tears down the project root — a build process exiting, a test removing its\n * temp root — then races the writes: `rmSync` empties a directory that a\n * pending `mkdir` immediately recreates, and the removal fails with ENOTEMPTY.\n *\n * Every started write registers here and deregisters when it settles, so\n * `flushCodegenWrites()` can await them instead of guessing at a delay.\n */\nconst pendingCodegenWrites = new Set<Promise<void>>();\n\n/**\n * Resolve once every codegen write started so far has landed on disk.\n *\n * Safe to call at any time and from anywhere — writes are tracked per process,\n * not per plugin instance, so a caller does not need a handle on the plugin\n * that started them. Never rejects: the tracked copy of each write has its\n * rejection swallowed, so a failing write cannot turn a teardown barrier into\n * an unhandled rejection. Callers that care about failure await the promise\n * `writeRouteCodegen` returned instead.\n */\nexport async function flushCodegenWrites(): Promise<void> {\n  // Loop rather than a single Promise.all: a write started while we were\n  // awaiting would otherwise be missed, and the set would still be non-empty\n  // on return.\n  //\n  // Each round drops what it awaited rather than trusting the per-write\n  // `finally` to have run, so the two removal paths are independent — a\n  // deregistration that stopped firing would leak memory in dev, but it can\n  // never turn this into a spin.\n  while (pendingCodegenWrites.size > 0) {\n    const inFlight = [...pendingCodegenWrites];\n    await Promise.all(inFlight);\n    for (const write of inFlight) pendingCodegenWrites.delete(write);\n  }\n}\n\n/**\n * Write the generated route map, segment types, and the timber-env.d.ts\n * reference file for `tree`.\n *\n * Returns a promise that **rejects** if any write fails. The dev/build plugin\n * does not await it (types are a developer convenience there, not a runtime\n * dependency) and logs instead; `timber check` awaits it and fails the command.\n * Either way the write is registered with `flushCodegenWrites()`.\n */\nexport function writeRouteCodegen(tree: RouteTree, appDir: string, root: string): Promise<void> {\n  const timberDir = join(root, '.timber');\n  const content = generateRouteMap(tree, { appDir, outputDir: timberDir });\n  const routesPath = join(root, CODEGEN_OUTPUT);\n  const envPath = join(root, ENV_DTS_FILENAME);\n\n  const done = mkdir(timberDir, { recursive: true })\n    .then(() =>\n      Promise.all([\n        writeFile(routesPath, content, 'utf-8'),\n        writeFile(envPath, TIMBER_ENV_DTS, 'utf-8'),\n        writeSegmentTypes(tree, appDir, root),\n      ])\n    )\n    .then(() => undefined);\n\n  // The tracked copy swallows rejection so `flushCodegenWrites` — a teardown\n  // barrier — never rejects and never leaves an unhandled rejection behind.\n  // The returned promise keeps its rejection for callers that want it.\n  const tracked = done.catch(() => undefined);\n  pendingCodegenWrites.add(tracked);\n  void tracked.finally(() => pendingCodegenWrites.delete(tracked));\n\n  return done;\n}\n","/**\n * AST-based export detection for route files.\n *\n * Uses Vite's `parseAst` (backed by oxc) to precisely detect named and\n * default exports, replacing the regex-based approach that was fragile\n * with TypeScript syntax (type exports, `as` aliases, comments, etc.).\n */\n\nimport { existsSync } from 'node:fs';\nimport { parseAst } from 'vite';\nimport { readFileCached } from './file-cache.ts';\n\ninterface AstNode {\n  type: string;\n  exportKind?: string;\n  declaration?: AstNode;\n  specifiers?: Array<{\n    exported?: { name: string };\n    local?: { name: string };\n    exportKind?: string;\n  }>;\n  id?: { name: string };\n  declarations?: Array<{ id?: { name: string }; init?: AstNode }>;\n  /** Set on re-exports: `export { X } from './y'`. Absent on local exports. */\n  source?: { value?: string } | null;\n  /** Set on runtime-transparent wrappers: `X as T`, `X satisfies T`, `(X)`, `X!`. */\n  expression?: AstNode;\n  /** Set on `Identifier` nodes. */\n  name?: string;\n}\n\ninterface ProgramNode {\n  body: AstNode[];\n}\n\nfunction tryParse(source: string): ProgramNode | null {\n  try {\n    return parseAst(source, { lang: 'tsx' }) as unknown as ProgramNode;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Collect all named export identifiers from a parsed program.\n * Handles: `export function X`, `export const X`, `export { X }`,\n * `export { X } from '...'`, `export { Y as X }`.\n */\nfunction collectNamedExports(program: ProgramNode): Set<string> {\n  const names = new Set<string>();\n  for (const stmt of program.body) {\n    if (stmt.type !== 'ExportNamedDeclaration') continue;\n    // Skip `export type ...` declarations — they're erased at runtime\n    if (stmt.exportKind === 'type') continue;\n\n    if (stmt.declaration) {\n      if (stmt.declaration.id?.name) {\n        names.add(stmt.declaration.id.name);\n      }\n      if (stmt.declaration.declarations) {\n        for (const decl of stmt.declaration.declarations) {\n          if (decl.id?.name) names.add(decl.id.name);\n        }\n      }\n    }\n\n    if (stmt.specifiers) {\n      for (const spec of stmt.specifiers) {\n        // Skip `export { type X }` — per-specifier type exports\n        if (spec.exportKind === 'type') continue;\n        if (spec.exported?.name && spec.exported.name !== 'default') {\n          names.add(spec.exported.name);\n        }\n      }\n    }\n  }\n  return names;\n}\n\n/**\n * The specifier exporting a *runtime* default from this statement, if any.\n *\n * Type-only exports erase, so they are not default exports at runtime — and\n * TypeScript spells that two ways, on two different nodes: `export type { X as\n * default }` marks the **statement**, `export { type X as default }` marks the\n * **specifier**. Both have to be checked, or a type alias reads as a component:\n * a status file whose only default is a type has nothing for the error boundary\n * to receive (the renderer's `mod?.default` skips it), so treating it as one\n * would fail a build over a file that cannot break anything.\n *\n * One implementation because two callers must agree on what \"has a default\n * export\" means: `hasDefaultExport` decides whether to warn that a page has\n * none, and `fileDefaultExportIsLocalValue` decides whether to fail the build.\n */\nfunction defaultSpecifier(stmt: AstNode): NonNullable<AstNode['specifiers']>[number] | null {\n  if (stmt.type !== 'ExportNamedDeclaration' || !stmt.specifiers) return null;\n  if (stmt.exportKind === 'type') return null;\n  for (const spec of stmt.specifiers) {\n    if (spec.exportKind === 'type') continue;\n    if (spec.exported?.name === 'default') return spec;\n  }\n  return null;\n}\n\n/**\n * Check whether a program has a default export.\n * Handles: `export default ...`, `export { X as default }`,\n * `export { default } from '...'`. Type-only defaults do not count —\n * see `defaultSpecifier`.\n */\nfunction hasDefaultExport(program: ProgramNode): boolean {\n  for (const stmt of program.body) {\n    if (stmt.type === 'ExportDefaultDeclaration') return true;\n    if (defaultSpecifier(stmt)) return true;\n  }\n  return false;\n}\n\n/**\n * Check whether a program has any bare `export * from '...'` declarations.\n * Excludes `export * as X from '...'` (namespace re-exports) since those\n * create a namespace object, not individual top-level exports.\n */\nfunction hasStarExport(program: ProgramNode): boolean {\n  return program.body.some(\n    (stmt) =>\n      stmt.type === 'ExportAllDeclaration' && !(stmt as any).exported && stmt.exportKind !== 'type'\n  );\n}\n\n/**\n * Check if a file exports a specific named export.\n * Returns false if the file doesn't exist or can't be parsed.\n */\nexport function fileHasExport(filePath: string, exportName: string): boolean {\n  if (!existsSync(filePath)) return false;\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return false;\n    return collectNamedExports(program).has(exportName);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if a file has any of the given named exports.\n * Returns the set of matching export names.\n */\nexport function fileHasAnyExport(filePath: string, exportNames: readonly string[]): Set<string> {\n  const matches = new Set<string>();\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return matches;\n    const exports = collectNamedExports(program);\n    for (const name of exportNames) {\n      if (exports.has(name)) matches.add(name);\n    }\n  } catch {\n    // Graceful fallback: return empty set\n  }\n  return matches;\n}\n\n/**\n * Check if a file has a default export.\n * Returns false if the file doesn't exist or can't be parsed.\n */\nexport function fileHasDefaultExport(filePath: string): boolean {\n  if (!existsSync(filePath)) return false;\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return false;\n    return hasDefaultExport(program);\n  } catch {\n    return false;\n  }\n}\n\n/** Node types whose value is unambiguously constructed by this module. */\nconst FUNCTION_LIKE = new Set([\n  'FunctionDeclaration',\n  'FunctionExpression',\n  'ArrowFunctionExpression',\n  'ClassDeclaration',\n  'ClassExpression',\n]);\n\n/**\n * Expression wrappers that erase at runtime and so cannot change where a value\n * was constructed: `X as T`, `X satisfies T`, `<T>X`, `X!`, `X<T>`, `(X)`.\n */\nconst TRANSPARENT_WRAPPERS = new Set([\n  'TSAsExpression',\n  'TSSatisfiesExpression',\n  'TSTypeAssertion',\n  'TSNonNullExpression',\n  'TSInstantiationExpression',\n  'ParenthesizedExpression',\n]);\n\n/**\n * Strip runtime-transparent wrappers so the node underneath can be classified.\n *\n * Without this, `(() => <h1 />) satisfies React.FC` reads as a\n * `TSSatisfiesExpression` rather than the arrow function it compiles to, and a\n * provably-local component is misread as one whose origin cannot be\n * determined — turning a build error into a warning.\n */\nfunction unwrapTransparent(node: AstNode): AstNode {\n  let current = node;\n  while (TRANSPARENT_WRAPPERS.has(current.type) && current.expression) {\n    current = current.expression;\n  }\n  return current;\n}\n\n/**\n * Whether `name` is bound at module top level to a function or class written\n * in this file. An imported binding can never match: imports are\n * `ImportDeclaration` specifiers, not function/class/variable declarations,\n * and a module-level name cannot be both.\n */\nfunction bindsLocalFunction(program: ProgramNode, name: string): boolean {\n  for (const stmt of program.body) {\n    // `export function X() {}` binds X locally too — unwrap the export.\n    const decl = stmt.type === 'ExportNamedDeclaration' ? stmt.declaration : stmt;\n    if (!decl) continue;\n    if (\n      (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') &&\n      decl.id?.name === name\n    ) {\n      return true;\n    }\n    if (decl.type === 'VariableDeclaration') {\n      for (const d of decl.declarations ?? []) {\n        if (d.id?.name === name && d.init && FUNCTION_LIKE.has(unwrapTransparent(d.init).type)) {\n          return true;\n        }\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Whether the default export is *provably* a value constructed by this module:\n * `export default function/class/() => {}`, or a name bound to a function or\n * class declared here — whether it leaves via `export default Name` or\n * `export { Name as default }`. Both spellings are the same fact about where\n * the value was built, so both must answer the same way.\n *\n * This is the sound half of \"is this a server component?\". A file with no\n * `'use client'` directive whose default export is built here is a server\n * component, full stop. Everything else — `export { default } from\n * './client-thing'`, `export default Imported`, `export default memo(X)`,\n * an unparseable file — returns false, because the exported value may have\n * been minted in a module that *does* carry the directive. Callers must not\n * infer \"server component\" from a missing directive alone.\n */\nexport function fileDefaultExportIsLocalValue(filePath: string): boolean {\n  if (!existsSync(filePath)) return false;\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return false;\n    for (const stmt of program.body) {\n      if (stmt.type === 'ExportDefaultDeclaration') {\n        const decl = stmt.declaration && unwrapTransparent(stmt.declaration);\n        if (!decl) return false;\n        if (FUNCTION_LIKE.has(decl.type)) return true;\n        if (decl.type === 'Identifier' && decl.name) {\n          return bindsLocalFunction(program, decl.name);\n        }\n        return false;\n      }\n\n      // `export { Name as default }` — the same default export by another\n      // spelling. `hasDefaultExport` already counts it, so an analysis that\n      // skipped it here would let the exact defect this powers slip through\n      // as a warning.\n      const spec = defaultSpecifier(stmt);\n      if (spec) {\n        // `export { X as default } from './client-thing'` re-exports another\n        // module's value — the directive governing it lives over there.\n        if (stmt.source) return false;\n        return spec.local?.name ? bindsLocalFunction(program, spec.local.name) : false;\n      }\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if a file has any `export * from '...'` declarations.\n * Returns false if the file doesn't exist or can't be parsed.\n */\nexport function fileHasStarExport(filePath: string): boolean {\n  if (!existsSync(filePath)) return false;\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return false;\n    return hasStarExport(program);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Parsed value of `export const prerender` from a route file.\n *\n * - `true` / `false` — literal boolean\n * - `{ ttl?, tags? }` — ISR options object (prerender: true is implied)\n * - `undefined` — no `export const prerender` found\n *\n * See design/45-cache-lifetimes.md §\"Route-Level Static\".\n */\nexport type PrerenderExportValue = boolean | { ttl?: number; tags?: string[] };\n\nfunction extractLiteralValue(node: AstNode): unknown {\n  if (!node) return undefined;\n  const n = node as any;\n  if (n.type === 'Literal') return n.value;\n  if (n.type === 'UnaryExpression' && n.operator === '-' && n.argument?.type === 'Literal') {\n    return -(n.argument.value as number);\n  }\n  if (n.type === 'ArrayExpression') {\n    const elements = n.elements as AstNode[] | undefined;\n    if (!elements) return undefined;\n    const result: unknown[] = [];\n    for (const el of elements) {\n      const v = extractLiteralValue(el);\n      if (v === undefined) return undefined;\n      result.push(v);\n    }\n    return result;\n  }\n  return undefined;\n}\n\nfunction extractObjectLiteral(node: AstNode): Record<string, unknown> | undefined {\n  if ((node as any).type !== 'ObjectExpression') return undefined;\n  const props = (node as any).properties as AstNode[] | undefined;\n  if (!props) return undefined;\n  const result: Record<string, unknown> = {};\n  for (const prop of props) {\n    const p = prop as any;\n    if (p.type === 'SpreadElement') return undefined;\n    if (p.type !== 'Property' || p.computed) return undefined;\n    const key =\n      p.key?.type === 'Identifier'\n        ? p.key.name\n        : p.key?.type === 'Literal'\n          ? String(p.key.value)\n          : undefined;\n    if (!key) return undefined;\n    const value = extractLiteralValue(p.value);\n    if (value === undefined) return undefined;\n    result[key] = value;\n  }\n  return result;\n}\n\n/**\n * Extract the value of `export const prerender` from a file.\n * Returns undefined if the file doesn't export `prerender` or can't be parsed.\n *\n * Supports:\n *   export const prerender = true;\n *   export const prerender = false;\n *   export const prerender = { ttl: 3600, tags: ['docs'] };\n */\nexport function getPrerenderExport(filePath: string): PrerenderExportValue | undefined {\n  if (!existsSync(filePath)) return undefined;\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return undefined;\n\n    for (const stmt of program.body) {\n      if (stmt.type !== 'ExportNamedDeclaration') continue;\n      if (stmt.exportKind === 'type') continue;\n      if (!stmt.declaration) continue;\n      const decl = stmt.declaration;\n      if (decl.type !== 'VariableDeclaration') continue;\n      const declarations = decl.declarations as\n        | Array<{\n            id?: { name?: string };\n            init?: AstNode;\n          }>\n        | undefined;\n      if (!declarations) continue;\n      for (const d of declarations) {\n        if (d.id?.name !== 'prerender' || !d.init) continue;\n        const init = d.init as any;\n        if (init.type === 'Literal' && typeof init.value === 'boolean') {\n          return init.value;\n        }\n        if (init.type === 'ObjectExpression') {\n          const obj = extractObjectLiteral(init);\n          if (!obj) return undefined;\n          const result: { ttl?: number; tags?: string[] } = {};\n          if ('ttl' in obj && typeof obj.ttl === 'number') result.ttl = obj.ttl;\n          if (\n            'tags' in obj &&\n            Array.isArray(obj.tags) &&\n            obj.tags.every((t: unknown) => typeof t === 'string')\n          ) {\n            result.tags = obj.tags as string[];\n          }\n          return result;\n        }\n        return undefined;\n      }\n    }\n    return undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Check if a file starts with a specific directive (e.g. \"use client\").\n * Directives are string literal expression statements at the top of the file.\n */\nexport function fileHasDirective(filePath: string, directive: string): boolean {\n  if (!existsSync(filePath)) return false;\n  try {\n    const source = readFileCached(filePath);\n    const program = tryParse(source);\n    if (!program) return false;\n    for (const stmt of program.body) {\n      if (stmt.type !== 'ExpressionStatement') break;\n      const expr = (stmt as any).expression;\n      if (expr?.type !== 'Literal' || typeof expr.value !== 'string') break;\n      if (expr.value === directive) return true;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n","/**\n * Convention linter — validates common misconfigurations in the route tree.\n *\n * Runs at scan time (build and dev startup). Each check produces a warning\n * with the file path, what's wrong, and what to do about it.\n *\n * Most checks are warnings — they don't block the build. The goal is to catch\n * issues that would otherwise produce cryptic runtime behavior (silent 404s,\n * empty pages, confusing React errors).\n *\n * A check emits `level: 'error'` only when the misconfiguration is *proven*\n * (never inferred from an absence the analysis cannot see through) and fatal\n * to rendering. `plugins/routing.ts` turns those into a thrown build error,\n * so a false positive there refuses a working app — see\n * `classifyClientBoundaryFile` for how that bar is met.\n *\n * Design doc: 07-routing.md, 10-error-handling.md\n */\n\nimport { existsSync } from 'node:fs';\nimport type { RouteFile, RouteTree, SegmentNode } from './types.ts';\nimport { swallow } from '../server/logger.ts';\nimport {\n  fileDefaultExportIsLocalValue,\n  fileHasAnyExport,\n  fileHasDefaultExport,\n  fileHasDirective,\n  fileHasStarExport,\n} from './export-detect.ts';\n\n// ─── Types ──────────────────────────────────────────────────────────────────\n\nexport interface ConventionWarning {\n  /** Warning ID for deduplication and filtering. */\n  id: string;\n  /** Human-readable single-line summary. */\n  summary: string;\n  /** Multi-line details with file path and fix suggestion. */\n  details: string;\n  /** Severity: 'warn' for potential issues, 'error' for definite misconfigurations. */\n  level: 'warn' | 'error';\n}\n\n// ─── Lint Rules ─────────────────────────────────────────────────────────────\n\n/**\n * Run all convention lint checks on a route tree.\n *\n * Returns an array of warnings. Empty array means everything looks good.\n */\nexport function lintConventions(tree: RouteTree, appDir: string): ConventionWarning[] {\n  const warnings: ConventionWarning[] = [];\n\n  // Check 1: app/ directory exists (caller should check before scanning,\n  // but we validate the root has at least one routable file)\n  checkEmptyApp(tree.root, appDir, warnings);\n\n  // Check 2: route.ts without recognized HTTP method exports\n  checkRouteExports(tree.root, warnings);\n\n  // Check 3: Segments with layout but no page/route anywhere in subtree\n  // (not a misconfiguration per se — layouts without pages are valid for\n  // route groups. Skip this check.)\n\n  // Check 4: Root segment has no layout.tsx (no HTML shell)\n  checkRootLayout(tree.root, warnings);\n\n  // Check 5: page.tsx / layout.tsx without default export\n  checkDefaultExports(tree.root, warnings);\n\n  // Check 6: Client layouts cannot suppress server children before Flight\n  // serializes them. They remain valid UI boundaries, but not authorization\n  // or data-hiding boundaries.\n  checkClientLayouts(tree.root, warnings);\n\n  // Check 7: error.tsx / 404.tsx / 4xx.tsx / … without 'use client' directive\n  checkClientBoundaryFiles(tree.root, warnings);\n  if (tree.globalError) {\n    checkFileUseClientDirective(tree.globalError, 'global-error', warnings);\n  }\n\n  return warnings;\n}\n\nfunction checkClientLayouts(node: SegmentNode, warnings: ConventionWarning[]): void {\n  if (node.layout && isScriptExtension(node.layout.extension)) {\n    try {\n      const isClient = fileHasDirective(node.layout.filePath, 'use client');\n      const isProvablyServer = fileDefaultExportIsLocalValue(node.layout.filePath);\n      if (isClient || !isProvablyServer) {\n        const certainty = isClient\n          ? `This layout is a client component.`\n          : `Timber cannot prove this layout is a server component because its default export comes from another module or an opaque expression.`;\n        warnings.push({\n          id: `CLIENT_LAYOUT_NOT_AUTH_BOUNDARY:${node.layout.filePath}`,\n          summary: isClient\n            ? `Client layout cannot securely suppress server children: ${node.layout.filePath}`\n            : `Layout may resolve to a client component and cannot be trusted as an auth boundary: ${node.layout.filePath}`,\n          details:\n            `  File: ${node.layout.filePath}\\n\\n` +\n            `  ${certainty}\\n` +\n            `  React Flight resolves server content passed to a client layout before the layout runs in the browser.\\n` +\n            `  Conditionally omitting children here does not prevent descendant server components from executing or being serialized.\\n\\n` +\n            `  To fix: Put authorization in access.ts or a provably server layout with a locally defined default component, and keep client components inside that boundary.\\n`,\n          level: 'warn',\n        });\n      }\n    } catch (err) {\n      swallow(err, `convention-lint: unreadable layout file ${node.layout.filePath}`);\n    }\n  }\n  for (const child of node.children) checkClientLayouts(child, warnings);\n  for (const slot of Object.values(node.slots)) checkClientLayouts(slot, warnings);\n}\n\n// ─── Check: Empty App ───────────────────────────────────────────────────────\n\n/**\n * Warn when the app/ directory has no routable files at all.\n *\n * This catches the \"I created app/ but didn't add any pages\" case where\n * every request silently 404s with no guidance.\n */\nfunction checkEmptyApp(root: SegmentNode, appDir: string, warnings: ConventionWarning[]): void {\n  if (hasAnyRoutable(root)) return;\n\n  warnings.push({\n    id: 'EMPTY_APP',\n    summary: 'No pages or route handlers found in app/',\n    details:\n      `  Directory: ${appDir}\\n\\n` +\n      '  Your app/ directory has no page.tsx or route.ts files.\\n' +\n      '  Every request will return 404.\\n\\n' +\n      '  To fix: Create app/page.tsx with a default export:\\n\\n' +\n      '    export default function Home() {\\n      return <h1>Hello</h1>;\\n    }\\n',\n    level: 'warn',\n  });\n}\n\n/**\n * Check if a segment tree has any routable files (page or route) anywhere.\n */\nfunction hasAnyRoutable(node: SegmentNode): boolean {\n  if (node.page || node.route) return true;\n  for (const child of node.children) {\n    if (hasAnyRoutable(child)) return true;\n  }\n  for (const slot of Object.values(node.slots)) {\n    if (hasAnyRoutable(slot)) return true;\n  }\n  return false;\n}\n\n/**\n * Check if a segment tree has any page files (not just route handlers).\n * Used by checkRootLayout to avoid false positives for API-only apps (TIM-794).\n * API-only apps (just route.ts handlers) don't need a root layout.\n */\nfunction hasAnyPage(node: SegmentNode): boolean {\n  if (node.page) return true;\n  for (const child of node.children) {\n    if (hasAnyPage(child)) return true;\n  }\n  for (const slot of Object.values(node.slots)) {\n    if (hasAnyPage(slot)) return true;\n  }\n  return false;\n}\n\n// ─── Check: Route Exports ───────────────────────────────────────────────────\n\n/** HTTP methods that route.ts can export. */\nconst HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] as const;\n\n/**\n * Warn when a route.ts file doesn't appear to export any recognized HTTP methods.\n *\n * Uses AST-based detection via parseAst for precise matching.\n * Falls back silently when the file can't be parsed (syntax errors produce\n * no spurious warning — the TS compiler will catch those).\n */\nfunction checkRouteExports(node: SegmentNode, warnings: ConventionWarning[]): void {\n  if (node.route) {\n    const filePath = node.route.filePath;\n    try {\n      const methods = fileHasAnyExport(filePath, HTTP_METHODS);\n      if (methods.size === 0 && !fileHasStarExport(filePath)) {\n        const hasDefault = fileHasDefaultExport(filePath);\n        const hint = hasDefault\n          ? '  It looks like you have a default export. route.ts uses named exports\\n' +\n            '  for HTTP methods (GET, POST, etc.), not a default export.\\n'\n          : '';\n\n        warnings.push({\n          id: 'ROUTE_NO_METHODS',\n          summary: `route.ts has no HTTP method exports: ${filePath}`,\n          details:\n            `  File: ${filePath}\\n\\n` +\n            '  route.ts files must export named HTTP method handlers.\\n' +\n            '  Without them, the route matches but returns 405 Method Not Allowed.\\n\\n' +\n            hint +\n            '  Example:\\n\\n' +\n            '    export function GET(ctx: RouteContext) {\\n' +\n            \"      return Response.json({ hello: 'world' });\\n\" +\n            '    }\\n',\n          level: 'warn',\n        });\n      }\n    } catch (err) {\n      swallow(err, `convention-lint: unreadable route.ts ${filePath}`);\n    }\n  }\n\n  // Recurse\n  for (const child of node.children) {\n    checkRouteExports(child, warnings);\n  }\n  for (const slot of Object.values(node.slots)) {\n    checkRouteExports(slot, warnings);\n  }\n}\n\n// ─── Check: Root Layout ─────────────────────────────────────────────────────\n\n/**\n * Warn when the root segment has no layout.tsx.\n *\n * Without a root layout, there's no HTML shell (<html>, <body>).\n * The page will render but may have hydration issues or no proper document structure.\n */\nfunction checkRootLayout(root: SegmentNode, warnings: ConventionWarning[]): void {\n  if (root.layout) return;\n\n  // Only warn if there are pages — API-only apps (just route.ts handlers)\n  // don't need a root layout (TIM-794).\n  if (!hasAnyPage(root)) return;\n\n  warnings.push({\n    id: 'NO_ROOT_LAYOUT',\n    summary: 'No root layout.tsx found',\n    details:\n      '  Your app has pages but no root layout.\\n' +\n      '  Without app/layout.tsx, pages have no <html> or <body> wrapper.\\n\\n' +\n      '  To fix: Create app/layout.tsx:\\n\\n' +\n      '    export default function RootLayout({ children }: { children: React.ReactNode }) {\\n' +\n      '      return (\\n' +\n      '        <html lang=\"en\">\\n' +\n      '          <body>{children}</body>\\n' +\n      '        </html>\\n' +\n      '      );\\n' +\n      '    }\\n',\n    level: 'warn',\n  });\n}\n\n// ─── Check: Default Exports ───────────────────────────────────────────\n\n/**\n * Warn when page.tsx or layout.tsx files don't have a default export.\n *\n * Without a default export:\n * - page.tsx: the page renders nothing (empty content)\n * - layout.tsx: the layout module loads but has no component to render\n *\n * Uses AST-based detection via parseAst for precise matching. Falls back\n * silently when the file can't be parsed (no spurious warning on syntax errors).\n */\nfunction checkDefaultExports(node: SegmentNode, warnings: ConventionWarning[]): void {\n  // Check page files (tsx/ts/jsx/js only — not mdx, which is default-exported by the mdx compiler)\n  if (node.page && isScriptExtension(node.page.extension)) {\n    checkFileDefaultExport(node.page.filePath, 'page', warnings);\n  }\n\n  // Check layout files\n  if (node.layout && isScriptExtension(node.layout.extension)) {\n    checkFileDefaultExport(node.layout.filePath, 'layout', warnings);\n  }\n\n  // Recurse\n  for (const child of node.children) {\n    checkDefaultExports(child, warnings);\n  }\n  for (const slot of Object.values(node.slots)) {\n    checkDefaultExports(slot, warnings);\n  }\n}\n\nfunction isScriptExtension(ext: string): boolean {\n  return ext === 'tsx' || ext === 'ts' || ext === 'jsx' || ext === 'js';\n}\n\nfunction checkFileDefaultExport(\n  filePath: string,\n  fileType: string,\n  warnings: ConventionWarning[]\n): void {\n  try {\n    if (!fileHasDefaultExport(filePath)) {\n      warnings.push({\n        id: `NO_DEFAULT_EXPORT:${filePath}`,\n        summary: `${fileType}.tsx has no default export: ${filePath}`,\n        details:\n          `  File: ${filePath}\\n\\n` +\n          `  ${fileType}.tsx files must export a default React component.\\n` +\n          `  Without a default export, the ${fileType === 'page' ? 'page renders nothing' : 'layout has no component to wrap children'}.\\n\\n` +\n          `  To fix: Add a default export:\\n\\n` +\n          `    export default function My${fileType === 'page' ? 'Page' : 'Layout'}(${fileType === 'layout' ? '{ children }' : ''}) {\\n` +\n          `      return ${fileType === 'layout' ? '<div>{children}</div>' : '<h1>Hello</h1>'};\\n` +\n          `    }\\n`,\n        level: 'warn',\n      });\n    }\n  } catch (err) {\n    swallow(err, `convention-lint: unreadable ${fileType} file ${filePath}`);\n  }\n}\n\n// ─── Check: Client Boundary Directive ───────────────────────────────────────\n\n/**\n * Check every file the renderer hands to `TimberErrorBoundary` as a component\n * prop: `error.tsx`, `global-error.tsx`, and the status-code family\n * (`404.tsx`, `4xx.tsx`, `503.tsx`, …).\n *\n * `TimberErrorBoundary` is a client component, so a server component passed as\n * `fallbackComponent` is a function crossing the RSC → client boundary. React\n * Flight refuses to serialize it, and because the boundary wraps the segment's\n * *children*, the failure hits every page under that segment — not just the\n * error path. The raw message (\"Functions cannot be passed directly to Client\n * Components\") names neither the file nor the fix (TIM-1329).\n *\n * `.json` status files never reach React at all, and are not in `statusFiles`.\n */\nfunction checkClientBoundaryFiles(node: SegmentNode, warnings: ConventionWarning[]): void {\n  if (node.error) {\n    checkFileUseClientDirective(node.error, 'error', warnings);\n  }\n\n  for (const [key, file] of Object.entries(node.statusFiles ?? {})) {\n    checkFileUseClientDirective(file, key, warnings);\n  }\n\n  for (const child of node.children) {\n    checkClientBoundaryFiles(child, warnings);\n  }\n  for (const slot of Object.values(node.slots)) {\n    checkClientBoundaryFiles(slot, warnings);\n  }\n}\n\n/**\n * `'client'` — carries the directive.\n * `'server'` — proven server component: no directive, and the default export is\n *   a function or class built by this very module, so no other file's directive\n *   can be governing it.\n * `'unknown'` — no directive, but the exported value may come from elsewhere\n *   (`export { default } from './client-thing'`), or the file could not be\n *   read or parsed. Never escalated to a build error.\n */\ntype ClientBoundaryVerdict = 'client' | 'server' | 'unknown';\n\nfunction classifyClientBoundaryFile(filePath: string): ClientBoundaryVerdict {\n  if (fileHasDirective(filePath, 'use client')) return 'client';\n  if (fileDefaultExportIsLocalValue(filePath)) return 'server';\n  return 'unknown';\n}\n\n/** Example component name for the fix snippet, keyed by convention name. */\nfunction exampleComponentName(convention: string): string {\n  if (convention === 'global-error') return 'GlobalError';\n  if (convention === 'error') return 'ErrorBoundary';\n  if (convention === '404') return 'NotFound';\n  return 'StatusPage';\n}\n\n/**\n * @param file      the route file (its extension decides whether the check applies)\n * @param convention the convention name — `error`, `global-error`, `404`, `4xx`, …\n */\nfunction checkFileUseClientDirective(\n  file: RouteFile,\n  convention: string,\n  warnings: ConventionWarning[]\n): void {\n  // Only script extensions need the 'use client' check — .json status files\n  // never reach React at all, and are not in `statusFiles`.\n  if (!isScriptExtension(file.extension)) return;\n\n  const filePath = file.filePath;\n  const label = `${convention}.${file.extension}`;\n  let verdict: ClientBoundaryVerdict;\n  try {\n    verdict = classifyClientBoundaryFile(filePath);\n  } catch (err) {\n    swallow(err, `convention-lint: unreadable ${label} file ${filePath}`);\n    return;\n  }\n  if (verdict === 'client') return;\n\n  const isError = verdict === 'server';\n  const name = exampleComponentName(convention);\n  const props =\n    convention === 'error' || convention === 'global-error' ? '{ error, reset }' : '{ status }';\n\n  warnings.push({\n    id: `NEEDS_USE_CLIENT:${filePath}`,\n    summary: isError\n      ? `${label} is a server component and must be a client component: ${filePath}`\n      : `${label} may be missing 'use client': ${filePath}`,\n    details:\n      `  File: ${filePath}\\n\\n` +\n      `  ${label} is handed to timber's error boundary — a client\\n` +\n      '  component — as a prop. A server component cannot cross that boundary:\\n' +\n      '  React fails with \"Functions cannot be passed directly to Client\\n' +\n      '  Components\", and every page under this segment fails to render.\\n\\n' +\n      (isError\n        ? \"  To fix: Add 'use client' as the first line of the file:\\n\\n\" +\n          \"    'use client';\\n\\n\" +\n          `    export default function ${name}(${props}) {\\n` +\n          '      return <h1>…</h1>;\\n' +\n          '    }\\n'\n        : // The default export comes from somewhere this analysis cannot follow\n          // — a re-export, an imported binding, a wrapper call. It may well\n          // already be a client component, so say what was checked rather than\n          // assert a break.\n          \"  This file has no 'use client' directive, and its default export\\n\" +\n          '  comes from elsewhere, so timber cannot tell which it is. If the\\n' +\n          \"  module it re-exports starts with 'use client', nothing is wrong\\n\" +\n          '  and you can ignore this. Otherwise add the directive there.\\n'),\n    level: isError ? 'error' : 'warn',\n  });\n}\n\n// ─── Check: App Directory Exists ────────────────────────────────────────────\n\n/**\n * Check if the app/ directory exists. Called before scanning.\n * Returns a warning if missing, or null if the directory exists.\n */\nexport function checkAppDirExists(appDir: string): ConventionWarning | null {\n  if (existsSync(appDir)) return null;\n\n  return {\n    id: 'NO_APP_DIR',\n    summary: 'No app/ directory found',\n    details:\n      `  Expected: ${appDir}\\n\\n` +\n      '  timber.js requires an app/ directory for file-system routing.\\n' +\n      '  Every request will return 404 until you create it.\\n\\n' +\n      '  To fix: Create the app/ directory with a page:\\n\\n' +\n      '    mkdir -p app\\n' +\n      '    # Create app/layout.tsx and app/page.tsx\\n',\n    level: 'error',\n  };\n}\n\n// ─── Formatting ─────────────────────────────────────────────────────────────\n\nimport type { InspectColor } from 'node:util';\nimport { styleText } from 'node:util';\n\ntype Format = InspectColor | readonly InspectColor[];\nconst noValidate = { validateStream: false } as const;\n\nexport interface FormatOptions {\n  /**\n   * Emit ANSI escapes. Off when the text becomes an `Error` message —\n   * whoever prints it decides its formatting, and colored escapes inside\n   * an exception leak into logs and stack traces.\n   */\n  color?: boolean;\n}\n\n/**\n * Format warnings for terminal output.\n *\n * Groups by severity, uses colors, and includes fix suggestions.\n */\nexport function formatConventionWarnings(\n  warnings: ConventionWarning[],\n  options: FormatOptions = {}\n): string {\n  const { color = true } = options;\n  const style = (fmt: Format, text: string) => (color ? styleText(fmt, text, noValidate) : text);\n  if (warnings.length === 0) return '';\n\n  const errors = warnings.filter((w) => w.level === 'error');\n  const warns = warnings.filter((w) => w.level === 'warn');\n\n  const lines: string[] = [];\n\n  if (errors.length > 0) {\n    lines.push(\n      `${style(['red', 'bold'], '[timber]')} ${style('red', `${errors.length} configuration error${errors.length !== 1 ? 's' : ''}:`)}`\n    );\n    for (const e of errors) {\n      lines.push('');\n      lines.push(`  ${style('red', '✗')} ${e.summary}`);\n      lines.push(style('dim', e.details));\n    }\n  }\n\n  if (warns.length > 0) {\n    if (errors.length > 0) lines.push('');\n    lines.push(\n      `${style(['yellow', 'bold'], '[timber]')} ${style('yellow', `${warns.length} configuration warning${warns.length !== 1 ? 's' : ''}:`)}`\n    );\n    for (const w of warns) {\n      lines.push('');\n      lines.push(`  ${style('yellow', '⚠')} ${w.summary}`);\n      lines.push(style('dim', w.details));\n    }\n  }\n\n  return lines.join('\\n');\n}\n"],"mappings":"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"}

package/dist/_chunks/tree-match-CdbvYTBz.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-match-CdbvYTBz.js","names":[],"sources":["../../src/server/tree-match.ts"],"sourcesContent":["/**\n * Shared URL-matching tree walker for segment trees.\n *\n * Both the main route matcher (`route-matcher.ts`) and slot resolver\n * (`slot-resolver.ts`) need to walk a SegmentNode tree, matching URL\n * parts against children with the same priority semantics:\n *\n *   static > dynamic > catch-all > optional-catch-all\n *\n * Before this module, each had its own walker with subtle divergences\n * (different group handling, missing backtracking, incomplete\n * optional-catch-all support). This shared walker is the single\n * source of truth for URL-to-segment matching.\n *\n * See design/07-routing.md §\"Request Lifecycle\" and TIM-940.\n */\n\nimport type { SegmentNode } from '../routing/types.ts';\n\n// ─── Public API ───────────────────────────────────────────────────────────\n\n/** Result of matching URL parts against a segment tree. */\nexport interface TreeMatchResult<TFile> {\n  /** Matched segment chain from root to leaf, inclusive. */\n  chain: SegmentNode<TFile>[];\n  /** Collected params, keyed by param name. Catch-all params are string[]. */\n  params: Record<string, string | string[]>;\n}\n\nexport interface TreeMatchOptions {\n  /**\n   * When true (default), only match if the leaf node has a page or route\n   * handler. Set to false for metadata route matching, where we just need\n   * to find the owning segment regardless of whether it has a page.\n   */\n  requireTerminal?: boolean;\n}\n\n/**\n * Match URL path parts against a segment tree.\n *\n * Walks the tree depth-first with backtracking, applying priority\n * ordering globally across group boundaries. Returns the matched\n * segment chain and collected params, or null if no route matches.\n *\n * By default, a match requires a terminal node (one with `page` or\n * `route`) at the leaf. Pass `{ requireTerminal: false }` to match\n * any segment (used by metadata route matching).\n *\n * @param root  The root segment node to start matching from.\n * @param parts URL path parts (e.g. ['blog', 'hello-world']).\n *              Empty array matches the root itself (if terminal).\n */\nexport function matchUrlParts<TFile>(\n  root: SegmentNode<TFile>,\n  parts: string[],\n  options?: TreeMatchOptions\n): TreeMatchResult<TFile> | null {\n  const chain: SegmentNode<TFile>[] = [];\n  const params: Record<string, string | string[]> = {};\n  const requireTerminal = options?.requireTerminal ?? true;\n\n  if (matchNode(root, parts, 0, chain, params, requireTerminal)) {\n    return { chain, params };\n  }\n  return null;\n}\n\n// ─── Internal ─────────────────────────────────────────────────────────────\n\n/**\n * A child node flattened through group segments, along with the\n * chain of group nodes that must appear in the segment chain\n * before the child to preserve the tree path.\n */\ninterface EffectiveChild<TFile> {\n  child: SegmentNode<TFile>;\n  groupChain: SegmentNode<TFile>[];\n}\n\n/**\n * Flatten children through group segments.\n *\n * Groups are transparent for URL matching — their non-group descendants\n * are returned with the chain of group nodes leading to them. This lets\n * the caller apply priority ordering (static > dynamic > catch-all >\n * optional-catch-all) across all groups uniformly instead of per-group.\n */\nfunction collectEffectiveChildren<TFile>(\n  node: SegmentNode<TFile>,\n  groupChain: SegmentNode<TFile>[] = []\n): EffectiveChild<TFile>[] {\n  const result: EffectiveChild<TFile>[] = [];\n  for (const child of node.children) {\n    if (child.segmentType === 'group') {\n      const nested = collectEffectiveChildren(child, [...groupChain, child]);\n      result.push(...nested);\n    } else {\n      result.push({ child, groupChain });\n    }\n  }\n  return result;\n}\n\n/** A node is terminal if it can serve a response (has a page or route handler). */\nfunction isTerminal<TFile>(node: SegmentNode<TFile>): boolean {\n  return !!(node.page || node.route);\n}\n\n/** Combined affix length for specificity ordering. */\nfunction affixLength<TFile>(node: SegmentNode<TFile>): number {\n  return (node.paramPrefix?.length ?? 0) + (node.paramSuffix?.length ?? 0);\n}\n\n/**\n * Recursive depth-first matcher with backtracking.\n *\n * Mutates `chain` and `params` in place for performance; backtracks\n * (restores previous state) when a candidate doesn't lead to a match.\n */\nfunction matchNode<TFile>(\n  node: SegmentNode<TFile>,\n  parts: string[],\n  index: number,\n  chain: SegmentNode<TFile>[],\n  params: Record<string, string | string[]>,\n  requireTerminal: boolean\n): boolean {\n  chain.push(node);\n\n  // All parts consumed — check if this node is terminal (or any node if !requireTerminal)\n  if (index >= parts.length) {\n    if (!requireTerminal || isTerminal(node)) return true;\n\n    // Groups don't consume URL segments, so a group child's page can\n    // match at the same URL depth. Recurse into groups transparently.\n    for (const child of node.children) {\n      if (child.segmentType === 'group') {\n        if (matchNode(child, parts, index, chain, params, requireTerminal)) {\n          return true;\n        }\n      }\n    }\n\n    // Optional catch-all with zero segments (direct and through groups).\n    // The param is NOT set — matching Next.js semantics for [[...slug]]\n    // with no path segments.\n    const effective = collectEffectiveChildren(node);\n    for (const { child, groupChain } of effective) {\n      if (child.segmentType === 'optional-catch-all' && (!requireTerminal || isTerminal(child))) {\n        chain.push(...groupChain, child);\n        return true;\n      }\n    }\n\n    chain.pop();\n    return false;\n  }\n\n  const part = parts[index];\n\n  // Flatten children through groups so priority ordering applies globally.\n  const effective = collectEffectiveChildren(node);\n\n  // 1. Static segments (exact name match)\n  for (const { child, groupChain } of effective) {\n    if (child.segmentType === 'static' && child.segmentName === part) {\n      chain.push(...groupChain);\n      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {\n        return true;\n      }\n      chain.length -= groupChain.length;\n    }\n  }\n\n  // 2. Affixed dynamic segments (e.g. img-[id].png) — more specific than bare dynamic.\n  //    Sorted by specificity: longer combined prefix+suffix wins.\n  const affixed = effective.filter(\n    ({ child }) =>\n      child.segmentType === 'dynamic' && child.paramName && (child.paramPrefix || child.paramSuffix)\n  );\n  affixed.sort((a, b) => affixLength(b.child) - affixLength(a.child));\n  for (const { child, groupChain } of affixed) {\n    const prefix = child.paramPrefix ?? '';\n    const suffix = child.paramSuffix ?? '';\n    if (\n      part.length > prefix.length + suffix.length &&\n      (!prefix || part.startsWith(prefix)) &&\n      (!suffix || part.endsWith(suffix))\n    ) {\n      const value = part.slice(prefix.length, part.length - (suffix.length || 0));\n      chain.push(...groupChain);\n      const prev = params[child.paramName!];\n      params[child.paramName!] = value;\n      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {\n        return true;\n      }\n      // Backtrack\n      chain.length -= groupChain.length;\n      if (prev !== undefined) {\n        params[child.paramName!] = prev;\n      } else {\n        delete params[child.paramName!];\n      }\n    }\n  }\n\n  // 3. Bare dynamic segments ([param])\n  for (const { child, groupChain } of effective) {\n    if (\n      child.segmentType === 'dynamic' &&\n      child.paramName &&\n      !child.paramPrefix &&\n      !child.paramSuffix\n    ) {\n      chain.push(...groupChain);\n      const prev = params[child.paramName];\n      params[child.paramName] = part;\n      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {\n        return true;\n      }\n      // Backtrack\n      chain.length -= groupChain.length;\n      if (prev !== undefined) {\n        params[child.paramName] = prev;\n      } else {\n        delete params[child.paramName];\n      }\n    }\n  }\n\n  // 4. Catch-all segments ([...param]) — must be terminal unless the\n  // caller passed requireTerminal:false (metadata route matching needs to\n  // find the owning segment even when it has no page).\n  for (const { child, groupChain } of effective) {\n    if (\n      child.segmentType === 'catch-all' &&\n      child.paramName &&\n      (!requireTerminal || isTerminal(child))\n    ) {\n      chain.push(...groupChain, child);\n      params[child.paramName] = parts.slice(index);\n      return true;\n    }\n  }\n\n  // 5. Optional catch-all segments ([[...param]]) — same terminal rule\n  for (const { child, groupChain } of effective) {\n    if (\n      child.segmentType === 'optional-catch-all' &&\n      child.paramName &&\n      (!requireTerminal || isTerminal(child))\n    ) {\n      chain.push(...groupChain, child);\n      params[child.paramName] = parts.slice(index);\n      return true;\n    }\n  }\n\n  chain.pop();\n  return false;\n}\n"],"mappings":"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"}