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

package/src/plugins/build-report.ts

@@ -20,6 +20,7 @@ import type { Plugin, Logger } from 'vite';
 import type { PluginContext } from '../plugin-context.ts';
 import type { SegmentNode, RouteTree } from '../routing/types.ts';
 import type { CaptureSummary } from '../server/prebuilt-builder.ts';
+import type { PrebuiltCaptureResult } from './prebuilt-capture.ts';
 import type { PrebuiltManifest } from '../server/prebuilt/payload-source.ts';
 import { collectLeafRoutes } from '../routing/walkers.ts';
 import { formatSize } from '../utils/format.ts';
@@ -199,13 +200,10 @@ export interface PrebuiltReportData {
   skippedReasons: Array<{ componentId: string; route: string; message: string }>;
 }
 
-export function loadPrebuiltManifest(buildDir: string): PrebuiltManifest | null {
-  try {
-    const raw = readFileSync(join(buildDir, 'prebuilt', 'manifest.json'), 'utf-8');
-    return JSON.parse(raw) as PrebuiltManifest;
-  } catch {
-    return null;
-  }
+/** Read the manifest of the prebuilt artifact this build recorded, if any. */
+export function loadPrebuiltManifest(prebuiltDir: string | undefined): PrebuiltManifest | null {
+  if (!prebuiltDir) return null;
+  return JSON.parse(readFileSync(join(prebuiltDir, 'manifest.json'), 'utf-8')) as PrebuiltManifest;
 }
 
 export function buildPrebuiltReportData(
@@ -488,17 +486,79 @@ function suppressNonClientLogs(config: { command: string; logger: Logger }): voi
   };
 }
 
