@timber-js/app 0.2.0-alpha.206 → 0.2.0-alpha.208

package/src/client/segment-cache.ts

@@ -74,6 +74,16 @@ export interface SegmentNode {
  */
 export class SegmentCache {
   private root: SegmentNode | undefined;
+  /**
+   * Monotonic counter. Bumped by `invalidateReuse()` (TIM-1466).
+   * `serializeStateTree` suppresses `segments` and `slots` when
+   * `reuseInvalidatedAt > reuseRestoredAt`. Only `restoreReuse()`
+   * advances `reuseRestoredAt` — `set()` does not, because a
+   * pre-invalidation navigation's commit thunk would lift suppression
+   * before a post-invalidation request has been sent (codex on #1167).
+   */
+  private reuseInvalidatedAt = 0;
+  private reuseRestoredAt = 0;
 
   get(segment: string): SegmentNode | undefined {
     if (segment === '/' || segment === this.root?.segment) {
@@ -90,6 +100,33 @@ export class SegmentCache {
 
   clear(): void {
     this.root = undefined;
+    this.reuseRestoredAt = this.reuseInvalidatedAt;
+  }
+
+  /**
+   * Suppress segment and slot reuse without destroying the tree
+   * structure (TIM-1466). `serializeStateTree` sends empty
+   * `segments`/`slots` (forcing a full render) while `treePaths`
+   * still reflects the mounted tree for interception scoping.
+   * Call `restoreReuse()` once post-invalidation data has been
+   * fetched and committed.
+   */
+  invalidateReuse(): void {
+    this.reuseInvalidatedAt++;
+  }
+
+  /**
+   * Lift reuse suppression. Called after the segment cache has been
+   * rebuilt from a response that was fetched with suppression active
+   * (i.e. the server sent a full render). Safe to call idempotently.
+   */
+  restoreReuse(): void {
+    this.reuseRestoredAt = this.reuseInvalidatedAt;
+  }
+
+  /** Whether segment/slot reuse is currently suppressed (TIM-1466). */
+  isReuseSuppressed(): boolean {
+    return this.reuseInvalidatedAt > this.reuseRestoredAt;
   }
 
   /**
@@ -116,9 +153,12 @@ export class SegmentCache {
     const segments: string[] = [];
     const slots: string[] = [];
     const treePaths: string[] = [];
+    const suppressed = this.reuseInvalidatedAt > this.reuseRestoredAt;
     if (this.root) {
-      collectSyncSegments(this.root, segments, mergeableFilter);
-      collectSyncSlots(this.root, slots);
+      if (!suppressed) {
+        collectSyncSegments(this.root, segments, mergeableFilter);
+        collectSyncSlots(this.root, slots);
+      }
       collectTreePaths(this.root, treePaths);
     }
     const tree: StateTree = { segments };
@@ -324,6 +364,27 @@ function prefetchMapKey(key: PrefetchKey): string {
   return `${key.from.length}:${key.from}:${key.scope.length}:${key.scope}:${key.url}`;
 }
 
+/**
+ * Extract the destination URL from a length-prefixed map key.
+ * Key format: `${from.length}:${from}:${scope.length}:${scope}:${url}`
+ */
+function extractUrlFromMapKey(mapKey: string): string | null {
+  // Parse from-length prefix
+  const firstColon = mapKey.indexOf(':');
+  if (firstColon === -1) return null;
+  const fromLen = parseInt(mapKey.slice(0, firstColon), 10);
+  if (Number.isNaN(fromLen)) return null;
+  // Skip past `from.length:from:`
+  const scopeStart = firstColon + 1 + fromLen + 1;
+  // Parse scope-length prefix
+  const secondColon = mapKey.indexOf(':', scopeStart);
+  if (secondColon === -1) return null;
+  const scopeLen = parseInt(mapKey.slice(scopeStart, secondColon), 10);
+  if (Number.isNaN(scopeLen)) return null;
+  // Skip past `scope.length:scope:` — remainder is the URL
+  return mapKey.slice(secondColon + 1 + scopeLen + 1);
+}
+
 /**
  * The `scope` half of a `PrefetchKey`, derived from the state tree that will
  * actually be sent. Taking it from the header value rather than re-walking the
@@ -334,8 +395,12 @@ export function prefetchScopeOf(stateTree: StateTree | undefined): string {
 }
 
 /** Outcome of a prefetch flight — discriminated so NonRscResponse is a
- *  success (stores a negative entry) rather than a rejection. */
-export type FlightOutcome = { kind: 'ready'; result: PrefetchResult } | { kind: 'non-route' };
+ *  success (stores a negative entry) rather than a rejection.
+ *  `startGen` is the eviction generation at flight start — joiners that
+ *  started after a gen bump must reject pre-invalidation results (TIM-1464). */
+export type FlightOutcome =
+  | { kind: 'ready'; result: PrefetchResult; startGen: number }
+  | { kind: 'non-route'; startGen: number };
 
 /**
  * Short-lived cache for hover-triggered prefetches. Entries expire after
@@ -410,16 +475,19 @@ export class PrefetchCache {
     // Capture the eviction generation before the flight starts. If an
     // action evicts caches while this flight is in progress, the gen
     // will have bumped and the stale result is discarded (TIM-1476).
+    // The starting gen is also included in the outcome so joiners
+    // that started after a gen bump can detect pre-invalidation
+    // results (TIM-1464).
     const genAtStart = this.evictionGen;
     return this.flights.do(prefetchMapKey(key), async (signal) => {
       try {
         const result = await doFetch(signal);
         if (!signal.aborted && this.evictionGen === genAtStart) this.set(key, result);
-        return { kind: 'ready' as const, result };
+        return { kind: 'ready' as const, result, startGen: genAtStart };
       } catch (err) {
         if (isNonRoute(err)) {
           if (!signal.aborted && this.evictionGen === genAtStart) this.setNegative(key);
-          return { kind: 'non-route' as const };
+          return { kind: 'non-route' as const, startGen: genAtStart };
         }
         throw err;
       }
@@ -455,16 +523,47 @@ export class PrefetchCache {
   }
 
   /**
-   * Invalidate all entries whose destination URL matches (TIM-1454).
-   * Used by `revalidatePath` on a non-current route so the next navigation
-   * fetches fresh data instead of replaying a stale prefetch.
+   * Invalidate entries whose destination URL matches (TIM-1454).
+   *
+   * When `url` has no search string, evicts all entries sharing that
+   * pathname — `/products` evicts `/products?page=1` too, because
+   * `revalidatePath('/products')` invalidates the route regardless of
+   * query (TIM-1465).
+   *
+   * When `url` has a search string, only the exact URL is evicted.
+   *
+   * Also bumps the eviction generation so in-flight singleflight
+   * flights for the invalidated URL(s) discard their results on
+   * completion (TIM-1464).
    */
   invalidateUrl(url: string): void {
+    const hasSearch = url.includes('?');
+    const pathname = hasSearch ? null : url;
+
     for (const [mapKey] of this.entries) {
-      if (mapKey.endsWith(':' + url)) {
-        this.entries.delete(mapKey);
+      // The map key is `${from.length}:${from}:${scope.length}:${scope}:${url}`.
+      // The destination URL is the suffix after the last unescaped colon pair.
+      if (hasSearch) {
+        if (mapKey.endsWith(':' + url)) {
+          this.entries.delete(mapKey);
+        }
+      } else {
+        // Extract the URL suffix — everything after the scope block.
+        // Match any entry whose URL pathname matches.
+        const entryUrl = extractUrlFromMapKey(mapKey);
+        if (entryUrl !== null) {
+          const qIndex = entryUrl.indexOf('?');
+          const entryPathname = qIndex === -1 ? entryUrl : entryUrl.slice(0, qIndex);
+          if (entryPathname === pathname) {
+            this.entries.delete(mapKey);
+          }
+        }
       }
     }
+
+    // Fence in-flight flights so a prefetch that started before
+    // invalidation cannot store its stale result (TIM-1464).
+    this.evictionGen++;
   }
 
   /**

package/src/index.ts

@@ -28,6 +28,7 @@ import { timberBuildManifest } from './plugins/build-manifest.ts';
 import { timberDevLogs, originalConsole, wrapLoggerWithOriginalConsole } from './dev-tools/logs.ts';
 import { resolveForwardConsole } from './dev-tools/browser-logs.ts';
 import { timberReactProd } from './plugins/react-prod.ts';
+import { timberReactResolve } from './plugins/react-resolve.ts';
 import { timberChunks } from './plugins/chunks.ts';
 import { clientChunkGroup } from './plugins/client-chunks.ts';
 import { timberServerBundle } from './plugins/server-bundle.ts';
@@ -553,6 +554,7 @@ export function timber(config?: TimberUserConfig): PluginOption[] {
   // imports manifest. See @vitejs/plugin-rsc's buildApp implementation.
   return [
     rootSync,
+    timberReactResolve(),
     timberReactProd(),
     // @vitejs/plugin-react provides React Fast Refresh (state-preserving HMR)
     // for client components via Babel transform. Placed before @vitejs/plugin-rsc

package/src/plugins/react-resolve.ts

@@ -0,0 +1,149 @@
+/**
+ * timber-react-resolve — Deduplicate React across timber and user project.
+ *
+ * Without this plugin, pnpm's strict isolation can install two physical
+ * copies of React when the user's pinned version differs from timber's
+ * peer dep. Timber's 47 bare `from 'react'` imports resolve to one copy
+ * while react-dom uses the other — causing "Invalid hook call" hydration
+ * crashes with no indication of the real cause.
+ *
+ * The fix: inject `resolve.dedupe` entries so Vite always resolves React
+ * packages from the project root. Unlike `resolve.alias`, `dedupe`
+ * preserves Vite's per-environment export conditions — the RSC
+ * environment still gets the `react-server` build, SSR gets the SSR
+ * build, and the browser gets the browser build. The deduplication
+ * happens at the package level, not the file level.
+ *
+ * A `configResolved` check detects version mismatches between timber's
+ * resolved React and the project's React, and logs an actionable error.
+ *
+ * Design doc: 18-build-system.md §"Module Resolution"
+ * Task: TIM-1520
+ */
+
+import { createRequire } from 'node:module';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { Plugin } from 'vite';
+
+/**
+ * React packages to deduplicate. Vite's `resolve.dedupe` extracts the
+ * base package name (via `deepImportRE`) before checking, so subpath
+ * specifiers like `react/jsx-runtime` are covered by the base `react`
+ * entry — listing them separately has no effect.
+ */
+export const REACT_DEDUPE_PACKAGES = ['react', 'react-dom'] as const;
+
+// ANSI escape codes — match config-validation.ts style
+const RED = '\x1b[31m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+/**
+ * Read the version from a package's package.json given a resolve root.
+ */
+function readPackageVersion(packageName: string, resolveRoot: string): string | null {
+  try {
+    const req = createRequire(`${resolveRoot}/package.json`);
+    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
+    const pkg = req(pkgJsonPath) as { version?: string };
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export interface ReactVersionMismatch {
+  specifier: string;
+  timberVersion: string;
+  projectVersion: string;
+}
+
+/**
+ * Check whether timber's React and the user project's React resolve to
+ * the same version. Returns mismatches if any.
+ */
+export function detectReactMismatch(projectRoot: string): ReactVersionMismatch[] {
+  const mismatches: ReactVersionMismatch[] = [];
+  const timberRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+  for (const pkg of ['react', 'react-dom'] as const) {
+    const timberVersion = readPackageVersion(pkg, timberRoot);
+    const projectVersion = readPackageVersion(pkg, projectRoot);
+
+    if (timberVersion && projectVersion && timberVersion !== projectVersion) {
+      mismatches.push({ specifier: pkg, timberVersion, projectVersion });
+    }
+  }
+
+  return mismatches;
+}
+
+/**
+ * Format React version mismatches as an actionable warning.
+ */
+export function formatReactMismatch(mismatches: ReactVersionMismatch[]): string {
+  if (mismatches.length === 0) return '';
+
+  const lines: string[] = [];
+  lines.push(
+    `${RED}${BOLD}[timber]${RESET} ${RED}React version mismatch detected — this causes silent hydration crashes${RESET}`
+  );
+  lines.push('');
+  for (const m of mismatches) {
+    lines.push(
+      `  ${RED}✗${RESET} ${m.specifier}: timber has ${BOLD}${m.timberVersion}${RESET}, project has ${BOLD}${m.projectVersion}${RESET}`
+    );
+  }
+  lines.push('');
+  lines.push(
+    `  ${DIM}This typically causes "Invalid hook call" errors because two copies of${RESET}`
+  );
+  lines.push(`  ${DIM}React are loaded. timber's resolve.dedupe should handle this, but${RESET}`);
+  lines.push(
+    `  ${DIM}if you see hook errors, ensure your React version satisfies timber's peer dep.${RESET}`
+  );
+  lines.push('');
+  lines.push(`  ${DIM}Fix: update React in your project to match —${RESET}`);
+  lines.push(
+    `  ${BOLD}pnpm add react@${mismatches[0].timberVersion} react-dom@${mismatches[0].timberVersion}${RESET}`
+  );
+
+  return lines.join('\n');
+}
+
+/**
+ * Create the timber-react-resolve Vite plugin.
+ */
+export function timberReactResolve(): Plugin {
+  return {
+    name: 'timber-react-resolve',
+    enforce: 'pre',
+
+    config(userConfig) {
+      // Merge with any existing dedupe entries the user may have set.
+      const existing = userConfig.resolve?.dedupe ?? [];
+      const merged = [...existing];
+
+      for (const pkg of REACT_DEDUPE_PACKAGES) {
+        if (!merged.includes(pkg)) {
+          merged.push(pkg);
+        }
+      }
+
+      return {
+        resolve: {
+          dedupe: merged,
+        },
+      };
+    },
+
+    configResolved(resolved) {
+      const mismatches = detectReactMismatch(resolved.root);
+      if (mismatches.length > 0) {
+        process.stderr.write(`${formatReactMismatch(mismatches)}\n\n`);
+      }
+    },
+  };
+}

package/src/plugins/routing.ts

@@ -45,7 +45,7 @@ const SEGMENT_PREFIX = '\0$segment:';
  * File convention names we track for changes that require manifest regeneration.
  */
 const ROUTE_FILE_PATTERNS =
-  /\/(page|layout|middleware|access|route|error|global-error|default|denied|schema|\d{3}|[45]xx|sitemap|robots|manifest|favicon|icon|opengraph-image|apple-icon)\./;
+  /\/(page|layout|middleware|access|route|error|global-error|default|denied|schema|proxy|\d{3}|[45]xx|sitemap|robots|manifest|favicon|icon|opengraph-image|apple-icon)\./;
 
 /**
  * Create the timber-routing Vite plugin.

package/src/routing/convention-lint.ts

@@ -79,6 +79,9 @@ export function lintConventions(tree: RouteTree, appDir: string): ConventionWarn
     checkFileUseClientDirective(tree.globalError, 'global-error', warnings);
   }
 
+  // Check 8: middleware.ts inside a parallel slot subtree (silently dead)
+  checkSlotMiddleware(tree.root, warnings);
+
   return warnings;
 }
 
@@ -431,6 +434,63 @@ function checkFileUseClientDirective(
   });
 }
 
+// ─── Check: Slot Middleware ─────────────────────────────────────────────────
+
+/**
+ * Error when middleware.ts appears inside a parallel slot subtree.
+ *
+ * Middleware is collected from the main matched segment chain only
+ * (route-matcher.ts `collectMiddlewareChain`). The slot resolver never
+ * walks `middleware` on its matched chain, so a middleware.ts under any
+ * `@slot/` directory silently never executes. `access.ts` in slot chains
+ * DOES run (via SlotAccessGate), making the asymmetry invisible unless
+ * you know to look.
+ *
+ * This is a build error rather than a warning: the file provably cannot
+ * run and its presence misleads the author into thinking the slot is
+ * middleware-protected.
+ *
+ * See design/07-routing.md §"Parallel Routes"
+ */
+function checkSlotMiddleware(node: SegmentNode, warnings: ConventionWarning[]): void {
+  for (const [slotName, slotRoot] of Object.entries(node.slots)) {
+    collectSlotMiddleware(slotRoot, slotName, warnings);
+  }
+  for (const child of node.children) {
+    checkSlotMiddleware(child, warnings);
+  }
+}
+
+/**
+ * Walk a slot subtree and report every middleware.ts found.
+ */
+function collectSlotMiddleware(
+  node: SegmentNode,
+  slotName: string,
+  warnings: ConventionWarning[]
+): void {
+  if (node.middleware) {
+    warnings.push({
+      id: `SLOT_MIDDLEWARE:${node.middleware.filePath}`,
+      summary: `middleware.ts inside slot @${slotName} never executes: ${node.middleware.filePath}`,
+      details:
+        `  File: ${node.middleware.filePath}\n\n` +
+        `  Middleware is collected from the main route chain only.\n` +
+        `  The slot resolver does not run middleware — this file is silently dead.\n` +
+        `  (access.ts in slots does run via SlotAccessGate; middleware.ts does not.)\n\n` +
+        `  To fix: Move the middleware logic into access.ts for slot-scoped auth,\n` +
+        `  or into a middleware.ts on the main route chain outside the slot.\n`,
+      level: 'error',
+    });
+  }
+  for (const child of node.children) {
+    collectSlotMiddleware(child, slotName, warnings);
+  }
+  for (const [nestedSlotName, nestedSlot] of Object.entries(node.slots)) {
+    collectSlotMiddleware(nestedSlot, nestedSlotName, warnings);
+  }
+}
+
 // ─── Check: App Directory Exists ────────────────────────────────────────────
 
 /**

package/src/schema-bridge.ts

@@ -36,8 +36,10 @@ import type { Codec } from './codec.ts';
 
 /** Minimal Standard Schema interface for auto-detection. */
 export interface StandardSchemaV1<Output = unknown> {
-  '~standard': {
-    validate(value: unknown): StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+  readonly '~standard': {
+    readonly validate: (
+      value: unknown
+    ) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
   };
 }
 

package/src/server/action-client.ts

@@ -44,8 +44,10 @@ export class ActionError<TCode extends string = string> extends Error {
  * requiring exact structural matches on issues/path shapes.
  */
 interface StandardSchemaV1<Output = unknown> {
-  '~standard': {
-    validate(value: unknown): StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
+  readonly '~standard': {
+    readonly validate: (
+      value: unknown
+    ) => StandardSchemaResult<Output> | Promise<StandardSchemaResult<Output>>;
   };
 }
 

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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"}