vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

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

@@ -3,124 +3,565 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
+import { handleError } from '../error/handleError.js';
+import { shouldCausePanic } from '../error/panicThresholdHandler.js';
+import { fileWriter } from './fileWriter.js';
 import { createRenderMetrics } from '../metrics/createRenderMetrics.js';
-import { renderPage } from './renderPage.js';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
 
-const renderPages = async function* _renderPages(autoDiscoveredFiles, handlerOptions, cssFilesByPage) {
-  const routes = Array.from(autoDiscoveredFiles.urlMap.keys());
+function resolvePathWithManifest(path, manifest) {
+  const entry = manifest[path];
+  if (entry && entry.file) {
+    return entry.file;
+  }
+  return path;
+}
+const renderPages = (routes, handlerOptions, renderPage) => {
+  const {
+    autoDiscoveredFiles,
+    cssFilesByPage,
+    manifest = {},
+    ...options
+  } = handlerOptions;
   const completedRoutes = /* @__PURE__ */ new Set();
-  const failedRoutes = /* @__PURE__ */ new Set();
-  const baseMetrics = createRenderMetrics(routes[0]);
+  const failedRoutes = /* @__PURE__ */ new Map();
+  const activeStreams = /* @__PURE__ */ new Map();
   const results = /* @__PURE__ */ new Map();
-  const errors = [];
   if (!autoDiscoveredFiles.urlMap) {
-    throw new Error("No urlMap provided to renderPages");
+    return async function* _renderPages() {
+      yield {
+        type: "error",
+        error: new Error("No urlMap provided to renderPages"),
+        route: "",
+        failedRoutes: /* @__PURE__ */ new Map(),
+        completedRoutes: /* @__PURE__ */ new Set(),
+        results: /* @__PURE__ */ new Map()
+      };
+      return {
+        type: "error",
+        error: new Error("No urlMap provided to renderPages"),
+        route: "",
+        failedRoutes: /* @__PURE__ */ new Map(),
+        completedRoutes: /* @__PURE__ */ new Set(),
+        results: /* @__PURE__ */ new Map()
+      };
+    }();
   }
-  for (const route of routes) {
-    const { page, props, root, html } = autoDiscoveredFiles.urlMap.get(route) || {};
-    if (!page) continue;
-    try {
-      const pageRenderer = renderPage({
-        ...handlerOptions,
-        route,
-        pagePath: page,
-        propsPath: props,
-        rootPath: root,
-        htmlPath: html,
-        cssFiles: cssFilesByPage.get(route) ?? /* @__PURE__ */ new Map()
-      });
-      for await (const result of pageRenderer) {
-        if (result.type === "skip") continue;
-        if (result.type === "error") {
-          failedRoutes.add(route);
-          errors.push(result.error);
+  return async function* _renderPages() {
+    for (const route of routes) {
+      if (options.signal?.aborted) {
+        yield {
+          type: "error",
+          error: options.signal.reason || new Error("Build aborted"),
+          route,
+          failedRoutes,
+          completedRoutes,
+          results
+        };
+        return {
+          type: "error",
+          error: options.signal.reason || new Error("Build aborted"),
+          route,
+          failedRoutes,
+          completedRoutes,
+          results
+        };
+      }
+      const { page, props, root, html } = autoDiscoveredFiles.urlMap.get(route) || {};
+      if (!page) continue;
+      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;
+        if (options.verbose) {
+          options.logger?.info(
+            `[renderPages] Resolved paths for route ${route}:`
+          );
+          options.logger?.info(`  page: ${page} -> ${resolvedPagePath}`);
+          options.logger?.info(`  props: ${props} -> ${resolvedPropsPath}`);
+          options.logger?.info(`  root: ${root} -> ${resolvedRootPath}`);
+          options.logger?.info(`  html: ${html} -> ${resolvedHtmlPath}`);
+        }
+        if (options.verbose) {
+          options.logger?.info(
+            `[renderPages] Global CSS: ${options.globalCss?.size} files`
+          );
+          for (const [key, value] of options.globalCss?.entries() ?? []) {
+            options.logger?.info(
+              `[renderPages] Global CSS: ${key} -> ${value.as} (${value.children ? "inline" : "link"})`
+            );
+          }
+          options.logger?.info(
+            `[renderPages] CSS files: ${cssFilesByPage.get(route)?.size} files`
+          );
+          for (const [key, value] of cssFilesByPage.get(route)?.entries() ?? []) {
+            options.logger?.info(
+              `[renderPages] CSS file: ${key} -> ${value.as} (${value.children ? "inline" : "link"})`
+            );
+          }
+        }
+        const renderPageWrapperOnEvent = (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(
+                `[renderPages] Panic error for route ${event.data.route}: ${event.data.error.message}`
+              );
+              failedRoutes.set(event.data.route, event.data.error);
+            } else {
+              options.logger?.warn(
+                `[renderPages] Non-panic error for route ${event.data.route}: ${event.data.error.message}`
+              );
+            }
+          }
+        };
+        const routeHandlerOptions = {
+          ...options,
+          manifest,
+          route,
+          pagePath: resolvedPagePath,
+          propsPath: resolvedPropsPath,
+          rootPath: resolvedRootPath,
+          htmlPath: resolvedHtmlPath,
+          cssFiles: cssFilesByPage.get(route) ?? /* @__PURE__ */ new Map(),
+          // Ensure global CSS is available to Html component
+          globalCss: options.globalCss ?? /* @__PURE__ */ new Map(),
+          // Generate unique ID for this route
+          id: `${route}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+          // Override onEvent to use our wrapper
+          onEvent: renderPageWrapperOnEvent
+        };
+        const pageRenderer = renderPage(routeHandlerOptions);
+        if (options.verbose) {
+          options.logger?.info(
+            `[renderPages] Starting to process route: ${route}`
+          );
+        }
+        for await (const result of pageRenderer) {
+          if (options.verbose) {
+            options.logger?.info(
+              `[renderPages] Received result for route ${route}: ${result.type}`
+            );
+          }
+          if (result.type === "skip") {
+            if (options.verbose) {
+              options.logger?.info(
+                `[renderPages] Skipping RSC for route ${route} due to error: ${result.reason}`
+              );
+            }
+            failedRoutes.set(route, result.reason);
+            results.set(route, {
+              type: "success",
+              html: result.html,
+              rsc: result.rsc,
+              metrics: result.metrics
+            });
+            try {
+              const wrapperOnEvent = (event) => {
+                if (options.onEvent) {
+                  options.onEvent(event);
+                }
+                if (event.type === "file.write.done" && event.data.route === route && event.data.fileType === "html") {
+                  const routeResult = results.get(route);
+                  if (routeResult && routeResult.type === "success") {
+                    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);
+                    }
+                  }
+                }
+              };
+              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]);
+              completedRoutes.add(route);
+              if (options.verbose) {
+                options.logger?.info(
+                  `[renderPages] Wrote HTML-only file for skipped route: ${route}`
+                );
+              }
+            } catch (writeError) {
+              if (options.verbose) {
+                options.logger?.error(
+                  `[renderPages] Failed to write HTML for skipped route ${route}: ${writeError}`
+                );
+              }
+              completedRoutes.delete(route);
+            }
+            continue;
+          }
+          if (result.type === "error") {
+            if (options.verbose) {
+              options.logger?.error(
+                `[renderPages] Error for route ${route}: ${result.error}`
+              );
+            }
+            failedRoutes.set(route, result.error);
+            yield {
+              type: "error",
+              error: result.error,
+              route,
+              failedRoutes,
+              completedRoutes,
+              results
+            };
+            continue;
+          }
+          if (result.type === "success") {
+            if (options.verbose) {
+              options.logger?.info(
+                `[renderPages] Success for route ${route}, starting file writes`
+              );
+            }
+            completedRoutes.add(route);
+            results.set(route, {
+              type: "success",
+              html: result.html,
+              rsc: result.rsc,
+              metrics: result.metrics
+            });
+            activeStreams.set(route, {
+              html: result.html,
+              rsc: result.rsc
+            });
+            try {
+              const wrapperOnEvent = (event) => {
+                try {
+                  if (options.onEvent) {
+                    options.onEvent(event);
+                  }
+                } catch (error) {
+                  options.logger?.error(`[renderPages] onEvent handler threw error: ${error.message}`);
+                  for (const [, streams] of activeStreams) {
+                    try {
+                      streams.html.abort("Build cancelled");
+                      streams.rsc.abort("Build cancelled");
+                    } catch (abortError) {
+                    }
+                  }
+                  if (options.rscWorker) {
+                    try {
+                      options.rscWorker.postMessage({
+                        type: "SHUTDOWN",
+                        id: "*"
+                      });
+                    } catch (shutdownError) {
+                    }
+                  }
+                  throw error;
+                }
+                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(
+                      `[renderPages] Panic error for route ${event.data.route}: ${event.data.error.message}`
+                    );
+                    failedRoutes.set(event.data.route, event.data.error);
+                  } else {
+                    options.logger?.warn(
+                      `[renderPages] Non-panic error for route ${event.data.route}: ${event.data.error.message}`
+                    );
+                  }
+                }
+                if (event.type === "file.write.done" && event.data.route === route) {
+                  const routeResult = results.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);
+                      }
+                      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
+                          })
+                          // this stream is consumed by the html stream
+                        });
+                        if (options.onMetrics) {
+                          options.onMetrics(rscFullMetrics);
+                        }
+                      }
+                    } 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);
+                      }
+                    }
+                  }
+                }
+              };
+              const renderPageOnEvent = (event) => {
+                wrapperOnEvent(event);
+              };
+              const rscWritePromise = fileWriter(
+                result.rsc,
+                "rsc",
+                {
+                  ...options,
+                  route,
+                  onEvent: renderPageOnEvent,
+                  logger: options.logger
+                },
+                options.signal
+              );
+              const htmlWritePromise = fileWriter(
+                result.html,
+                "html",
+                {
+                  ...options,
+                  route,
+                  onEvent: renderPageOnEvent,
+                  logger: options.logger
+                },
+                options.signal
+              );
+              await Promise.all([rscWritePromise, htmlWritePromise]);
+              activeStreams.delete(route);
+              if (options.verbose) {
+                options.logger?.info(
+                  `[renderPages] Successfully wrote files for route: ${route}`
+                );
+              }
+            } catch (error) {
+              if (options.verbose) {
+                options.logger?.error(
+                  `[renderPages] Failed to write files for route: ${route}: ${error}`
+                );
+              }
+              failedRoutes.set(route, error);
+              completedRoutes.delete(route);
+              results.delete(route);
+            }
+            yield {
+              type: "success",
+              route,
+              completedRoutes,
+              failedRoutes,
+              results
+            };
+          }
+        }
+      } catch (err) {
+        const panicError = handleError({
+          error: err,
+          logger: options.logger,
+          panicThreshold: options.panicThreshold});
+        if (panicError != null) {
           yield {
             type: "error",
-            error: result.error,
+            error: panicError,
+            route,
             failedRoutes,
             completedRoutes,
-            htmlSizes: baseMetrics.htmlSizes,
-            rscSizes: baseMetrics.rscSizes,
-            streamMetrics: baseMetrics.streamMetrics,
             results
           };
-          continue;
+          break;
         }
-        if (result.type === "success") {
-          completedRoutes.add(route);
-          results.set(route, {
-            html: result.html,
-            rsc: result.rsc,
-            metrics: result.metrics
-          });
-          baseMetrics.htmlSizes.set(route, result.metrics.rscFull.bytes);
-          baseMetrics.rscSizes.set(route, result.metrics.rscHeadless.bytes);
-          baseMetrics.streamMetrics = {
-            ...baseMetrics.streamMetrics,
-            chunks: Math.max(
-              baseMetrics.streamMetrics.chunks,
-              result.metrics.rscFull.chunks
-            ),
-            bytes: Math.max(
-              baseMetrics.streamMetrics.bytes,
-              result.metrics.rscFull.bytes
-            ),
-            duration: Math.max(
-              baseMetrics.streamMetrics.duration,
-              result.metrics.rscFull.duration
-            ),
-            startTime: Math.min(
-              baseMetrics.streamMetrics.startTime,
-              result.metrics.rscFull.startTime
-            )
-          };
-          yield {
-            type: "success",
-            completedRoutes,
-            htmlSizes: baseMetrics.htmlSizes,
-            rscSizes: baseMetrics.rscSizes,
-            streamMetrics: baseMetrics.streamMetrics,
-            results
-          };
+        try {
+          results.delete(route);
+          completedRoutes.delete(route);
+          failedRoutes.set(route, err);
+        } catch (cleanupError) {
+          options.logger?.warn(
+            `Failed to cleanup resources for route ${route}: ${cleanupError}`
+          );
         }
+        yield {
+          type: "success",
+          // Change from error to success for non-panic route errors
+          route,
+          failedRoutes,
+          completedRoutes,
+          results
+        };
+        if (options.panicThreshold === "none") {
+          if (options.verbose) {
+            options.logger.info(
+              `[renderPages] Stopping render loop due to error with panicThreshold: "none"`
+            );
+          }
+          break;
+        }
+      }
+    }
+    if (options.verbose) {
+      options.logger.info(
+        `[renderPages] Final state - completedRoutes: ${completedRoutes.size}, failedRoutes: ${failedRoutes.size}`
+      );
+    }
+    yield {
+      type: "success",
+      route: "",
+      // No specific route for final result
+      completedRoutes,
+      failedRoutes,
+      results
+    };
+    if (options.verbose) {
+      options.logger.info(`[renderPages] Returning success result`);
+    }
+    if (options.verbose) {
+      options.logger.info(`[renderPages] About to return success result`);
+    }
+    const shouldPanic = failedRoutes.size > 0 && shouldCausePanic(
+      Array.from(failedRoutes.values())[0],
+      // Check first failed route
+      { panicThreshold: options.panicThreshold }
+    );
+    if (options.verbose) {
+      options.logger?.info(
+        `[renderPages] Panic check - failedRoutes.size: ${failedRoutes.size}, panicThreshold: ${options.panicThreshold}, shouldPanic: ${shouldPanic}`
+      );
+    }
+    if (shouldPanic) {
+      const firstError = Array.from(failedRoutes.values())[0];
+      if (options.verbose) {
+        options.logger?.error(
+          `[renderPages] Yielding panic error: ${firstError instanceof Error ? firstError.message : String(firstError)}`
+        );
       }
-    } catch (err) {
-      failedRoutes.add(route);
-      errors.push(err instanceof Error ? err : new Error(String(err)));
       yield {
         type: "error",
-        error: err instanceof Error ? err : new Error(String(err)),
+        error: firstError instanceof Error ? firstError : new Error(String(firstError)),
+        route: "",
+        // No specific route for global panic
+        completedRoutes,
         failedRoutes,
+        results
+      };
+      return {
+        type: "error",
+        error: firstError instanceof Error ? firstError : new Error(String(firstError)),
+        route: "",
         completedRoutes,
-        htmlSizes: baseMetrics.htmlSizes,
-        rscSizes: baseMetrics.rscSizes,
-        streamMetrics: baseMetrics.streamMetrics,
+        failedRoutes,
         results
       };
     }
-  }
-  if (failedRoutes.size > 0) {
     return {
-      type: "error",
-      error: errors[0],
-      failedRoutes,
+      type: "success",
       completedRoutes,
-      htmlSizes: baseMetrics.htmlSizes,
-      rscSizes: baseMetrics.rscSizes,
-      streamMetrics: baseMetrics.streamMetrics,
+      failedRoutes,
       results
     };
-  }
-  return {
-    type: "success",
-    completedRoutes,
-    failedRoutes: void 0,
-    htmlSizes: baseMetrics.htmlSizes,
-    rscSizes: baseMetrics.rscSizes,
-    streamMetrics: baseMetrics.streamMetrics,
-    results
-  };
+  }();
 };
 
 export { renderPages };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"renderPages.js","sources":["../../../plugin/react-static/renderPages.ts"],"sourcesContent":["/**\n * renderPages.ts\n *\n * PURPOSE: Processes React Server Components (RSC) streams and writes output files\n *\n * This module:\n * 1. Creates RSC and HTML streams for each route\n * 2. Pipes RSC stream directly to .rsc files\n * 3. Transforms RSC to HTML via worker and pipes to .html files\n * 4. Collects metrics and handles errors\n */\nimport { createRenderMetrics } from \"../metrics/createRenderMetrics.js\";\nimport { renderPage } from \"./renderPage.js\";\nimport type { PassThrough } from \"node:stream\";\nimport type {\n  StreamMetrics,\n  RenderPagesResult,\n  AutoDiscoveredFiles,\n  CssContent,\n  MultiPageHandlerOptions,\n} from \"../types.js\";\n\nexport type RenderPagesReturn = AsyncGenerator<RenderPagesResult, RenderPagesResult, unknown>;\n\nexport type RenderPagesFn = <\n  Opt extends MultiPageHandlerOptions = MultiPageHandlerOptions\n>(\n  autoDiscoveredFiles: AutoDiscoveredFiles, \n  handlerOptions: Opt,\n  cssFilesByPage: Map<string, Map<string, CssContent<boolean>>>\n) => RenderPagesReturn;\n\nexport const renderPages: RenderPagesFn = async function* _renderPages(\n  autoDiscoveredFiles,\n  handlerOptions,\n  cssFilesByPage\n) {\n  const routes = Array.from(autoDiscoveredFiles.urlMap.keys());\n  const completedRoutes = new Set<string>();\n  const failedRoutes = new Set<string>();\n  const baseMetrics = createRenderMetrics(routes[0]);\n  const results = new Map<\n    string,\n    {\n      html: PassThrough;\n      rsc: PassThrough;\n      metrics: {\n        rscFull: StreamMetrics;\n        rscHeadless: StreamMetrics;\n      };\n    }\n  >();\n  const errors: Error[] = [];\n\n  if (!autoDiscoveredFiles.urlMap) {\n    throw new Error(\"No urlMap provided to renderPages\");\n  }\n\n  for (const route of routes) {\n    const { page, props, root, html } = autoDiscoveredFiles.urlMap.get(route) || {};\n    if (!page) continue;\n\n    try {\n      const pageRenderer = renderPage({\n        ...handlerOptions,\n        route,\n        pagePath: page as string,\n        propsPath: props as string,\n        rootPath: root as string,\n        htmlPath: html as string,\n        cssFiles: cssFilesByPage.get(route) ?? new Map(),\n      });\n\n      for await (const result of pageRenderer) {\n        if (result.type === \"skip\") continue;\n\n        if (result.type === \"error\") {\n          failedRoutes.add(route);\n          errors.push(result.error);\n          yield {\n            type: \"error\",\n            error: result.error,\n            failedRoutes,\n            completedRoutes,\n            htmlSizes: baseMetrics.htmlSizes,\n            rscSizes: baseMetrics.rscSizes,\n            streamMetrics: baseMetrics.streamMetrics,\n            results,\n          } as const;\n          continue;\n        }\n\n        if (result.type === \"success\") {\n          completedRoutes.add(route);\n          results.set(route, {\n            html: result.html,\n            rsc: result.rsc,\n            metrics: result.metrics,\n          });\n\n          // Update metrics\n          baseMetrics.htmlSizes.set(route, result.metrics.rscFull.bytes);\n          baseMetrics.rscSizes.set(route, result.metrics.rscHeadless.bytes);\n          baseMetrics.streamMetrics = {\n            ...baseMetrics.streamMetrics,\n            chunks: Math.max(\n              baseMetrics.streamMetrics.chunks,\n              result.metrics.rscFull.chunks\n            ),\n            bytes: Math.max(\n              baseMetrics.streamMetrics.bytes,\n              result.metrics.rscFull.bytes\n            ),\n            duration: Math.max(\n              baseMetrics.streamMetrics.duration,\n              result.metrics.rscFull.duration\n            ),\n            startTime: Math.min(\n              baseMetrics.streamMetrics.startTime,\n              result.metrics.rscFull.startTime\n            ),\n          };\n\n          yield {\n            type: \"success\",\n            completedRoutes,\n            htmlSizes: baseMetrics.htmlSizes,\n            rscSizes: baseMetrics.rscSizes,\n            streamMetrics: baseMetrics.streamMetrics,\n            results,\n          } as const;\n        }\n      }\n    } catch (err) {\n      failedRoutes.add(route);\n      errors.push(err instanceof Error ? err : new Error(String(err)));\n      yield {\n        type: \"error\",\n        error: err instanceof Error ? err : new Error(String(err)),\n        failedRoutes,\n        completedRoutes,\n        htmlSizes: baseMetrics.htmlSizes,\n        rscSizes: baseMetrics.rscSizes,\n        streamMetrics: baseMetrics.streamMetrics,\n        results,\n      } as const;\n    }\n  }\n\n  if (failedRoutes.size > 0) {\n    return {\n      type: \"error\",\n      error: errors[0],\n      failedRoutes,\n      completedRoutes,\n      htmlSizes: baseMetrics.htmlSizes,\n      rscSizes: baseMetrics.rscSizes,\n      streamMetrics: baseMetrics.streamMetrics,\n      results,\n    } as const;\n  }\n\n  return {\n    type: \"success\",\n    completedRoutes,\n    failedRoutes: undefined,\n    htmlSizes: baseMetrics.htmlSizes,\n    rscSizes: baseMetrics.rscSizes,\n    streamMetrics: baseMetrics.streamMetrics,\n    results,\n  } as const;\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"renderPages.js","sources":["../../../plugin/react-static/renderPages.ts"],"sourcesContent":["/**\n * renderPages.ts\n *\n * PURPOSE: Renders multiple pages in parallel with proper error handling\n *\n * This module:\n * 1. Takes a list of routes and renders each page\n * 2. Handles errors gracefully with configurable panic thresholds\n * 3. Collects metrics for each rendered page\n * 4. Supports retrying failed routes with fallback components\n * 5. Retries failed routes with no-op Page component for minimal HTML shells\n */\nimport type { RenderPagesResult, RenderPageResult } from \"../types.js\";\nimport type { RenderPagesFn } from \"./types.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { shouldCausePanic } from \"../error/panicThresholdHandler.js\";\nimport { fileWriter } from \"./fileWriter.js\";\n\nimport type { Manifest } from \"vite\";\nimport { createRenderMetrics } from \"../metrics/createRenderMetrics.js\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\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 all pages for static generation\n *\n * This function:\n * 1. Iterates through all routes in the urlMap\n * 2. Renders each page using the provided renderPage function\n * 3. Writes both RSC and HTML files for each route\n * 4. Handles errors according to panic threshold\n * 5. Retries failed routes with no-op Page component for minimal HTML shells\n */\nexport const renderPages: RenderPagesFn = (\n  routes,\n  handlerOptions,\n  renderPage\n) => {\n  const {\n    autoDiscoveredFiles,\n    cssFilesByPage,\n    manifest = {},\n    ...options\n  } = handlerOptions;\n  const completedRoutes = new Set<string>();\n  const failedRoutes = new Map<string, unknown>();\n  const activeStreams = new Map<string, { html: { abort: (reason?: unknown) => void }, rsc: { abort: (reason?: unknown) => void } }>();\n\n  const results = new Map<string, RenderPageResult>();\n\n  if (!autoDiscoveredFiles.urlMap) {\n    // Return an error result instead of throwing\n    return (async function* _renderPages(): AsyncGenerator<RenderPagesResult, RenderPagesResult, unknown> {\n      yield {\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      } satisfies RenderPagesResult;\n      return {\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      } satisfies RenderPagesResult;\n    })();\n  }\n\n  return (async function* _renderPages(): AsyncGenerator<RenderPagesResult, RenderPagesResult, unknown> {\n    // First pass: render all routes normally\n    for (const route of routes) {\n      // Check for abort signal\n      if (options.signal?.aborted) {\n        yield {\n          type: \"error\",\n          error: options.signal.reason || new Error(\"Build aborted\"),\n          route: route,\n          failedRoutes,\n          completedRoutes,\n          results,\n        } satisfies RenderPagesResult;\n        return {\n          type: \"error\",\n          error: options.signal.reason || new Error(\"Build aborted\"),\n          route: route,\n          failedRoutes,\n          completedRoutes,\n          results,\n        } satisfies RenderPagesResult;\n      }\n      const { page, props, root, html } =\n        autoDiscoveredFiles.urlMap.get(route) || {};\n      if (!page) continue;\n\n      try {\n        const resolvedPagePath = page\n          ? resolvePathWithManifest(page, manifest)\n          : undefined;\n        const resolvedPropsPath = props\n          ? resolvePathWithManifest(props, manifest)\n          : undefined;\n        const resolvedRootPath = root\n          ? resolvePathWithManifest(root, manifest)\n          : undefined;\n        const resolvedHtmlPath = html\n          ? resolvePathWithManifest(html, manifest)\n          : undefined;\n\n        if (options.verbose) {\n          options.logger?.info(\n            `[renderPages] Resolved paths for route ${route}:`\n          );\n          options.logger?.info(`  page: ${page} -> ${resolvedPagePath}`);\n          options.logger?.info(`  props: ${props} -> ${resolvedPropsPath}`);\n          options.logger?.info(`  root: ${root} -> ${resolvedRootPath}`);\n          options.logger?.info(`  html: ${html} -> ${resolvedHtmlPath}`);\n        }\n        if (options.verbose) {\n          options.logger?.info(\n            `[renderPages] Global CSS: ${options.globalCss?.size} files`\n          );\n          for (const [key, value] of options.globalCss?.entries() ?? []) {\n            options.logger?.info(\n              `[renderPages] Global CSS: ${key} -> ${value.as} (${\n                value.children ? \"inline\" : \"link\"\n              })`\n            );\n          }\n          options.logger?.info(\n            `[renderPages] CSS files: ${cssFilesByPage.get(route)?.size} files`\n          );\n          for (const [key, value] of cssFilesByPage.get(route)?.entries() ??\n            []) {\n            options.logger?.info(\n              `[renderPages] CSS file: ${key} -> ${value.as} (${\n                value.children ? \"inline\" : \"link\"\n              })`\n            );\n          }\n        }\n\n        // Create a wrapper onEvent that handles route.error events in renderPages\n        const renderPageWrapperOnEvent = (event: any) => {\n          // Call the original onEvent first\n          if (options.onEvent) {\n            options.onEvent(event);\n          }\n\n          // Handle route.error events here in renderPages\n          if (event.type === \"route.error\") {\n            // Make panic decision in the main thread based on panicThreshold\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              // This is a panic threshold error, add it to failed routes\n              options.logger?.error(\n                `[renderPages] Panic error for route ${event.data.route}: ${event.data.error.message}`\n              );\n              failedRoutes.set(event.data.route, event.data.error);\n            } else {\n              // For non-panic errors, just log and continue\n              options.logger?.warn(\n                `[renderPages] Non-panic error for route ${event.data.route}: ${event.data.error.message}`\n              );\n            }\n          }\n        };\n\n        // Create unique handler options for this route\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          // Ensure global CSS is available to Html component\n          globalCss: options.globalCss ?? new Map(),\n          // Generate unique ID for this route\n          id: `${route}-${Date.now()}-${Math.random()\n            .toString(36)\n            .substring(2, 11)}`,\n          // Override onEvent to use our wrapper\n          onEvent: renderPageWrapperOnEvent,\n        };\n\n        const pageRenderer = renderPage(routeHandlerOptions);\n\n        if (options.verbose) {\n          options.logger?.info(\n            `[renderPages] Starting to process route: ${route}`\n          );\n        }\n\n        for await (const result of pageRenderer) {\n          if (options.verbose) {\n            options.logger?.info(\n              `[renderPages] Received result for route ${route}: ${result.type}`\n            );\n          }\n\n          if (result.type === \"skip\") {\n            if (options.verbose) {\n              options.logger?.info(\n                `[renderPages] Skipping RSC for route ${route} due to error: ${result.reason}`\n              );\n            }\n\n            // For skipped routes, we still want to write the HTML file (client-only)\n            // but skip the RSC file since there was a server error\n            failedRoutes.set(route, result.reason);\n\n            // Store the result with the streams provided by renderPage\n            results.set(route, {\n              type: \"success\",\n              html: result.html,\n              rsc: result.rsc,\n              metrics: result.metrics,\n            });\n\n            // Write both HTML and RSC files for skipped routes (RSC will be empty)\n            try {\n              const wrapperOnEvent = (event: any) => {\n                if (options.onEvent) {\n                  options.onEvent(event);\n                }\n\n                // Handle metrics for HTML-only writes\n                if (\n                  event.type === \"file.write.done\" &&\n                  event.data.route === route &&\n                  event.data.fileType === \"html\"\n                ) {\n                  const routeResult = results.get(route);\n                  if (routeResult && routeResult.type === \"success\") {\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:\n                        endTime -\n                        routeResult.metrics.html.streamMetrics.startTime,\n                      chunkRate:\n                        (event.data.chunks || 0) /\n                        ((endTime -\n                          routeResult.metrics.html.streamMetrics.startTime) /\n                          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:\n                          endTime -\n                          routeResult.metrics.html.streamMetrics.startTime,\n                        endTime: endTime,\n                      }),\n                    });\n\n                    if (options.onMetrics) {\n                      options.onMetrics(htmlMetrics);\n                    }\n                  }\n                }\n              };\n\n              const rscWritePromise = fileWriter(\n                result.rsc as any,\n                \"rsc\",\n                {\n                  ...options,\n                  route,\n                  onEvent: wrapperOnEvent,\n                  logger: options.logger,\n                },\n                options.signal\n              );\n\n              const htmlWritePromise = fileWriter(\n                result.html as any,\n                \"html\",\n                {\n                  ...options,\n                  route,\n                  onEvent: wrapperOnEvent,\n                  logger: options.logger,\n                },\n                options.signal\n              );\n\n              // Wait for both RSC and HTML files to be written\n              await Promise.all([rscWritePromise, htmlWritePromise]);\n\n              completedRoutes.add(route);\n\n              if (options.verbose) {\n                options.logger?.info(\n                  `[renderPages] Wrote HTML-only file for skipped route: ${route}`\n                );\n              }\n            } catch (writeError) {\n              if (options.verbose) {\n                options.logger?.error(\n                  `[renderPages] Failed to write HTML for skipped route ${route}: ${writeError}`\n                );\n              }\n              // Remove from completed routes if HTML write failed\n              completedRoutes.delete(route);\n            }\n\n            continue;\n          }\n\n          if (result.type === \"error\") {\n            if (options.verbose) {\n              options.logger?.error(\n                `[renderPages] Error for route ${route}: ${result.error}`\n              );\n            }\n            failedRoutes.set(route, result.error);\n            yield {\n              type: \"error\",\n              error: result.error,\n              route: route,\n              failedRoutes,\n              completedRoutes,\n              results,\n            } satisfies RenderPagesResult;\n            continue;\n          }\n\n          if (result.type === \"success\") {\n            if (options.verbose) {\n              options.logger?.info(\n                `[renderPages] Success for route ${route}, starting file writes`\n              );\n            }\n            completedRoutes.add(route);\n            // Store the result with the correct type structure\n            results.set(route, {\n              type: \"success\",\n              html: result.html,\n              rsc: result.rsc,\n              metrics: result.metrics,\n            });\n\n            // Store active streams for potential abortion during cancellation\n            activeStreams.set(route, {\n              html: result.html,\n              rsc: result.rsc,\n            });\n\n            // Write files directly in renderPages\n            try {\n              // Create a wrapper onEvent that calls both the renderPage's event handler and the original onEvent\n              const wrapperOnEvent = (event: any) => {\n                try {\n                  // Call the original onEvent first\n                  if (options.onEvent) {\n                    options.onEvent(event);\n                  }\n                } catch (error) {\n                  // If onEvent throws an error (e.g., build cancellation), we need to stop processing\n                  // This prevents the worker from continuing to process after the build is cancelled\n                  options.logger?.error(`[renderPages] onEvent handler threw error: ${(error as Error).message}`);\n                  \n                  // First, abort all active streams to stop data flow\n                  // This is critical to prevent unhandled errors and memory leaks\n                  for (const [, streams] of activeStreams) {\n                    try {\n                      streams.html.abort(\"Build cancelled\");\n                      streams.rsc.abort(\"Build cancelled\");\n                    } catch (abortError) {\n                      // Streams may already be closed, ignore\n                    }\n                  }\n                  \n                  // Then send shutdown signal to worker to prevent it from continuing to process\n                  if (options.rscWorker) {\n                    try {\n                      options.rscWorker.postMessage({\n                        type: \"SHUTDOWN\",\n                        id: \"*\",\n                      });\n                    } catch (shutdownError) {\n                      // Worker may already be terminated, ignore\n                    }\n                  }\n                  \n                  // Re-throw the error to stop the build process\n                  throw error;\n                }\n\n                // Handle route.error events\n                if (event.type === \"route.error\") {\n                  // Make panic decision in the main thread based on panicThreshold\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                    // This is a panic threshold error, add it to failed routes to be yielded\n                    options.logger?.error(\n                      `[renderPages] Panic error for route ${event.data.route}: ${event.data.error.message}`\n                    );\n                    failedRoutes.set(event.data.route, event.data.error);\n                  } else {\n                    // For non-panic errors, just log and continue\n                    options.logger?.warn(\n                      `[renderPages] Non-panic error for route ${event.data.route}: ${event.data.error.message}`\n                    );\n                  }\n                }\n\n                // Handle metrics collection here since the renderPage function's event handler is not being called\n                if (\n                  event.type === \"file.write.done\" &&\n                  event.data.route === route\n                ) {\n                  const routeResult = results.get(route);\n                  if (routeResult && routeResult.type === \"success\") {\n                    if (event.data.fileType === \"html\") {\n                      // Update HTML metrics with actual file data\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:\n                          endTime -\n                          routeResult.metrics.html.streamMetrics.startTime,\n                        chunkRate:\n                          (event.data.chunks || 0) /\n                          ((endTime -\n                            routeResult.metrics.html.streamMetrics.startTime) /\n                            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:\n                            endTime -\n                            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 (the RSC chunks sent to HTML worker)\n                      // Only if metrics.rscFull exists (might be missing on errors)\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:\n                            routeResult.metrics.rscFull.fromMainThread,\n                          fromRscWorker:\n                            routeResult.metrics.rscFull.fromRscWorker,\n                          fromHtmlWorker:\n                            routeResult.metrics.rscFull.fromHtmlWorker,\n                          processingTime:\n                            rscFullEndTime -\n                            routeResult.metrics.rscFull.streamMetrics.startTime,\n                          chunks:\n                            routeResult.metrics.rscFull.streamMetrics.chunks,\n                          chunkRate:\n                            routeResult.metrics.rscFull.streamMetrics.chunks /\n                            ((rscFullEndTime -\n                              routeResult.metrics.rscFull.streamMetrics\n                                .startTime) /\n                              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:\n                              rscFullEndTime -\n                              routeResult.metrics.rscFull.streamMetrics.startTime,\n                            endTime: rscFullEndTime,\n                          }),\n                          // this stream is consumed by the html stream\n                        });\n\n                        if (options.onMetrics) {\n                          options.onMetrics(rscFullMetrics);\n                        }\n                      }\n                    } else if (event.data.fileType === \"rsc\") {\n                      // Update RSC metrics with actual file data\n                      const rscEndTime = performance.now();\n                      const rscMetrics = createRenderMetrics({\n                        route: route,\n                        type: routeResult.metrics.rscHeadless.type,\n                        fromMainThread:\n                          routeResult.metrics.rscHeadless.fromMainThread,\n                        fromRscWorker:\n                          routeResult.metrics.rscHeadless.fromRscWorker,\n                        fromHtmlWorker:\n                          routeResult.metrics.rscHeadless.fromHtmlWorker,\n                        fileSize: event.data.content.length,\n                        chunks: event.data.chunks || 0,\n                        processingTime:\n                          rscEndTime -\n                          routeResult.metrics.rscHeadless.streamMetrics\n                            .startTime,\n                        chunkRate:\n                          (event.data.chunks || 0) /\n                          ((rscEndTime -\n                            routeResult.metrics.rscHeadless.streamMetrics\n                              .startTime) /\n                            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:\n                            rscEndTime -\n                            routeResult.metrics.rscHeadless.streamMetrics\n                              .startTime,\n                          endTime: rscEndTime,\n                        }),\n                      });\n\n                      if (options.onMetrics) {\n                        options.onMetrics(rscMetrics);\n                      }\n                    }\n                  }\n                }\n              };\n\n              // Create a wrapper that calls the renderPage's event handler\n              const renderPageOnEvent = (event: any) => {\n                // This will be called by the renderPage function's event handler\n                wrapperOnEvent(event);\n              };\n\n              const rscWritePromise = fileWriter(\n                result.rsc as any,\n                \"rsc\",\n                {\n                  ...options,\n                  route,\n                  onEvent: renderPageOnEvent,\n                  logger: options.logger,\n                },\n                options.signal\n              );\n\n              const htmlWritePromise = fileWriter(\n                result.html as any,\n                \"html\",\n                {\n                  ...options,\n                  route,\n                  onEvent: renderPageOnEvent,\n                  logger: options.logger,\n                },\n                options.signal\n              );\n\n              // Wait for both RSC and HTML files to be written\n              await Promise.all([rscWritePromise, htmlWritePromise]);\n\n              // Clean up active streams after successful completion\n              activeStreams.delete(route);\n\n              // Metrics are now handled by the individual renderPage functions\n              // No need to duplicate metrics collection here\n\n              if (options.verbose) {\n                options.logger?.info(\n                  `[renderPages] Successfully wrote files for route: ${route}`\n                );\n              }\n            } catch (error) {\n              if (options.verbose) {\n                options.logger?.error(\n                  `[renderPages] Failed to write files for route: ${route}: ${error}`\n                );\n              }\n              // If file writing fails, treat it as a failed route\n              failedRoutes.set(route, error);\n              completedRoutes.delete(route);\n              results.delete(route);\n            }\n\n            // Yield after each page is completed\n            yield {\n              type: \"success\",\n              route: route,\n              completedRoutes,\n              failedRoutes,\n              results,\n            } satisfies RenderPagesResult;\n          }\n        }\n      } catch (err) {\n        const panicError = handleError({\n          error: err,\n          logger: options.logger,\n          panicThreshold: options.panicThreshold,\n          context: `renderPages(${route})`,\n        });\n\n        // If this is a panic error, yield it immediately to fail the build\n        if (panicError != null) {\n          yield {\n            type: \"error\",\n            error: panicError,\n            route: route,\n            failedRoutes,\n            completedRoutes,\n            results,\n          } satisfies RenderPagesResult;\n          break; // Stop processing additional routes for panic errors\n        }\n\n        // Clean up any resources that might have been created\n        try {\n          // Clear any cached state for this route\n          results.delete(route);\n          completedRoutes.delete(route);\n\n          // Add to failed routes for non-panic errors\n          failedRoutes.set(route, err);\n        } catch (cleanupError) {\n          options.logger?.warn(\n            `Failed to cleanup resources for route ${route}: ${cleanupError}`\n          );\n        }\n\n        yield {\n          type: \"success\", // Change from error to success for non-panic route errors\n          route: route,\n          failedRoutes,\n          completedRoutes,\n          results,\n        } satisfies RenderPagesResult;\n\n        // For panicThreshold: \"none\", stop processing additional routes when there's an error\n        // This prevents the build from continuing with broken pages\n        if (options.panicThreshold === \"none\") {\n          if (options.verbose) {\n            options.logger.info(\n              `[renderPages] Stopping render loop due to error with panicThreshold: \"none\"`\n            );\n          }\n          break;\n        }\n      }\n    }\n\n    if (options.verbose) {\n      options.logger.info(\n        `[renderPages] Final state - completedRoutes: ${completedRoutes.size}, failedRoutes: ${failedRoutes.size}`\n      );\n    }\n\n    // Always yield a final result before checking panic threshold\n    yield {\n      type: \"success\",\n      route: \"\", // No specific route for final result\n      completedRoutes,\n      failedRoutes,\n      results,\n    } satisfies RenderPagesResult;\n\n    if (options.verbose) {\n      options.logger.info(`[renderPages] Returning success result`);\n    }\n\n    if (options.verbose) {\n      options.logger.info(`[renderPages] About to return success result`);\n    }\n\n    // Use centralized panic threshold logic\n    const shouldPanic = failedRoutes.size > 0 && shouldCausePanic(\n      Array.from(failedRoutes.values())[0], // Check first failed route\n      { panicThreshold: options.panicThreshold }\n    );\n\n    if (options.verbose) {\n      options.logger?.info(\n        `[renderPages] Panic check - failedRoutes.size: ${failedRoutes.size}, panicThreshold: ${options.panicThreshold}, shouldPanic: ${shouldPanic}`\n      );\n    }\n\n    if (shouldPanic) {\n      const firstError = Array.from(failedRoutes.values())[0];\n      if (options.verbose) {\n        options.logger?.error(\n          `[renderPages] Yielding panic error: ${firstError instanceof Error ? firstError.message : String(firstError)}`\n        );\n      }\n      // Use yield for panic errors to maintain stream contract\n      yield {\n        type: \"error\",\n        error: firstError instanceof Error ? firstError : new Error(String(firstError)),\n        route: \"\", // No specific route for global panic\n        completedRoutes,\n        failedRoutes,\n        results,\n      } satisfies RenderPagesResult;\n      return {\n        type: \"error\",\n        error: firstError instanceof Error ? firstError : new Error(String(firstError)),\n        route: \"\",\n        completedRoutes,\n        failedRoutes,\n        results,\n      } satisfies RenderPagesResult;\n    }\n\n    return {\n      type: \"success\",\n      completedRoutes,\n      failedRoutes: failedRoutes,\n      results,\n    } satisfies RenderPagesResult;\n  })();\n};\n"],"names":[],"mappings":"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"}