@timber-js/app 0.2.0-alpha.158 → 0.2.0-alpha.159

package/src/plugins/prerender-sugar.ts

@@ -0,0 +1,329 @@
+/**
+ * timber-prerender-sugar — Vite plugin that desugars `export const prerender`
+ * on page and layout files into `cache.component(...)` wrappers.
+ *
+ * Design doc: design/45-cache-lifetimes.md §"Route-Level Static" and
+ * §"Layout Propagation".
+ *
+ * `export const prerender = true` on a page is pure sugar: it desugars to
+ * wrapping the page's default export in `timber.cache.component(Component,
+ * { prerender: true })`. Layout propagation cascades a layout's
+ * `export const prerender` to descendant pages via most-specific-wins:
+ * walk the segment tree from leaf to root, first explicit value wins.
+ *
+ * A layout that declares `export const prerender` is ALSO wrapped — the
+ * layout's flight payload is its own static shell (`children` is a
+ * separate component boundary), so caching it is natural (nav, sidebar,
+ * footer benefit from build-time rendering). See design/45 §Layout
+ * Propagation.
+ *
+ * This transform runs BEFORE timber-prebuilt so the generated
+ * `cache.component(...)` call is picked up by the callsite rewrite.
+ */
+
+import MagicString from 'magic-string';
+import { parseAst } from 'vite';
+import type { Plugin } from 'vite';
+import type { PluginContext } from '../plugin-context.js';
+import type { SegmentNode, RouteFile } from '../routing/types.js';
+import { getPrerenderExport, type PrerenderExportValue } from '../routing/export-detect.js';
+
+interface AstNode {
+  type: string;
+  start: number;
+  end: number;
+  name?: string;
+  declaration?: AstNode;
+  id?: AstNode & { name?: string };
+  expression?: AstNode;
+}
+
+/**
+ * Walk the segment tree and resolve the effective prerender value for
+ * every page and layout. Returns a map from file path to resolved value.
+ *
+ * **Pages:** walk from leaf toward root; first explicit `export const prerender`
+ * wins (page > nearest layout > ... > root layout). If none, dynamic.
+ *
+ * **Layouts:** a layout that declares `export const prerender` is wrapped
+ * directly (its own shell is a separate component boundary from `children`).
+ * Layouts without their own declaration are NOT wrapped — they don't
+ * inherit from ancestors, because wrapping a layout's shell without the
+ * author's explicit opt-in would cache content they may expect to be dynamic.
+ */
+export function resolvePagePrerender(root: SegmentNode): Map<string, PrerenderExportValue> {
+  const result = new Map<string, PrerenderExportValue>();
+
+  function walk(node: SegmentNode, ancestorStack: PrerenderExportValue[]) {
+    if (node.segmentType === 'intercepting' || node.segmentType === 'private') return;
+
+    // Check this segment's layout for a prerender export
+    const layoutValue = node.layout ? getPrerenderExport(node.layout.filePath) : undefined;
+    const stack = layoutValue !== undefined ? [layoutValue, ...ancestorStack] : ancestorStack;
+
+    // Wrap the layout itself if it declares prerender (truthy)
+    if (node.layout && layoutValue !== undefined && layoutValue !== false) {
+      result.set(node.layout.filePath, layoutValue);
+    }
+
+    if (node.page) {
+      const pageValue = getPrerenderExport(node.page.filePath);
+      // Page's own value takes priority; otherwise use nearest ancestor
+      const resolved = pageValue !== undefined ? pageValue : stack[0];
+      // Only record if the resolved value is truthy (prerender: true or options object)
+      // prerender: false explicitly opts out
+      if (resolved !== undefined && resolved !== false) {
+        result.set(node.page.filePath, resolved);
+      }
+    }
+
+    for (const child of node.children) walk(child, stack);
+    for (const slot of Object.values(node.slots)) walk(slot, stack);
+  }
+
+  walk(root, []);
+  return result;
+}
+
+/**
+ * Build the `cache.component` options source text from a resolved value.
+ */
+function buildOptionsSource(value: PrerenderExportValue): string {
+  if (value === true) return '{ prerender: true }';
+  if (typeof value === 'object') {
+    const parts = ['prerender: true'];
+    if (value.ttl !== undefined) parts.push(`ttl: ${value.ttl}`);
+    if (value.tags !== undefined) parts.push(`tags: ${JSON.stringify(value.tags)}`);
+    return `{ ${parts.join(', ')} }`;
+  }
+  return '{ prerender: true }';
+}
+
+/**
+ * Find the default export in the AST and return info needed for the rewrite.
+ */
+interface DefaultExportInfo {
+  kind: 'declaration' | 'expression' | 'identifier';
+  node: AstNode;
+  name?: string;
+  /** For `export { X as default, Y }` — position of the default specifier. */
+  specifierIndex?: number;
+  specifierCount?: number;
+  specifierStart?: number;
+  specifierEnd?: number;
+}
+
+function findDefaultExport(program: { body: AstNode[] }, source: string): DefaultExportInfo | null {
+  for (const stmt of program.body) {
+    if (stmt.type !== 'ExportDefaultDeclaration' || !stmt.declaration) continue;
+    const decl = stmt.declaration;
+
+    // export default function Name(...) { ... }
+    // export default class Name { ... }
+    if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+      const name = decl.id?.name;
+      if (name) return { kind: 'declaration', node: stmt, name };
+      // Anonymous function/class — treat as expression
+      return { kind: 'expression', node: stmt };
+    }
+
+    // export default SomeIdentifier
+    if (decl.type === 'Identifier') {
+      return { kind: 'identifier', node: stmt, name: decl.name };
+    }
+
+    // export default <expression>
+    return { kind: 'expression', node: stmt };
+  }
+
+  // Check for `export { X as default }` (not re-exports from other modules)
+  for (const stmt of program.body) {
+    if (stmt.type !== 'ExportNamedDeclaration') continue;
+    // Skip re-exports: `export { X as default } from './other'`
+    if ((stmt as any).source) continue;
+    const specifiers = (stmt as any).specifiers as
+      | Array<{
+          type: string;
+          start: number;
+          end: number;
+          local?: { name: string };
+          exported?: { name: string };
+        }>
+      | undefined;
+    if (!specifiers) continue;
+    for (let i = 0; i < specifiers.length; i++) {
+      const spec = specifiers[i];
+      if (spec.exported?.name === 'default' && spec.local?.name && spec.local.name !== 'default') {
+        return {
+          kind: 'identifier' as const,
+          node: stmt,
+          name: spec.local.name,
+          specifierIndex: i,
+          specifierCount: specifiers.length,
+          specifierStart: spec.start,
+          specifierEnd: spec.end,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+export function timberPrerenderSugar(ctx: PluginContext): Plugin {
+  let resolvedPages: Map<string, PrerenderExportValue> | null = null;
+
+  function ensureResolved() {
+    if (resolvedPages) return;
+    if (!ctx.routeTree) {
+      resolvedPages = new Map();
+      return;
+    }
+    resolvedPages = resolvePagePrerender(ctx.routeTree.root);
+  }
+
+  return {
+    name: 'timber-prerender-sugar',
+
+    buildStart() {
+      // Reset on each build (watch mode rebuilds)
+      resolvedPages = null;
+    },
+
+    transform(code, id) {
+      // Only process in RSC environment (same gate as prebuilt.ts)
+      if (this?.environment?.name === 'client') return;
+      // Skip node_modules
+      if (id.includes('node_modules')) return;
+
+      ensureResolved();
+      if (!resolvedPages || resolvedPages.size === 0) return;
+
+      const value = resolvedPages.get(id);
+      if (!value) return;
+
+      // This page has a resolved prerender value — wrap its default export
+      let program: { body: AstNode[] };
+      try {
+        program = parseAst(code, { lang: 'tsx' }) as unknown as { body: AstNode[] };
+      } catch {
+        return;
+      }
+
+      const defaultExport = findDefaultExport(program, code);
+      if (!defaultExport) {
+        // Warn if the file has a prerender export but no wrappable default export
+        // (e.g. `export { default } from './impl'` — a re-export we can't rewrite).
+        if (value) {
+          const relPath = id.replace(ctx.root + '/', '');
+          console.warn(
+            `[timber] ${relPath}: export const prerender is declared but the default ` +
+              `export cannot be wrapped (re-export or missing). The prerender declaration ` +
+              `will be ignored for this file.`
+          );
+        }
+        return;
+      }
+
+      // Skip if the default export is already a cache.component(...) call —
+      // avoid double-wrapping. Only check the default export itself, not the
+      // whole file (a page may use cache.component for child components).
+      if (defaultExport.kind === 'expression' && defaultExport.node.declaration) {
+        const declText = code.slice(
+          defaultExport.node.declaration.start,
+          defaultExport.node.declaration.end
+        );
+        if (declText.includes('.component(')) return;
+      }
+
+      // Record this page as desugared for downstream attribution
+      ctx.prerenderSugarPages ??= new Set();
+      ctx.prerenderSugarPages.add(id);
+
+      const s = new MagicString(code);
+      const optionsSource = buildOptionsSource(value);
+
+      // Add the cache import at the top (after directives)
+      const importAlias = '__timber_prerender_cache__';
+      let insertOffset = 0;
+      for (const stmt of program.body) {
+        const isDirective =
+          stmt.type === 'ExpressionStatement' && typeof (stmt as any).directive === 'string';
+        if (!isDirective) {
+          insertOffset = stmt.start;
+          break;
+        }
+      }
+      s.appendLeft(
+        insertOffset,
+        `import { cache as ${importAlias} } from '@timber-js/app/cache';\n`
+      );
+
+      switch (defaultExport.kind) {
+        case 'declaration': {
+          // `export default function Name() { ... }`
+          // → `function Name() { ... }` + `export default cache.component(Name, opts)`
+          const declStart = defaultExport.node.declaration!.start;
+          // Remove `export default ` prefix
+          s.overwrite(defaultExport.node.start, declStart, '');
+          // Append the wrapped export at the end
+          s.append(
+            `\nexport default ${importAlias}.component(${defaultExport.name}, ${optionsSource});\n`
+          );
+          break;
+        }
+        case 'identifier': {
+          if (defaultExport.specifierCount !== undefined && defaultExport.specifierCount > 1) {
+            // Multi-specifier: `export { Page as default, generateStaticSegmentParams }`
+            // Remove only the default specifier + surrounding comma, keep others.
+            const specStart = defaultExport.specifierStart!;
+            const specEnd = defaultExport.specifierEnd!;
+            const idx = defaultExport.specifierIndex!;
+            // Remove the specifier and a comma (trailing if first, leading otherwise)
+            if (idx === 0) {
+              // First specifier: remove text up to (but not including) the next specifier start
+              const nextSpec = (defaultExport.node as any).specifiers?.[1];
+              if (nextSpec) s.remove(specStart, nextSpec.start);
+            } else {
+              // Not first: remove from end of previous specifier to this specifier's end
+              const prevSpec = (defaultExport.node as any).specifiers?.[idx - 1];
+              if (prevSpec) s.remove(prevSpec.end, specEnd);
+            }
+            // Append the wrapped default export separately
+            s.appendLeft(
+              defaultExport.node.end,
+              `\nexport default ${importAlias}.component(${defaultExport.name}, ${optionsSource});`
+            );
+          } else {
+            // `export default MyPage` or `export { MyPage as default }` (sole specifier)
+            // → `export default cache.component(MyPage, opts)`
+            s.overwrite(
+              defaultExport.node.start,
+              defaultExport.node.end,
+              `export default ${importAlias}.component(${defaultExport.name}, ${optionsSource});`
+            );
+          }
+          break;
+        }
+        case 'expression': {
+          // `export default () => <div/>` or `export default async function() { ... }`
+          // → `const __default = ...; export default cache.component(__default, opts)`
+          const decl = defaultExport.node.declaration!;
+          s.overwrite(defaultExport.node.start, decl.start, 'const __timber_default_page__ = ');
+          // Ensure trailing semicolon
+          const afterExpr = code.charAt(defaultExport.node.end - 1) === ';' ? '' : ';';
+          s.appendLeft(
+            defaultExport.node.end,
+            `${afterExpr}\nexport default ${importAlias}.component(__timber_default_page__, ${optionsSource});`
+          );
+          break;
+        }
+      }
+
+      return {
+        code: s.toString(),
+        map: s.generateMap({ hires: 'boundary' }),
+      };
+    },
+  };
+}

package/src/plugins/server-bundle.ts

@@ -36,8 +36,18 @@ const NODE_BUILTINS: string[] = builtinModules.flatMap((m) => [m, `node:${m}`]);
 //     in a server bundle.
 //
 // Mirrored on both rsc and ssr environments. See TIM-988.
+// Cloudflare runtime modules (cloudflare:workers, cloudflare:sockets, etc.)
+// available at runtime on Workers but must not be bundled.
+const CLOUDFLARE_BUILTINS = [
+  'cloudflare:workers',
+  'cloudflare:sockets',
+  'cloudflare:email',
+  'cloudflare:workflows',
+];
+
 const BUILD_ONLY_EXTERNALS: string[] = [
   ...NODE_BUILTINS,
+  ...CLOUDFLARE_BUILTINS,
   'vite',
   'nitro',
   'rollup',
@@ -114,10 +124,12 @@ export function timberServerBundle(): Plugin[] {
         environments: {
           rsc: {
             resolve: { noExternal: true, external: BUILD_ONLY_EXTERNALS },
+            build: { rolldownOptions: { external: [/^cloudflare:/] } },
             define: serverDefine,
           },
           ssr: {
             resolve: { noExternal: true, external: BUILD_ONLY_EXTERNALS },
+            build: { rolldownOptions: { external: [/^cloudflare:/] } },
             define: serverDefine,
           },
         },

package/src/plugins/shims.ts

@@ -57,6 +57,15 @@ export const SUBPATH_SRC_MAP: Record<string, string> = {
   'search-params': 'search-params/index.ts',
   'segment-params': 'segment-params/index.ts',
 
+  'cache/stores/memory': 'cache/stores/memory.ts',
+  'cache/stores/redis': 'cache/stores/redis.ts',
+  'cache/stores/cloudflare-kv': 'cache/stores/cloudflare-kv.ts',
+  'cache/stores/vercel': 'cache/stores/vercel.ts',
+
+  'cdn': 'cdn/index.ts',
+  'cdn/cloudflare': 'cdn/cloudflare-purge.ts',
+  'cdn/fastly': 'cdn/fastly-purge.ts',
+
   'adapters/cloudflare': 'adapters/cloudflare.ts',
   'adapters/cloudflare/cache': 'adapters/cloudflare-kv-cache.ts',
   'adapters/cloudflare/dev': 'adapters/cloudflare-dev.ts',

package/src/plugins/static-build.ts

@@ -95,7 +95,6 @@ export function timberStaticBuild(ctx: PluginContext): Plugin {
      *
      * In static mode, we check every app/ file for:
      * - Dynamic API usage (getCookies(), getHeaders()) → build error
-     * - When client JS disabled: 'use client' / 'use server' directives → build error
      */
     transform(code: string, id: string) {
       // Read ctx.config lazily inside the hook — not at plugin construction

package/src/routing/codegen.ts

@@ -18,7 +18,7 @@ import {
   emitResolveSegmentFieldHelper,
   formatSearchParamsType,
 } from './codegen-shared.js';
-import { readFileCached } from './file-cache.js';
+import { fileHasExport } from './export-detect.js';
 import { formatLinkCatchAllOverloads, formatTypedLinkOverloads } from './link-codegen.js';
 
 /** Options for route map generation. */
@@ -249,26 +249,6 @@ function paramTypeForSegment(segmentType: string): ParamEntry['type'] {
   }
 }
 
-/**
- * Check if a file exports a specific named export.
- *
- * Uses a lightweight regex check — not full AST parsing. The actual type
- * extraction happens via the TypeScript compiler in the generated .d.ts.
- */
-function fileHasExport(filePath: string, exportName: string): boolean {
-  if (!existsSync(filePath)) return false;
-  try {
-    const content = readFileCached(filePath);
-    const e = exportName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return (
-      new RegExp(`export\\s+(const|let|var)\\s+${e}\\b`).test(content) ||
-      new RegExp(`export\\s*\\{[^}]*\\b${e}\\b[^}]*\\}`).test(content)
-    );
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Find a legacy `segmentParams` export on layout.tsx or page.tsx.
  *

package/src/routing/convention-lint.ts

@@ -14,7 +14,12 @@
 import { existsSync } from 'node:fs';
 import type { RouteTree, SegmentNode } from './types.js';
 import { swallow } from '../server/logger.js';
-import { readFileCached } from './file-cache.js';
+import {
+  fileHasAnyExport,
+  fileHasDefaultExport,
+  fileHasDirective,
+  fileHasStarExport,
+} from './export-detect.js';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -56,6 +61,12 @@ export function lintConventions(tree: RouteTree, appDir: string): ConventionWarn
   // Check 5: page.tsx / layout.tsx without default export
   checkDefaultExports(tree.root, warnings);
 
+  // Check 6: error.tsx / global-error.tsx without 'use client' directive
+  checkErrorDirectives(tree.root, warnings);
+  if (tree.globalError && isScriptExtension(tree.globalError.extension)) {
+    checkFileUseClientDirective(tree.globalError.filePath, 'global-error', warnings);
+  }
+
   return warnings;
 }
 
@@ -116,37 +127,23 @@ function hasAnyPage(node: SegmentNode): boolean {
 // ─── 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[^}]*\\}`
-);
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] as const;
 
 /**
  * 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.
+ * Uses AST-based detection via parseAst for precise matching.
+ * Falls back silently when the file can't be parsed (syntax errors produce
+ * no spurious warning — the TS compiler will catch those).
  */
 function checkRouteExports(node: SegmentNode, warnings: ConventionWarning[]): void {
   if (node.route) {
     const filePath = node.route.filePath;
     try {
-      const source = readFileCached(filePath);
-      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
+      const methods = fileHasAnyExport(filePath, HTTP_METHODS);
+      if (methods.size === 0 && !fileHasStarExport(filePath)) {
+        const hasDefault = fileHasDefaultExport(filePath);
+        const hint = hasDefault
           ? '  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'
           : '';
@@ -215,18 +212,6 @@ function checkRootLayout(root: SegmentNode, warnings: ConventionWarning[]): void
 
 // ─── 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.
  *
@@ -234,7 +219,8 @@ const DEFAULT_EXPORT_PATTERN =
  * - 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.
+ * Uses AST-based detection via parseAst for precise matching. Falls back
+ * silently when the file can't be parsed (no spurious warning on syntax errors).
  */
 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)
@@ -266,8 +252,7 @@ function checkFileDefaultExport(
   warnings: ConventionWarning[]
 ): void {
   try {
-    const source = readFileCached(filePath);
-    if (!DEFAULT_EXPORT_PATTERN.test(source)) {
+    if (!fileHasDefaultExport(filePath)) {
       warnings.push({
         id: `NO_DEFAULT_EXPORT:${filePath}`,
         summary: `${fileType}.tsx has no default export: ${filePath}`,
@@ -287,6 +272,56 @@ function checkFileDefaultExport(
   }
 }
 
+// ─── Check: Error Directive ─────────────────────────────────────────────────
+
+/**
+ * Warn when error.tsx or global-error.tsx is missing 'use client'.
+ *
+ * React's error boundary API requires client components. Without the directive,
+ * the error boundary silently fails — the component renders as a server component
+ * with no error catching. Users discover this only via cryptic runtime errors.
+ */
+function checkErrorDirectives(node: SegmentNode, warnings: ConventionWarning[]): void {
+  if (node.error && isScriptExtension(node.error.extension)) {
+    checkFileUseClientDirective(node.error.filePath, 'error', warnings);
+  }
+
+  for (const child of node.children) {
+    checkErrorDirectives(child, warnings);
+  }
+  for (const slot of Object.values(node.slots)) {
+    checkErrorDirectives(slot, warnings);
+  }
+}
+
+function checkFileUseClientDirective(
+  filePath: string,
+  fileType: string,
+  warnings: ConventionWarning[]
+): void {
+  try {
+    if (!fileHasDirective(filePath, 'use client')) {
+      warnings.push({
+        id: `ERROR_NO_USE_CLIENT:${filePath}`,
+        summary: `${fileType}.tsx is missing 'use client': ${filePath}`,
+        details:
+          `  File: ${filePath}\n\n` +
+          `  ${fileType}.tsx must start with 'use client' because React error\n` +
+          '  boundaries require client components. Without it, the error boundary\n' +
+          '  silently fails and errors are uncaught.\n\n' +
+          "  To fix: Add 'use client' as the first line of the file:\n\n" +
+          "    'use client';\n\n" +
+          `    export default function ${fileType === 'global-error' ? 'GlobalError' : 'ErrorBoundary'}({ error, reset }) {\n` +
+          '      return <div><h2>Something went wrong</h2><button onClick={reset}>Try again</button></div>;\n' +
+          '    }\n',
+        level: 'warn',
+      });
+    }
+  } catch (err) {
+    swallow(err, `convention-lint: unreadable ${fileType} file ${filePath}`);
+  }
+}
+
 // ─── Check: App Directory Exists ────────────────────────────────────────────
 
 /**
@@ -312,11 +347,12 @@ export function checkAppDirExists(appDir: string): ConventionWarning | null {
 
 // ─── Formatting ─────────────────────────────────────────────────────────────
 
-const YELLOW = '\x1b[33m';
-const RED = '\x1b[31m';
-const BOLD = '\x1b[1m';
-const DIM = '\x1b[2m';
-const RESET = '\x1b[0m';
+import type { InspectColor } from 'node:util';
+import { styleText } from 'node:util';
+
+type Format = InspectColor | readonly InspectColor[];
+const noValidate = { validateStream: false } as const;
+const style = (fmt: Format, text: string) => styleText(fmt, text, noValidate);
 
 /**
  * Format warnings for terminal output.
@@ -333,24 +369,24 @@ export function formatConventionWarnings(warnings: ConventionWarning[]): string
 
   if (errors.length > 0) {
     lines.push(
-      `${RED}${BOLD}[timber]${RESET} ${RED}${errors.length} configuration error${errors.length !== 1 ? 's' : ''}:${RESET}`
+      `${style(['red', 'bold'], '[timber]')} ${style('red', `${errors.length} configuration error${errors.length !== 1 ? 's' : ''}:`)}`
     );
     for (const e of errors) {
       lines.push('');
-      lines.push(`  ${RED}✗${RESET} ${e.summary}`);
-      lines.push(`${DIM}${e.details}${RESET}`);
+      lines.push(`  ${style('red', '✗')} ${e.summary}`);
+      lines.push(style('dim', e.details));
     }
   }
 
   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}`
+      `${style(['yellow', 'bold'], '[timber]')} ${style('yellow', `${warns.length} configuration warning${warns.length !== 1 ? 's' : ''}:`)}`
     );
     for (const w of warns) {
       lines.push('');
-      lines.push(`  ${YELLOW}⚠${RESET} ${w.summary}`);
-      lines.push(`${DIM}${w.details}${RESET}`);
+      lines.push(`  ${style('yellow', '⚠')} ${w.summary}`);
+      lines.push(style('dim', w.details));
     }
   }