vite-plugin-react-server 1.4.2 → 1.4.3

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

@@ -1,295 +1,297 @@
-import { handleError } from "../error/handleError.js";
-import { fileWriter } from "./fileWriter.js";
-import { createRenderMetrics } from "../metrics/createRenderMetrics.js";
-import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+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];
-    if (entry && entry.file) {
-        return entry.file;
-    }
-    return path;
+  const entry = manifest[path];
+  if (entry && entry.file) {
+    return entry.file;
+  }
+  return path;
 }
-/**
- * Renders a single route completely, consuming all yields from renderPage
- * and writing the RSC and HTML files. Collects metrics and handles events
- * identically to the sequential renderPages.
- */
 async function renderSingleRoute(route, handlerOptions, renderPage, manifest, failedRoutes) {
-    const { autoDiscoveredFiles, cssFilesByPage, ...options } = handlerOptions;
-    const { page, props, root, html } = autoDiscoveredFiles.urlMap?.get(route) || {};
-    if (!page) {
-        return { route, results: [], error: new Error(`No page found for route ${route}`) };
-    }
-    try {
-        const resolvedPagePath = page ? resolvePathWithManifest(page, manifest) : undefined;
-        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}`);
-                }
+  const { autoDiscoveredFiles, cssFilesByPage, ...options } = handlerOptions;
+  const { page, props, root, html } = autoDiscoveredFiles.urlMap?.get(route) || {};
+  if (!page) {
+    return { route, results: [], error: new Error(`No page found for route ${route}`) };
+  }
+  try {
+    const resolvedPagePath = page ? resolvePathWithManifest(page, manifest) : void 0;
+    const resolvedPropsPath = props ? resolvePathWithManifest(props, manifest) : void 0;
+    const resolvedRootPath = root ? resolvePathWithManifest(root, manifest) : void 0;
+    const resolvedHtmlPath = html ? resolvePathWithManifest(html, manifest) : void 0;
+    const routeResults = /* @__PURE__ */ new Map();
+    const wrapperOnEvent = (event) => {
+      if (options.onEvent) {
+        options.onEvent(event);
+      }
+      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}`
+          );
+        }
+      }
+      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,
+              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) / 1e3),
+              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
+              })
+            });
+            if (options.onMetrics) {
+              options.onMetrics(htmlMetrics);
             }
-            // 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);
-                        }
-                    }
-                }
+            if (routeResult.metrics?.rscFull) {
+              const rscFullEndTime = performance.now();
+              const rscFullMetrics = createRenderMetrics({
+                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) / 1e3),
+                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);
+              }
             }
-        };
-        const routeHandlerOptions = {
-            ...options,
-            manifest,
-            route,
-            pagePath: resolvedPagePath,
-            propsPath: resolvedPropsPath,
-            rootPath: resolvedRootPath,
-            htmlPath: resolvedHtmlPath,
-            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 = [];
-        let routeError;
-        // Consume all yields from the page renderer and write files
-        for await (const result of pageRenderer) {
-            results.push(result);
-            if (result.type === "error" && result.error) {
-                routeError = result.error instanceof Error ? result.error : new Error(String(result.error));
+          } else if (event.data.fileType === "rsc") {
+            const rscEndTime = performance.now();
+            const rscMetrics = createRenderMetrics({
+              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) / 1e3),
+              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);
             }
-            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]);
-            }
-        }
-        if (routeError) {
-            return { route, results, error: routeError };
+          }
         }
