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

package/src/routing/convention-lint.ts

@@ -0,0 +1,356 @@
+/**
+ * Convention linter — validates common misconfigurations in the route tree.
+ *
+ * Runs at scan time (build and dev startup). Each check produces a warning
+ * with the file path, what's wrong, and what to do about it.
+ *
+ * These are warnings, not errors — they don't block the build. The goal is
+ * to catch issues that would otherwise produce cryptic runtime behavior
+ * (silent 404s, empty pages, confusing React errors).
+ *
+ * Design doc: 07-routing.md, 10-error-handling.md
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import type { RouteTree, SegmentNode } from './types.js';
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface ConventionWarning {
+  /** Warning ID for deduplication and filtering. */
+  id: string;
+  /** Human-readable single-line summary. */
+  summary: string;
+  /** Multi-line details with file path and fix suggestion. */
+  details: string;
+  /** Severity: 'warn' for potential issues, 'error' for definite misconfigurations. */
+  level: 'warn' | 'error';
+}
+
+// ─── Lint Rules ─────────────────────────────────────────────────────────────
+
+/**
+ * Run all convention lint checks on a route tree.
+ *
+ * Returns an array of warnings. Empty array means everything looks good.
+ */
+export function lintConventions(tree: RouteTree, appDir: string): ConventionWarning[] {
+  const warnings: ConventionWarning[] = [];
+
+  // Check 1: app/ directory exists (caller should check before scanning,
+  // but we validate the root has at least one routable file)
+  checkEmptyApp(tree.root, appDir, warnings);
+
+  // Check 2: route.ts without recognized HTTP method exports
+  checkRouteExports(tree.root, warnings);
+
+  // Check 3: Segments with layout but no page/route anywhere in subtree
+  // (not a misconfiguration per se — layouts without pages are valid for
+  // route groups. Skip this check.)
+
+  // Check 4: Root segment has no layout.tsx (no HTML shell)
+  checkRootLayout(tree.root, warnings);
+
+  // Check 5: page.tsx / layout.tsx without default export
+  checkDefaultExports(tree.root, warnings);
+
+  return warnings;
+}
+
+// ─── Check: Empty App ───────────────────────────────────────────────────────
+
+/**
+ * Warn when the app/ directory has no routable files at all.
+ *
+ * This catches the "I created app/ but didn't add any pages" case where
+ * every request silently 404s with no guidance.
+ */
+function checkEmptyApp(root: SegmentNode, appDir: string, warnings: ConventionWarning[]): void {
+  if (hasAnyRoutable(root)) return;
+
+  warnings.push({
+    id: 'EMPTY_APP',
+    summary: 'No pages or route handlers found in app/',
+    details:
+      `  Directory: ${appDir}\n\n` +
+      '  Your app/ directory has no page.tsx or route.ts files.\n' +
+      '  Every request will return 404.\n\n' +
+      '  To fix: Create app/page.tsx with a default export:\n\n' +
+      '    export default function Home() {\n      return <h1>Hello</h1>;\n    }\n',
+    level: 'warn',
+  });
+}
+
+/**
+ * Check if a segment tree has any routable files (page or route) anywhere.
+ */
+function hasAnyRoutable(node: SegmentNode): boolean {
+  if (node.page || node.route) return true;
+  for (const child of node.children) {
+    if (hasAnyRoutable(child)) return true;
+  }
+  for (const [, slot] of node.slots) {
+    if (hasAnyRoutable(slot)) return true;
+  }
+  return false;
+}
+
+/**
+ * Check if a segment tree has any page files (not just route handlers).
+ * Used by checkRootLayout to avoid false positives for API-only apps (TIM-794).
+ * API-only apps (just route.ts handlers) don't need a root layout.
+ */
+function hasAnyPage(node: SegmentNode): boolean {
+  if (node.page) return true;
+  for (const child of node.children) {
+    if (hasAnyPage(child)) return true;
+  }
+  for (const [, slot] of node.slots) {
+    if (hasAnyPage(slot)) return true;
+  }
+  return false;
+}
+
+// ─── Check: Route Exports ───────────────────────────────────────────────────
+
+/** HTTP methods that route.ts can export. */
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+
+/**
+ * Pattern to detect named exports that look like HTTP method handlers.
+ * Matches: export function GET, export const GET, export async function POST, etc.
+ * Also matches: export { GET } or re-exports like export { GET } from './handler'.
+ *
+ * The re-export branch uses word boundaries (\b) around method names to avoid
+ * matching substrings (e.g. TARGET should not match GET). See TIM-795.
+ */
+const EXPORT_PATTERN = new RegExp(
+  `export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+(${HTTP_METHODS.join('|')})\\b` +
+    `|export\\s*\\{[^}]*\\b(${HTTP_METHODS.join('|')})\\b[^}]*\\}`
+);
+
+/**
+ * Warn when a route.ts file doesn't appear to export any recognized HTTP methods.
+ *
+ * Uses static analysis (regex on source text) — not module loading.
+ * This is intentionally conservative: it may miss complex re-exports but
+ * catches the common case of an empty route.ts or one with wrong export names.
+ */
+function checkRouteExports(node: SegmentNode, warnings: ConventionWarning[]): void {
+  if (node.route) {
+    const filePath = node.route.filePath;
+    try {
+      const source = readFileSync(filePath, 'utf-8');
+      if (!EXPORT_PATTERN.test(source)) {
+        // Check if there's a default export (common mistake)
+        const hasDefaultExport = /export\s+default\b/.test(source);
+        const hint = hasDefaultExport
+          ? '  It looks like you have a default export. route.ts uses named exports\n' +
+            '  for HTTP methods (GET, POST, etc.), not a default export.\n'
+          : '';
+
+        warnings.push({
+          id: 'ROUTE_NO_METHODS',
+          summary: `route.ts has no HTTP method exports: ${filePath}`,
+          details:
+            `  File: ${filePath}\n\n` +
+            '  route.ts files must export named HTTP method handlers.\n' +
+            '  Without them, the route matches but returns 405 Method Not Allowed.\n\n' +
+            hint +
+            '  Example:\n\n' +
+            '    export function GET(ctx: RouteContext) {\n' +
+            "      return Response.json({ hello: 'world' });\n" +
+            '    }\n',
+          level: 'warn',
+        });
+      }
+    } catch {
+      // Can't read the file — skip silently
+    }
+  }
+
+  // Recurse
+  for (const child of node.children) {
+    checkRouteExports(child, warnings);
+  }
+  for (const [, slot] of node.slots) {
+    checkRouteExports(slot, warnings);
+  }
+}
+
+// ─── Check: Root Layout ─────────────────────────────────────────────────────
+
+/**
+ * Warn when the root segment has no layout.tsx.
+ *
+ * Without a root layout, there's no HTML shell (<html>, <body>).
+ * The page will render but may have hydration issues or no proper document structure.
+ */
+function checkRootLayout(root: SegmentNode, warnings: ConventionWarning[]): void {
+  if (root.layout) return;
+
+  // Only warn if there are pages — API-only apps (just route.ts handlers)
+  // don't need a root layout (TIM-794).
+  if (!hasAnyPage(root)) return;
+
+  warnings.push({
+    id: 'NO_ROOT_LAYOUT',
+    summary: 'No root layout.tsx found',
+    details:
+      '  Your app has pages but no root layout.\n' +
+      '  Without app/layout.tsx, pages have no <html> or <body> wrapper.\n\n' +
+      '  To fix: Create app/layout.tsx:\n\n' +
+      '    export default function RootLayout({ children }: { children: React.ReactNode }) {\n' +
+      '      return (\n' +
+      '        <html lang="en">\n' +
+      '          <body>{children}</body>\n' +
+      '        </html>\n' +
+      '      );\n' +
+      '    }\n',
+    level: 'warn',
+  });
+}
+
+// ─── Check: Default Exports ───────────────────────────────────────────
+
+/**
+ * Pattern to detect a default export in source code.
+ * Matches: export default function, export default class, export default
+ * Also matches: export { X as default }, export { default } from './Impl'
+ *
+ * The third alternative catches bare `default` re-exports (TIM-790).
+ * The negative lookahead (?!\s+as\b) prevents matching `export { default as X }`
+ * which is a named export, not a default export (TIM-806).
+ */
+const DEFAULT_EXPORT_PATTERN =
+  /export\s+default\b|export\s*\{[^}]*\bas\s+default\b|export\s*\{[^}]*\bdefault\b(?!\s+as\b)[^}]*\}/;
+
+/**
+ * Warn when page.tsx or layout.tsx files don't have a default export.
+ *
+ * Without a default export:
+ * - page.tsx: the page renders nothing (empty content)
+ * - layout.tsx: the layout module loads but has no component to render
+ *
+ * Uses static analysis (regex on source text) — intentionally conservative.
+ */
+function checkDefaultExports(node: SegmentNode, warnings: ConventionWarning[]): void {
+  // Check page files (tsx/ts/jsx/js only — not mdx, which is default-exported by the mdx compiler)
+  if (node.page && isScriptExtension(node.page.extension)) {
+    checkFileDefaultExport(node.page.filePath, 'page', warnings);
+  }
+
+  // Check layout files
+  if (node.layout && isScriptExtension(node.layout.extension)) {
+    checkFileDefaultExport(node.layout.filePath, 'layout', warnings);
+  }
+
+  // Recurse
+  for (const child of node.children) {
+    checkDefaultExports(child, warnings);
+  }
+  for (const [, slot] of node.slots) {
+    checkDefaultExports(slot, warnings);
+  }
+}
+
+function isScriptExtension(ext: string): boolean {
+  return ext === 'tsx' || ext === 'ts' || ext === 'jsx' || ext === 'js';
+}
+
+function checkFileDefaultExport(
+  filePath: string,
+  fileType: string,
+  warnings: ConventionWarning[]
+): void {
+  try {
+    const source = readFileSync(filePath, 'utf-8');
+    if (!DEFAULT_EXPORT_PATTERN.test(source)) {
+      warnings.push({
+        id: `NO_DEFAULT_EXPORT:${filePath}`,
+        summary: `${fileType}.tsx has no default export: ${filePath}`,
+        details:
+          `  File: ${filePath}\n\n` +
+          `  ${fileType}.tsx files must export a default React component.\n` +
+          `  Without a default export, the ${fileType === 'page' ? 'page renders nothing' : 'layout has no component to wrap children'}.\n\n` +
+          `  To fix: Add a default export:\n\n` +
+          `    export default function My${fileType === 'page' ? 'Page' : 'Layout'}(${fileType === 'layout' ? '{ children }' : ''}) {\n` +
+          `      return ${fileType === 'layout' ? '<div>{children}</div>' : '<h1>Hello</h1>'};\n` +
+          `    }\n`,
+        level: 'warn',
+      });
+    }
+  } catch {
+    // Can't read file — skip silently
+  }
+}
+
+// ─── Check: App Directory Exists ────────────────────────────────────────────
+
+/**
+ * Check if the app/ directory exists. Called before scanning.
+ * Returns a warning if missing, or null if the directory exists.
+ */
+export function checkAppDirExists(appDir: string): ConventionWarning | null {
+  if (existsSync(appDir)) return null;
+
+  return {
+    id: 'NO_APP_DIR',
+    summary: 'No app/ directory found',
+    details:
+      `  Expected: ${appDir}\n\n` +
+      '  timber.js requires an app/ directory for file-system routing.\n' +
+      '  Every request will return 404 until you create it.\n\n' +
+      '  To fix: Create the app/ directory with a page:\n\n' +
+      '    mkdir -p app\n' +
+      '    # Create app/layout.tsx and app/page.tsx\n',
+    level: 'error',
+  };
+}
+
+// ─── Formatting ─────────────────────────────────────────────────────────────
+
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+/**
+ * Format warnings for terminal output.
+ *
+ * Groups by severity, uses colors, and includes fix suggestions.
+ */
+export function formatConventionWarnings(warnings: ConventionWarning[]): string {
+  if (warnings.length === 0) return '';
+
+  const errors = warnings.filter((w) => w.level === 'error');
+  const warns = warnings.filter((w) => w.level === 'warn');
+
+  const lines: string[] = [];
+
+  if (errors.length > 0) {
+    lines.push(
+      `${RED}${BOLD}[timber]${RESET} ${RED}${errors.length} configuration error${errors.length !== 1 ? 's' : ''}:${RESET}`
+    );
+    for (const e of errors) {
+      lines.push('');
+      lines.push(`  ${RED}✗${RESET} ${e.summary}`);
+      lines.push(`${DIM}${e.details}${RESET}`);
+    }
+  }
+
+  if (warns.length > 0) {
+    if (errors.length > 0) lines.push('');
+    lines.push(
+      `${YELLOW}${BOLD}[timber]${RESET} ${YELLOW}${warns.length} configuration warning${warns.length !== 1 ? 's' : ''}:${RESET}`
+    );
+    for (const w of warns) {
+      lines.push('');
+      lines.push(`  ${YELLOW}⚠${RESET} ${w.summary}`);
+      lines.push(`${DIM}${w.details}${RESET}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/routing/index.ts

@@ -12,3 +12,5 @@ export type {
 export { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS } from './types.js';
 export { collectInterceptionRewrites } from './interception.js';
 export type { InterceptionRewrite } from './interception.js';
+export { classifyUrlSegment } from './segment-classify.js';
+export type { UrlSegment } from './segment-classify.js';

package/src/routing/scanner.ts

@@ -18,8 +18,9 @@ import type {
   ScannerConfig,
   InterceptionMarker,
 } from './types.js';
+import { classifyUrlSegment } from './segment-classify.js';
 import { DEFAULT_PAGE_EXTENSIONS, INTERCEPTION_MARKERS } from './types.js';
-import { classifyMetadataRoute, isDynamicMetadataExtension } from '#/server/metadata-routes.js';
+import { classifyMetadataRoute, isDynamicMetadataExtension } from '../server/metadata-routes.js';
 
 /**
  * Pattern matching encoded path delimiters that must be rejected during route discovery.
@@ -53,7 +54,7 @@ const LEGACY_STATUS_FILES: Record<string, number> = {
 /**
  * File convention names that are always .ts/.tsx (never .mdx etc.)
  */
-const FIXED_CONVENTIONS = new Set(['middleware', 'access', 'route', 'prerender', 'search-params']);
+const FIXED_CONVENTIONS = new Set(['middleware', 'access', 'route', 'params']);
 
 /**
  * Status-code file patterns:
@@ -83,6 +84,14 @@ export function scanRoutes(appDir: string, config: ScannerConfig = {}): RouteTre
     tree.proxy = proxyFile;
   }
 
+  // Check for global-error.{tsx,ts,jsx,js} at app root.
+  // Tier 2 error page — renders standalone (no layouts) when no segment-level
+  // error file is found. See design/10-error-handling.md §"Tier 2".
+  const globalErrorFile = findPageExtFile(appDir, 'global-error', extSet);
+  if (globalErrorFile) {
+    tree.globalError = globalErrorFile;
+  }
+
   // Scan the root directory's files
   scanSegmentFiles(appDir, tree.root, extSet);
 
@@ -92,6 +101,10 @@ export function scanRoutes(appDir: string, config: ScannerConfig = {}): RouteTre
   // Validate: detect route group collisions (different groups producing pages at the same URL)
   validateRouteGroupCollisions(tree.root);
 
+  // Validate: detect duplicate param names in nested dynamic segments
+  // e.g., /[id]/items/[id] — same param name in ancestor and descendant
+  validateDuplicateParamNames(tree.root);
+
   return tree;
 }
 
@@ -153,22 +166,12 @@ export function classifySegment(dirName: string): {
     return { type: 'group' };
   }
 
-  // Optional catch-all: [[...name]]
-  if (dirName.startsWith('[[...') && dirName.endsWith(']]')) {
-    const paramName = dirName.slice(5, -2);
-    return { type: 'optional-catch-all', paramName };
-  }
-
-  // Catch-all: [...name]
-  if (dirName.startsWith('[...') && dirName.endsWith(']')) {
-    const paramName = dirName.slice(4, -1);
-    return { type: 'catch-all', paramName };
-  }
-
-  // Dynamic: [name]
-  if (dirName.startsWith('[') && dirName.endsWith(']')) {
-    const paramName = dirName.slice(1, -1);
-    return { type: 'dynamic', paramName };
+  // Bracket-syntax segments: [param], [...param], [[...param]]
+  // Delegated to the shared character-based classifier. If you change
+  // bracket syntax, update segment-classify.ts — not here.
+  const urlSeg = classifyUrlSegment(dirName);
+  if (urlSeg.kind !== 'static') {
+    return { type: urlSeg.kind, paramName: urlSeg.name };
   }
 
   return { type: 'static' };
@@ -278,11 +281,8 @@ function scanSegmentFiles(dirPath: string, node: SegmentNode, extSet: Set<string
         case 'route':
           node.route = file;
           break;
-        case 'prerender':
-          node.prerender = file;
-          break;
-        case 'search-params':
-          node.searchParams = file;
+        case 'params':
+          node.params = file;
           break;
       }
       continue;
@@ -482,6 +482,54 @@ function collectRoutableLeaves(
   }
 }
 
+/**
+ * Validate that no route chain contains duplicate dynamic param names.
+ *
+ * Example violation:
+ *   app/[id]/items/[id]/page.tsx — 'id' appears twice in the ancestor chain.
+ *
+ * Route groups are transparent — params accumulate through them.
+ * Slots are independent — duplicate detection does NOT cross slot boundaries.
+ *
+ * See design/07-routing.md §"Duplicate Param Name Detection"
+ */
+function validateDuplicateParamNames(root: SegmentNode): void {
+  walkForDuplicateParams(root, new Map());
+}
+
+/**
+ * Recursively walk the segment tree, tracking seen param names → segment paths.
+ * Throws on the first duplicate found.
+ */
+function walkForDuplicateParams(node: SegmentNode, seen: Map<string, string>): void {
+  // If this node introduces a param name, check for duplicates
+  if (node.paramName) {
+    const existing = seen.get(node.paramName);
+    if (existing) {
+      throw new Error(
+        `[timber] Duplicate param name '${node.paramName}' in route chain.\n` +
+          `  First defined at: ${existing}\n` +
+          `  Duplicate at: ${node.urlPath || '/'}\n` +
+          `  Rename one of the segments to avoid ambiguity.`
+      );
+    }
+    // Add to seen for descendants (use a new Map to avoid polluting siblings)
+    seen = new Map(seen);
+    seen.set(node.paramName, node.urlPath || '/');
+  }
+
+  // Recurse into children (they inherit the accumulated params)
+  for (const child of node.children) {
+    walkForDuplicateParams(child, seen);
+  }
+
+  // Slots are independent parallel routes — start fresh param tracking
+  // (a slot's params don't conflict with the main route's params)
+  for (const [, slotNode] of node.slots) {
+    walkForDuplicateParams(slotNode, new Map(seen));
+  }
+}
+
 /**
  * Find a fixed-extension file (proxy.ts) in a directory.
  */
@@ -498,3 +546,25 @@ function findFixedFile(dirPath: string, name: string): RouteFile | undefined {
   }
   return undefined;
 }
+
+/**
+ * Find a file using the configured page extensions (tsx, ts, jsx, js, mdx, etc.).
+ * Used for app-root conventions like global-error that aren't per-segment.
+ */
+function findPageExtFile(
+  dirPath: string,
+  name: string,
+  extSet: Set<string>
+): RouteFile | undefined {
+  for (const ext of extSet) {
+    const fullPath = join(dirPath, `${name}.${ext}`);
+    try {
+      if (statSync(fullPath).isFile()) {
+        return { filePath: fullPath, extension: ext };
+      }
+    } catch {
+      // File doesn't exist
+    }
+  }
+  return undefined;
+}

package/src/routing/segment-classify.ts

@@ -0,0 +1,89 @@
+/**
+ * Shared URL segment classifier.
+ *
+ * Single-pass character parser that classifies a route segment token
+ * (e.g. "dashboard", "[id]", "[...slug]", "[[...path]]") into a typed
+ * discriminated union. Used by both server-side routing and client-side
+ * Link interpolation.
+ *
+ * NO regex. NO Node.js-only APIs. Safe to import from browser code.
+ *
+ * Malformed input (unclosed brackets, empty names, etc.) falls through
+ * to { kind: 'static' } — the safe default.
+ *
+ * If you change the bracket syntax, update ONLY this file. Every
+ * consumer imports from here.
+ *
+ * See design/07-routing.md §"Route Segments"
+ */
+
+export type UrlSegment =
+  | { kind: 'static'; value: string }
+  | { kind: 'dynamic'; name: string }
+  | { kind: 'catch-all'; name: string }
+  | { kind: 'optional-catch-all'; name: string };
+
+/**
+ * Classify a URL path segment token.
+ *
+ * Walks the string left-to-right in one pass:
+ *   1. If it doesn't start with '[', it's static.
+ *   2. Count opening brackets (1 or 2) to detect optional.
+ *   3. Check for '...' to detect catch-all.
+ *   4. Read the param name up to the closing bracket.
+ *   5. Validate the expected closing sequence (']' or ']]').
+ *   6. Reject if there are leftover characters after the close.
+ *
+ * Any structural violation → static (safe default).
+ */
+export function classifyUrlSegment(token: string): UrlSegment {
+  const len = token.length;
+
+  // Must start with '[' to be dynamic
+  if (len === 0 || token[0] !== '[') {
+    return { kind: 'static', value: token };
+  }
+
+  let i = 1;
+
+  // Check for optional: '[[...'
+  const optional = token[i] === '[';
+  if (optional) i++;
+
+  // Check for catch-all: '...'
+  const catchAll = i + 2 < len && token[i] === '.' && token[i + 1] === '.' && token[i + 2] === '.';
+  if (catchAll) i += 3;
+
+  // Read param name — everything up to ']'
+  const nameStart = i;
+  while (i < len && token[i] !== ']') i++;
+
+  // Must have found a ']' and name must be non-empty
+  if (i >= len || i === nameStart) {
+    return { kind: 'static', value: token };
+  }
+
+  const name = token.slice(nameStart, i);
+  i++; // skip first ']'
+
+  // Optional requires a second ']'
+  if (optional) {
+    if (i >= len || token[i] !== ']') {
+      return { kind: 'static', value: token };
+    }
+    i++;
+  }
+
+  // Must be at end of string — no trailing characters
+  if (i !== len) {
+    return { kind: 'static', value: token };
+  }
+
+  if (optional && catchAll) return { kind: 'optional-catch-all', name };
+  if (catchAll) return { kind: 'catch-all', name };
+  if (optional) {
+    // '[[name]]' without '...' is malformed — not a valid segment syntax
+    return { kind: 'static', value: token };
+  }
+  return { kind: 'dynamic', name };
+}

package/src/routing/status-file-lint.ts

@@ -15,7 +15,7 @@
 
 import { readFileSync } from 'node:fs';
 import type { RouteTree, SegmentNode } from './types.js';
-import { detectFileDirective } from '#/utils/directive-parser.js';
+import { detectFileDirective } from '../utils/directive-parser.js';
 
 /** Extensions that require 'use client' (component files, not MDX/JSON). */
 const CLIENT_REQUIRED_EXTENSIONS = new Set(['tsx', 'jsx', 'ts', 'js']);
@@ -31,7 +31,8 @@ export interface StatusFileLintWarning {
  * that are missing it.
  *
  * MDX and JSON status files are excluded — MDX files are server components
- * by design, and JSON files are data, not components.
+ * by design (pre-rendered as elements via fallbackElement, see TIM-503),
+ * and JSON files are data, not components.
  */
 export function lintStatusFileDirectives(tree: RouteTree): StatusFileLintWarning[] {
   const warnings: StatusFileLintWarning[] = [];

package/src/routing/types.ts

@@ -59,6 +59,12 @@ export interface SegmentNode {
   middleware?: RouteFile;
   access?: RouteFile;
   route?: RouteFile;
+  /**
+   * params.ts — isomorphic convention file exporting segmentParams and/or searchParams.
+   * Discovered by the scanner like middleware.ts and access.ts.
+   * See design/07-routing.md §"params.ts Convention File"
+   */
+  params?: RouteFile;
   error?: RouteFile;
   default?: RouteFile;
   /** Status-code files: 4xx.tsx, 5xx.tsx, {status}.tsx (component format) */
@@ -69,10 +75,7 @@ export interface SegmentNode {
   denied?: RouteFile;
   /** Legacy compat: not-found.tsx (maps to 404), forbidden.tsx (403), unauthorized.tsx (401) */
   legacyStatusFiles?: Map<string, RouteFile>;
-  /** prerender.ts — signals build-time pre-rendering for this segment's shell */
-  prerender?: RouteFile;
-  /** search-params.ts — typed search params definition for this route */
-  searchParams?: RouteFile;
+
   /** Metadata route files (sitemap.ts, robots.ts, icon.tsx, etc.) keyed by base name */
   metadataRoutes?: Map<string, RouteFile>;
 
@@ -88,6 +91,16 @@ export interface RouteTree {
   root: SegmentNode;
   /** All discovered proxy.ts files (should be at most one, in app/) */
   proxy?: RouteFile;
+  /**
+   * Global error page: app/global-error.{tsx,ts,jsx,js}
+   *
+   * Rendered as a standalone full-page replacement (no layout wrapping)
+   * when no segment-level error file is found. SSR-only render path.
+   * Must provide its own <html> and <body>.
+   *
+   * See design/10-error-handling.md §"Tier 2 — Global Error Page"
+   */
+  globalError?: RouteFile;
 }
 
 /** Configuration passed to the scanner */

package/src/rsc-runtime/rsc.ts

@@ -16,4 +16,6 @@ export {
   loadServerAction,
   decodeReply,
   decodeAction,
+  encryptActionBoundArgs,
+  decryptActionBoundArgs,
 } from '@vitejs/plugin-rsc/rsc';