vite-plugin-react-server 1.4.1 → 1.4.3

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

@@ -1,623 +1,537 @@
 /**
- * plugin.ts
- *
- * PURPOSE: Main Vite plugin for React Server Components (RSC) static site generation
- *
- * This module:
- * 1. Orchestrates the entire static site generation process
- * 2. Manages the lifecycle of the RSC rendering process
- * 3. Handles file writing for both initial page loads and client-side navigation
- *    - Writes .html files for initial page loads (complete HTML document)
- *    - Writes .rsc files for client-side navigation (RSC content only)
- * 4. Provides hooks for Vite to integrate with the build process
- * 5. Manages worker threads for parallel rendering
- * 6. Handles error reporting and metrics collection
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
  */
-import { createLogger, } from "vite";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { createBuildLoader } from "./createBuildLoader.server.js";
-import { renderPagesBatched } from "./renderPagesBatched.js";
-import { renderPages as renderPagesSequential } from "./renderPages.js";
-import { getBundleManifest } from "../helpers/getBundleManifest.js";
-import { createWorker } from "../worker/createWorker.js";
-import { serializedOptions, serializeResolvedConfig, } from "../helpers/serializeUserOptions.js";
-import { performance } from "node:perf_hooks";
-import { baseURL } from "../utils/envUrls.node.js";
-import { handleError } from "../error/handleError.js";
-import { shouldCausePanic } from "../error/panicThresholdHandler.js";
-import { renderPage } from "./renderPage.server.js";
-import { temporaryReferences } from "./temporaryReferences.server.js";
-import { configurePreviewServer } from "./configurePreviewServer.js";
-import { envPrefixFromConfig } from "../config/envPrefixFromConfig.js";
-import { processCssFilesForPages } from "./processCssFilesForPages.js";
-import { createWorkerStartupMetrics } from "../metrics/createWorkerStartupMetrics.js";
-import { tryManifest } from "../helpers/tryManifest.js";
-import { join } from "node:path";
-import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
-import { assertReactServer } from "../config/getCondition.js";
-import { toError } from "../error/toError.js";
+import { createLogger } from 'vite';
+import { resolveOptions } from '../config/resolveOptions.js';
+import { createBuildLoader } from './createBuildLoader.server.js';
+import { renderPagesBatched } from './renderPagesBatched.js';
+import { renderPages } from './renderPages.js';
+import { getBundleManifest } from '../helpers/getBundleManifest.js';
+import { createWorker } from '../worker/createWorker.js';
+import { serializedOptions, serializeResolvedConfig } from '../helpers/serializeUserOptions.js';
+import { performance } from 'node:perf_hooks';
+import { baseURL } from '../utils/envUrls.node.js';
+import { handleError } from '../error/handleError.js';
+import { shouldCausePanic } from '../error/panicThresholdHandler.js';
+import { renderPage } from './renderPage.server.js';
+import { temporaryReferences } from './temporaryReferences.server.js';
+import { configurePreviewServer } from './configurePreviewServer.js';
+import { envPrefixFromConfig } from '../config/envPrefixFromConfig.js';
+import { processCssFilesForPages } from './processCssFilesForPages.js';
+import { createWorkerStartupMetrics } from '../metrics/createWorkerStartupMetrics.js';
+import { tryManifest } from '../helpers/tryManifest.js';
+import { join } from 'node:path';
+import { resolveAutoDiscover } from '../config/autoDiscover/resolveAutoDiscover.js';
+import { assertReactServer } from '../config/getCondition.js';
+import { toError } from '../error/toError.js';
+
 assertReactServer();
-/**
- * Main entrypoint for the static plugin.
- *
- * This plugin is responsible for:
- * 1. Orchestrating the static site generation process
- * 2. Handling the lifecycle of the RSC rendering process (main thread)
- * 3. Writing .html files for initial page loads (complete HTML document)
- * 4. Writing .rsc files for client-side navigation (RSC content only)
- * 5. Managing worker threads for parallel rendering (html worker)
- * 6. Handling error reporting and metrics collection
- */
-// Global worker instance to prevent duplicate creation across plugin instances
 let globalWorker;
