vite-plugin-react-server 1.3.6 → 1.4.0

package/dist/plugin/dev-server/plugin.server.js

@@ -5,6 +5,7 @@
  */
 import { configureReactServer } from './configureReactServer.server.js';
 import { resolveOptions } from '../config/resolveOptions.js';
+import { readFileSync } from 'node:fs';
 
 const vitePluginReactDevServer = function _vitePluginReactServerDevServer(options) {
   if (options == null) {
@@ -22,13 +23,59 @@ const vitePluginReactDevServer = function _vitePluginReactServerDevServer(option
     name: "vite-plugin-react-server:server-hmr",
     apply: "serve",
     // Server-level handleHotUpdate — sends custom WS event to client
+    // Vite 6 Environment API: hotUpdate runs per-environment.
+    // Prevent server/ssr environments from triggering page reload for client components.
+    hotUpdate(ctx) {
+      const { file, server } = ctx;
+      const envName = ctx.environment?.name ?? "unknown";
+      const moduleBase = userOptions.moduleBase || "src";
+      const projectRoot = userOptions.projectRoot || server?.config?.root || "";
+      const normalizedFile = file.replace(projectRoot, "").replace(/^\/+/, "");
+      const isSourceFile = normalizedFile.startsWith(moduleBase + "/");
+      if (!isSourceFile) return;
+      if (envName === "client") {
+        const isClient = (file.endsWith(".tsx") || file.endsWith(".ts") || file.endsWith(".jsx") || file.endsWith(".js")) && (() => {
+          try {
+            const head = readFileSync(file, "utf-8").slice(0, 200);
+            return /^\s*["']use client["']/.test(head.split("\n")[0]);
+          } catch {
+            return false;
+          }
+        })();
+        if (isClient) return;
+        server.config.logger.info(`[vite-plugin-react-server] File changed (RSC refetch): ${normalizedFile}`);
+        server.ws.send({
+          type: "custom",
+          event: "vite-plugin-react-server:server-component-update",
+          data: { file: normalizedFile, path: file }
+        });
+        return [];
+      }
+      if (envName === "server") {
+        const mod = ctx.environment?.moduleGraph?.getModulesByFile(file);
+        if (mod) {
+          for (const m of mod) {
+            ctx.environment.moduleGraph.invalidateModule(m);
+          }
+        }
+      }
+      return [];
+    },
     handleHotUpdate({ file, server }) {
       const moduleBase = userOptions.moduleBase || "src";
       const projectRoot = userOptions.projectRoot || server.config.root;
       const normalizedFile = file.replace(projectRoot, "").replace(/^\/+/, "");
-      const isServerFile = normalizedFile.startsWith(moduleBase + "/") && (file.endsWith(".tsx") || file.endsWith(".ts") || file.endsWith(".jsx") || file.endsWith(".js"));
-      if (isServerFile) {
-        server.config.logger.info(`[vite-plugin-react-server] Server component changed: ${normalizedFile}`);
+      const isSourceFile = normalizedFile.startsWith(moduleBase + "/") && (file.endsWith(".tsx") || file.endsWith(".ts") || file.endsWith(".jsx") || file.endsWith(".js"));
+      const isClientFile = isSourceFile && (() => {
+        try {
+          const head = readFileSync(file, "utf-8").slice(0, 200);
+          return /^\s*["']use client["']/.test(head.split("\n")[0]);
+        } catch {
+          return false;
+        }
+      })();
+      if (isSourceFile && !isClientFile) {
+        server.config.logger.info(`[vite-plugin-react-server] File changed (RSC refetch): ${normalizedFile}`);
         server.ws.send({
           type: "custom",
           event: "vite-plugin-react-server:server-component-update",
@@ -45,6 +92,9 @@ const vitePluginReactDevServer = function _vitePluginReactServerDevServer(option
         }
         return [];
       }
+      if (isClientFile) {
+        return [];
+      }
     }
   };
   const serverPlugin = {
@@ -105,4 +155,4 @@ const vitePluginReactDevServer = function _vitePluginReactServerDevServer(option
 };
 
 export { vitePluginReactDevServer };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.server.js","sources":["../../../plugin/dev-server/plugin.server.ts"],"sourcesContent":["import type { StreamPluginOptions } from \"../../types.js\";\nimport { configureReactServer } from \"./configureReactServer.server.js\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport type { Plugin, ViteDevServer } from \"vite\";\n\n/**\n * Dev server plugin for server environment.\n * Returns two plugins: one for HMR handling (all environments) and one for server config.\n */\nexport const vitePluginReactDevServer = function _vitePluginReactServerDevServer(options: StreamPluginOptions): Plugin[] {\n  if (options == null) {\n    throw new Error(\"options is required\");\n  }\n\n  const resolvedOptions = resolveOptions(options);\n  if (resolvedOptions.type === \"error\") {\n    if (resolvedOptions.error != null) {\n      throw resolvedOptions.error;\n    }\n    throw new Error(\"Failed to resolve options\");\n  }\n  const userOptions = resolvedOptions.userOptions;\n\n  // Separate plugin for HMR handling (must apply to all environments)\n  const hmrPlugin = {\n    name: \"vite-plugin-react-server:server-hmr\",\n    apply: \"serve\" as const,\n    // Server-level handleHotUpdate — sends custom WS event to client\n    handleHotUpdate({ file, server }: { file: string; server: ViteDevServer }) {\n      const moduleBase = userOptions.moduleBase || \"src\";\n      const projectRoot = userOptions.projectRoot || server.config.root;\n      const normalizedFile = file.replace(projectRoot, '').replace(/^\\/+/, '');\n      const isServerFile = normalizedFile.startsWith(moduleBase + '/') && \n        (file.endsWith('.tsx') || file.endsWith('.ts') || file.endsWith('.jsx') || file.endsWith('.js'));\n      \n      if (isServerFile) {\n        server.config.logger.info(`[vite-plugin-react-server] Server component changed: ${normalizedFile}`);\n        \n        // Send custom HMR event so client can refetch RSC stream\n        server.ws.send({\n          type: 'custom',\n          event: 'vite-plugin-react-server:server-component-update',\n          data: {\n            file: normalizedFile,\n            path: file,\n          },\n        });\n        \n        // Invalidate the server module so next request gets fresh content\n        const mod = server.environments['server']?.moduleGraph?.getModulesByFile(file);\n        if (mod) {\n          for (const m of mod) {\n            server.environments['server']?.moduleGraph?.invalidateModule(m);\n          }\n        }\n        \n        // Return empty array to prevent Vite's default full-page reload\n        // The client will refetch the RSC stream via the custom event\n        return [];\n      }\n    },\n  };\n\n  const serverPlugin = {\n    name: \"vite-plugin-react-server:dev-server-server\",\n    apply: \"serve\" as const,\n    applyToEnvironment(partialEnvironment: any) {\n      return partialEnvironment?.consumer === 'server';\n    },\n    configureServer(server: ViteDevServer) {\n      // Log that plugin is being configured\n      server.config.logger.info(`[vite-plugin-react-server] Dev server plugin configured for server environment (react-server condition)`);\n      \n      // Configure the React server for server environment (direct RSC processing)\n      // This uses the existing configureReactServer.server.js implementation\n      configureReactServer({\n        server,\n        autoDiscoveredFiles: {\n          propsMap: new Map(),\n          pageMap: new Map(),\n          rootMap: new Map(),\n          htmlMap: new Map(),\n          routeMap: new Map(),\n          urlMap: new Map(),\n          errors: [],\n          workerPaths: {},\n          serverEntry: null,\n          clientEntry: {},\n          clientInputs: {},\n          staticInputs: {},\n          serverInputs: {},\n          // staticManifest removed from AutoDiscoveredFiles\n          serverActions: {},\n        },\n        userOptions,\n        serverManifest: {},\n        resolvedConfig: server.config,\n      });\n    },\n  };\n\n  // Fix CJS named imports in server environment.\n  // Vite's esbuild JSX transform (and @vitejs/plugin-react if present) generates\n  // named imports like `import { useEffect } from \"react\"`. In the server environment,\n  // react's react-server export is CJS-only, and Node's ESM interop doesn't support\n  // named exports from CJS. This post-transform rewrites them.\n  const cjsFixPlugin: Plugin = {\n    name: \"vite-plugin-react-server:server-cjs-fix\",\n    apply: \"serve\" as const,\n    enforce: \"post\" as const,\n    applyToEnvironment(env: any) {\n      return env?.name === 'server';\n    },\n    transform(code: string, id: string) {\n      if (id.includes('node_modules')) return;\n      if (!id.match(/\\.[jt]sx?$/)) return;\n      \n      const namedImportRe = /import\\s*\\{([^}]+)\\}\\s*from\\s*[\"']react[\"']\\s*;?/g;\n      if (!namedImportRe.test(code)) return;\n      \n      namedImportRe.lastIndex = 0;\n      let counter = 0;\n      const result = code.replace(namedImportRe, (_match, imports) => {\n        const alias = `__react_cjs_${counter++}`;\n        return `import ${alias} from \"react\"; const {${imports}} = ${alias};`;\n      });\n      \n      return { code: result, map: null };\n    },\n  };\n\n  return [hmrPlugin, cjsFixPlugin, serverPlugin];\n};\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.server.js","sources":["../../../plugin/dev-server/plugin.server.ts"],"sourcesContent":["import type { StreamPluginOptions } from \"../../types.js\";\nimport { configureReactServer } from \"./configureReactServer.server.js\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport type { Plugin, ViteDevServer } from \"vite\";\nimport { readFileSync } from \"node:fs\";\n\n/**\n * Dev server plugin for server environment.\n * Returns two plugins: one for HMR handling (all environments) and one for server config.\n */\nexport const vitePluginReactDevServer = function _vitePluginReactServerDevServer(options: StreamPluginOptions): Plugin[] {\n  if (options == null) {\n    throw new Error(\"options is required\");\n  }\n\n  const resolvedOptions = resolveOptions(options);\n  if (resolvedOptions.type === \"error\") {\n    if (resolvedOptions.error != null) {\n      throw resolvedOptions.error;\n    }\n    throw new Error(\"Failed to resolve options\");\n  }\n  const userOptions = resolvedOptions.userOptions;\n\n  // Separate plugin for HMR handling (must apply to all environments)\n  const hmrPlugin = {\n    name: \"vite-plugin-react-server:server-hmr\",\n    apply: \"serve\" as const,\n    // Server-level handleHotUpdate — sends custom WS event to client\n    // Vite 6 Environment API: hotUpdate runs per-environment.\n    // Prevent server/ssr environments from triggering page reload for client components.\n    hotUpdate(ctx: any) {\n      const { file, server } = ctx;\n      const envName = ctx.environment?.name ?? 'unknown';\n      \n      const moduleBase = userOptions.moduleBase || \"src\";\n      const projectRoot = userOptions.projectRoot || server?.config?.root || '';\n      const normalizedFile = file.replace(projectRoot, '').replace(/^\\/+/, '');\n      const isSourceFile = normalizedFile.startsWith(moduleBase + '/');\n      \n      if (!isSourceFile) return;\n      \n      // Client environment: let Vite/@vitejs/plugin-react handle it\n      if (envName === 'client') {\n        // Check if it's a client component — let Fast Refresh handle it\n        const isClient = (file.endsWith('.tsx') || file.endsWith('.ts') || file.endsWith('.jsx') || file.endsWith('.js')) && (() => {\n          try {\n            const head = readFileSync(file, 'utf-8').slice(0, 200);\n            return /^\\s*[\"']use client[\"']/.test(head.split('\\n')[0]);\n          } catch { return false; }\n        })();\n        \n        if (isClient) return; // Let Fast Refresh handle client components\n        \n        // Server component changed — send RSC refetch event to client\n        // Only do this once (from client env) to avoid duplicate events\n        server.config.logger.info(`[vite-plugin-react-server] File changed (RSC refetch): ${normalizedFile}`);\n        server.ws.send({\n          type: 'custom',\n          event: 'vite-plugin-react-server:server-component-update',\n          data: { file: normalizedFile, path: file },\n        });\n        \n        return []; // Don't trigger client-side page reload\n      }\n      \n      // Server/SSR environments: suppress page reload for all source files\n      // Server components are handled by the RSC refetch event sent above\n      // Invalidate the server module so next RSC request gets fresh content\n      if (envName === 'server') {\n        const mod = ctx.environment?.moduleGraph?.getModulesByFile(file);\n        if (mod) {\n          for (const m of mod) {\n            ctx.environment.moduleGraph.invalidateModule(m);\n          }\n        }\n      }\n      return [];\n    },\n    handleHotUpdate({ file, server }: { file: string; server: ViteDevServer }) {\n      const moduleBase = userOptions.moduleBase || \"src\";\n      const projectRoot = userOptions.projectRoot || server.config.root;\n      const normalizedFile = file.replace(projectRoot, '').replace(/^\\/+/, '');\n      const isSourceFile = normalizedFile.startsWith(moduleBase + '/') && \n        (file.endsWith('.tsx') || file.endsWith('.ts') || file.endsWith('.jsx') || file.endsWith('.js'));\n      \n      // Skip client components — let @vitejs/plugin-react handle them\n      // with Fast Refresh (preserves component-level state).\n      const isClientFile = isSourceFile && (() => {\n        try {\n          const head = readFileSync(file, 'utf-8').slice(0, 200);\n          return /^\\s*[\"']use client[\"']/.test(head.split('\\n')[0]);\n        } catch { return false; }\n      })();\n      \n      if (isSourceFile && !isClientFile) {\n        server.config.logger.info(`[vite-plugin-react-server] File changed (RSC refetch): ${normalizedFile}`);\n        \n        // Send custom HMR event so client can refetch RSC stream\n        server.ws.send({\n          type: 'custom',\n          event: 'vite-plugin-react-server:server-component-update',\n          data: {\n            file: normalizedFile,\n            path: file,\n          },\n        });\n        \n        // Invalidate the server module so next request gets fresh content\n        const mod = server.environments['server']?.moduleGraph?.getModulesByFile(file);\n        if (mod) {\n          for (const m of mod) {\n            server.environments['server']?.moduleGraph?.invalidateModule(m);\n          }\n        }\n        \n        // Return empty array to prevent Vite's default full-page reload\n        // The client will refetch the RSC stream via the custom event\n        return [];\n      }\n      \n      if (isClientFile) {\n        // Client components are handled by @vitejs/plugin-react (Fast Refresh)\n        // or Vite's client-side HMR. Return empty to prevent the server\n        // environment from triggering a full page reload.\n        return [];\n      }\n    },\n  };\n\n  const serverPlugin = {\n    name: \"vite-plugin-react-server:dev-server-server\",\n    apply: \"serve\" as const,\napplyToEnvironment(partialEnvironment: any) {\n      return partialEnvironment?.consumer === 'server';\n    },\n    configureServer(server: ViteDevServer) {\n      // Log that plugin is being configured\n      server.config.logger.info(`[vite-plugin-react-server] Dev server plugin configured for server environment (react-server condition)`);\n      \n      // Configure the React server for server environment (direct RSC processing)\n      // This uses the existing configureReactServer.server.js implementation\n      configureReactServer({\n        server,\n        autoDiscoveredFiles: {\n          propsMap: new Map(),\n          pageMap: new Map(),\n          rootMap: new Map(),\n          htmlMap: new Map(),\n          routeMap: new Map(),\n          urlMap: new Map(),\n          errors: [],\n          workerPaths: {},\n          serverEntry: null,\n          clientEntry: {},\n          clientInputs: {},\n          staticInputs: {},\n          serverInputs: {},\n          // staticManifest removed from AutoDiscoveredFiles\n          serverActions: {},\n        },\n        userOptions,\n        serverManifest: {},\n        resolvedConfig: server.config,\n      });\n    },\n  };\n\n  // Fix CJS named imports in server environment.\n  // Vite's esbuild JSX transform (and @vitejs/plugin-react if present) generates\n  // named imports like `import { useEffect } from \"react\"`. In the server environment,\n  // react's react-server export is CJS-only, and Node's ESM interop doesn't support\n  // named exports from CJS. This post-transform rewrites them.\n  const cjsFixPlugin: Plugin = {\n    name: \"vite-plugin-react-server:server-cjs-fix\",\n    apply: \"serve\" as const,\n    enforce: \"post\" as const,\n    applyToEnvironment(env: any) {\n      return env?.name === 'server';\n    },\n    transform(code: string, id: string) {\n      if (id.includes('node_modules')) return;\n      if (!id.match(/\\.[jt]sx?$/)) return;\n      \n      const namedImportRe = /import\\s*\\{([^}]+)\\}\\s*from\\s*[\"']react[\"']\\s*;?/g;\n      if (!namedImportRe.test(code)) return;\n      \n      namedImportRe.lastIndex = 0;\n      let counter = 0;\n      const result = code.replace(namedImportRe, (_match, imports) => {\n        const alias = `__react_cjs_${counter++}`;\n        return `import ${alias} from \"react\"; const {${imports}} = ${alias};`;\n      });\n      \n      return { code: result, map: null };\n    },\n  };\n\n  return [hmrPlugin, cjsFixPlugin, serverPlugin];\n};\n"],"names":[],"mappings":"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"}

package/dist/plugin/react-static/plugin.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.server.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/plugin.server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,OAAO,KAAK,EAIV,YAAY,EACb,MAAM,aAAa,CAAC;AAyCrB,eAAO,MAAM,iBAAiB,EAAE,YA+nB/B,CAAC"}
+{"version":3,"file":"plugin.server.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/plugin.server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAaH,OAAO,KAAK,EAIV,YAAY,EACb,MAAM,aAAa,CAAC;AA0CrB,eAAO,MAAM,iBAAiB,EAAE,YAwoB/B,CAAC"}

package/dist/plugin/react-static/plugin.server.js

@@ -16,7 +16,8 @@
 import { createLogger, } from "vite";
 import { resolveOptions } from "../config/resolveOptions.js";
 import { createBuildLoader } from "./createBuildLoader.server.js";
-import { renderPages } from "./renderPages.js";
+import { renderPagesBatched } from "./renderPagesBatched.js";
+import { renderPages as renderPagesSequential } from "./renderPages.js";
 import { getBundleManifest } from "../helpers/getBundleManifest.js";
 import { createWorker } from "../worker/createWorker.js";
 import { serializedOptions, serializeResolvedConfig, } from "../helpers/serializeUserOptions.js";
@@ -375,6 +376,12 @@ export const reactStaticPlugin = function _reactStaticPlugin(options) {
                         }
                     }
                 }
+                // Select render mode based on build config
+                const renderMode = userOptions.build?.renderMode ?? "parallel";
+                const renderPages = renderMode === "sequential" ? renderPagesSequential : renderPagesBatched;
+                if (userOptions.verbose) {
+                    logger.info(`[static] Using ${renderMode} rendering${renderMode === "parallel" ? ` (batch size: ${userOptions.build?.batchSize ?? 8})` : ""}`);
+                }
                 // this will render the routes
                 const renderPagesGenerator = renderPages(routes, {
                     ...handlerOptions,
@@ -393,6 +400,7 @@ export const reactStaticPlugin = function _reactStaticPlugin(options) {
                     staticManifest: staticManifest, // Pass static manifest for path resolution
                     autoDiscoveredFiles: autoDiscoveredFiles,
                     cssFilesByPage: cssFilesByPage,
+                    batchSize: userOptions.build?.batchSize,
                 }, renderPage);
                 // Process render results
                 let finalResult;

package/dist/plugin/react-static/renderPagesBatched.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderPagesBatched.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/renderPagesBatched.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAA2C,MAAM,YAAY,CAAC;AA0GzF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAkJhC,CAAC"}
+{"version":3,"file":"renderPagesBatched.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/renderPagesBatched.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAA2C,MAAM,YAAY,CAAC;AA4OzF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,aA6HhC,CAAC"}

package/dist/plugin/react-static/renderPagesBatched.js

@@ -1,5 +1,7 @@
 import { handleError } from "../error/handleError.js";
 import { fileWriter } from "./fileWriter.js";
+import { createRenderMetrics } from "../metrics/createRenderMetrics.js";
+import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
 const DEFAULT_BATCH_SIZE = 8;
 function resolvePathWithManifest(path, manifest) {
     const entry = manifest[path];
@@ -10,9 +12,10 @@ function resolvePathWithManifest(path, manifest) {
 }
 /**
  * Renders a single route completely, consuming all yields from renderPage
- * and writing the RSC and HTML files
+ * and writing the RSC and HTML files. Collects metrics and handles events
+ * identically to the sequential renderPages.
  */
-async function renderSingleRoute(route, handlerOptions, renderPage, manifest) {
+async function renderSingleRoute(route, handlerOptions, renderPage, manifest, failedRoutes) {
     const { autoDiscoveredFiles, cssFilesByPage, ...options } = handlerOptions;
     const { page, props, root, html } = autoDiscoveredFiles.urlMap?.get(route) || {};
     if (!page) {
@@ -23,6 +26,120 @@ async function renderSingleRoute(route, handlerOptions, renderPage, manifest) {
         const resolvedPropsPath = props ? resolvePathWithManifest(props, manifest) : undefined;
         const resolvedRootPath = root ? resolvePathWithManifest(root, manifest) : undefined;
         const resolvedHtmlPath = html ? resolvePathWithManifest(html, manifest) : undefined;
+        // Store results for metrics tracking
+        const routeResults = new Map();
+        // Create onEvent wrapper that handles route.error and metrics collection
+        // This mirrors the sequential renderPages behavior exactly
+        const wrapperOnEvent = (event) => {
+            // Call the original onEvent first
+            if (options.onEvent) {
+                options.onEvent(event);
+            }
+            // Handle route.error events
+            if (event.type === "route.error") {
+                const detectedPanicError = handleError({
+                    error: event.data.error,
+                    logger: options.logger,
+                    panicThreshold: event.data.panicThreshold,
+                    context: `route.error (${event.data.route})`,
+                });
+                if (detectedPanicError != null) {
+                    options.logger?.error(`[renderPagesBatched] Panic error for route ${event.data.route}: ${event.data.error.message}`);
+                    failedRoutes.set(event.data.route, event.data.error);
+                }
+                else {
+                    options.logger?.warn(`[renderPagesBatched] Non-panic error for route ${event.data.route}: ${event.data.error.message}`);
+                }
+            }
+            // Handle metrics collection on file.write.done
+            if (event.type === "file.write.done" && event.data.route === route) {
+                const routeResult = routeResults.get(route);
+                if (routeResult && routeResult.type === "success") {
+                    if (event.data.fileType === "html") {
+                        const endTime = performance.now();
+                        const htmlMetrics = createRenderMetrics({
+                            route: route,
+                            type: routeResult.metrics.html.type,
+                            fromMainThread: routeResult.metrics.html.fromMainThread,
+                            fromRscWorker: routeResult.metrics.html.fromRscWorker,
+                            fromHtmlWorker: routeResult.metrics.html.fromHtmlWorker,
+                            fileSize: event.data.content.length,
+                            chunks: event.data.chunks || 0,
+                            processingTime: endTime - routeResult.metrics.html.streamMetrics.startTime,
+                            chunkRate: (event.data.chunks || 0) / ((endTime - routeResult.metrics.html.streamMetrics.startTime) / 1000),
+                            fileName: event.data.fileName,
+                            outputPath: event.data.path,
+                            baseDir: event.data.baseDir,
+                            routePath: event.data.routePath,
+                            streamMetrics: createStreamMetrics({
+                                ...routeResult.metrics.html.streamMetrics,
+                                chunks: event.data.chunks || 0,
+                                bytes: event.data.content.length,
+                                duration: endTime - routeResult.metrics.html.streamMetrics.startTime,
+                                endTime: endTime,
+                            }),
+                        });
+                        if (options.onMetrics) {
+                            options.onMetrics(htmlMetrics);
+                        }
+                        // Also emit RSC Full metrics if available
+                        if (routeResult.metrics?.rscFull) {
+                            const rscFullEndTime = performance.now();
+                            const rscFullMetrics = createRenderMetrics({
+                                route: route,
+                                type: routeResult.metrics.rscFull.type,
+                                fromMainThread: routeResult.metrics.rscFull.fromMainThread,
+                                fromRscWorker: routeResult.metrics.rscFull.fromRscWorker,
+                                fromHtmlWorker: routeResult.metrics.rscFull.fromHtmlWorker,
+                                processingTime: rscFullEndTime - routeResult.metrics.rscFull.streamMetrics.startTime,
+                                chunks: routeResult.metrics.rscFull.streamMetrics.chunks,
+                                chunkRate: routeResult.metrics.rscFull.streamMetrics.chunks / ((rscFullEndTime - routeResult.metrics.rscFull.streamMetrics.startTime) / 1000),
+                                fileName: event.data.fileName,
+                                outputPath: event.data.path,
+                                baseDir: event.data.baseDir,
+                                routePath: event.data.routePath,
+                                streamMetrics: createStreamMetrics({
+                                    ...routeResult.metrics.rscFull.streamMetrics,
+                                    duration: rscFullEndTime - routeResult.metrics.rscFull.streamMetrics.startTime,
+                                    endTime: rscFullEndTime,
+                                }),
+                            });
+                            if (options.onMetrics) {
+                                options.onMetrics(rscFullMetrics);
+                            }
+                        }
+                    }
+                    else if (event.data.fileType === "rsc") {
+                        const rscEndTime = performance.now();
+                        const rscMetrics = createRenderMetrics({
+                            route: route,
+                            type: routeResult.metrics.rscHeadless.type,
+                            fromMainThread: routeResult.metrics.rscHeadless.fromMainThread,
+                            fromRscWorker: routeResult.metrics.rscHeadless.fromRscWorker,
+                            fromHtmlWorker: routeResult.metrics.rscHeadless.fromHtmlWorker,
+                            fileSize: event.data.content.length,
+                            chunks: event.data.chunks || 0,
+                            processingTime: rscEndTime - routeResult.metrics.rscHeadless.streamMetrics.startTime,
+                            chunkRate: (event.data.chunks || 0) / ((rscEndTime - routeResult.metrics.rscHeadless.streamMetrics.startTime) / 1000),
+                            fileName: event.data.fileName,
+                            outputPath: event.data.path,
+                            baseDir: event.data.baseDir,
+                            routePath: event.data.routePath,
+                            streamMetrics: createStreamMetrics({
+                                ...routeResult.metrics.rscHeadless.streamMetrics,
+                                chunks: event.data.chunks || 0,
+                                bytes: event.data.content.length,
+                                duration: rscEndTime - routeResult.metrics.rscHeadless.streamMetrics.startTime,
+                                endTime: rscEndTime,
+                            }),
+                        });
+                        if (options.onMetrics) {
+                            options.onMetrics(rscMetrics);
+                        }
+                    }
+                }
+            }
+        };
         const routeHandlerOptions = {
             ...options,
             manifest,
@@ -34,6 +151,7 @@ async function renderSingleRoute(route, handlerOptions, renderPage, manifest) {
             cssFiles: cssFilesByPage?.get(route) ?? new Map(),
             globalCss: options.globalCss ?? new Map(),
             id: `${route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+            onEvent: wrapperOnEvent,
         };
         const pageRenderer = renderPage(routeHandlerOptions);
         const results = [];
@@ -41,18 +159,17 @@ async function renderSingleRoute(route, handlerOptions, renderPage, manifest) {
         // Consume all yields from the page renderer and write files
         for await (const result of pageRenderer) {
             results.push(result);
-            // Track error results
             if (result.type === "error" && result.error) {
                 routeError = result.error instanceof Error ? result.error : new Error(String(result.error));
             }
-            // Write files for success and skip results
-            if ((result.type === "success" || result.type === "skip") && result.html && result.rsc) {
-                const rscWritePromise = fileWriter(result.rsc, "rsc", { ...options, route, logger: options.logger }, options.signal);
-                const htmlWritePromise = fileWriter(result.html, "html", { ...options, route, logger: options.logger }, options.signal);
+            if (result.type === "success" || result.type === "skip") {
+                // Store result for metrics tracking (wrapperOnEvent needs this)
+                routeResults.set(route, result);
+                const rscWritePromise = fileWriter(result.rsc, "rsc", { ...options, route, onEvent: wrapperOnEvent, logger: options.logger }, options.signal);
+                const htmlWritePromise = fileWriter(result.html, "html", { ...options, route, onEvent: wrapperOnEvent, logger: options.logger }, options.signal);
                 await Promise.all([rscWritePromise, htmlWritePromise]);
             }
         }
-        // Return error if any result was an error
         if (routeError) {
             return { route, results, error: routeError };
         }
@@ -116,7 +233,7 @@ export const renderPagesBatched = (routes, handlerOptions, renderPage) => {
                 return abortResult;
             }
             // Render all pages in this batch concurrently
-            const batchPromises = batch.map(route => renderSingleRoute(route, handlerOptions, renderPage, manifest));
+            const batchPromises = batch.map(route => renderSingleRoute(route, handlerOptions, renderPage, manifest, failedRoutes));
             const batchResults = await Promise.all(batchPromises);
             // Process results from this batch
             for (const { route, results: pageResults, error } of batchResults) {
@@ -130,6 +247,16 @@ export const renderPagesBatched = (routes, handlerOptions, renderPage) => {
                     if (panicError != null) {
                         failedRoutes.set(route, error);
                         options.logger?.error(`[renderPagesBatched] Panic error for route ${route}: ${error.message}`);
+                        const errorResult = {
+                            type: "error",
+                            error,
+                            route,
+                            failedRoutes,
+                            completedRoutes,
+                            results,
+                        };
+                        yield errorResult;
+                        return errorResult;
                     }
                     else {
                         options.logger?.warn(`[renderPagesBatched] Non-panic error for route ${route}: ${error.message}`);
@@ -137,7 +264,6 @@ export const renderPagesBatched = (routes, handlerOptions, renderPage) => {
                 }
                 else {
                     completedRoutes.add(route);
-                    // Yield each result from this page
                     for (const result of pageResults) {
                         if (result.type === "success" || result.type === "skip") {
                             results.set(route, result);
@@ -156,32 +282,6 @@ export const renderPagesBatched = (routes, handlerOptions, renderPage) => {
                 options.logger?.info(`[renderPagesBatched] Completed batch: ${completedRoutes.size}/${routeArray.length} pages`);
             }
         }
-        // Check if we should panic based on failed routes
-        if (failedRoutes.size > 0) {
-            const firstError = Array.from(failedRoutes.values())[0];
-            const panicError = handleError({
-                error: firstError,
-                logger: options.logger,
-                panicThreshold: options.panicThreshold,
-                context: `renderPagesBatched final check`,
-            });
-            if (panicError != null) {
-                if (options.verbose) {
-                    options.logger?.error(`[renderPagesBatched] Build failed due to panic threshold: ${failedRoutes.size} routes failed`);
-                }
-                // Yield error before returning
-                const errorResult = {
-                    type: "error",
-                    error: panicError,
-                    route: "",
-                    failedRoutes,
-                    completedRoutes,
-                    results,
-                };
-                yield errorResult;
-                return errorResult;
-            }
-        }
         // Final success result
         const finalResult = {
             type: "success",

package/dist/plugin/react-static/types.d.ts

@@ -59,6 +59,7 @@ export type RenderPagesHandlerOptions = Omit<CreateHandlerOptions, "pagePath" |
     cssFilesByPage: Map<string, Map<string, CssContent>>;
     serverPipeableStreamOptions: any;
     staticManifest?: Manifest;
+    batchSize?: number;
 };
 export type RenderPagesFn = (routes: string[], handlerOptions: RenderPagesHandlerOptions, renderPage: RenderPageFn) => RenderPagesReturn;
 export type RenderPageReturn = AsyncGenerator<RenderPageResult, void, unknown>;

package/dist/plugin/react-static/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/types.ts"],"names":[],"mappings":"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"}

package/dist/plugin/types.d.ts

@@ -724,6 +724,21 @@ export type BuildConfig = {
     rscExtension?: string;
     cssModuleExtension?: string;
     nodeExtension?: string;
+    /**
+     * Controls how pages are rendered during static generation.
+     *
+     * - `"parallel"` (default): Renders pages in concurrent batches for faster builds.
+     *   Use `batchSize` to control concurrency (default: 8).
+     * - `"sequential"`: Renders pages one at a time. Slower but uses less memory
+     *   and produces deterministic output order.
+     */
+    renderMode?: "parallel" | "sequential";
+    /**
+     * Number of pages to render concurrently when `renderMode` is `"parallel"`.
+     * Higher values use more memory but build faster.
+     * @default 8
+     */
+    batchSize?: number;
 };
 export type DevConfig = {
     useHtmlWorker?: boolean | undefined;