-        return { route, results };
+      }
+    };
+    const routeHandlerOptions = {
+      ...options,
+      manifest,
+      route,
+      pagePath: resolvedPagePath,
+      propsPath: resolvedPropsPath,
+      rootPath: resolvedRootPath,
+      htmlPath: resolvedHtmlPath,
+      cssFiles: cssFilesByPage?.get(route) ?? /* @__PURE__ */ new Map(),
+      globalCss: options.globalCss ?? /* @__PURE__ */ new Map(),
+      id: `${route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+      onEvent: wrapperOnEvent
+    };
+    const pageRenderer = renderPage(routeHandlerOptions);
+    const results = [];
+    let routeError;
+    for await (const result of pageRenderer) {
+      results.push(result);
+      if (result.type === "error" && result.error) {
+        routeError = result.error instanceof Error ? result.error : new Error(String(result.error));
+      }
+      if (result.type === "success" || result.type === "skip") {
+        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]);
+      }
     }
-    catch (error) {
-        return { route, results: [], error: error };
+    if (routeError) {
+      return { route, results, error: routeError };
     }
+    return { route, results };
+  } catch (error) {
+    return { route, results: [], error };
+  }
 }
-/**
- * Splits array into chunks of specified size
- */
 function chunk(array, size) {
-    const chunks = [];
-    for (let i = 0; i < array.length; i += size) {
-        chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
 }
-/**
- * Batched version of renderPages that renders pages in parallel batches
- */
-export const renderPagesBatched = (routes, handlerOptions, renderPage) => {
-    const { autoDiscoveredFiles, manifest = {}, ...options } = handlerOptions;
-    const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
-    const completedRoutes = new Set();
-    const failedRoutes = new Map();
-    const results = new Map();
-    if (!autoDiscoveredFiles?.urlMap) {
-        return (async function* _renderPagesBatched() {
+const renderPagesBatched = (routes, handlerOptions, renderPage) => {
+  const {
+    autoDiscoveredFiles,
+    manifest = {},
+    ...options
+  } = handlerOptions;
+  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+  const completedRoutes = /* @__PURE__ */ new Set();
+  const failedRoutes = /* @__PURE__ */ new Map();
+  const results = /* @__PURE__ */ new Map();
+  if (!autoDiscoveredFiles?.urlMap) {
+    return async function* _renderPagesBatched() {
+      const errorResult = {
+        type: "error",
+        error: new Error("No urlMap provided to renderPages"),
+        route: "",
+        failedRoutes: /* @__PURE__ */ new Map(),
+        completedRoutes: /* @__PURE__ */ new Set(),
+        results: /* @__PURE__ */ new Map()
+      };
+      yield errorResult;
+      return errorResult;
+    }();
+  }
+  return async function* _renderPagesBatched() {
+    const routeArray = Array.from(routes);
+    const batches = chunk(routeArray, batchSize);
+    if (options.verbose) {
+      options.logger?.info(
+        `[renderPagesBatched] Rendering ${routeArray.length} pages in ${batches.length} batches of ${batchSize}`
+      );
+    }
+    for (const batch of batches) {
+      if (options.signal?.aborted) {
+        const abortResult = {
+          type: "error",
+          error: options.signal.reason || new Error("Build aborted"),
+          route: batch[0] || "",
+          failedRoutes,
+          completedRoutes,
+          results
+        };
+        yield abortResult;
+        return abortResult;
+      }
+      const batchPromises = batch.map(
+        (route) => renderSingleRoute(route, handlerOptions, renderPage, manifest, failedRoutes)
+      );
+      const batchResults = await Promise.all(batchPromises);
+      for (const { route, results: pageResults, error } of batchResults) {
+        if (error) {
+          const panicError = handleError({
+            error,
+            logger: options.logger,
+            panicThreshold: options.panicThreshold});
+          if (panicError != null) {
+            failedRoutes.set(route, error);
+            options.logger?.error(`[renderPagesBatched] Panic error for route ${route}: ${error.message}`);
             const errorResult = {
-                type: "error",
-                error: new Error("No urlMap provided to renderPages"),
-                route: "",
-                failedRoutes: new Map(),
-                completedRoutes: new Set(),
-                results: new Map(),
+              type: "error",
+              error,
+              route,
+              failedRoutes,
+              completedRoutes,
+              results
             };
             yield errorResult;
             return errorResult;
-        })();
-    }
-    return (async function* _renderPagesBatched() {
-        const routeArray = Array.from(routes);
-        const batches = chunk(routeArray, batchSize);
-        if (options.verbose) {
-            options.logger?.info(`[renderPagesBatched] Rendering ${routeArray.length} pages in ${batches.length} batches of ${batchSize}`);
-        }
-        for (const batch of batches) {
-            // Check for abort signal
-            if (options.signal?.aborted) {
-                const abortResult = {
-                    type: "error",
-                    error: options.signal.reason || new Error("Build aborted"),
-                    route: batch[0] || "",
-                    failedRoutes,
-                    completedRoutes,
-                    results,
-                };
-                yield abortResult;
-                return abortResult;
-            }
-            // Render all pages in this batch concurrently
-            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) {
-                if (error) {
-                    const panicError = handleError({
-                        error,
-                        logger: options.logger,
-                        panicThreshold: options.panicThreshold,
-                        context: `renderPagesBatched(${route})`,
-                    });
-                    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}`);
-                    }
-                }
-                else {
-                    completedRoutes.add(route);
-                    for (const result of pageResults) {
-                        if (result.type === "success" || result.type === "skip") {
-                            results.set(route, result);
-                            yield {
-                                type: "success",
-                                route,
-                                failedRoutes,
-                                completedRoutes,
-                                results,
-                            };
-                        }
-                    }
-                }
-            }
-            if (options.verbose) {
-                options.logger?.info(`[renderPagesBatched] Completed batch: ${completedRoutes.size}/${routeArray.length} pages`);
+          } else {
+            options.logger?.warn(`[renderPagesBatched] Non-panic error for route ${route}: ${error.message}`);
+          }
+        } else {
+          completedRoutes.add(route);
+          for (const result of pageResults) {
+            if (result.type === "success" || result.type === "skip") {
+              results.set(route, result);
+              yield {
+                type: "success",
+                route,
+                failedRoutes,
+                completedRoutes,
+                results
+              };
             }
+          }
         }