-export const reactStaticPlugin = function _reactStaticPlugin(options) {
-    let worker;
-    let logger;
-    let resolvedConfig;
-    let autoDiscoveredFiles = null;
-    let serverManifest = undefined;
-    let configEnv;
-    const timing = {
-        start: performance.now(),
-        configResolved: 0,
-        buildStart: 0,
-        renderStart: 0,
-    };
-    const resolvedOptions = resolveOptions(options);
-    if (resolvedOptions.type === "error") {
-        throw resolvedOptions.error;
-    }
-    const userOptions = resolvedOptions.userOptions;
-    return {
-        name: "vite:plugin-react-server/server-static",
-        enforce: "post",
-        api: {
-            meta: { timing },
-        },
-        async config(_config, viteConfigEnv) {
-            configEnv = viteConfigEnv;
-        },
-        applyToEnvironment(partialEnvironment) {
-            if (["server"].includes(partialEnvironment.name)) {
-                return true;
+const reactStaticPlugin = function _reactStaticPlugin(options) {
+  let worker;
+  let logger;
+  let resolvedConfig;
+  let autoDiscoveredFiles = null;
+  let serverManifest = void 0;
+  let configEnv;
+  const timing = {
+    start: performance.now(),
+    configResolved: 0,
+    buildStart: 0,
+    renderStart: 0
+  };
+  const resolvedOptions = resolveOptions(options);
+  if (resolvedOptions.type === "error") {
+    throw resolvedOptions.error;
+  }
+  const userOptions = resolvedOptions.userOptions;
+  return {
+    name: "vite:plugin-react-server/server-static",
+    enforce: "post",
+    api: {
+      meta: { timing }
+    },
+    async config(_config, viteConfigEnv) {
+      configEnv = viteConfigEnv;
+    },
+    applyToEnvironment(partialEnvironment) {
+      if (["server"].includes(
+        partialEnvironment.name
+      )) {
+        return true;
+      }
+      return false;
+    },
+    async configResolved(config) {
+      resolvedConfig = config;
+      if (!logger) {
+        logger = config.customLogger ?? createLogger();
+      }
+      const autoDiscoverResult = await resolveAutoDiscover({
+        config,
+        configEnv,
+        userOptions,
+        logger
+      });
+      if (autoDiscoverResult.type === "error") {
+        throw autoDiscoverResult.error;
+      }
+      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+    },
+    async buildStart() {
+      if (!logger) {
+        logger = this.environment.logger;
+      }
+      timing.buildStart = performance.now();
+      if (userOptions.onEvent && autoDiscoveredFiles) {
+        try {
+          userOptions.onEvent({
+            type: "build.start",
+            data: {
+              pages: Array.from(autoDiscoveredFiles.urlMap.keys()),
+              files: autoDiscoveredFiles
             }
-            return false;
-        },
-        async configResolved(config) {
-            resolvedConfig = config;
-            if (!logger) {
-                logger = config.customLogger ?? createLogger();
+          });
+        } catch (error) {
+          const panicError = handleError({
+            error,
+            logger,
+            panicThreshold: userOptions.panicThreshold});
+          if (panicError != null) {
+            worker?.terminate();
+            throw panicError;
+          } else {
+            this.error(new Error("Failed to emit build.start event"));
+          }
+        }
+      }
+    },
+    // the preview server helps to view the generated static folder, but only when the static plugin is enabled
+    // if no build.pages, then the preview server will instead use default vite preview server
+    // it works the same under both conditions
+    async configurePreviewServer(server) {
+      logger = server.config.customLogger || server.config.logger;
+      configurePreviewServer({
+        server,
+        userOptions
+      });
+    },
+    async renderStart() {
+      timing.renderStart = performance.now();
+    },
+    generateBundle(_options, bundle) {
+      if (this.environment.name === "server") {
+        const keysToDelete = [];
+        for (const [key, chunk] of Object.entries(bundle)) {
+          if (chunk.type === "chunk") {
+            const isVirtual = chunk.fileName?.includes("_virtual") || key.includes("_virtual") || chunk.facadeModuleId?.includes("_virtual") || chunk.moduleIds?.some((id) => id.includes("_virtual"));
+            const isDynamicImportHelper = chunk.fileName?.includes("dynamic-import-helper") || key.includes("dynamic-import-helper");
+            if (isVirtual && !isDynamicImportHelper) {
+              keysToDelete.push(key);
+              if (userOptions.verbose) {
+                logger?.info(`[plugin.server] Filtered out virtual file: ${chunk.fileName || key} (moduleId: ${chunk.facadeModuleId || chunk.moduleIds?.[0]})`);
+              }
             }
-            const autoDiscoverResult = await resolveAutoDiscover({
-                config: config,
-                configEnv: configEnv,
-                userOptions,
-                logger,
-            });
-            if (autoDiscoverResult.type === "error") {
-                throw autoDiscoverResult.error;
+          }
+        }
+        for (const key of keysToDelete) {
+          delete bundle[key];
+        }
+      }
+    },
+    async writeBundle(_options, bundle) {
+      if (this.environment.name !== "server") {
+        if (userOptions.verbose) {
+          logger?.info(`[plugin.server] Skipping static generation for environment: ${this.environment.name}`);
+        }
+        return;
+      }
+      let panicError = null;
+      let bundleManifest = void 0;
+      if (!logger) {
+        logger = this.environment.logger;
+      }
+      try {
+        bundleManifest = getBundleManifest({
+          bundle,
+          normalizer: userOptions.normalizer
+        });
+        const manifestPath = typeof resolvedConfig.build.manifest === "string" ? resolvedConfig.build.manifest : ".vite/manifest.json";
+        if (!bundleManifest[manifestPath] || !("source" in bundleManifest[manifestPath])) {
+          throw new Error("Server manifest not found");
+        }
+        serverManifest = JSON.parse(
+          bundleManifest[manifestPath].source
+        );
+        if (!serverManifest) {
+          throw new Error("Failed to parse server manifest");
+        }
+      } catch (error) {
+        const panicError2 = handleError({
+          error,
+          logger,
+          panicThreshold: userOptions.panicThreshold});
+        if (panicError2 != null) {
+          throw panicError2;
+        } else {
+          throw new Error("Failed to get bundle manifest");
+        }
+      }
+      try {
+        const staticManifestResult = await tryManifest({
+          root: userOptions.projectRoot,
+          outDir: join(userOptions.build.outDir, userOptions.build.static),
+          manifestPath: resolvedConfig.build.manifest,
+          ssrManifest: false
+        });
+        if (staticManifestResult.type === "error") {
+          throw staticManifestResult.error;
+        }
+        const staticManifest = staticManifestResult.manifest;
+        const buildLoader = createBuildLoader(
+          {
+            userOptions,
+            serverManifest: serverManifest ?? {},
+            staticManifest
+          },
+          bundle,
+          temporaryReferences,
+          logger
+        );
+        const { cssFilesByPage, globalCss } = processCssFilesForPages({
+          userOptions,
+          autoDiscoveredFiles,
+          serverManifest,
+          staticManifest,
+          bundle,
+          logger
+        });
+        if (userOptions.verbose) {
+          logger.info(
+            `[plugin.server] cssFilesByPage size: ${cssFilesByPage.size}`
+          );
+          for (const [route, cssMap] of cssFilesByPage.entries()) {
+            logger.info(
+              `[plugin.server] Route ${route}: ${cssMap.size} CSS files`
+            );
+          }
+        }
+        const indexHtml = staticManifest?.["index.html"]?.file;
+        const serverPipeableStreamOptions = {
+          ...userOptions.serverPipeableStreamOptions,
+          bootstrapModules: [
+            ...indexHtml ? [baseURL(indexHtml)] : [],
+            ...userOptions.serverPipeableStreamOptions?.bootstrapModules ?? []
+          ]
+        };
+        userOptions.serverPipeableStreamOptions = serverPipeableStreamOptions;
+        const clientPipeableStreamOptions = {
+          ...userOptions.clientPipeableStreamOptions,
+          bootstrapModules: [
+            ...indexHtml ? [baseURL(indexHtml)] : [],
+            ...userOptions.clientPipeableStreamOptions?.bootstrapModules ?? []
+          ]
+        };
+        const routes = !autoDiscoveredFiles ? [] : Array.from(autoDiscoveredFiles.urlMap.keys());
+        if (routes.length === 0) {
+          logger?.info(
+            "[plugin.server] No pages to generate, skipping static generation"
+          );
+          return;
+        }
+        const serializedUserOptions = serializedOptions(
+          userOptions,
+          autoDiscoveredFiles
+        );
+        if (globalWorker) {
+          logger?.warn("[plugin.server] Global worker already exists, reusing existing worker");
+          worker = globalWorker;
+        } else {
+          const workerStartTime = performance.now();
+          const viteEnvPrefix = envPrefixFromConfig(resolvedConfig);
+          const routeCount = autoDiscoveredFiles?.urlMap.size ?? 0;
+          const maxListeners = routeCount + 1;
+          const workerResult = await createWorker({
+            projectRoot: userOptions.projectRoot,
+            workerPath: userOptions.htmlWorkerPath,
+            currentCondition: "react-server",
+            reverseCondition: "react-client",
+            // HTML worker needs react-client for react-dom/server
+            maxListeners,
+            envPrefix: viteEnvPrefix,
+            logger,
+            workerData: {
+              resolvedConfig: serializeResolvedConfig(resolvedConfig),
+              userOptions: serializedUserOptions,
+              configEnv
             }
-            autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
-        },
-        async buildStart() {
-            if (!logger) {
-                logger = this.environment.logger;
+          });
+          if (workerResult.type === "error") {
+            if (workerResult.error != null) {
+              throw workerResult.error;
             }
-            timing.buildStart = performance.now();
-            if (userOptions.onEvent && autoDiscoveredFiles) {
-                try {
-                    userOptions.onEvent({
-                        type: "build.start",
-                        data: {
-                            pages: Array.from(autoDiscoveredFiles.urlMap.keys()),
-                            files: autoDiscoveredFiles,
-                        },
-                    });
-                }
-                catch (error) {
-                    const panicError = handleError({
-                        error,
-                        logger: logger,
-                        panicThreshold: userOptions.panicThreshold,
-                        context: "buildStart",
-                    });
-                    if (panicError != null) {
-                        worker?.terminate();
-                        throw panicError;
-                    }
-                    else {
-                        this.error(new Error("Failed to emit build.start event"));
-                    }
-                }
+            throw new Error("React static plugin failed to create worker");
+          } else if (workerResult.type === "skip") {
+            logger.info("Worker not created, skipping static build");
+            return;
+          } else {
+            worker = workerResult.worker;
+            const workerStartupTime = performance.now() - workerStartTime;
+            if (userOptions.onMetrics) {
+              const workerStartupMetric = createWorkerStartupMetrics({
+                route: "/",
+                // Worker startup is global, not route-specific
+                workerType: "html",
+                // This is the HTML worker for server-side static generation
+                startupTime: workerStartupTime,
+                fromMainThread: true,
+                fromRscWorker: false,
+                fromHtmlWorker: false,
+                description: `HTML worker startup for server-side static generation`
+              });
+              if (this.environment.name === "server") {
+                userOptions.onMetrics(workerStartupMetric);
+              }
             }
-        },
-        // the preview server helps to view the generated static folder, but only when the static plugin is enabled
-        // if no build.pages, then the preview server will instead use default vite preview server
-        // it works the same under both conditions
-        async configurePreviewServer(server) {
-            logger = server.config.customLogger || server.config.logger;
-            configurePreviewServer({
-                server,
-                userOptions,
+            globalWorker = worker;
+          }
+        }
+        const { onEvent, ...handlerOptions } = userOptions;
+        if (typeof userOptions.onEvent === "function") {
+          try {
+            const r = userOptions.onEvent({
+              type: "build.ssg.start",
+              data: {
+                pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
+                options: null,
+                // No specific rollup output options for static generation
+                bundle
+              }
             });
-        },
-        async renderStart() {
-            timing.renderStart = performance.now();
-        },
-        generateBundle(_options, bundle) {
-            // Filter out unnecessary _virtual files from the bundle
-            // Keep dynamic-import-helper.js since it's needed for dynamic imports
-            // Note: Static builds are handled by plugin.client.ts, this only handles server builds
-            if (this.environment.name === "server") {
-                const keysToDelete = [];
-                for (const [key, chunk] of Object.entries(bundle)) {
-                    if (chunk.type === "chunk") {
-                        // Check fileName, key, moduleIds, and facadeModuleId for _virtual
-                        const isVirtual = chunk.fileName?.includes("_virtual") ||
-                            key.includes("_virtual") ||
-                            chunk.facadeModuleId?.includes("_virtual") ||
-                            chunk.moduleIds?.some(id => id.includes("_virtual"));
-                        // Keep dynamic-import-helper.js - it's needed for dynamic imports
-                        const isDynamicImportHelper = chunk.fileName?.includes("dynamic-import-helper") ||
-                            key.includes("dynamic-import-helper");
-                        if (isVirtual && !isDynamicImportHelper) {
-                            keysToDelete.push(key);
-                            if (userOptions.verbose) {
-                                logger?.info(`[plugin.server] Filtered out virtual file: ${chunk.fileName || key} (moduleId: ${chunk.facadeModuleId || chunk.moduleIds?.[0]})`);
-                            }
-                        }
-                    }
-                }
-                // Delete after iteration to avoid modifying while iterating
-                for (const key of keysToDelete) {
-                    delete bundle[key];
-                }
-            }
-        },
-        async writeBundle(_options, bundle) {
-            // Only execute static generation for the server environment
-            if (this.environment.name !== "server") {
-                if (userOptions.verbose) {
-                    logger?.info(`[plugin.server] Skipping static generation for environment: ${this.environment.name}`);
-                }
-                return;
+            if (r != null && typeof r === "object" && "then" in r) {
+              await r;
             }
-            let panicError = null;
-            let bundleManifest = undefined;
-            if (!logger) {
-                logger = this.environment.logger;
+          } catch (error) {
+            const eventPanicError = handleError({
+              error,
+              logger,
+              panicThreshold: userOptions.panicThreshold,
+              context: "onEvent(build.ssg.start)"
+            });
+            if (eventPanicError != null) {
+              throw eventPanicError;
+            } else {
+              throw new Error("Failed to emit build.ssg.start event");
             }
-            // handle the bundle manifest
-            try {
-                bundleManifest = getBundleManifest({
-                    bundle,
-                    normalizer: userOptions.normalizer,
-                });
-                // make sure that we have a manifest
-                const manifestPath = typeof resolvedConfig.build.manifest === "string"
-                    ? resolvedConfig.build.manifest
-                    : ".vite/manifest.json";
-                if (!bundleManifest[manifestPath] ||
-                    !("source" in bundleManifest[manifestPath])) {
-                    throw new Error("Server manifest not found");
-                }
-                // parse the manifest
-                serverManifest = JSON.parse(bundleManifest[manifestPath].source);
-                // make sure that we have a manifest
-                if (!serverManifest) {
-                    throw new Error("Failed to parse server manifest");
-                }
+          }
+        }
+        const renderMode = userOptions.build?.renderMode ?? "parallel";
+        const renderPages$1 = renderMode === "sequential" ? renderPages : renderPagesBatched;
+        if (userOptions.verbose) {
+          logger.info(`[static] Using ${renderMode} rendering${renderMode === "parallel" ? ` (batch size: ${userOptions.build?.batchSize ?? 8})` : ""}`);
+        }
+        const renderPagesGenerator = renderPages$1(
+          routes,
+          {
+            ...handlerOptions,
+            loader: buildLoader,
+            worker,
+            htmlWorker: worker,
+            // Pass the HTML worker for HTML generation
+            logger,
+            // Pass global CSS to downstream renderer
+            globalCss,
+            // Pass abort signal to cancel operations when errors occur
+            signal: AbortSignal.timeout(handlerOptions.htmlTimeout),
+            onEvent,
+            serverPipeableStreamOptions,
+            clientPipeableStreamOptions,
+            manifest: serverManifest ?? {},
+            staticManifest,
+            // Pass static manifest for path resolution
+            autoDiscoveredFiles,
+            cssFilesByPage,
+            batchSize: userOptions.build?.batchSize
+          },
+          renderPage
+        );
+        let finalResult;
+        try {
+          for await (const result of renderPagesGenerator) {
+            if (result.type === "error") {
+              throw result.error;
             }
-            catch (error) {
-                const panicError = handleError({
-                    error,
-                    logger: logger,
-                    panicThreshold: userOptions.panicThreshold,
-                    context: "writeBundle(bundleManifest)",
-                });
-                if (panicError != null) {
-                    throw panicError;
-                }
-                else {
-                    throw new Error("Failed to get bundle manifest");
-                }
+            if (result.type === "success" && result.failedRoutes && result.failedRoutes.size > 0) {
+              const firstError = result.failedRoutes.values().next().value;
+              if (firstError != null && shouldCausePanic(firstError, { panicThreshold: userOptions.panicThreshold })) {
+                throw firstError;
+              }
+              for (const [route, error] of result.failedRoutes) {
+                const err = error instanceof Error ? error : toError(error);
+                this.warn(
+                  new Error("Failed to render route: " + route + "\n" + err.message + "\n" + err.stack, { cause: err })
+                );
+              }
             }
-            try {
-                const staticManifestResult = await tryManifest({
-                    root: userOptions.projectRoot,
-                    outDir: join(userOptions.build.outDir, userOptions.build.static),
-                    manifestPath: resolvedConfig.build.manifest,
-                    ssrManifest: false,
-                });
-                if (staticManifestResult.type === "error") {
-                    throw staticManifestResult.error;
-                }
-                const staticManifest = staticManifestResult.manifest;
-                // Don't create helper file - let resolveVirtualAndNodeModules shim handle it
-                // Same approach as client environment - no special file needed
-                const buildLoader = createBuildLoader({
-                    userOptions: userOptions,
-                    serverManifest: serverManifest ?? {},
-                    staticManifest: staticManifest,
-                }, bundle, temporaryReferences, logger);
-                // Create CSS props for each CSS file
-                const { cssFilesByPage, globalCss } = processCssFilesForPages({
-                    userOptions,
-                    autoDiscoveredFiles,
-                    serverManifest,
-                    staticManifest,
-                    bundle,
-                    logger,
-                });
-                if (userOptions.verbose) {
-                    logger.info(`[plugin.server] cssFilesByPage size: ${cssFilesByPage.size}`);
-                    for (const [route, cssMap] of cssFilesByPage.entries()) {
-                        logger.info(`[plugin.server] Route ${route}: ${cssMap.size} CSS files`);
-                    }
-                }
-                const indexHtml = staticManifest?.["index.html"]?.file;
-                const serverPipeableStreamOptions = {
-                    ...userOptions.serverPipeableStreamOptions,
-                    bootstrapModules: [
-                        ...(indexHtml ? [baseURL(indexHtml)] : []),
-                        ...(userOptions.serverPipeableStreamOptions?.bootstrapModules ??
-                            []),
-                    ],
-                };
-                userOptions.serverPipeableStreamOptions = serverPipeableStreamOptions;
-                const clientPipeableStreamOptions = {
-                    ...userOptions.clientPipeableStreamOptions,
-                    bootstrapModules: [
-                        ...(indexHtml ? [baseURL(indexHtml)] : []),
-                        ...(userOptions.clientPipeableStreamOptions?.bootstrapModules ??
-                            []),
-                    ],
-                };
-                // Get routes for worker configuration
-                const routes = !autoDiscoveredFiles
-                    ? []
-                    : Array.from(autoDiscoveredFiles.urlMap.keys());
-                // If no pages to generate, skip static generation entirely (including worker creation)
-                if (routes.length === 0) {
-                    logger?.info("[plugin.server] No pages to generate, skipping static generation");
-                    return;
-                }
-                const serializedUserOptions = serializedOptions(userOptions, autoDiscoveredFiles);
-                // Create HTML worker for HTML generation
-                // IMPORTANT: We create a new worker for each page render to ensure completely clean state
-                // This prevents race conditions where worker state persists between renders
-                // Guard against duplicate worker creation if plugin is instantiated multiple times
-                if (globalWorker) {
-                    logger?.warn("[plugin.server] Global worker already exists, reusing existing worker");
-                    worker = globalWorker;
-                }
-                else {
-                    const workerStartTime = performance.now();
-                    const viteEnvPrefix = envPrefixFromConfig(resolvedConfig);
-                    const routeCount = autoDiscoveredFiles?.urlMap.size ?? 0;
-                    const maxListeners = routeCount + 1;
-                    const workerResult = await createWorker({
-                        projectRoot: userOptions.projectRoot,
-                        workerPath: userOptions.htmlWorkerPath,
-                        currentCondition: "react-server",
-                        reverseCondition: "react-client", // HTML worker needs react-client for react-dom/server
-                        maxListeners: maxListeners,
-                        envPrefix: viteEnvPrefix,
-                        logger: logger,
-                        workerData: {
-                            resolvedConfig: serializeResolvedConfig(resolvedConfig),
-                            userOptions: serializedUserOptions,
-                            configEnv,
-                        },
-                    });
-                    if (workerResult.type === "error") {
-                        if (workerResult.error != null) {
-                            throw workerResult.error;
-                        }
-                        throw new Error("React static plugin failed to create worker");
-                    }
-                    else if (workerResult.type === "skip") {
-                        logger.info("Worker not created, skipping static build");
-                        return;
-                    }
-                    else {
-                        worker = workerResult.worker;
-                        // Emit worker startup metric after worker is created
-                        const workerStartupTime = performance.now() - workerStartTime;
-                        if (userOptions.onMetrics) {
-                            const workerStartupMetric = createWorkerStartupMetrics({
-                                route: "/", // Worker startup is global, not route-specific
-                                workerType: "html", // This is the HTML worker for server-side static generation
-                                startupTime: workerStartupTime,
-                                fromMainThread: true,
-                                fromRscWorker: false,
-                                fromHtmlWorker: false,
-                                description: `HTML worker startup for server-side static generation`,
-                            });
-                            // Only emit metrics from the server environment to prevent duplicates
-                            if (this.environment.name === "server") {
-                                userOptions.onMetrics(workerStartupMetric);
-                            }
-                        }
-                        // Store the worker globally to prevent duplicate creation
-                        globalWorker = worker;
-                    }
-                }
-                // No RSC worker needed for static generation - main thread runs with react-server conditions
-                // Render pages - component resolution now happens per-route in renderPage
-                const { onEvent, ...handlerOptions } = userOptions;
-                // Emit the static site generation start event
-                if (typeof userOptions.onEvent === "function") {
-                    try {
-                        const r = userOptions.onEvent({
-                            type: "build.ssg.start",
-                            data: {
-                                pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
-                                options: null, // No specific rollup output options for static generation
-                                bundle: bundle,
-                            },
-                        });
-                        if (r != null && typeof r === "object" && "then" in r) {
-                            await r;
-                        }
-                    }
-                    catch (error) {
-                        const eventPanicError = handleError({
-                            error,
-                            logger: logger,
-                            panicThreshold: userOptions.panicThreshold,
-                            context: "onEvent(build.ssg.start)",
-                        });
-                        if (eventPanicError != null) {
-                            throw eventPanicError; // Re-throw to abort the build
-                        }
-                        else {
-                            throw new Error("Failed to emit build.ssg.start event");
-                        }
-                    }
-                }
-                // Select render mode based on build config
-                const renderMode = userOptions.build?.renderMode ?? "parallel";
-                const renderPages = renderMode === "sequential" ? renderPagesSequential : renderPagesBatched;
-                if (userOptions.verbose) {
-                    logger.info(`[static] Using ${renderMode} rendering${renderMode === "parallel" ? ` (batch size: ${userOptions.build?.batchSize ?? 8})` : ""}`);
-                }
-                // this will render the routes
-                const renderPagesGenerator = renderPages(routes, {
-                    ...handlerOptions,
-                    loader: buildLoader,
-                    worker: worker,
-                    htmlWorker: worker, // Pass the HTML worker for HTML generation
-                    logger: logger,
-                    // Pass global CSS to downstream renderer
-                    globalCss,
-                    // Pass abort signal to cancel operations when errors occur
-                    signal: AbortSignal.timeout(handlerOptions.htmlTimeout),
-                    onEvent: onEvent,
-                    serverPipeableStreamOptions: serverPipeableStreamOptions,
-                    clientPipeableStreamOptions: clientPipeableStreamOptions,
-                    manifest: serverManifest ?? {},
-                    staticManifest: staticManifest, // Pass static manifest for path resolution
-                    autoDiscoveredFiles: autoDiscoveredFiles,
-                    cssFilesByPage: cssFilesByPage,
-                    batchSize: userOptions.build?.batchSize,
-                }, renderPage);
-                // Process render results
-                let finalResult;
-                try {
-                    for await (const result of renderPagesGenerator) {
-                        // Handle error results immediately
-                        if (result.type === "error") {
-                            throw result.error;
-                        }
-                        // Handle failed routes based on panic threshold
-                        if (result.type === "success" &&
-                            result.failedRoutes &&
-                            result.failedRoutes.size > 0) {
-                            // Use centralized panic threshold logic
-                            const firstError = result.failedRoutes.values().next().value;
-                            if (firstError != null && shouldCausePanic(firstError, { panicThreshold: userOptions.panicThreshold })) {
-                                // This should cause a panic, throw the error
-                                throw firstError;
-                            }
-                            // For non-panic errors, log warnings but continue
-                            for (const [route, error] of result.failedRoutes) {
-                                const err = error instanceof Error ? error : toError(error);
-                                this.warn(new Error("Failed to render route: " + route + "\n" + err.message + "\n" + err.stack, { cause: err }));
-                            }
-                        }
-                        finalResult = result;
-                    }
-                }
-                catch (renderError) {
-                    // Handle render errors with panic threshold logic
-                    const renderPanicError = handleError({
-                        error: renderError,
-                        logger: logger,
-                        panicThreshold: userOptions.panicThreshold,
-                        context: "renderPages",
-                    });
-                    if (renderPanicError != null) {
-                        throw renderPanicError;
-                    }
-                    throw renderError;
-                }
-                if (!finalResult) {
-                    throw new Error("No render result produced");
-                }
-                // Calculate duration from timing
-                const duration = Math.round(performance.now() - (timing.renderStart || timing.start));
-                this.info(`Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`);
-                // Emit the static site generation completion event once
-                if (typeof userOptions.onEvent === "function") {
-                    try {
-                        const r = userOptions.onEvent({
-                            type: "build.ssg.end",
-                            data: {
-                                pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
-                                options: null, // No specific rollup output options for static generation
-                                bundle: bundle,
-                            },
-                        });
-                        if (r != null && typeof r === "object" && "then" in r) {
-                            await r;
-                        }
-                    }
-                    catch (error) {
-                        if (error != null) {
-                            throw error; // Re-throw to abort the build
-                        }
-                        else {
-                            throw new Error("Failed to emit build.ssg.end event");
-                        }
-                    }
-                }
-                if (process.env["NODE_ENV"] !== "production") {
-                    this.warn(`THIS BUILD IS NOT INTENDED FOR PRODUCTION (${process.env["NODE_ENV"]})`);
-                }
-                // Update timing
-                timing.render =
-                    performance.now() - (timing.renderStart ?? timing.start);
-            }
-            catch (error) {
-                panicError = handleError({
-                    error,
-                    logger: logger,
-                    panicThreshold: userOptions.panicThreshold,
-                    context: "writeBundle",
-                });
-                // Let the finally block handle additional cleanup
-            }
-            finally {
-                // Reset any cached state to prevent issues in subsequent builds
-                autoDiscoveredFiles = null;
-                serverManifest = undefined;
-                // Clean up worker if it exists
-                if (worker) {
-                    try {
-                        worker.removeAllListeners();
-                        worker.terminate();
-                    }
-                    catch (terminateError) {
-                        // Ignore termination errors
-                    }
-                    worker = undefined;
-                    // Reset global worker since it's been terminated
-                    globalWorker = undefined;
-                }
+            finalResult = result;
+          }
+        } catch (renderError) {
+          const renderPanicError = handleError({
+            error: renderError,
+            logger,
+            panicThreshold: userOptions.panicThreshold,
+            context: "renderPages"
+          });
+          if (renderPanicError != null) {
+            throw renderPanicError;
+          }
+          throw renderError;
+        }
+        if (!finalResult) {
+          throw new Error("No render result produced");
+        }
+        const duration = Math.round(
+          performance.now() - (timing.renderStart || timing.start)
+        );
+        this.info(
+          `Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`
+        );
+        if (typeof userOptions.onEvent === "function") {
+          try {
+            const r = userOptions.onEvent({
+              type: "build.ssg.end",
+              data: {
+                pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
+                options: null,
+                // No specific rollup output options for static generation
+                bundle
+              }
+            });
+            if (r != null && typeof r === "object" && "then" in r) {
+              await r;
             }
-            if (panicError != null) {
-                // Ensure we have a proper Error object that can have properties set on it
-                const errorToThrow = panicError instanceof Error
-                    ? panicError
-                    : new Error(String(panicError));
-                // Create a new Error object to avoid the "code" property issue
-                const finalError = new Error(errorToThrow.message);
-                finalError.stack = errorToThrow.stack;
-                finalError.cause = errorToThrow.cause;
-                // Copy any additional properties that might be needed
-                if (errorToThrow.name)
-                    finalError.name = errorToThrow.name;
-                throw finalError;
+          } catch (error) {
+            if (error != null) {
+              throw error;
+            } else {
+              throw new Error("Failed to emit build.ssg.end event");
             }
-        },
-        async closeBundle() {
-            // Clean up _virtual files after build completes
-            // These are Vite's internal virtual modules and aren't needed in the final output
-            if (this.environment.name === "server") {
-                try {
-                    const { existsSync } = await import("node:fs");
-                    const { join, resolve } = await import("node:path");
-                    // Use the resolved output directory from the environment config
-                    const resolvedOutDir = this.environment.config.build?.outDir
-                        ? resolve(this.environment.config.root || userOptions.projectRoot, this.environment.config.build.outDir)
-                        : resolve(userOptions.projectRoot, userOptions.build.outDir);
-                    // Don't clean up server/_virtual - we need dynamic-import-helper.js for runtime
-                    // Only clean up static/_virtual if it exists (shouldn't, but just in case)
-                    const staticOutDir = join(resolvedOutDir, userOptions.build.static || "static");
-                    const staticVirtualDir = join(staticOutDir, "_virtual");
-                    if (existsSync(staticVirtualDir)) {
-                        const { rmSync } = await import("node:fs");
-                        rmSync(staticVirtualDir, { recursive: true, force: true });
-                        if (userOptions.verbose) {
-                            logger?.info(`[plugin.server] Cleaned up _virtual directory: ${staticVirtualDir}`);
-                        }
-                    }
-                }
-                catch (error) {
-                    // Non-critical - log but don't fail the build
-                    if (userOptions.verbose) {
-                        logger?.warn(`[plugin.server] Failed to clean up _virtual directory: ${error}`);
-                    }
-                }
+          }
+        }
+        if (process.env["NODE_ENV"] !== "production") {
+          this.warn(
+            `THIS BUILD IS NOT INTENDED FOR PRODUCTION (${process.env["NODE_ENV"]})`
+          );
+        }
+        timing.render = performance.now() - (timing.renderStart ?? timing.start);
+      } catch (error) {
+        panicError = handleError({
+          error,
+          logger,
+          panicThreshold: userOptions.panicThreshold});
+      } finally {
+        autoDiscoveredFiles = null;
+        serverManifest = void 0;
+        if (worker) {
+          try {
+            worker.removeAllListeners();
+            worker.terminate();
+          } catch (terminateError) {
+          }
+          worker = void 0;
+          globalWorker = void 0;
+        }
+      }
+      if (panicError != null) {
+        const errorToThrow = panicError instanceof Error ? panicError : new Error(String(panicError));
+        const finalError = new Error(errorToThrow.message);
+        finalError.stack = errorToThrow.stack;
+        finalError.cause = errorToThrow.cause;
+        if (errorToThrow.name) finalError.name = errorToThrow.name;
+        throw finalError;
+      }
+    },
+    async closeBundle() {
+      if (this.environment.name === "server") {
+        try {
+          const { existsSync } = await import('node:fs');
+          const { join: join2, resolve } = await import('node:path');
+          const resolvedOutDir = this.environment.config.build?.outDir ? resolve(this.environment.config.root || userOptions.projectRoot, this.environment.config.build.outDir) : resolve(userOptions.projectRoot, userOptions.build.outDir);
+          const staticOutDir = join2(resolvedOutDir, userOptions.build.static || "static");
+          const staticVirtualDir = join2(staticOutDir, "_virtual");
+          if (existsSync(staticVirtualDir)) {
+            const { rmSync } = await import('node:fs');
+            rmSync(staticVirtualDir, { recursive: true, force: true });
+            if (userOptions.verbose) {
+              logger?.info(`[plugin.server] Cleaned up _virtual directory: ${staticVirtualDir}`);
             }
-            // Graceful worker shutdown - only at the end of the entire build process
-            if (worker) {
-                try {
-                    await Promise.race([
-                        new Promise((resolve, reject) => {
-                            const timeout = setTimeout(() => {
-                                reject(new Error("Worker shutdown timeout"));
-                            }, userOptions.workerShutdownTimeout);
-                            const backupTimeout = setTimeout(() => {
-                                reject(new Error("Worker shutdown backup timeout"));
-                            }, Math.floor(userOptions.workerShutdownTimeout * 0.6)); // 60% of main timeout
-                            const messageHandler = (message) => {
-                                if (message.type === "SHUTDOWN_COMPLETE") {
-                                    if (userOptions.verbose) {
-                                        logger.info("Worker shutdown complete");
-                                    }
-                                    clearTimeout(timeout);
-                                    clearTimeout(backupTimeout);
-                                    worker?.removeListener("message", messageHandler);
-                                    // Remove all other event listeners as well
-                                    worker?.removeAllListeners();
-                                    resolve();
-                                }
-                                else if (message.type === "CLEANUP_COMPLETE") {
-                                    // Handle cleanup complete messages during shutdown - this is normal
-                                    if (userOptions.verbose) {
-                                        logger.info("Worker cleanup completed during shutdown");
-                                    }
-                                    // Don't resolve here - wait for SHUTDOWN_COMPLETE
-                                }
-                                else {
-                                    if (userOptions.verbose) {
-                                        logger.info("Worker is still busy, received message " + message?.type);
-                                    }
-                                }
-                            };
-                            worker?.on("message", messageHandler);
-                            // Send shutdown message
-                            worker?.postMessage({
-                                type: "SHUTDOWN",
-                                id: "*",
-                            });
-                        }),
-                    ]);
-                }
-                catch (error) {
-                    // If shutdown protocol fails, force terminate
-                    this.warn("Worker shutdown protocol failed, forcing termination: " +
-                        (error instanceof Error ? error.message : String(error)));
-                    // Don't try to clean up listeners in error case - just force terminate
-                }
-                finally {
-                    // Always force cleanup and termination
-                    if (worker) {
-                        try {
-                            worker.removeAllListeners();
-                            worker.terminate();
-                        }
-                        catch (terminateError) {
-                            // Ignore termination errors
-                        }
-                        worker = undefined;
-                        // Reset global worker since it's been terminated
-                        globalWorker = undefined;
-                    }
+          }
+        } catch (error) {
+          if (userOptions.verbose) {
+            logger?.warn(`[plugin.server] Failed to clean up _virtual directory: ${error}`);
+          }
+        }
+      }
+      if (worker) {
+        try {
+          await Promise.race([
+            new Promise((resolve, reject) => {
+              const timeout = setTimeout(() => {
+                reject(new Error("Worker shutdown timeout"));
+              }, userOptions.workerShutdownTimeout);
+              const backupTimeout = setTimeout(() => {
+                reject(new Error("Worker shutdown backup timeout"));
+              }, Math.floor(userOptions.workerShutdownTimeout * 0.6));
+              const messageHandler = (message) => {
+                if (message.type === "SHUTDOWN_COMPLETE") {
+                  if (userOptions.verbose) {
+                    logger.info("Worker shutdown complete");
+                  }
+                  clearTimeout(timeout);
+                  clearTimeout(backupTimeout);
+                  worker?.removeListener("message", messageHandler);
+                  worker?.removeAllListeners();
+                  resolve();
+                } else if (message.type === "CLEANUP_COMPLETE") {
+                  if (userOptions.verbose) {
+                    logger.info("Worker cleanup completed during shutdown");
+                  }
+                } else {
+                  if (userOptions.verbose) {
+                    logger.info(
+                      "Worker is still busy, received message " + message?.type
+                    );
+                  }
                 }
+              };
+              worker?.on("message", messageHandler);
+              worker?.postMessage({
+                type: "SHUTDOWN",
+                id: "*"
+              });
+            })
+          ]);
+        } catch (error) {
+          this.warn(
+            "Worker shutdown protocol failed, forcing termination: " + (error instanceof Error ? error.message : String(error))
+          );
+        } finally {
+          if (worker) {
+            try {
+              worker.removeAllListeners();
+              worker.terminate();
+            } catch (terminateError) {
             }
-        },
-    };
+            worker = void 0;
+            globalWorker = void 0;
+          }
+        }
+      }
+    }
+  };
 };
+
+export { reactStaticPlugin };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.server.js","sources":["../../../plugin/react-static/plugin.server.ts"],"sourcesContent":["/**\n * plugin.ts\n *\n * PURPOSE: Main Vite plugin for React Server Components (RSC) static site generation\n *\n * This module:\n * 1. Orchestrates the entire static site generation process\n * 2. Manages the lifecycle of the RSC rendering process\n * 3. Handles file writing for both initial page loads and client-side navigation\n *    - Writes .html files for initial page loads (complete HTML document)\n *    - Writes .rsc files for client-side navigation (RSC content only)\n * 4. Provides hooks for Vite to integrate with the build process\n * 5. Manages worker threads for parallel rendering\n * 6. Handles error reporting and metrics collection\n */\n\nimport type { Worker } from \"node:worker_threads\";\nimport {\n  type ConfigEnv,\n  type Logger,\n  type Manifest,\n  type ManifestChunk,\n  type ResolvedConfig,\n  createLogger,\n} from \"vite\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport { createBuildLoader } from \"./createBuildLoader.server.js\";\nimport type {\n  BuildTiming,\n  RenderPagesResult,\n  AutoDiscoveredFiles,\n  VitePluginFn,\n} from \"../types.js\";\nimport { renderPagesBatched } from \"./renderPagesBatched.js\";\nimport { renderPages as renderPagesSequential } from \"./renderPages.js\";\nimport { getBundleManifest } from \"../helpers/getBundleManifest.js\";\nimport { createWorker } from \"../worker/createWorker.js\";\nimport {\n  serializedOptions,\n  serializeResolvedConfig,\n} from \"../helpers/serializeUserOptions.js\";\nimport { performance } from \"node:perf_hooks\";\nimport { baseURL } from \"../utils/envUrls.node.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { shouldCausePanic } from \"../error/panicThresholdHandler.js\";\nimport { renderPage } from \"./renderPage.server.js\";\nimport { temporaryReferences } from \"./temporaryReferences.server.js\";\nimport { configurePreviewServer } from \"./configurePreviewServer.js\";\nimport { envPrefixFromConfig } from \"../config/envPrefixFromConfig.js\";\n\nimport { processCssFilesForPages } from \"./processCssFilesForPages.js\";\nimport { createWorkerStartupMetrics } from \"../metrics/createWorkerStartupMetrics.js\";\nimport { tryManifest } from \"../helpers/tryManifest.js\";\nimport { join } from \"node:path\";\nimport { resolveAutoDiscover } from \"../config/autoDiscover/resolveAutoDiscover.js\";\nimport { assertReactServer } from \"../config/getCondition.js\";\nimport { toError } from \"../error/toError.js\";\n\nassertReactServer();\n\n/**\n * Main entrypoint for the static plugin.\n *\n * This plugin is responsible for:\n * 1. Orchestrating the static site generation process\n * 2. Handling the lifecycle of the RSC rendering process (main thread)\n * 3. Writing .html files for initial page loads (complete HTML document)\n * 4. Writing .rsc files for client-side navigation (RSC content only)\n * 5. Managing worker threads for parallel rendering (html worker)\n * 6. Handling error reporting and metrics collection\n */\n// Global worker instance to prevent duplicate creation across plugin instances\nlet globalWorker: Worker | undefined;\n\nexport const reactStaticPlugin: VitePluginFn = function _reactStaticPlugin(\n  options\n) {\n  let worker: Worker | undefined;\n  let logger: Logger;\n  let resolvedConfig: ResolvedConfig;\n  let autoDiscoveredFiles: AutoDiscoveredFiles | null = null;\n  let serverManifest: Manifest | undefined = undefined;\n  let configEnv: ConfigEnv | undefined;\n  const timing: BuildTiming = {\n    start: performance.now(),\n    configResolved: 0,\n    buildStart: 0,\n    renderStart: 0,\n  };\n\n  const resolvedOptions = resolveOptions(options);\n  if (resolvedOptions.type === \"error\") {\n    throw resolvedOptions.error;\n  }\n  const userOptions = resolvedOptions.userOptions;\n\n  return {\n    name: \"vite:plugin-react-server/server-static\",\n    enforce: \"post\",\n    api: {\n      meta: { timing },\n    },\n    async config(_config, viteConfigEnv) {\n      configEnv = viteConfigEnv;\n    },\n    applyToEnvironment(partialEnvironment) {\n\n      if (\n        [\"server\"].includes(\n          partialEnvironment.name as \"client\" | \"server\" | \"ssr\"\n        )\n      ) {\n        return true;\n      }\n      return false;\n    },\n    async configResolved(config) {\n      resolvedConfig = config;\n      if (!logger) {\n        logger = config.customLogger ?? createLogger();\n      }\n      const autoDiscoverResult = await resolveAutoDiscover({\n        config: config,\n        configEnv: configEnv!,\n        userOptions,\n        logger,\n      });\n      if (autoDiscoverResult.type === \"error\") {\n        throw autoDiscoverResult.error;\n      }\n      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;\n    },\n    async buildStart() {\n      if (!logger) {\n        logger = this.environment.logger;\n      }\n      timing.buildStart = performance.now();\n      if (userOptions.onEvent && autoDiscoveredFiles) {\n        try {\n          userOptions.onEvent({\n            type: \"build.start\",\n            data: {\n              pages: Array.from(autoDiscoveredFiles.urlMap.keys()),\n              files: autoDiscoveredFiles,\n            },\n          });\n        } catch (error) {\n          const panicError = handleError({\n            error,\n            logger: logger,\n            panicThreshold: userOptions.panicThreshold,\n            context: \"buildStart\",\n          });\n          if (panicError != null) {\n            worker?.terminate();\n            throw panicError;\n          } else {\n            this.error(new Error(\"Failed to emit build.start event\"));\n          }\n        }\n      }\n    },\n\n    // the preview server helps to view the generated static folder, but only when the static plugin is enabled\n    // if no build.pages, then the preview server will instead use default vite preview server\n    // it works the same under both conditions\n    async configurePreviewServer(server) {\n      logger = server.config.customLogger || server.config.logger;\n      configurePreviewServer({\n        server,\n        userOptions,\n      });\n    },\n\n    async renderStart() {\n      timing.renderStart = performance.now();\n    },\n    generateBundle(_options, bundle) {\n      // Filter out unnecessary _virtual files from the bundle\n      // Keep dynamic-import-helper.js since it's needed for dynamic imports\n      // Note: Static builds are handled by plugin.client.ts, this only handles server builds\n      if (this.environment.name === \"server\") {\n        const keysToDelete: string[] = [];\n        for (const [key, chunk] of Object.entries(bundle)) {\n          if (chunk.type === \"chunk\") {\n            // Check fileName, key, moduleIds, and facadeModuleId for _virtual\n            const isVirtual = \n              chunk.fileName?.includes(\"_virtual\") ||\n              key.includes(\"_virtual\") ||\n              chunk.facadeModuleId?.includes(\"_virtual\") ||\n              chunk.moduleIds?.some(id => id.includes(\"_virtual\"));\n            \n            // Keep dynamic-import-helper.js - it's needed for dynamic imports\n            const isDynamicImportHelper = \n              chunk.fileName?.includes(\"dynamic-import-helper\") ||\n              key.includes(\"dynamic-import-helper\");\n            \n            if (isVirtual && !isDynamicImportHelper) {\n              keysToDelete.push(key);\n              if (userOptions.verbose) {\n                logger?.info(`[plugin.server] Filtered out virtual file: ${chunk.fileName || key} (moduleId: ${chunk.facadeModuleId || chunk.moduleIds?.[0]})`);\n              }\n            }\n          }\n        }\n        // Delete after iteration to avoid modifying while iterating\n        for (const key of keysToDelete) {\n          delete bundle[key];\n        }\n      }\n    },\n\n    async writeBundle(_options, bundle) {\n      // Only execute static generation for the server environment\n      if (this.environment.name !== \"server\") {\n        if (userOptions.verbose) {\n          logger?.info(`[plugin.server] Skipping static generation for environment: ${this.environment.name}`);\n        }\n        return;\n      }\n      \n      let panicError: Error | null = null;\n      let bundleManifest:\n        | {\n            [key: string]: ManifestChunk & {\n              source: string;\n            };\n          }\n        | undefined = undefined;\n      if (!logger) {\n        logger = this.environment.logger;\n      }\n\n      // handle the bundle manifest\n      try {\n        bundleManifest = getBundleManifest<false>({\n          bundle,\n          normalizer: userOptions.normalizer,\n        });\n\n        // make sure that we have a manifest\n        const manifestPath =\n          typeof resolvedConfig.build.manifest === \"string\"\n            ? resolvedConfig.build.manifest\n            : \".vite/manifest.json\";\n        if (\n          !bundleManifest[manifestPath] ||\n          !(\"source\" in bundleManifest[manifestPath])\n        ) {\n          throw new Error(\"Server manifest not found\");\n        }\n\n        // parse the manifest\n        serverManifest = JSON.parse(\n          bundleManifest[manifestPath].source as string\n        );\n\n        // make sure that we have a manifest\n        if (!serverManifest) {\n          throw new Error(\"Failed to parse server manifest\");\n        }\n      } catch (error) {\n        const panicError = handleError({\n          error,\n          logger: logger,\n          panicThreshold: userOptions.panicThreshold,\n          context: \"writeBundle(bundleManifest)\",\n        });\n        if (panicError != null) {\n          throw panicError;\n        } else {\n          throw new Error(\"Failed to get bundle manifest\");\n        }\n      }\n\n      try {\n        const staticManifestResult = await tryManifest({\n          root: userOptions.projectRoot,\n          outDir: join(userOptions.build.outDir, userOptions.build.static),\n          manifestPath: resolvedConfig.build.manifest,\n          ssrManifest: false,\n        });\n        if (staticManifestResult.type === \"error\") {\n          throw staticManifestResult.error;\n        }\n        const staticManifest = staticManifestResult.manifest;\n        \n        // Don't create helper file - let resolveVirtualAndNodeModules shim handle it\n        // Same approach as client environment - no special file needed\n        \n        const buildLoader = createBuildLoader(\n          {\n            userOptions: userOptions,\n            serverManifest: serverManifest ?? {},\n            staticManifest: staticManifest,\n          },\n          bundle,\n          temporaryReferences,\n          logger\n        );\n        // Create CSS props for each CSS file\n        const { cssFilesByPage, globalCss } = processCssFilesForPages({\n          userOptions,\n          autoDiscoveredFiles,\n          serverManifest,\n          staticManifest,\n          bundle,\n          logger,\n        });\n\n        if (userOptions.verbose) {\n          logger.info(\n            `[plugin.server] cssFilesByPage size: ${cssFilesByPage.size}`\n          );\n          for (const [route, cssMap] of cssFilesByPage.entries()) {\n            logger.info(\n              `[plugin.server] Route ${route}: ${cssMap.size} CSS files`\n            );\n            \n          }\n        }\n\n        const indexHtml = staticManifest?.[\"index.html\"]?.file;\n        const serverPipeableStreamOptions = {\n          ...userOptions.serverPipeableStreamOptions,\n          bootstrapModules: [\n            ...(indexHtml ? [baseURL(indexHtml)] : []),\n            ...(userOptions.serverPipeableStreamOptions?.bootstrapModules ??\n              []),\n          ],\n        };\n        userOptions.serverPipeableStreamOptions = serverPipeableStreamOptions;\n        const clientPipeableStreamOptions = {\n          ...userOptions.clientPipeableStreamOptions,\n          bootstrapModules: [\n            ...(indexHtml ? [baseURL(indexHtml)] : []),\n            ...(userOptions.clientPipeableStreamOptions?.bootstrapModules ??\n              []),\n          ],\n        };\n        // Get routes for worker configuration\n        const routes = !autoDiscoveredFiles\n          ? []\n          : Array.from(autoDiscoveredFiles!.urlMap.keys());\n\n        // If no pages to generate, skip static generation entirely (including worker creation)\n        if (routes.length === 0) {\n          logger?.info(\n            \"[plugin.server] No pages to generate, skipping static generation\"\n          );\n          return;\n        }\n\n        const serializedUserOptions = serializedOptions(\n          userOptions,\n          autoDiscoveredFiles!\n        );\n        // Create HTML worker for HTML generation\n        // IMPORTANT: We create a new worker for each page render to ensure completely clean state\n        // This prevents race conditions where worker state persists between renders\n        // Guard against duplicate worker creation if plugin is instantiated multiple times\n        if (globalWorker) {\n          logger?.warn(\"[plugin.server] Global worker already exists, reusing existing worker\");\n          worker = globalWorker;\n        } else {\n          const workerStartTime = performance.now();\n          const viteEnvPrefix = envPrefixFromConfig(resolvedConfig);\n          const routeCount = autoDiscoveredFiles?.urlMap.size ?? 0;\n          const maxListeners = routeCount + 1;\n          const workerResult = await createWorker({\n            projectRoot: userOptions.projectRoot,\n            workerPath: userOptions.htmlWorkerPath,\n            currentCondition: \"react-server\",\n            reverseCondition: \"react-client\", // HTML worker needs react-client for react-dom/server\n            maxListeners: maxListeners,\n            envPrefix: viteEnvPrefix,\n            logger: logger,\n            workerData: {\n              resolvedConfig: serializeResolvedConfig(resolvedConfig),\n              userOptions: serializedUserOptions,\n              configEnv,\n            },\n          });\n          if (workerResult.type === \"error\") {\n            if (workerResult.error != null) {\n              throw workerResult.error;\n            }\n            throw new Error(\"React static plugin failed to create worker\");\n          } else if (workerResult.type === \"skip\") {\n            logger.info(\"Worker not created, skipping static build\");\n            return;\n          } else {\n            worker = workerResult.worker;\n            // Emit worker startup metric after worker is created\n            const workerStartupTime = performance.now() - workerStartTime;\n            if (userOptions.onMetrics) {\n              const workerStartupMetric = createWorkerStartupMetrics({\n                route: \"/\", // Worker startup is global, not route-specific\n                workerType: \"html\", // This is the HTML worker for server-side static generation\n                startupTime: workerStartupTime,\n                fromMainThread: true,\n                fromRscWorker: false,\n                fromHtmlWorker: false,\n                description: `HTML worker startup for server-side static generation`,\n              });\n              // Only emit metrics from the server environment to prevent duplicates\n              if (this.environment.name === \"server\") {\n                userOptions.onMetrics(workerStartupMetric);\n              }\n            }\n            // Store the worker globally to prevent duplicate creation\n            globalWorker = worker;\n          }\n        }\n\n        // No RSC worker needed for static generation - main thread runs with react-server conditions\n        // Render pages - component resolution now happens per-route in renderPage\n        const { onEvent, ...handlerOptions } = userOptions;\n\n        // Emit the static site generation start event\n        if (typeof userOptions.onEvent === \"function\") {\n          try {\n            const r = userOptions.onEvent({\n              type: \"build.ssg.start\",\n              data: {\n                pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),\n                options: null as any, // No specific rollup output options for static generation\n                bundle: bundle,\n              },\n            });\n            if (r != null && typeof r === \"object\" && \"then\" in r) {\n              await (r as Promise<any>);\n            }\n          } catch (error) {\n            const eventPanicError = handleError({\n              error,\n              logger: logger,\n              panicThreshold: userOptions.panicThreshold,\n              context: \"onEvent(build.ssg.start)\",\n            });\n            if (eventPanicError != null) {\n              throw eventPanicError; // Re-throw to abort the build\n            } else {\n              throw new Error(\"Failed to emit build.ssg.start event\");\n            }\n          }\n        }\n\n        // Select render mode based on build config\n        const renderMode = userOptions.build?.renderMode ?? \"parallel\";\n        const renderPages = renderMode === \"sequential\" ? renderPagesSequential : renderPagesBatched;\n\n        if (userOptions.verbose) {\n          logger.info(`[static] Using ${renderMode} rendering${renderMode === \"parallel\" ? ` (batch size: ${userOptions.build?.batchSize ?? 8})` : \"\"}`);\n        }\n\n        // this will render the routes\n        const renderPagesGenerator = renderPages(\n          routes,\n          {\n            ...handlerOptions,\n            loader: buildLoader,\n            worker: worker,\n            htmlWorker: worker, // Pass the HTML worker for HTML generation\n            logger: logger,\n            // Pass global CSS to downstream renderer\n            globalCss,\n            // Pass abort signal to cancel operations when errors occur\n            signal: AbortSignal.timeout(handlerOptions.htmlTimeout),\n            onEvent: onEvent,\n            serverPipeableStreamOptions: serverPipeableStreamOptions,\n            clientPipeableStreamOptions: clientPipeableStreamOptions,\n            manifest: serverManifest ?? {},\n            staticManifest: staticManifest, // Pass static manifest for path resolution\n            autoDiscoveredFiles: autoDiscoveredFiles!,\n            cssFilesByPage: cssFilesByPage,\n            batchSize: userOptions.build?.batchSize,\n          },\n          renderPage\n        );\n\n        // Process render results\n        let finalResult: RenderPagesResult | undefined;\n        try {\n          for await (const result of renderPagesGenerator) {\n            // Handle error results immediately\n            if (result.type === \"error\") {\n              throw result.error;\n            }\n\n            // Handle failed routes based on panic threshold\n            if (\n              result.type === \"success\" &&\n              result.failedRoutes &&\n              result.failedRoutes.size > 0\n            ) {\n              // Use centralized panic threshold logic\n              const firstError = result.failedRoutes.values().next().value;\n              if (firstError != null && shouldCausePanic(firstError, { panicThreshold: userOptions.panicThreshold })) {\n                // This should cause a panic, throw the error\n                throw firstError;\n              }\n              // For non-panic errors, log warnings but continue\n              for (const [route, error] of result.failedRoutes) {\n                const err = error instanceof Error ? error : toError(error);\n                this.warn(\n                  new Error(\"Failed to render route: \" + route + \"\\n\" + err.message + \"\\n\" + err.stack, { cause: err })\n                );\n              }\n            }\n\n            finalResult = result;\n          }\n        } catch (renderError) {\n          // Handle render errors with panic threshold logic\n          const renderPanicError = handleError({\n            error: renderError,\n            logger: logger,\n            panicThreshold: userOptions.panicThreshold,\n            context: \"renderPages\",\n          });\n          if (renderPanicError != null) {\n            throw renderPanicError;\n          }\n          throw renderError;\n        }\n\n        if (!finalResult) {\n          throw new Error(\"No render result produced\");\n        }\n        // Calculate duration from timing\n        const duration = Math.round(\n          performance.now() - (timing.renderStart || timing.start)\n        );\n\n        this.info(\n          `Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`\n        );\n\n        // Emit the static site generation completion event once\n        if (typeof userOptions.onEvent === \"function\") {\n          try {\n            const r = userOptions.onEvent({\n              type: \"build.ssg.end\",\n              data: {\n                pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),\n                options: null as any, // No specific rollup output options for static generation\n                bundle: bundle,\n              },\n            });\n            if (r != null && typeof r === \"object\" && \"then\" in r) {\n              await (r as Promise<any>);\n            }\n          } catch (error) {\n            if (error != null) {\n              throw error; // Re-throw to abort the build\n            } else {\n              throw new Error(\"Failed to emit build.ssg.end event\");\n            }\n          }\n        }\n\n        if (process.env[\"NODE_ENV\"] !== \"production\") {\n          this.warn(\n            `THIS BUILD IS NOT INTENDED FOR PRODUCTION (${process.env[\"NODE_ENV\"]})`\n          );\n        }\n\n        // Update timing\n        timing.render =\n          performance.now() - (timing.renderStart ?? timing.start);\n      } catch (error) {\n        panicError = handleError({\n          error,\n          logger: logger,\n          panicThreshold: userOptions.panicThreshold,\n          context: \"writeBundle\",\n        });\n\n        // Let the finally block handle additional cleanup\n      } finally {\n        // Reset any cached state to prevent issues in subsequent builds\n        autoDiscoveredFiles = null;\n        serverManifest = undefined;\n        \n        // Clean up worker if it exists\n        if (worker) {\n          try {\n            worker.removeAllListeners();\n            worker.terminate();\n          } catch (terminateError) {\n            // Ignore termination errors\n          }\n          worker = undefined;\n          // Reset global worker since it's been terminated\n          globalWorker = undefined;\n        }\n      }\n\n      if (panicError != null) {\n        // Ensure we have a proper Error object that can have properties set on it\n        const errorToThrow =\n          panicError instanceof Error\n            ? panicError\n            : new Error(String(panicError));\n\n        // Create a new Error object to avoid the \"code\" property issue\n        const finalError = new Error(errorToThrow.message);\n        finalError.stack = errorToThrow.stack;\n        finalError.cause = errorToThrow.cause;\n\n        // Copy any additional properties that might be needed\n        if (errorToThrow.name) finalError.name = errorToThrow.name;\n\n        throw finalError;\n      }\n    },\n\n    async closeBundle() {\n      // Clean up _virtual files after build completes\n      // These are Vite's internal virtual modules and aren't needed in the final output\n      if (this.environment.name === \"server\") {\n        try {\n          const { existsSync } = await import(\"node:fs\");\n          const { join, resolve } = await import(\"node:path\");\n          \n          // Use the resolved output directory from the environment config\n          const resolvedOutDir = this.environment.config.build?.outDir \n            ? resolve(this.environment.config.root || userOptions.projectRoot, this.environment.config.build.outDir)\n            : resolve(userOptions.projectRoot, userOptions.build.outDir);\n          \n          // Don't clean up server/_virtual - we need dynamic-import-helper.js for runtime\n          // Only clean up static/_virtual if it exists (shouldn't, but just in case)\n          const staticOutDir = join(resolvedOutDir, userOptions.build.static || \"static\");\n          const staticVirtualDir = join(staticOutDir, \"_virtual\");\n          if (existsSync(staticVirtualDir)) {\n            const { rmSync } = await import(\"node:fs\");\n            rmSync(staticVirtualDir, { recursive: true, force: true });\n            if (userOptions.verbose) {\n              logger?.info(`[plugin.server] Cleaned up _virtual directory: ${staticVirtualDir}`);\n            }\n          }\n        } catch (error) {\n          // Non-critical - log but don't fail the build\n          if (userOptions.verbose) {\n            logger?.warn(`[plugin.server] Failed to clean up _virtual directory: ${error}`);\n          }\n        }\n      }\n\n      // Graceful worker shutdown - only at the end of the entire build process\n      if (worker) {\n        try {\n          await Promise.race([\n            new Promise<void>((resolve, reject) => {\n              const timeout = setTimeout(() => {\n                reject(new Error(\"Worker shutdown timeout\"));\n              }, userOptions.workerShutdownTimeout);\n\n              const backupTimeout = setTimeout(() => {\n                reject(new Error(\"Worker shutdown backup timeout\"));\n              }, Math.floor(userOptions.workerShutdownTimeout * 0.6)); // 60% of main timeout\n\n              const messageHandler = (message: any) => {\n                if (message.type === \"SHUTDOWN_COMPLETE\") {\n                  if (userOptions.verbose) {\n                    logger.info(\"Worker shutdown complete\");\n                  }\n                  clearTimeout(timeout);\n                  clearTimeout(backupTimeout);\n                  worker?.removeListener(\"message\", messageHandler);\n                  // Remove all other event listeners as well\n                  worker?.removeAllListeners();\n                  resolve();\n                } else if (message.type === \"CLEANUP_COMPLETE\") {\n                  // Handle cleanup complete messages during shutdown - this is normal\n                  if (userOptions.verbose) {\n                    logger.info(\"Worker cleanup completed during shutdown\");\n                  }\n                  // Don't resolve here - wait for SHUTDOWN_COMPLETE\n                } else {\n                  if (userOptions.verbose) {\n                    logger.info(\n                      \"Worker is still busy, received message \" + message?.type\n                    );\n                  }\n                }\n              };\n\n              worker?.on(\"message\", messageHandler);\n\n              // Send shutdown message\n              worker?.postMessage({\n                type: \"SHUTDOWN\",\n                id: \"*\",\n              });\n            }),\n          ]);\n        } catch (error) {\n          // If shutdown protocol fails, force terminate\n          this.warn(\n            \"Worker shutdown protocol failed, forcing termination: \" +\n              (error instanceof Error ? error.message : String(error))\n          );\n          // Don't try to clean up listeners in error case - just force terminate\n        } finally {\n          // Always force cleanup and termination\n          if (worker) {\n            try {\n              worker.removeAllListeners();\n              worker.terminate();\n            } catch (terminateError) {\n              // Ignore termination errors\n            }\n            worker = undefined;\n            // Reset global worker since it's been terminated\n            globalWorker = undefined;\n          }\n        }\n      }\n    },\n  } as const;\n};\n"],"names":["panicError","renderPages","renderPagesSequential","join"],"mappings":"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"}