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

Vite plugin for React Server Components (RSC)

/**
 * 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 } 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();
let globalWorker;
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
            }
          });
        } 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]})`);
              }
            }
          }
        }
        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
            }
          });
          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;
            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);
              }
            }
            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
              }
            });
            if (r != null && typeof r === "object" && "then" in r) {
              await r;
            }
          } 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");
            }
          }
        }
        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;
            }
            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 })
                );
              }
            }
            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;
            }
          } catch (error) {
            if (error != null) {
              throw error;
            } 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"]})`
          );
        }
        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();
            await 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}`);
            }
          }
        } 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          panicThres