vite-plugin-react-server 1.3.6 → 1.4.0

package/oss-experimental/react-server-dom-esm/cjs/react-server-dom-esm-client.browser.development.js

@@ -50,7 +50,7 @@
       var existingPromise = asyncModuleCache.get(metadata.specifier);
       if (existingPromise)
         return "fulfilled" === existingPromise.status ? null : existingPromise;
-      var modulePromise = import(metadata.specifier);
+      var modulePromise = import(/* @vite-ignore */ metadata.specifier);
       modulePromise.then(
         function (value) {
           modulePromise.status = "fulfilled";

package/oss-experimental/react-server-dom-esm/cjs/react-server-dom-esm-client.browser.production.js

@@ -26,7 +26,7 @@ function preloadModule(metadata) {
   var existingPromise = asyncModuleCache.get(metadata.specifier);
   if (existingPromise)
     return "fulfilled" === existingPromise.status ? null : existingPromise;
-  var modulePromise = import(metadata.specifier);
+  var modulePromise = import(/* @vite-ignore */ metadata.specifier);
   modulePromise.then(
     function (value) {
       modulePromise.status = "fulfilled";

package/oss-experimental/react-server-dom-esm/cjs/react-server-dom-esm-client.node.development.js

@@ -50,7 +50,7 @@
       var existingPromise = asyncModuleCache.get(metadata.specifier);
       if (existingPromise)
         return "fulfilled" === existingPromise.status ? null : existingPromise;
-      var modulePromise = import(metadata.specifier);
+      var modulePromise = import(/* @vite-ignore */ metadata.specifier);
       modulePromise.then(
         function (value) {
           modulePromise.status = "fulfilled";

package/oss-experimental/react-server-dom-esm/cjs/react-server-dom-esm-client.node.production.js

@@ -27,7 +27,7 @@ function preloadModule(metadata) {
   var existingPromise = asyncModuleCache.get(metadata.specifier);
   if (existingPromise)
     return "fulfilled" === existingPromise.status ? null : existingPromise;
-  var modulePromise = import(metadata.specifier);
+  var modulePromise = import(/* @vite-ignore */ metadata.specifier);
   modulePromise.then(
     function (value) {
       modulePromise.status = "fulfilled";

package/oss-experimental/react-server-dom-esm/cjs/react-server-dom-esm-server.node.development.js

@@ -2854,7 +2854,7 @@
       var existingPromise = asyncModuleCache.get(metadata.specifier);
       if (existingPromise)
         return "fulfilled" === existingPromise.status ? null : existingPromise;
-      var modulePromise = import(metadata.specifier);
+      var modulePromise = import(/* @vite-ignore */ metadata.specifier);
       modulePromise.then(
         function (value) {
           modulePromise.status = "fulfilled";

package/oss-experimental/react-server-dom-esm/cjs/react-server-dom-esm-server.node.production.js

@@ -1952,7 +1952,7 @@ function preloadModule(metadata) {
   var existingPromise = asyncModuleCache.get(metadata.specifier);
   if (existingPromise)
     return "fulfilled" === existingPromise.status ? null : existingPromise;
-  var modulePromise = import(metadata.specifier);
+  var modulePromise = import(/* @vite-ignore */ metadata.specifier);
   modulePromise.then(
     function (value) {
       modulePromise.status = "fulfilled";

package/oss-experimental/react-server-dom-esm/esm/react-server-dom-esm-client.browser.development.js

@@ -122,7 +122,7 @@ function preloadModule(metadata) {
     return existingPromise;
   } else {
     // $FlowFixMe[unsupported-syntax]
-    var modulePromise = import(metadata.specifier);
+    var modulePromise = import(/* @vite-ignore */ metadata.specifier);
     modulePromise.then(function (value) {
       var fulfilledThenable = modulePromise;
       fulfilledThenable.status = 'fulfilled';

package/oss-experimental/react-server-dom-esm/esm/react-server-dom-esm-client.browser.production.js

@@ -55,7 +55,7 @@ function preloadModule(metadata) {
     return existingPromise;
   } else {
     // $FlowFixMe[unsupported-syntax]
-    const modulePromise = import(metadata.specifier);
+    const modulePromise = import(/* @vite-ignore */ metadata.specifier);
     modulePromise.then(value => {
       const fulfilledThenable = modulePromise;
       fulfilledThenable.status = 'fulfilled';

package/oss-experimental/react-server-dom-esm/package.json

@@ -32,12 +32,12 @@
     "./client.node": "./client.node.js",
     "./server": {
       "react-server": "./server.node.js",
-      "default": "./server.js"
+      "default": "./server.node.js"
     },
     "./server.node": "./server.node.js",
     "./static": {
       "react-server": "./static.node.js",
-      "default": "./static.js"
+      "default": "./static.node.js"
     },
     "./static.node": "./static.node.js",
     "./node-loader": "./esm/react-server-dom-esm-node-loader.production.js",
@@ -60,4 +60,4 @@
     "acorn-loose": "^8.3.0",
     "webpack-sources": "^3.2.0"
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-react-server",
-  "version": "1.3.6",
+  "version": "1.4.0",
   "description": "Vite plugin for React Server Components (RSC)",
   "type": "module",
   "main": "./dist/plugin/index.js",
@@ -43,7 +43,9 @@
     "./stream": "./dist/plugin/stream/index.js",
     "./stream/client": "./dist/plugin/stream/index.client.js",
     "./stream/server": "./dist/plugin/stream/index.server.js",
-    "./env": "./dist/plugin/env/plugin.js",
+    "./env": {
+      "types": "./env.d.ts"
+    },
     "./config": "./dist/plugin/config/index.js",
     "./error": "./dist/plugin/error/index.js",
     "./vendor": "./dist/plugin/vendor/index.js",

package/plugin/config/resolveOptions.ts

@@ -668,6 +668,8 @@ export const resolveOptions: ResolveOptionsFn = function _resolveOptions(
     useHtmlWorker: options.build?.useHtmlWorker ?? 
       // Force useHtmlWorker to true when build.pages is explicitly configured, regardless of default logic
       (options.build?.pages && (Array.isArray(options.build.pages) || typeof options.build.pages === 'function')) ? true : DEFAULT_CONFIG.BUILD.useHtmlWorker,
+    renderMode: options.build?.renderMode ?? "parallel",
+    batchSize: options.build?.batchSize ?? 8,
   } satisfies ResolvedUserOptions["build"];
 
   // Development configuration

package/plugin/dev-server/plugin.client.ts

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import type { VitePluginFn } from "../../types.js";
 import { configureReactServer } from "./configureReactServer.client.js";
 import { resolveOptions } from "../config/resolveOptions.js";
@@ -84,11 +85,21 @@ export const vitePluginReactDevServer: VitePluginFn = function _vitePluginReactS
       
       // Normalize paths for comparison (handle both absolute and relative)
       const normalizedFile = file.replace(projectRoot, '').replace(/^\/+/, '');
-      const isServerFile = normalizedFile.startsWith(moduleBase + '/') && 
+      const isSourceFile = normalizedFile.startsWith(moduleBase + '/') && 
         (file.endsWith('.tsx') || file.endsWith('.ts') || file.endsWith('.jsx') || file.endsWith('.js'));
       
+      // Skip client components — let @vitejs/plugin-react handle them with Fast Refresh
+      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; }
+      })();
+      
+      const isServerFile = isSourceFile && !isClientFile;
+      
       // Always log for debugging
-      server.config.logger.info(`[vite-plugin-react-server] handleHotUpdate: file=${file}, normalized=${normalizedFile}, isServerFile=${isServerFile}, hasHandler=${!!hmrHandler}`);
+      server.config.logger.info(`[vite-plugin-react-server] handleHotUpdate: file=${file}, normalized=${normalizedFile}, isServerFile=${isServerFile}, isClientFile=${isClientFile}, hasHandler=${!!hmrHandler}`);
       
       if (isServerFile && hmrHandler) {
         isProcessingHmr = true;

package/plugin/dev-server/plugin.server.ts

@@ -2,6 +2,7 @@ import type { StreamPluginOptions } from "../../types.js";
 import { configureReactServer } from "./configureReactServer.server.js";
 import { resolveOptions } from "../config/resolveOptions.js";
 import type { Plugin, ViteDevServer } from "vite";
+import { readFileSync } from "node:fs";
 
 /**
  * Dev server plugin for server environment.
@@ -26,15 +27,74 @@ export const vitePluginReactDevServer = function _vitePluginReactServerDevServer
     name: "vite-plugin-react-server:server-hmr",
     apply: "serve" as const,
     // 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: any) {
+      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;
+      
+      // Client environment: let Vite/@vitejs/plugin-react handle it
+      if (envName === 'client') {
+        // Check if it's a client component — let Fast Refresh handle it
+        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; // Let Fast Refresh handle client components
+        
+        // Server component changed — send RSC refetch event to client
+        // Only do this once (from client env) to avoid duplicate events
+        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 []; // Don't trigger client-side page reload
+      }
+      
+      // Server/SSR environments: suppress page reload for all source files
+      // Server components are handled by the RSC refetch event sent above
+      // Invalidate the server module so next RSC request gets fresh content
+      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 }: { file: string; server: ViteDevServer }) {
       const moduleBase = userOptions.moduleBase || "src";
       const projectRoot = userOptions.projectRoot || server.config.root;
       const normalizedFile = file.replace(projectRoot, '').replace(/^\/+/, '');
-      const isServerFile = normalizedFile.startsWith(moduleBase + '/') && 
+      const isSourceFile = 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}`);
+      // Skip client components — let @vitejs/plugin-react handle them
+      // with Fast Refresh (preserves component-level state).
+      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}`);
         
         // Send custom HMR event so client can refetch RSC stream
         server.ws.send({
@@ -58,13 +118,20 @@ export const vitePluginReactDevServer = function _vitePluginReactServerDevServer
         // The client will refetch the RSC stream via the custom event
         return [];
       }
+      
+      if (isClientFile) {
+        // Client components are handled by @vitejs/plugin-react (Fast Refresh)
+        // or Vite's client-side HMR. Return empty to prevent the server
+        // environment from triggering a full page reload.
+        return [];
+      }
     },
   };
 
   const serverPlugin = {
     name: "vite-plugin-react-server:dev-server-server",
     apply: "serve" as const,
-    applyToEnvironment(partialEnvironment: any) {
+applyToEnvironment(partialEnvironment: any) {
       return partialEnvironment?.consumer === 'server';
     },
     configureServer(server: ViteDevServer) {

package/plugin/react-static/plugin.server.ts

@@ -31,7 +31,8 @@ import type {
   AutoDiscoveredFiles,
   VitePluginFn,
 } from "../types.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 {
@@ -445,6 +446,14 @@ export const reactStaticPlugin: VitePluginFn = function _reactStaticPlugin(
           }
         }
 
+        // 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,
@@ -465,6 +474,7 @@ export const reactStaticPlugin: VitePluginFn = function _reactStaticPlugin(
             staticManifest: staticManifest, // Pass static manifest for path resolution
             autoDiscoveredFiles: autoDiscoveredFiles!,
             cssFilesByPage: cssFilesByPage,
+            batchSize: userOptions.build?.batchSize,
           },
           renderPage
         );

package/plugin/react-static/renderPagesBatched.ts

@@ -10,6 +10,8 @@ import type { RenderPagesFn, RenderPageFn, RenderPagesHandlerOptions } from "./t
 import { handleError } from "../error/handleError.js";
 import { fileWriter } from "./fileWriter.js";
 import type { Manifest } from "vite";
+import { createRenderMetrics } from "../metrics/createRenderMetrics.js";
+import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
 
 const DEFAULT_BATCH_SIZE = 8;
 
@@ -23,13 +25,15 @@ function resolvePathWithManifest(path: string, manifest: Manifest): string {
 
 /**
  * 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: string,
   handlerOptions: RenderPagesHandlerOptions,
   renderPage: RenderPageFn,
   manifest: Manifest,
+  failedRoutes: Map<string, unknown>,
 ): Promise<{ route: string; results: RenderPageResult[]; error?: Error }> {
   const { autoDiscoveredFiles, cssFilesByPage, ...options } = handlerOptions;
   const { page, props, root, html } = autoDiscoveredFiles.urlMap?.get(route) || {};
@@ -44,6 +48,131 @@ async function renderSingleRoute(
     const resolvedRootPath = root ? resolvePathWithManifest(root, manifest) : undefined;
     const resolvedHtmlPath = html ? resolvePathWithManifest(html, manifest) : undefined;
 
+    // Store results for metrics tracking
+    const routeResults = new Map<string, RenderPageResult>();
+
+    // Create onEvent wrapper that handles route.error and metrics collection
+    // This mirrors the sequential renderPages behavior exactly
+    const wrapperOnEvent = (event: any) => {
+      // 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,
@@ -55,6 +184,7 @@ async function renderSingleRoute(
       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);
@@ -65,24 +195,25 @@ async function renderSingleRoute(
     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) {
+      if (result.type === "success" || result.type === "skip") {
+        // Store result for metrics tracking (wrapperOnEvent needs this)
+        routeResults.set(route, result);
+
         const rscWritePromise = fileWriter(
           result.rsc as any,
           "rsc",
-          { ...options, route, logger: options.logger },
+          { ...options, route, onEvent: wrapperOnEvent, logger: options.logger },
           options.signal
         );
 
         const htmlWritePromise = fileWriter(
           result.html as any,
           "html",
-          { ...options, route, logger: options.logger },
+          { ...options, route, onEvent: wrapperOnEvent, logger: options.logger },
           options.signal
         );
 
@@ -90,7 +221,6 @@ async function renderSingleRoute(
       }
     }
 
-    // Return error if any result was an error
     if (routeError) {
       return { route, results, error: routeError };
     }
@@ -173,7 +303,7 @@ export const renderPagesBatched: RenderPagesFn = (
 
       // Render all pages in this batch concurrently
       const batchPromises = batch.map(route => 
-        renderSingleRoute(route, handlerOptions, renderPage, manifest)
+        renderSingleRoute(route, handlerOptions, renderPage, manifest, failedRoutes)
       );
 
       const batchResults = await Promise.all(batchPromises);
@@ -191,13 +321,22 @@ export const renderPagesBatched: RenderPagesFn = (
           if (panicError != null) {
             failedRoutes.set(route, error);
             options.logger?.error(`[renderPagesBatched] Panic error for route ${route}: ${error.message}`);
+            const errorResult: RenderPagesResult = {
+              type: "error",
+              error,
+              route,
+              failedRoutes,
+              completedRoutes,
+              results,
+            };
+            yield errorResult;
+            return errorResult;
           } else {
             options.logger?.warn(`[renderPagesBatched] Non-panic error for route ${route}: ${error.message}`);
           }
         } 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);
@@ -220,36 +359,6 @@ export const renderPagesBatched: RenderPagesFn = (
       }
     }
 
-    // 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: RenderPagesResult = {
-          type: "error",
-          error: panicError,
-          route: "",
-          failedRoutes,
-          completedRoutes,
-          results,
-        };
-        yield errorResult;
-        return errorResult;
-      }
-    }
-
     // Final success result
     const finalResult: RenderPagesResult = {
       type: "success",

package/plugin/react-static/types.ts

@@ -133,6 +133,7 @@ export type RenderPagesHandlerOptions = Omit<
   cssFilesByPage: Map<string, Map<string, CssContent>>;
   serverPipeableStreamOptions: any;
   staticManifest?: Manifest; // Static manifest for consistent module IDs
+  batchSize?: number; // Concurrency for parallel rendering
 };
 
 export type RenderPagesFn = (

package/plugin/types.ts

@@ -1102,6 +1102,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 = {

package/plugin/vendor/register-vendor.ts

@@ -35,7 +35,7 @@ register("data:text/javascript," + encodeURIComponent(`
     "react-server-dom-esm/client.node":    join(ossDir, "client.node.js"),
     "react-server-dom-esm/server":         join(ossDir, "esm", "react-server-dom-esm-server.node.js"),
     "react-server-dom-esm/server.node":    join(ossDir, "esm", "react-server-dom-esm-server.node.js"),
-    "react-server-dom-esm/static":         join(ossDir, "static.js"),
+    "react-server-dom-esm/static":         join(ossDir, "static.node.js"),
     "react-server-dom-esm/static.node":    join(ossDir, "static.node.js"),
   };