-export function timberBuildReport(ctx: PluginContext): Plugin {
+/**
+ * What the post-build phase asks of the build report (plugins/post-build.ts).
+ * Printed from there, once, after every environment is built and after the
+ * prebuilt capture pass — so nothing here depends on the order in which
+ * Vite closes each environment's bundle.
+ */
+export interface BuildReportStep {
+  print(prebuilt: PrebuiltCaptureResult | null): void;
+}
+
+export function timberBuildReport(ctx: PluginContext): Plugin & { api: BuildReportStep } {
   let logger: Logger | null = null;
   let chunkSizes: Map<string, ChunkSize> | null = null;
   let clientBundle: Record<string, OutputChunkLike> | null = null;
-  let reported = false;
-  let deferReport = false;
   const buildStart = performance.now();
 
+  function printRouteTable(): void {
+    if (!ctx.routeTree || !chunkSizes || !clientBundle || !logger) return;
+
+    const outputMode = ctx.config.output ?? 'server';
+    const clientJsDisabled = ctx.clientJavascript.disabled;
+    const { entries, sharedGzip } = clientJsDisabled
+      ? {
+          entries: collectRoutes(ctx.routeTree).map((info) => ({
+            path: info.path,
+            type: classifyRoute(info.segments, outputMode),
+            size: 0,
+            firstLoadSize: 0,
+          })),
+          sharedGzip: 0,
+        }
+      : buildEntries(ctx.routeTree, chunkSizes, clientBundle, outputMode, ctx.appDir, ctx.root);
+    const elapsed = ((performance.now() - buildStart) / 1000).toFixed(2);
+    const lines = buildRouteReport(entries, sharedGzip);
+
+    logger.info('');
+    for (const line of lines) logger.info(line);
+
+    const warnings = buildWarnings(entries, ctx.config.budget);
+    if (warnings.length > 0) {
+      logger.info('');
+      for (const w of warnings) logger.warn(w);
+    }
+
+    logger.info('');
+    logger.info(
+      `✓ built ${entries.length} routes for all three environments (rsc, ssr, client) in ${elapsed}s`
+    );
+    logger.info('');
+  }
+
+  function printPrebuiltReport(prebuilt: PrebuiltCaptureResult | null): void {
+    if (!logger || !prebuilt) return;
+    const manifest = loadPrebuiltManifest(prebuilt.artifact?.path);
+    const prebuiltData = buildPrebuiltReportData(manifest, prebuilt.summary);
+    if (!prebuiltData) return;
+
+    logger.info('');
+    for (const line of buildPrebuiltReport(prebuiltData)) logger.info(line);
+    logger.info('');
+  }
+
   return {
     name: 'timber-build-report',
 
+    api: {
+      print(prebuilt) {
+        if (ctx.dev) return;
+        printRouteTable();
+        printPrebuiltReport(prebuilt);
+      },
+    },
+
     config(_cfg, { command }) {
       if (command !== 'build') return;
       return {
@@ -520,66 +580,6 @@ export function timberBuildReport(ctx: PluginContext): Plugin {
 
       chunkSizes = collectChunkSizes(bundle as Record<string, OutputChunkLike>);
       clientBundle = { ...bundle } as Record<string, OutputChunkLike>;
-      deferReport = true; // skip client's closeBundle; emit after SSR's
-    },
-
-    closeBundle() {
-      if (ctx.dev || reported) return;
-
-      // The client build's closeBundle fires before SSR starts.
-      // Defer one cycle so the report appears after all builds complete.
-      if (deferReport) {
-        deferReport = false;
-        return;
-      }
-      if (!ctx.routeTree || !chunkSizes || !clientBundle || !logger) return;
-
-      reported = true;
-      const outputMode = ctx.config.output ?? 'server';
-      const clientJsDisabled = ctx.clientJavascript.disabled;
-      const { entries, sharedGzip } = clientJsDisabled
-        ? {
-            entries: collectRoutes(ctx.routeTree).map((info) => ({
-              path: info.path,
-              type: classifyRoute(info.segments, outputMode),
-              size: 0,
-              firstLoadSize: 0,
-            })),
-            sharedGzip: 0,
-          }
-        : buildEntries(ctx.routeTree, chunkSizes, clientBundle, outputMode, ctx.appDir, ctx.root);
-      const elapsed = ((performance.now() - buildStart) / 1000).toFixed(2);
-      const lines = buildRouteReport(entries, sharedGzip);
-
-      logger.info('');
-      for (const line of lines) logger.info(line);
-
-      const warnings = buildWarnings(entries, ctx.config.budget);
-      if (warnings.length > 0) {
-        logger.info('');
-        for (const w of warnings) logger.warn(w);
-      }
-
-      logger.info('');
-      logger.info(
-        `✓ built ${entries.length} routes for all three environments (rsc, ssr, client) in ${elapsed}s`
-      );
-      logger.info('');
-    },
-
-    buildApp: {
-      order: 'post' as const,
-      async handler() {
-        if (ctx.dev || !logger) return;
-        const manifest = loadPrebuiltManifest(ctx.buildDir);
-        const prebuiltData = buildPrebuiltReportData(manifest, ctx.captureSummary);
-        if (!prebuiltData) return;
-
-        logger.info('');
-        const prebuiltLines = buildPrebuiltReport(prebuiltData);
-        for (const line of prebuiltLines) logger.info(line);
-        logger.info('');
-      },
     },
   };
 }

package/src/plugins/dev-server.ts

@@ -22,12 +22,15 @@ import type { PluginContext } from '../plugin-context.ts';
 import {
   sendErrorToOverlay,
   classifyErrorPhase,
-  fixErrorStacktrace,
   parseFirstAppFrame,
   type ErrorPhase,
 } from '../dev-tools/overlay.ts';
 import { generateDevErrorPage } from '../dev-tools/error-page.ts';
-import { extractHmrOptions, type DevErrorHmrOptions } from '../dev-tools/dev-page-shell.ts';
+import {
+  extractHmrOptions,
+  type DevErrorHmrOptions,
+  type DevHooks,
+} from '../dev-tools/dev-page-shell.ts';
 import { addVirtualModuleContext } from '../config-validation.ts';
 import { registerDevDiscovery } from './dev-discovery.ts';
 import {
@@ -36,7 +39,6 @@ import {
   type GraphUpdateChannel,
 } from './graph-endpoint.ts';
 import { compressResponse } from '../server/compress.ts';
-import { isSsrStreamError } from '../server/primitives.ts';
 import { isMetadataRouteServePath } from '../server/metadata-routes.ts';
 import { canonicalize } from '../server/canonicalize.ts';
 import { matchUrlParts } from '../server/tree-match.ts';
@@ -317,37 +319,18 @@ function createTimberMiddleware(server: ViteDevServer, ctx: PluginContext) {
       const rscModule = await rscEnv.runner.import(RSC_ENTRY_ID);
       handler = rscModule.default as (req: Request) => Promise<Response>;
 
-      // Wire pipeline errors into the browser error overlay.
-      // Set devPipelineErrorHandler directly on the pipeline config —
-      // no module-level singleton.
-      const config = rscModule.pipelineConfig as
-        | {
-            devPipelineErrorHandler?: (error: Error, phase: string) => void;
-            devHmrOptions?: DevErrorHmrOptions;
-          }
-        | undefined;
-      if (config) {
-        config.devPipelineErrorHandler = (error) => {
+      // Wire pipeline errors into the browser error overlay, and plumb the
+      // resolved HMR options into the RSC environment. The RSC entry can't
+      // read the Vite server config (separate module graph), but its dev 404
+      // page and fallback error page need the HMR endpoint (including Vite
+      // 8's required WS token) for auto-reload (TIM-1067).
+      const setDevHooks = rscModule.setDevHooks as ((hooks: DevHooks) => void) | undefined;
+      setDevHooks?.({
+        onPipelineError: (error) => {
           sendErrorToOverlay(server, error, classifyErrorPhase(error, projectRoot), projectRoot);
-        };
-        // Plumb the resolved HMR options into the RSC environment. The RSC
-        // entry can't read the Vite server config (separate module graph),
-        // but its dev 404 page and fallback error page need the HMR endpoint
-        // (including Vite 8's required WS token) for auto-reload (TIM-1067).
-        config.devHmrOptions = hmrOptions;
-      }
-
-      // Wire source-map handler so error pages show original positions.
-      // fixErrorStacktrace rewrites the error's stack trace in-place using
-      // the Vite dev server's module graph. See TIM-811.
-      const setSourceMap = rscModule.setDevSourceMapHandler as
-        | ((fn: (error: Error) => void) => void)
-        | undefined;
-      if (typeof setSourceMap === 'function') {
-        setSourceMap((error: Error) => {
-          fixErrorStacktrace(server, error);
-        });
-      }
+        },
+        hmrOptions,
+      });
     } catch (error) {
       // Module transform error — syntax error, missing import, etc.
       // Vite may already show its own overlay for these, but we still
@@ -404,18 +387,15 @@ function createTimberMiddleware(server: ViteDevServer, ctx: PluginContext) {
       // srvx skips its own writeHead since headers are already sent.
       await sendNodeResponse(res, finalResponse);
     } catch (error) {
-      // Pipeline error — classify the phase, send to overlay, respond 500.
-      // The dev server remains running for recovery on file fix + HMR.
+      // An error the pipeline did not turn into a response, or one sending
+      // the response threw — classify the phase, send to overlay, respond
+      // 500. The pipeline answers render errors itself (an SsrStreamError
+      // never gets here), so this sees the error as thrown. The dev server
+      // remains running for recovery on file fix + HMR.
       if (error instanceof Error) {
-        // Unwrap SsrStreamError to show the real cause in the error overlay.
-        // SsrStreamError wraps the original RSC render error with a generic
-        // message; the developer needs to see the actual error (e.g.,
-        // "useSegmentParams is not a function"), not the wrapper.
-        const displayError =
-          isSsrStreamError(error) && error.cause instanceof Error ? error.cause : error;
-        const phase = classifyErrorPhase(displayError, projectRoot);
-        sendErrorToOverlay(server, displayError, phase, projectRoot);
-        respond500(res, displayError, phase, projectRoot, hmrOptions);
+        const phase = classifyErrorPhase(error, projectRoot);
+        sendErrorToOverlay(server, error, phase, projectRoot);
+        respond500(res, error, phase, projectRoot, hmrOptions);
       } else {
         process.stderr.write(`\x1b[31m[timber] Dev server error:\x1b[0m ${String(error)}\n`);
         respond500(res, error, 'render', projectRoot, hmrOptions);

package/src/plugins/entries.ts

@@ -16,6 +16,7 @@ import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
 import type { PluginContext } from '../plugin-context.ts';
+import { resolveRenderTimeoutMs } from '../server/render-timeout.ts';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -146,7 +147,7 @@ function generateConfigModule(ctx: PluginContext): string {
     topLoader: ctx.config.topLoader,
     debug: ctx.config.debug ?? false,
     serverTiming: ctx.config.serverTiming,
-    renderTimeoutMs: ctx.config.renderTimeoutMs ?? 30_000,
+    renderTimeoutMs: resolveRenderTimeoutMs(ctx.config.renderTimeoutMs),
     // Auto-generated sitemap config — opt-in via timber.config.ts.
     // See design/16-metadata.md §"Auto-generated Sitemap"
     sitemap: ctx.config.sitemap,

package/src/plugins/fonts.ts

@@ -21,12 +21,13 @@
 import { parseAst } from 'vite';
 import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite';
 import type { PluginContext } from '../plugin-context.ts';
+import type { BuildManifest } from '../server/build-manifest.ts';
 import {
   downloadAndCacheFonts,
   generateProductionFontFaces,
   resolveDevFontFaces,
 } from '../fonts/google.ts';
-import { fontUrlPrefix } from '../fonts/paths.ts';
+import { FONT_OUTPUT_DIR, fontUrlPrefix } from '../fonts/paths.ts';
 import { FontPipeline } from '../fonts/pipeline.ts';
 import { runFontsTransform } from '../fonts/transform.ts';
 import { installFontDevMiddleware } from '../fonts/dev-middleware.ts';
@@ -57,15 +58,38 @@ export {
   parseLocalFontImportName,
 } from '../fonts/transform.ts';
 
+/**
+ * What the post-build phase asks of the font plugin (plugins/post-build.ts).
+ * Called after every environment has been built, so the font entries are
+ * complete — no environment's `generateBundle` has to run after the build
+ * manifest exists.
+ */
+export interface FontsBuildStep {
+  /** Write this build's font entries into the build manifest. */
+  contributeManifest(manifest: BuildManifest): void;
+  /**
+   * Directories of the client bundle this build filled with content-hashed
+   * font binaries — `[FONT_OUTPUT_DIR]` when any were emitted, else none.
+   */
+  immutableDirs(): string[];
+}
+
 /**
  * Create the timber-fonts Vite plugin.
  */
-export function timberFonts(ctx: PluginContext): Plugin {
+export function timberFonts(ctx: PluginContext): Plugin & { api: FontsBuildStep } {
   const pipeline = new FontPipeline({ hashOnRegister: !ctx.dev });
+  /** Whether the client environment emitted a binary this build. */
+  let emittedToClient = false;
 
   return {
     name: 'timber-fonts',
 
+    api: {
+      contributeManifest: (manifest) => writeFontManifest(pipeline, manifest, ctx.base),
+      immutableDirs: () => (emittedToClient ? [FONT_OUTPUT_DIR] : []),
+    },
+
     /**
      * Push Vite's resolved `base` into the pipeline so every font URL it
      * emits (@font-face src, manifest hrefs, dev middleware matching)
@@ -289,20 +313,24 @@ export function timberFonts(ctx: PluginContext): Plugin {
     },
 
     /**
-     * Emit font binaries and build-manifest entries.
+     * Emit font binaries.
      *
      * All font binaries (Google and local) use content-hashed filenames
      * for immutable caching. Font CSS is handled by Vite's CSS pipeline
-     * via virtual modules — we only emit binaries here.
+     * via virtual modules — we only emit binaries here. Manifest entries are
+     * written by the post-build phase through `api.contributeManifest`.
      */
     generateBundle() {
+      let emitted = 0;
       emitFontAssets(
         pipeline,
-        (asset) => this.emitFile(asset),
+        (asset) => {
+          emitted++;
+          return this.emitFile(asset);
+        },
         (msg) => this.warn(msg)
       );
-      if (!ctx.buildManifest) return;
-      writeFontManifest(pipeline, ctx.buildManifest, ctx.base);
+      if (this.environment?.name === 'client') emittedToClient = emitted > 0;
     },
   };
 }