-        // Final success result
-        const finalResult = {
-            type: "success",
-            route: "",
-            failedRoutes,
-            completedRoutes,
-            results,
-        };
-        return finalResult;
-    })();
+      }
+      if (options.verbose) {
+        options.logger?.info(
+          `[renderPagesBatched] Completed batch: ${completedRoutes.size}/${routeArray.length} pages`
+        );
+      }
+    }
+    const finalResult = {
+      type: "success",
+      route: "",
+      failedRoutes,
+      completedRoutes,
+      results
+    };
+    return finalResult;
+  }();
 };
+
+export { renderPagesBatched };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"renderPagesBatched.js","sources":["../../../plugin/react-static/renderPagesBatched.ts"],"sourcesContent":["/**\n * renderPagesBatched.ts\n *\n * Batched version of renderPages that renders multiple pages concurrently.\n * Uses Promise.all on batches to parallelize rendering while preserving\n * the async generator interface for compatibility.\n */\nimport type { RenderPagesResult, RenderPageResult } from \"../types.js\";\nimport type { RenderPagesFn, RenderPageFn, RenderPagesHandlerOptions } from \"./types.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { fileWriter } from \"./fileWriter.js\";\nimport type { Manifest } from \"vite\";\nimport { createRenderMetrics } from \"../metrics/createRenderMetrics.js\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\n\nconst DEFAULT_BATCH_SIZE = 8;\n\nfunction resolvePathWithManifest(path: string, manifest: Manifest): string {\n  const entry = manifest[path];\n  if (entry && entry.file) {\n    return entry.file;\n  }\n  return path;\n}\n\n/**\n * Renders a single route completely, consuming all yields from renderPage\n * and writing the RSC and HTML files. Collects metrics and handles events\n * identically to the sequential renderPages.\n */\nasync function renderSingleRoute(\n  route: string,\n  handlerOptions: RenderPagesHandlerOptions,\n  renderPage: RenderPageFn,\n  manifest: Manifest,\n  failedRoutes: Map<string, unknown>,\n): Promise<{ route: string; results: RenderPageResult[]; error?: Error }> {\n  const { autoDiscoveredFiles, cssFilesByPage, ...options } = handlerOptions;\n  const { page, props, root, html } = autoDiscoveredFiles.urlMap?.get(route) || {};\n  \n  if (!page) {\n    return { route, results: [], error: new Error(`No page found for route ${route}`) };\n  }\n\n  try {\n    const resolvedPagePath = page ? resolvePathWithManifest(page, manifest) : undefined;\n    const resolvedPropsPath = props ? resolvePathWithManifest(props, manifest) : undefined;\n    const resolvedRootPath = root ? resolvePathWithManifest(root, manifest) : undefined;\n    const resolvedHtmlPath = html ? resolvePathWithManifest(html, manifest) : undefined;\n\n    // Store results for metrics tracking\n    const routeResults = new Map<string, RenderPageResult>();\n\n    // Create onEvent wrapper that handles route.error and metrics collection\n    // This mirrors the sequential renderPages behavior exactly\n    const wrapperOnEvent = (event: any) => {\n      // Call the original onEvent first\n      if (options.onEvent) {\n        options.onEvent(event);\n      }\n\n      // Handle route.error events\n      if (event.type === \"route.error\") {\n        const detectedPanicError = handleError({\n          error: event.data.error,\n          logger: options.logger,\n          panicThreshold: event.data.panicThreshold,\n          context: `route.error (${event.data.route})`,\n        });\n        \n        if (detectedPanicError != null) {\n          options.logger?.error(\n            `[renderPagesBatched] Panic error for route ${event.data.route}: ${event.data.error.message}`\n          );\n          failedRoutes.set(event.data.route, event.data.error);\n        } else {\n          options.logger?.warn(\n            `[renderPagesBatched] Non-panic error for route ${event.data.route}: ${event.data.error.message}`\n          );\n        }\n      }\n\n      // Handle metrics collection on file.write.done\n      if (event.type === \"file.write.done\" && event.data.route === route) {\n        const routeResult = routeResults.get(route);\n        if (routeResult && routeResult.type === \"success\") {\n          if (event.data.fileType === \"html\") {\n            const endTime = performance.now();\n            const htmlMetrics = createRenderMetrics({\n              route: route,\n              type: routeResult.metrics.html.type,\n              fromMainThread: routeResult.metrics.html.fromMainThread,\n              fromRscWorker: routeResult.metrics.html.fromRscWorker,\n              fromHtmlWorker: routeResult.metrics.html.fromHtmlWorker,\n              fileSize: event.data.content.length,\n              chunks: event.data.chunks || 0,\n              processingTime: endTime - routeResult.metrics.html.streamMetrics.startTime,\n              chunkRate: (event.data.chunks || 0) / ((endTime - routeResult.metrics.html.streamMetrics.startTime) / 1000),\n              fileName: event.data.fileName,\n              outputPath: event.data.path,\n              baseDir: event.data.baseDir,\n              routePath: event.data.routePath,\n              streamMetrics: createStreamMetrics({\n                ...routeResult.metrics.html.streamMetrics,\n                chunks: event.data.chunks || 0,\n                bytes: event.data.content.length,\n                duration: endTime - routeResult.metrics.html.streamMetrics.startTime,\n                endTime: endTime,\n              }),\n            });\n\n            if (options.onMetrics) {\n              options.onMetrics(htmlMetrics);\n            }\n\n            // Also emit RSC Full metrics if available\n            if (routeResult.metrics?.rscFull) {\n              const rscFullEndTime = performance.now();\n              const rscFullMetrics = createRenderMetrics({\n                route: route,\n                type: routeResult.metrics.rscFull.type,\n                fromMainThread: routeResult.metrics.rscFull.fromMainThread,\n                fromRscWorker: routeResult.metrics.rscFull.fromRscWorker,\n                fromHtmlWorker: routeResult.metrics.rscFull.fromHtmlWorker,\n                processingTime: rscFullEndTime - routeResult.metrics.rscFull.streamMetrics.startTime,\n                chunks: routeResult.metrics.rscFull.streamMetrics.chunks,\n                chunkRate: routeResult.metrics.rscFull.streamMetrics.chunks / ((rscFullEndTime - routeResult.metrics.rscFull.streamMetrics.startTime) / 1000),\n                fileName: event.data.fileName,\n                outputPath: event.data.path,\n                baseDir: event.data.baseDir,\n                routePath: event.data.routePath,\n                streamMetrics: createStreamMetrics({\n                  ...routeResult.metrics.rscFull.streamMetrics,\n                  duration: rscFullEndTime - routeResult.metrics.rscFull.streamMetrics.startTime,\n                  endTime: rscFullEndTime,\n                }),\n              });\n\n              if (options.onMetrics) {\n                options.onMetrics(rscFullMetrics);\n              }\n            }\n          } else if (event.data.fileType === \"rsc\") {\n            const rscEndTime = performance.now();\n            const rscMetrics = createRenderMetrics({\n              route: route,\n              type: routeResult.metrics.rscHeadless.type,\n              fromMainThread: routeResult.metrics.rscHeadless.fromMainThread,\n              fromRscWorker: routeResult.metrics.rscHeadless.fromRscWorker,\n              fromHtmlWorker: routeResult.metrics.rscHeadless.fromHtmlWorker,\n              fileSize: event.data.content.length,\n              chunks: event.data.chunks || 0,\n              processingTime: rscEndTime - routeResult.metrics.rscHeadless.streamMetrics.startTime,\n              chunkRate: (event.data.chunks || 0) / ((rscEndTime - routeResult.metrics.rscHeadless.streamMetrics.startTime) / 1000),\n              fileName: event.data.fileName,\n              outputPath: event.data.path,\n              baseDir: event.data.baseDir,\n              routePath: event.data.routePath,\n              streamMetrics: createStreamMetrics({\n                ...routeResult.metrics.rscHeadless.streamMetrics,\n                chunks: event.data.chunks || 0,\n                bytes: event.data.content.length,\n                duration: rscEndTime - routeResult.metrics.rscHeadless.streamMetrics.startTime,\n                endTime: rscEndTime,\n              }),\n            });\n\n            if (options.onMetrics) {\n              options.onMetrics(rscMetrics);\n            }\n          }\n        }\n      }\n    };\n\n    const routeHandlerOptions = {\n      ...options,\n      manifest,\n      route,\n      pagePath: resolvedPagePath as string,\n      propsPath: resolvedPropsPath as string,\n      rootPath: resolvedRootPath as string,\n      htmlPath: resolvedHtmlPath as string,\n      cssFiles: cssFilesByPage?.get(route) ?? new Map(),\n      globalCss: options.globalCss ?? new Map(),\n      id: `${route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,\n      onEvent: wrapperOnEvent,\n    };\n\n    const pageRenderer = renderPage(routeHandlerOptions);\n    const results: RenderPageResult[] = [];\n    let routeError: Error | undefined;\n\n    // Consume all yields from the page renderer and write files\n    for await (const result of pageRenderer) {\n      results.push(result);\n      \n      if (result.type === \"error\" && result.error) {\n        routeError = result.error instanceof Error ? result.error : new Error(String(result.error));\n      }\n      \n      if (result.type === \"success\" || result.type === \"skip\") {\n        // Store result for metrics tracking (wrapperOnEvent needs this)\n        routeResults.set(route, result);\n\n        const rscWritePromise = fileWriter(\n          result.rsc as any,\n          \"rsc\",\n          { ...options, route, onEvent: wrapperOnEvent, logger: options.logger },\n          options.signal\n        );\n\n        const htmlWritePromise = fileWriter(\n          result.html as any,\n          \"html\",\n          { ...options, route, onEvent: wrapperOnEvent, logger: options.logger },\n          options.signal\n        );\n\n        await Promise.all([rscWritePromise, htmlWritePromise]);\n      }\n    }\n\n    if (routeError) {\n      return { route, results, error: routeError };\n    }\n\n    return { route, results };\n  } catch (error) {\n    return { route, results: [], error: error as Error };\n  }\n}\n\n/**\n * Splits array into chunks of specified size\n */\nfunction chunk<T>(array: T[], size: number): T[][] {\n  const chunks: T[][] = [];\n  for (let i = 0; i < array.length; i += size) {\n    chunks.push(array.slice(i, i + size));\n  }\n  return chunks;\n}\n\n/**\n * Batched version of renderPages that renders pages in parallel batches\n */\nexport const renderPagesBatched: RenderPagesFn = (\n  routes,\n  handlerOptions,\n  renderPage\n) => {\n  const {\n    autoDiscoveredFiles,\n    manifest = {},\n    ...options\n  } = handlerOptions;\n\n  const batchSize = (options as any).batchSize ?? DEFAULT_BATCH_SIZE;\n  const completedRoutes = new Set<string>();\n  const failedRoutes = new Map<string, unknown>();\n  const results = new Map<string, RenderPageResult>();\n\n  if (!autoDiscoveredFiles?.urlMap) {\n    return (async function* _renderPagesBatched(): AsyncGenerator<RenderPagesResult, RenderPagesResult, unknown> {\n      const errorResult: RenderPagesResult = {\n        type: \"error\",\n        error: new Error(\"No urlMap provided to renderPages\"),\n        route: \"\",\n        failedRoutes: new Map(),\n        completedRoutes: new Set(),\n        results: new Map(),\n      };\n      yield errorResult;\n      return errorResult;\n    })();\n  }\n\n  return (async function* _renderPagesBatched(): AsyncGenerator<RenderPagesResult, RenderPagesResult, unknown> {\n    const routeArray = Array.from(routes);\n    const batches = chunk(routeArray, batchSize);\n    \n    if (options.verbose) {\n      options.logger?.info(\n        `[renderPagesBatched] Rendering ${routeArray.length} pages in ${batches.length} batches of ${batchSize}`\n      );\n    }\n\n    for (const batch of batches) {\n      // Check for abort signal\n      if (options.signal?.aborted) {\n        const abortResult: RenderPagesResult = {\n          type: \"error\",\n          error: options.signal.reason || new Error(\"Build aborted\"),\n          route: batch[0] || \"\",\n          failedRoutes,\n          completedRoutes,\n          results,\n        };\n        yield abortResult;\n        return abortResult;\n      }\n\n      // Render all pages in this batch concurrently\n      const batchPromises = batch.map(route => \n        renderSingleRoute(route, handlerOptions, renderPage, manifest, failedRoutes)\n      );\n\n      const batchResults = await Promise.all(batchPromises);\n\n      // Process results from this batch\n      for (const { route, results: pageResults, error } of batchResults) {\n        if (error) {\n          const panicError = handleError({\n            error,\n            logger: options.logger,\n            panicThreshold: options.panicThreshold,\n            context: `renderPagesBatched(${route})`,\n          });\n\n          if (panicError != null) {\n            failedRoutes.set(route, error);\n            options.logger?.error(`[renderPagesBatched] Panic error for route ${route}: ${error.message}`);\n            const errorResult: RenderPagesResult = {\n              type: \"error\",\n              error,\n              route,\n              failedRoutes,\n              completedRoutes,\n              results,\n            };\n            yield errorResult;\n            return errorResult;\n          } else {\n            options.logger?.warn(`[renderPagesBatched] Non-panic error for route ${route}: ${error.message}`);\n          }\n        } else {\n          completedRoutes.add(route);\n          \n          for (const result of pageResults) {\n            if (result.type === \"success\" || result.type === \"skip\") {\n              results.set(route, result);\n              yield {\n                type: \"success\",\n                route,\n                failedRoutes,\n                completedRoutes,\n                results,\n              } satisfies RenderPagesResult;\n            }\n          }\n        }\n      }\n\n      if (options.verbose) {\n        options.logger?.info(\n          `[renderPagesBatched] Completed batch: ${completedRoutes.size}/${routeArray.length} pages`\n        );\n      }\n    }\n\n    // Final success result\n    const finalResult: RenderPagesResult = {\n      type: \"success\",\n      route: \"\",\n      failedRoutes,\n      completedRoutes,\n      results,\n    };\n\n    return finalResult;\n  })();\n};\n"],"names":[],"mappings":"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"}