vite-plugin-react-server 1.4.2 → 1.4.3

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

@@ -1,801 +1,715 @@
 /**
- * plugin.client.ts
- *
- * PURPOSE: Client-side static plugin for React Server Components
- *
- * This module:
- * 1. Handles static site generation in the client environment
- * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering
- * 3. Generates both RSC and HTML files for static pages
- * 4. Integrates with Vite's build process
- *
- * Feature parity with main react-static plugin, but in reverse. Uses rsc-worker to render rsc, and main thread for html.
- * This is not the default behavior, but is supported for testing and custom app development purposes.
- * Additionally, this can make it easier to use the --app flag to build all the modules + static generation at once.
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
  */
-import { createLogger, } from "vite";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { renderPagesBatched } from "./renderPagesBatched.js";
-import { performance } from "node:perf_hooks";
-import { renderPage } from "./renderPage.client.js";
-import { createWorker } from "../worker/createWorker.js";
-import { serializedOptions, serializeResolvedConfig, } from "../helpers/serializeUserOptions.js";
-import { getBundleManifest } from "../helpers/getBundleManifest.js";
-import { handleError } from "../error/handleError.js";
-import { shouldCausePanic } from "../error/panicThresholdHandler.js";
-import { configurePreviewServer } from "./configurePreviewServer.js";
-import { assertNonReactServer } from "../config/getCondition.js";
-import { envPrefixFromConfig } from "../config/envPrefixFromConfig.js";
-import { createWorkerStartupMetrics } from "../metrics/createWorkerStartupMetrics.js";
-import { processCssFilesForPages } from "./processCssFilesForPages.js";
-import { createBuildLoader } from "./createBuildLoader.client.js";
-import { getNodeEnv } from "../config/getNodeEnv.js";
-import { toError } from "../error/toError.js";
-import { addStaticManifest, manifests, getSharedManifestStore, } from "../bundle/manifests.js";
-import { deferStaticGeneration } from "../bundle/deferredStaticGeneration.js";
-import { resolveAutoDiscover } from "../config/index.js";
-import { join } from "node:path";
-import { baseURL } from "../utils/envUrls.node.js";
-import { tryManifest } from "../helpers/tryManifest.js";
-// cssCollector removed - using filesystem-based CSS processing
+import { createLogger } from 'vite';
+import { resolveOptions } from '../config/resolveOptions.js';
+import { renderPagesBatched } from './renderPagesBatched.js';
+import { performance } from 'node:perf_hooks';
+import { renderPage } from './renderPage.client.js';
+import { createWorker } from '../worker/createWorker.js';
+import { serializeResolvedConfig, serializedOptions } from '../helpers/serializeUserOptions.js';
+import { getBundleManifest } from '../helpers/getBundleManifest.js';
+import { handleError } from '../error/handleError.js';
+import { shouldCausePanic } from '../error/panicThresholdHandler.js';
+import { configurePreviewServer } from './configurePreviewServer.js';
+import { assertNonReactServer } from '../config/getCondition.js';
+import { envPrefixFromConfig } from '../config/envPrefixFromConfig.js';
+import { createWorkerStartupMetrics } from '../metrics/createWorkerStartupMetrics.js';
+import { processCssFilesForPages } from './processCssFilesForPages.js';
+import { createBuildLoader } from './createBuildLoader.client.js';
+import { getNodeEnv } from '../config/getNodeEnv.js';
+import { toError } from '../error/toError.js';
+import { addStaticManifest, manifests, getSharedManifestStore } from '../bundle/manifests.js';
+import { deferStaticGeneration } from '../bundle/deferredStaticGeneration.js';
+import { resolveAutoDiscover } from '../config/autoDiscover/resolveAutoDiscover.js';
+import { join } from 'node:path';
+import { baseURL } from '../utils/envUrls.node.js';
+import { tryManifest } from '../helpers/tryManifest.js';
+
 assertNonReactServer();
-/**
- * plugin.client.ts
- *
- * PURPOSE: Client-side static plugin for React Server Components
- *
- * This module:
- * 1. Handles static site generation in the client environment
- * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering
- * 3. Generates both RSC and HTML files for static pages
- * 4. Integrates with Vite's build process
- *
- * @param options
- * @returns
- */
-export const reactStaticPlugin = function _reactStaticPlugin(options) {
-    let logger;
-    let autoDiscoveredFiles = null;
-    let rscWorker = undefined;
-    let resolvedConfig = null;
-    let serverManifest = undefined;
-    let staticBundle = undefined;
-    let serverBundle = 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/client-static",
-        enforce: "post",
-        apply: "build", // Apply to build mode
-        api: {
-            meta: { timing },
-        },
-        async config(_config, viteConfigEnv) {
-            configEnv = viteConfigEnv;
-        },
-        applyToEnvironment(partialEnvironment) {
-            // Client static plugin should apply to static environment (browser/ESM builds)
-            // This is where we want to bundle everything and filter out _virtual files
-            // Apply to both "static" and "client" environments - we'll handle which one runs static generation in closeBundle
-            const envName = partialEnvironment.name;
-            if (["static", "client"].includes(envName)) {
-                return true;
+const reactStaticPlugin = function _reactStaticPlugin(options) {
+  let logger;
+  let autoDiscoveredFiles = null;
+  let rscWorker = void 0;
+  let resolvedConfig = null;
+  let serverManifest = void 0;
+  let staticBundle = void 0;
+  let serverBundle = 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/client-static",
+    enforce: "post",
+    apply: "build",
+    // Apply to build mode
+    api: {
+      meta: { timing }
+    },
+    async config(_config, viteConfigEnv) {
+      configEnv = viteConfigEnv;
+    },
+    applyToEnvironment(partialEnvironment) {
+      const envName = partialEnvironment.name;
+      if (["static", "client"].includes(envName)) {
+        return true;
+      }
+      return false;
+    },
+    async configResolved(config) {
+      timing.configResolved = performance.now();
+      logger = config.customLogger || createLogger();
+      resolvedConfig = config;
+      const autoDiscoverResult = await resolveAutoDiscover({
+        config,
+        configEnv: configEnv || {
+          mode: config.mode,
+          command: config.command},
+        userOptions,
+        logger
+      });
+      if (autoDiscoverResult.type === "error") {
+        throw autoDiscoverResult.error;
+      }
+      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+      if (userOptions.verbose) {
+        logger?.info(`Auto-discovery ${autoDiscoverResult.type === "success" ? "completed" : "skipped"}`);
+      }
+    },
+    async buildStart() {
+      timing.buildStart = performance.now();
+      if (userOptions.verbose) {
+        logger?.info("[react-static-client] Build started");
+      }
+      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) {
+            rscWorker?.terminate();
+            throw panicError;
+          }
+        }
+      }
+    },
+    async renderStart() {
+      timing.renderStart = performance.now();
+      if (userOptions.verbose) {
+        logger?.info("[react-static-client] Render started");
+      }
+    },
+    // 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 writeBundle(_options, bundle) {
+      try {
+        if (!autoDiscoveredFiles?.urlMap) {
+          return;
+        }
+        const bundleManifest = getBundleManifest({
+          bundle,
+          normalizer: userOptions.normalizer
+        });
+        if (this.environment.name === "static") {
+          addStaticManifest(bundleManifest);
+          staticBundle = bundle;
+        } else if (this.environment.name === "client") {
+          if (manifests.static) {
+            const staticManifest = manifests.static;
+            for (const [, chunk] of Object.entries(bundle)) {
+              if (chunk.type === "chunk" && chunk.fileName) {
+                const normalized = userOptions.normalizer(chunk.fileName);
+                let value = normalized[1];
+                if (value.startsWith(userOptions.moduleBasePath)) {
+                  value = value.slice(userOptions.moduleBasePath.length);
+                }
+                const entry = staticManifest[value];
+                if (entry && entry.file !== chunk.fileName) {
+                  chunk.fileName = entry.file;
+                }
+              }
             }
-            return false;
-        },
-        async configResolved(config) {
-            timing.configResolved = performance.now();
-            logger = config.customLogger || createLogger();
-            resolvedConfig = config;
-            // Perform auto-discovery to populate autoDiscoveredFiles
-            const autoDiscoverResult = await resolveAutoDiscover({
-                config: config,
+          }
+        } else if (this.environment.name === "server") {
+          serverBundle = bundle;
+        }
+        return;
+      } catch (error) {
+        const panicError = handleError({
+          error,
+          logger,
+          panicThreshold: userOptions.panicThreshold});
+        if (panicError != null) {
+          throw panicError;
+        }
+      }
+    },
+    async closeBundle() {
+      const envName = this.environment.name;
+      const isSsr = this.environment.config.build?.ssr === true;
+      if (userOptions.verbose) {
+        logger?.info(`[react-static-client] closeBundle called for environment: ${envName}, ssr: ${isSsr}`);
+      }
+      if (envName === "ssr" || envName === "server" || isSsr) {
+        if (userOptions.verbose) {
+          logger?.info(`[react-static-client] Skipping static generation for environment: ${envName} (ssr: ${isSsr})`);
+        }
+        return;
+      }
+      if (envName === "static" || envName === "client" && !isSsr) {
+        try {
+          const { rmSync, 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 outputDirs = [
+            join2(resolvedOutDir, userOptions.build.static || "static"),
+            join2(resolvedOutDir, userOptions.build.client || "client")
+          ];
+          for (const outDir of outputDirs) {
+            const virtualDir = join2(outDir, "_virtual");
+            if (existsSync(virtualDir)) {
+              rmSync(virtualDir, { recursive: true, force: true });
+              if (userOptions.verbose) {
+                logger?.info(`[react-static-client] Cleaned up _virtual directory: ${virtualDir}`);
+              }
+            }
+          }
+        } catch (error) {
+          if (userOptions.verbose) {
+            logger?.warn(`[react-static-client] Failed to clean up _virtual directory: ${error}`);
+          }
+        }
+      }
+      if (envName === "ssr" || envName === "server" || isSsr) {
+        if (userOptions.verbose) {
+          logger?.info(`[react-static-client] Skipping static generation - not in static environment (${envName}, ssr: ${isSsr})`);
+        }
+        return;
+      }
+      const closeBundleContext = this;
+      deferStaticGeneration(async () => {
+        try {
+          if (!autoDiscoveredFiles) {
+            if (userOptions.verbose) {
+              logger?.warn("[react-static-client] autoDiscoveredFiles not set, attempting to re-discover");
+            }
+            const { getStashedUserOptions, getEnvironmentId } = await import('../config/stashedOptionsState.js');
+            const { getCondition } = await import('../config/getCondition.js');
+            const envId = getEnvironmentId(getCondition(), resolvedConfig?.mode || "production");
+            const stashedOptions = getStashedUserOptions(envId);
+            if (stashedOptions && resolvedConfig) {
+              const autoDiscoverResult = await resolveAutoDiscover({
+                config: resolvedConfig,
                 configEnv: configEnv || {
-                    mode: config.mode,
-                    command: config.command,
-                    isSsrBuild: false,
-                    isPreview: false,
+                  mode: resolvedConfig.mode || "production",
+                  command: resolvedConfig.command || "build",
+                  isSsrBuild: false,
+                  isPreview: false
                 },
                 userOptions,
-                logger,
-            });
-            if (autoDiscoverResult.type === "error") {
-                throw autoDiscoverResult.error;
+                logger
+              });
+              if (autoDiscoverResult.type === "success") {
+                autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+                if (userOptions.verbose) {
+                  logger?.info(`[react-static-client] Re-discovered ${autoDiscoveredFiles.urlMap.size} pages`);
+                }
+              } else {
+                if (userOptions.verbose) {
+                  logger?.warn(`[react-static-client] Failed to re-discover pages: ${autoDiscoverResult.error}`);
+                }
+              }
             }
-            autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+          }
+          if (!autoDiscoveredFiles?.urlMap || autoDiscoveredFiles?.urlMap.size === 0) {
             if (userOptions.verbose) {
-                logger?.info(`Auto-discovery ${autoDiscoverResult.type === "success" ? "completed" : "skipped"}`);
+              logger?.warn(`[react-static-client] No pages to generate - urlMap is empty (size: ${autoDiscoveredFiles?.urlMap?.size || 0})`);
+              logger?.warn(`[react-static-client] autoDiscoveredFiles exists: ${!!autoDiscoveredFiles}, urlMap exists: ${!!autoDiscoveredFiles?.urlMap}`);
             }
-        },
-        async buildStart() {
-            timing.buildStart = performance.now();
+            return;
+          }
+          if (userOptions.verbose) {
+            logger?.info(`[react-static-client] Starting static generation with ${autoDiscoveredFiles.urlMap.size} pages`);
+          }
+          try {
             if (userOptions.verbose) {
-                logger?.info("[react-static-client] Build started");
+              logger?.info(`[react-static-client] Attempting to get server manifest from shared state`);
             }
-            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) {
-                        rscWorker?.terminate();
-                        throw panicError;
-                    }
-                }
+            const sharedState = getSharedManifestStore(closeBundleContext);
+            if (sharedState.server) {
+              serverManifest = sharedState.server;
+              if (userOptions.verbose) {
+                logger?.info(`[react-static-client] Got server manifest from shared state`);
+              }
+            } else {
+              throw new Error("No server manifest in shared state");
             }
-        },
-        async renderStart() {
-            timing.renderStart = performance.now();
+          } catch (error) {
             if (userOptions.verbose) {
-                logger?.info("[react-static-client] Render started");
+              logger?.info(`[react-static-client] Failed to get server manifest from shared state, trying filesystem: ${error}`);
             }
-        },
-        // 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,
+            const serverManifestPath = join(
+              userOptions.build.outDir,
+              userOptions.build.server
+            );
+            const manifestPath = typeof resolvedConfig?.build.manifest === "string" ? resolvedConfig.build.manifest : ".vite/manifest.json";
+            if (userOptions.verbose) {
+              logger?.info(`[react-static-client] Loading server manifest from: ${join(serverManifestPath, manifestPath)}`);
+            }
+            const serverManifestResult = await tryManifest({
+              root: userOptions.projectRoot,
+              outDir: serverManifestPath,
+              manifestPath,
+              ssrManifest: false
+            });
+            if (serverManifestResult.type === "error") {
+              if (userOptions.verbose) {
+                logger?.warn(`[react-static-client] Failed to load server manifest: ${serverManifestResult.error}`);
+              }
+              serverManifest = {};
+              if (userOptions.verbose) {
+                logger?.warn(`[react-static-client] Using empty server manifest as fallback`);
+              }
+            } else if (serverManifestResult.type === "skip") {
+              if (userOptions.verbose) {
+                logger?.warn(`[react-static-client] Server manifest not found, using empty manifest as fallback`);
+              }
+              serverManifest = {};
+            } else {
+              serverManifest = serverManifestResult.manifest;
+              if (userOptions.verbose) {
+                logger?.info(`[react-static-client] Loaded server manifest from filesystem`);
+              }
+            }
+          }
+          const staticManifestResult = await tryManifest({
+            root: userOptions.projectRoot,
+            outDir: join(userOptions.build.outDir, userOptions.build.static),
+            manifestPath: resolvedConfig?.build.manifest ?? ".vite/manifest.json",
+            ssrManifest: false
+          });
+          if (staticManifestResult.type === "error") {
+            throw staticManifestResult.error;
+          }
+          const staticManifest = staticManifestResult.manifest;
+          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 { cssFilesByPage, globalCss } = processCssFilesForPages({
+            userOptions,
+            autoDiscoveredFiles,
+            serverManifest,
+            staticManifest,
+            bundle: staticBundle || {},
+            logger
+          });
+          if (userOptions.verbose) {
+            for (const [route, cssMap] of cssFilesByPage.entries()) {
+              logger.info(
+                `[react-static-client] Route ${route}: ${cssMap.size} CSS files`
+              );
+              for (const [key, value] of cssMap.entries()) {
+                logger.info(
+                  `[react-static-client]   CSS file: ${key} -> ${value.as} (${value.children ? "inline" : "link"})`
+                );
+              }
+            }
+          }
+          const routes = Array.from(
+            autoDiscoveredFiles.urlMap.keys()
+          );
+          if (routes.length === 0) {
+            if (userOptions.verbose) {
+              logger?.info(
+                "[react-static-client] No pages to generate, skipping static generation"
+              );
+            }
+            return;
+          }
+          if (userOptions.verbose) {
+            logger?.info(`[react-static-client] Creating build loader`);
+          }
+          const buildLoader = createBuildLoader();
+          if (userOptions.verbose) {
+            logger?.info(`[react-static-client] Build loader created`);
+          }
+          if (userOptions.verbose) {
+            logger?.info(
+              `[react-static-client] Creating RSC worker with path: ${userOptions.rscWorkerPath}`
+            );
+          }
+          const workerStartTime = performance.now();
+          let rscWorkerResult;
+          try {
+            rscWorkerResult = await createWorker({
+              projectRoot: userOptions.projectRoot,
+              workerPath: userOptions.rscWorkerPath,
+              currentCondition: "react-client",
+              reverseCondition: "react-server",
+              maxListeners: Math.max(routes.length * 3, 10),
+              // Account for multiple listeners per route
+              envPrefix: envPrefixFromConfig(resolvedConfig),
+              logger,
+              verbose: userOptions.verbose,
+              mode: getNodeEnv(),
+              workerData: {
+                userOptions: serializedOptions(userOptions, autoDiscoveredFiles),
+                resolvedConfig: serializeResolvedConfig(resolvedConfig),
+                configEnv: (() => {
+                  const fallback = resolvedConfig ? {
+                    command: resolvedConfig.command,
+                    mode: resolvedConfig.mode,
+                    isSsrBuild: false,
+                    isPreview: false
+                  } : void 0;
+                  const finalConfigEnv = configEnv || fallback;
+                  return finalConfigEnv;
+                })(),
+                serverManifest: serverManifest || {},
+                // Use server manifest for page component resolution
+                bundle: staticBundle || {},
+                // Use static bundle (client build) for page component resolution
+                staticBundle: staticBundle || {},
+                // Pass static bundle separately for path resolution
+                id: "static-client-rsc-worker"
+              }
+            });
+          } catch (workerError) {
+            if (userOptions.verbose) {
+              logger?.error(`[react-static-client] Error creating RSC worker: ${workerError}`);
+            }
+            throw workerError;
+          }
+          if (rscWorkerResult.type !== "success") {
+            const err = rscWorkerResult.error ?? new Error(`Failed to create RSC worker`);
+            if (userOptions.verbose) {
+              logger?.error(
+                `[react-static-client] RSC worker creation failed, throwing error`,
+                { error: err }
+              );
+            }
+            throw err;
+          }
+          rscWorker = rscWorkerResult.worker;
+          if (userOptions.verbose) {
+            logger?.info(`[react-static-client] RSC worker created successfully`);
+          }
+          const workerStartupTime = performance.now() - workerStartTime;
+          if (userOptions.onMetrics) {
+            const workerStartupMetric = createWorkerStartupMetrics({
+              route: "/",
+              // Worker startup is global, not route-specific
+              workerType: "rsc",
+              // This is the RSC worker for client-side static generation
+              startupTime: workerStartupTime,
+              fromMainThread: true,
+              fromRscWorker: false,
+              fromHtmlWorker: false,
+              description: `RSC worker startup for client-side static generation`
             });
-        },
-        async writeBundle(_options, bundle) {
-            // Capture manifests from all environments
+            userOptions.onMetrics(workerStartupMetric);
+          }
+          const { onEvent, onMetrics, ...handlerOptions } = userOptions;
+          if (userOptions.verbose) {
+            logger?.info(`[react-static-client] Extracted onEvent: ${typeof onEvent}, userOptions.onEvent: ${typeof userOptions.onEvent}`);
+          }
+          if (!serverBundle && onEvent) {
+            const originalOnEvent = onEvent;
+            const tempOnEvent = (event) => {
+              if (event.type === "build.writeBundle.server") {
+                serverBundle = event.data.bundle;
+                logger?.info(
+                  "[react-static-client] Captured server bundle from build event"
+                );
+              }
+              originalOnEvent(event);
+            };
+            userOptions.onEvent = tempOnEvent;
+          }
+          const eventHandler = onEvent || userOptions.onEvent;
+          if (typeof eventHandler === "function") {
             try {
-                if (!autoDiscoveredFiles?.urlMap) {
-                    return;
+              if (userOptions.verbose) {
+                logger?.info(`[react-static-client] Emitting build.ssg.start event`);
+              }
+              const r = eventHandler({
+                type: "build.ssg.start",
+                data: {
+                  pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
+                  options: null,
+                  // No specific rollup output options for static generation
+                  bundle: staticBundle || {}
                 }
-                const bundleManifest = getBundleManifest({
-                    bundle,
-                    normalizer: userOptions.normalizer,
-                });
-                // Store manifest based on environment
-                if (this.environment.name === "static") {
-                    // Store in global manifest store for environment plugin access
-                    addStaticManifest(bundleManifest);
-                    staticBundle = 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 if (userOptions.verbose) {
+            logger?.warn(`[react-static-client] No onEvent handler available to emit build.ssg.start`);
+          }
+          const renderPagesGenerator = renderPagesBatched(
+            routes,
+            {
+              ...handlerOptions,
+              // Use the clean options instead of the original handlerOptions
+              worker: rscWorker,
+              // Pass the RSC worker for RSC rendering only
+              rscWorker,
+              // Pass the RSC worker for RSC rendering only
+              loader: buildLoader,
+              // Use proper build loader instead of no-op
+              logger,
+              autoDiscoveredFiles,
+              cssFilesByPage,
+              // Pass CSS files by page
+              serverPipeableStreamOptions,
+              // Pass server options to RSC worker
+              clientPipeableStreamOptions,
+              // Pass client options to RSC worker
+              globalCss,
+              // Pass global CSS
+              manifest: serverManifest || {},
+              // Server manifest for RSC worker
+              staticManifest,
+              // Static manifest for consistent module IDs
+              onEvent,
+              onMetrics
+              // Pass through the onMetrics callback (metric watcher)
+            },
+            renderPage
+          );
+          let finalResult = void 0;
+          try {
+            for await (const result of renderPagesGenerator) {
+              if (result.type === "error") {
+                if (userOptions.verbose) {
+                  logger?.error(`[react-static-client] Render error: ${result.error}`);
                 }
-                else if (this.environment.name === "client") {
-                    // Client build manifest (SSR modules) - stored globally now
-                    if (manifests.static) {
-                        const staticManifest = manifests.static;
-                        // Update bundle filenames to match static manifest
-                        for (const [, chunk] of Object.entries(bundle)) {
-                            if (chunk.type === "chunk" && chunk.fileName) {
-                                const normalized = userOptions.normalizer(chunk.fileName);
-                                let value = normalized[1];
-                                if (value.startsWith(userOptions.moduleBasePath)) {
-                                    value = value.slice(userOptions.moduleBasePath.length);
-                                }
-                                const entry = staticManifest[value];
-                                if (entry && entry.file !== chunk.fileName) {
-                                    // Update the filename to match static manifest
-                                    chunk.fileName = entry.file;
-                                }
-                            }
-                        }
-                    }
+                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;
                 }
-                else if (this.environment.name === "server") {
-                    // Server build manifest (server components) - stored globally now
-                    serverBundle = bundle;
+                for (const [route, error] of result.failedRoutes) {
+                  const err = error instanceof Error ? error : toError(error);
+                  closeBundleContext.warn(
+                    new Error(
+                      "Failed to render route: " + route + "\n" + err.message + "\n" + err.stack,
+                      { cause: err }
+                    )
+                  );
                 }
-                // Skip the static generation here - it will happen in closeBundle
-                return;
+              }
+              finalResult = result;
             }
-            catch (error) {
-                const panicError = handleError({
-                    error,
-                    logger: logger,
-                    panicThreshold: userOptions.panicThreshold,
-                    context: "writeBundle",
-                });
-                if (panicError != null) {
-                    throw panicError;
-                }
-            }
-        },
-        async closeBundle() {
-            const envName = this.environment.name;
-            const isSsr = this.environment.config.build?.ssr === true;
+          } catch (renderError) {
             if (userOptions.verbose) {
-                logger?.info(`[react-static-client] closeBundle called for environment: ${envName}, ssr: ${isSsr}`);
+              logger?.error(`[react-static-client] Error during renderPages: ${renderError}`);
             }
-            // Only run static generation in the non-SSR client environment (static builds)
-            // Skip SSR client builds and server builds
-            if (envName === "ssr" || envName === "server" || isSsr) {
-                if (userOptions.verbose) {
-                    logger?.info(`[react-static-client] Skipping static generation for environment: ${envName} (ssr: ${isSsr})`);
-                }
-                return;
+            throw renderError;
+          }
+          if (!finalResult) {
+            const errorMsg = "No render result produced";
+            if (userOptions.verbose) {
+              logger?.error(`[react-static-client] ${errorMsg}`);
             }
-            // Clean up _virtual files after build completes
-            // These are Vite's internal virtual modules and aren't needed in the final output
-            if (envName === "static" || (envName === "client" && !isSsr)) {
-                try {
-                    const { rmSync, 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);
-                    // Clean up _virtual from client/static output directories only
-                    // Don't clean up server/_virtual since we need dynamic-import-helper.js there
-                    const outputDirs = [
-                        join(resolvedOutDir, userOptions.build.static || "static"),
-                        join(resolvedOutDir, userOptions.build.client || "client"),
-                    ];
-                    for (const outDir of outputDirs) {
-                        const virtualDir = join(outDir, "_virtual");
-                        if (existsSync(virtualDir)) {
-                            rmSync(virtualDir, { recursive: true, force: true });
-                            if (userOptions.verbose) {
-                                logger?.info(`[react-static-client] Cleaned up _virtual directory: ${virtualDir}`);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    // Non-critical - log but don't fail the build
-                    if (userOptions.verbose) {
-                        logger?.warn(`[react-static-client] Failed to clean up _virtual directory: ${error}`);
-                    }
+            throw new Error(errorMsg);
+          }
+          if (userOptions.verbose) {
+            logger?.info(`[react-static-client] Render completed: ${finalResult.completedRoutes.size} pages, ${finalResult.failedRoutes?.size || 0} failed`);
+          }
+          const duration = Math.round(
+            performance.now() - (timing.renderStart || timing.start)
+          );
+          closeBundleContext.info(
+            `Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`
+          );
+          if (process.env["NODE_ENV"] !== "production") {
+            closeBundleContext.warn(
+              `THIS BUILD IS NOT INTENDED FOR PRODUCTION (${process.env["NODE_ENV"]})`
+            );
+          }
+          timing.render = performance.now() - (timing.renderStart ?? timing.start);
+          if (userOptions.verbose) {
+            logger?.info("[react-static-client] Static generation completed");
+          }
+          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: staticBundle || {}
                 }
+              });
+              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.end)"
+              });
+              if (eventPanicError != null) {
+                throw eventPanicError;
+              }
             }
-            // This runs after all writeBundle hooks are complete
-            // Run static generation in the non-SSR client environment (static builds)
-            // This could be "static" or "client" depending on how environments are configured
-            if (envName === "ssr" || envName === "server" || isSsr) {
-                if (userOptions.verbose) {
-                    logger?.info(`[react-static-client] Skipping static generation - not in static environment (${envName}, ssr: ${isSsr})`);
-                }
-                return;
+          }
+        } catch (error) {
+          const panicError = handleError({
+            error,
+            logger,
+            panicThreshold: userOptions.panicThreshold
+          });
+          if (rscWorker) {
+            const workerToCleanup = rscWorker;
+            try {
+              await Promise.race([
+                new Promise((resolve) => {
+                  const timeoutId = setTimeout(() => {
+                    workerToCleanup.removeAllListeners();
+                    workerToCleanup.terminate();
+                    resolve();
+                  }, 1e3);
+                  const messageHandler = (message) => {
+                    if (message.type === "SHUTDOWN_COMPLETE") {
+                      clearTimeout(timeoutId);
+                      workerToCleanup.removeListener("message", messageHandler);
+                      resolve();
+                    }
+                  };
+                  workerToCleanup.on("message", messageHandler);
+                  workerToCleanup.postMessage({ type: "SHUTDOWN" });
+                })
+              ]);
+              rscWorker = void 0;
+            } catch (cleanupError) {
+              logger.warn(`Failed to cleanup worker on error: ${cleanupError}`);
+              try {
+                workerToCleanup.removeAllListeners();
+                workerToCleanup.terminate();
+              } catch (terminateError) {
+              }
+              rscWorker = void 0;
             }
-            // Defer static generation to run after ALL environments complete their builds.
-            // This is necessary because we need the server manifest (from server env's writeBundle)
-            // to resolve function-based component paths like Root: (url) => 'src/CustomRoot.tsx'.
-            // The buildApp hook in createEnvironmentPlugin will call runDeferredStaticGeneration().
-            const closeBundleContext = this;
-            deferStaticGeneration(async () => {
+          }
+          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;
+          }
+        } finally {
+          if (rscWorker) {
+            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 shutdownMessageHandler = (message) => {
+                    if (message.type === "SHUTDOWN_COMPLETE") {
+                      clearTimeout(timeout);
+                      clearTimeout(backupTimeout);
+                      rscWorker?.removeListener(
+                        "message",
+                        shutdownMessageHandler
+                      );
+                      rscWorker?.removeAllListeners();
+                      resolve();
+                    }
+                  };
+                  rscWorker?.on("message", shutdownMessageHandler);
+                  rscWorker?.postMessage({
+                    type: "SHUTDOWN",
+                    id: "*"
+                  });
+                })
+              ]);
+            } catch {
+            } finally {
+              if (rscWorker) {
                 try {
-                    // Re-check autoDiscoveredFiles - it might not be set if configResolved didn't run
-                    // or if it was cleared. Try to get it from stashed options if needed
-                    if (!autoDiscoveredFiles) {
-                        if (userOptions.verbose) {
-                            logger?.warn("[react-static-client] autoDiscoveredFiles not set, attempting to re-discover");
-                        }
-                        const { getStashedUserOptions, getEnvironmentId } = await import("../config/stashedOptionsState.js");
-                        const { getCondition } = await import("../config/getCondition.js");
-                        const envId = getEnvironmentId(getCondition(), resolvedConfig?.mode || "production");
-                        const stashedOptions = getStashedUserOptions(envId);
-                        if (stashedOptions && resolvedConfig) {
-                            // Try to re-run auto-discovery if we have the config
-                            const autoDiscoverResult = await resolveAutoDiscover({
-                                config: resolvedConfig,
-                                configEnv: configEnv || {
-                                    mode: resolvedConfig.mode || "production",
-                                    command: resolvedConfig.command || "build",
-                                    isSsrBuild: false,
-                                    isPreview: false,
-                                },
-                                userOptions,
-                                logger,
-                            });
-                            if (autoDiscoverResult.type === "success") {
-                                autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
-                                if (userOptions.verbose) {
-                                    logger?.info(`[react-static-client] Re-discovered ${autoDiscoveredFiles.urlMap.size} pages`);
-                                }
-                            }
-                            else {
-                                if (userOptions.verbose) {
-                                    logger?.warn(`[react-static-client] Failed to re-discover pages: ${autoDiscoverResult.error}`);
-                                }
-                            }
-                        }
-                    }
-                    if (!autoDiscoveredFiles?.urlMap ||
-                        autoDiscoveredFiles?.urlMap.size === 0) {
-                        if (userOptions.verbose) {
-                            logger?.warn(`[react-static-client] No pages to generate - urlMap is empty (size: ${autoDiscoveredFiles?.urlMap?.size || 0})`);
-                            logger?.warn(`[react-static-client] autoDiscoveredFiles exists: ${!!autoDiscoveredFiles}, urlMap exists: ${!!autoDiscoveredFiles?.urlMap}`);
-                        }
-                        return;
-                    }
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] Starting static generation with ${autoDiscoveredFiles.urlMap.size} pages`);
-                    }
-                    // Check if we can access the shared manifest store
-                    try {
-                        if (userOptions.verbose) {
-                            logger?.info(`[react-static-client] Attempting to get server manifest from shared state`);
-                        }
-                        const sharedState = getSharedManifestStore(closeBundleContext);
-                        if (sharedState.server) {
-                            serverManifest = sharedState.server;
-                            if (userOptions.verbose) {
-                                logger?.info(`[react-static-client] Got server manifest from shared state`);
-                            }
-                        }
-                        else {
-                            throw new Error("No server manifest in shared state");
-                        }
-                    }
-                    catch (error) {
-                        if (userOptions.verbose) {
-                            logger?.info(`[react-static-client] Failed to get server manifest from shared state, trying filesystem: ${error}`);
-                        }
-                        const serverManifestPath = join(userOptions.build.outDir, userOptions.build.server);
-                        const manifestPath = (typeof resolvedConfig?.build.manifest === "string"
-                            ? resolvedConfig.build.manifest
-                            : ".vite/manifest.json");
-                        if (userOptions.verbose) {
-                            logger?.info(`[react-static-client] Loading server manifest from: ${join(serverManifestPath, manifestPath)}`);
-                        }
-                        const serverManifestResult = await tryManifest({
-                            root: userOptions.projectRoot,
-                            outDir: serverManifestPath,
-                            manifestPath: manifestPath,
-                            ssrManifest: false,
-                        });
-                        if (serverManifestResult.type === "error") {
-                            if (userOptions.verbose) {
-                                logger?.warn(`[react-static-client] Failed to load server manifest: ${serverManifestResult.error}`);
-                            }
-                            // Use empty manifest as fallback - static generation can proceed without it
-                            serverManifest = {};
-                            if (userOptions.verbose) {
-                                logger?.warn(`[react-static-client] Using empty server manifest as fallback`);
-                            }
-                        }
-                        else if (serverManifestResult.type === "skip") {
-                            if (userOptions.verbose) {
-                                logger?.warn(`[react-static-client] Server manifest not found, using empty manifest as fallback`);
-                            }
-                            // Use empty manifest as fallback - static generation can proceed without it
-                            serverManifest = {};
-                        }
-                        else {
-                            serverManifest = serverManifestResult.manifest;
-                            if (userOptions.verbose) {
-                                logger?.info(`[react-static-client] Loaded server manifest from filesystem`);
-                            }
-                        }
-                    }
-                    // Load static manifest from filesystem for CSS path mapping
-                    const staticManifestResult = await tryManifest({
-                        root: userOptions.projectRoot,
-                        outDir: join(userOptions.build.outDir, userOptions.build.static),
-                        manifestPath: resolvedConfig?.build.manifest ?? ".vite/manifest.json",
-                        ssrManifest: false,
-                    });
-                    if (staticManifestResult.type === "error") {
-                        throw staticManifestResult.error;
-                    }
-                    const staticManifest = staticManifestResult.manifest;
-                    // Construct bootstrapModules like the server plugin does
-                    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 ??
-                                []),
-                        ],
-                    };
-                    // Create CSS props for each CSS file (same as server-static)
-                    const { cssFilesByPage, globalCss } = processCssFilesForPages({
-                        userOptions,
-                        autoDiscoveredFiles,
-                        serverManifest,
-                        staticManifest,
-                        bundle: staticBundle || {},
-                        logger,
-                    });
-                    if (userOptions.verbose) {
-                        for (const [route, cssMap] of cssFilesByPage.entries()) {
-                            logger.info(`[react-static-client] Route ${route}: ${cssMap.size} CSS files`);
-                            for (const [key, value] of cssMap.entries()) {
-                                logger.info(`[react-static-client]   CSS file: ${key} -> ${value.as} (${value.children ? "inline" : "link"})`);
-                            }
-                        }
-                    }
-                    const routes = Array.from(autoDiscoveredFiles.urlMap.keys());
-                    // If no pages to generate, skip static generation
-                    if (routes.length === 0) {
-                        if (userOptions.verbose) {
-                            logger?.info("[react-static-client] No pages to generate, skipping static generation");
-                        }
-                        return;
-                    }
-                    // Use the static manifest to ensure consistent module IDs between RSC stream and client build
-                    // The static manifest contains the correct hashes that should be used for both builds
-                    // (staticManifest already loaded above)
-                    // Create a build loader for client mode (reuse server's sophisticated loader)
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] Creating build loader`);
-                    }
-                    const buildLoader = createBuildLoader();
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] Build loader created`);
-                    }
-                    // Create an RSC worker for generating RSC content
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] Creating RSC worker with path: ${userOptions.rscWorkerPath}`);
-                    }
-                    const workerStartTime = performance.now();
-                    let rscWorkerResult;
-                    try {
-                        rscWorkerResult = await createWorker({
-                            projectRoot: userOptions.projectRoot,
-                            workerPath: userOptions.rscWorkerPath,
-                            currentCondition: "react-client",
-                            reverseCondition: "react-server",
-                            maxListeners: Math.max(routes.length * 3, 10), // Account for multiple listeners per route
-                            envPrefix: envPrefixFromConfig(resolvedConfig),
-                            logger: logger,
-                            verbose: userOptions.verbose,
-                            mode: getNodeEnv(),
-                            workerData: {
-                                userOptions: serializedOptions(userOptions, autoDiscoveredFiles),
-                                resolvedConfig: serializeResolvedConfig(resolvedConfig),
-                                configEnv: (() => {
-                                    const fallback = resolvedConfig
-                                        ? {
-                                            command: resolvedConfig.command,
-                                            mode: resolvedConfig.mode,
-                                            isSsrBuild: false,
-                                            isPreview: false,
-                                        }
-                                        : undefined;
-                                    const finalConfigEnv = configEnv || fallback;
-                                    return finalConfigEnv;
-                                })(),
-                                serverManifest: serverManifest || {}, // Use server manifest for page component resolution
-                                bundle: staticBundle || {}, // Use static bundle (client build) for page component resolution
-                                staticBundle: staticBundle || {}, // Pass static bundle separately for path resolution
-                                id: "static-client-rsc-worker",
-                            },
-                        });
-                    }
-                    catch (workerError) {
-                        if (userOptions.verbose) {
-                            logger?.error(`[react-static-client] Error creating RSC worker: ${workerError}`);
-                        }
-                        throw workerError;
-                    }
-                    if (rscWorkerResult.type !== "success") {
-                        const err = rscWorkerResult.error ?? new Error(`Failed to create RSC worker`);
-                        if (userOptions.verbose) {
-                            logger?.error(`[react-static-client] RSC worker creation failed, throwing error`, { error: err });
-                        }
-                        throw err;
-                    }
-                    rscWorker = rscWorkerResult.worker;
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] RSC worker created successfully`);
-                    }
-                    // 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: "rsc", // This is the RSC worker for client-side static generation
-                            startupTime: workerStartupTime,
-                            fromMainThread: true,
-                            fromRscWorker: false,
-                            fromHtmlWorker: false,
-                            description: `RSC worker startup for client-side static generation`,
-                        });
-                        userOptions.onMetrics(workerStartupMetric);
-                    }
-                    // Render pages using client-side renderer with RSC worker only
-                    const { onEvent, onMetrics, ...handlerOptions } = userOptions;
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] Extracted onEvent: ${typeof onEvent}, userOptions.onEvent: ${typeof userOptions.onEvent}`);
-                    }
-                    // Capture server bundle from onEvent if not already captured
-                    if (!serverBundle && onEvent) {
-                        // Create a temporary event handler to capture the server bundle
-                        const originalOnEvent = onEvent;
-                        const tempOnEvent = (event) => {
-                            if (event.type === "build.writeBundle.server") {
-                                serverBundle = event.data.bundle;
-                                logger?.info("[react-static-client] Captured server bundle from build event");
-                            }
-                            // Call the original event handler
-                            originalOnEvent(event);
-                        };
-                        // Replace the onEvent temporarily to capture the server bundle
-                        userOptions.onEvent = tempOnEvent;
-                    }
-                    // Emit the static site generation start event
-                    // Use the extracted onEvent if available, otherwise fall back to userOptions.onEvent
-                    const eventHandler = onEvent || userOptions.onEvent;
-                    if (typeof eventHandler === "function") {
-                        try {
-                            if (userOptions.verbose) {
-                                logger?.info(`[react-static-client] Emitting build.ssg.start event`);
-                            }
-                            const r = eventHandler({
-                                type: "build.ssg.start",
-                                data: {
-                                    pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
-                                    options: null, // No specific rollup output options for static generation
-                                    bundle: staticBundle || {},
-                                },
-                            });
-                            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 if (userOptions.verbose) {
-                        logger?.warn(`[react-static-client] No onEvent handler available to emit build.ssg.start`);
-                    }
-                    const renderPagesGenerator = renderPagesBatched(routes, {
-                        ...handlerOptions, // Use the clean options instead of the original handlerOptions
-                        worker: rscWorker, // Pass the RSC worker for RSC rendering only
-                        rscWorker: rscWorker, // Pass the RSC worker for RSC rendering only
-                        loader: buildLoader, // Use proper build loader instead of no-op
-                        logger: logger,
-                        autoDiscoveredFiles: autoDiscoveredFiles,
-                        cssFilesByPage: cssFilesByPage, // Pass CSS files by page
-                        serverPipeableStreamOptions: serverPipeableStreamOptions, // Pass server options to RSC worker
-                        clientPipeableStreamOptions: clientPipeableStreamOptions, // Pass client options to RSC worker
-                        globalCss: globalCss, // Pass global CSS
-                        manifest: serverManifest || {}, // Server manifest for RSC worker
-                        staticManifest: staticManifest, // Static manifest for consistent module IDs
-                        onEvent: onEvent,
-                        onMetrics: onMetrics, // Pass through the onMetrics callback (metric watcher)
-                    }, renderPage);
-                    // Process the rendered pages
-                    let finalResult = undefined;
-                    try {
-                        for await (const result of renderPagesGenerator) {
-                            if (result.type === "error") {
-                                if (userOptions.verbose) {
-                                    logger?.error(`[react-static-client] Render error: ${result.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 (same as server plugin)
-                                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 other panic thresholds, log warnings but continue
-                                for (const [route, error] of result.failedRoutes) {
-                                    const err = error instanceof Error ? error : toError(error);
-                                    closeBundleContext.warn(new Error("Failed to render route: " +
-                                        route +
-                                        "\n" +
-                                        err.message +
-                                        "\n" +
-                                        err.stack, { cause: err }));
-                                }
-                            }
-                            finalResult = result;
-                        }
-                    }
-                    catch (renderError) {
-                        if (userOptions.verbose) {
-                            logger?.error(`[react-static-client] Error during renderPages: ${renderError}`);
-                        }
-                        throw renderError;
-                    }
-                    if (!finalResult) {
-                        const errorMsg = "No render result produced";
-                        if (userOptions.verbose) {
-                            logger?.error(`[react-static-client] ${errorMsg}`);
-                        }
-                        throw new Error(errorMsg);
-                    }
-                    if (userOptions.verbose) {
-                        logger?.info(`[react-static-client] Render completed: ${finalResult.completedRoutes.size} pages, ${finalResult.failedRoutes?.size || 0} failed`);
-                    }
-                    // File writes are handled by renderPages, no need to do them here
-                    // Calculate duration from timing
-                    const duration = Math.round(performance.now() - (timing.renderStart || timing.start));
-                    closeBundleContext.info(`Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`);
-                    if (process.env["NODE_ENV"] !== "production") {
-                        closeBundleContext.warn(`THIS BUILD IS NOT INTENDED FOR PRODUCTION (${process.env["NODE_ENV"]})`);
-                    }
-                    // Update timing
-                    timing.render =
-                        performance.now() - (timing.renderStart ?? timing.start);
-                    if (userOptions.verbose) {
-                        logger?.info("[react-static-client] Static generation completed");
-                    }
-                    // 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: staticBundle || {},
-                                },
-                            });
-                            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.end)",
-                            });
-                            if (eventPanicError != null) {
-                                throw eventPanicError; // Re-throw to abort the build
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    const panicError = handleError({
-                        error,
-                        context: "react-static-client",
-                        logger,
-                        panicThreshold: userOptions.panicThreshold,
-                    });
-                    // Ensure graceful shutdown on error
-                    if (rscWorker) {
-                        const workerToCleanup = rscWorker;
-                        try {
-                            // Use graceful shutdown protocol even on error
-                            await Promise.race([
-                                new Promise((resolve) => {
-                                    const timeoutId = setTimeout(() => {
-                                        workerToCleanup.removeAllListeners();
-                                        workerToCleanup.terminate();
-                                        resolve();
-                                    }, 1000); // 1 second timeout for graceful shutdown
-                                    const messageHandler = (message) => {
-                                        if (message.type === "SHUTDOWN_COMPLETE") {
-                                            clearTimeout(timeoutId);
-                                            workerToCleanup.removeListener("message", messageHandler);
-                                            resolve();
-                                        }
-                                    };
-                                    workerToCleanup.on("message", messageHandler);
-                                    workerToCleanup.postMessage({ type: "SHUTDOWN" });
-                                }),
-                            ]);
-                            rscWorker = undefined;
-                        }
-                        catch (cleanupError) {
-                            logger.warn(`Failed to cleanup worker on error: ${cleanupError}`);
-                            // Force terminate if graceful shutdown fails
-                            try {
-                                workerToCleanup.removeAllListeners();
-                                workerToCleanup.terminate();
-                            }
-                            catch (terminateError) {
-                                // Ignore termination errors
-                            }
-                            rscWorker = undefined;
-                        }
-                    }
-                    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;
-                    }
-                }
-                finally {
-                    // Graceful worker shutdown — runs on both success and error paths
-                    if (rscWorker) {
-                        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 shutdownMessageHandler = (message) => {
-                                        if (message.type === "SHUTDOWN_COMPLETE") {
-                                            clearTimeout(timeout);
-                                            clearTimeout(backupTimeout);
-                                            rscWorker?.removeListener("message", shutdownMessageHandler);
-                                            rscWorker?.removeAllListeners();
-                                            resolve();
-                                        }
-                                    };
-                                    rscWorker?.on("message", shutdownMessageHandler);
-                                    rscWorker?.postMessage({
-                                        type: "SHUTDOWN",
-                                        id: "*",
-                                    });
-                                }),
-                            ]);
-                        }
-                        catch {
-                            // Shutdown protocol failed — force terminate below
-                        }
-                        finally {
-                            if (rscWorker) {
-                                try {
-                                    rscWorker.removeAllListeners();
-                                    rscWorker.terminate();
-                                }
-                                catch {
-                                    // Ignore termination errors
-                                }
-                                rscWorker = undefined;
-                            }
-                        }
-                    }
-                    // Reset any cached state to prevent issues in subsequent builds
-                    autoDiscoveredFiles = null;
-                    serverManifest = undefined;
+                  rscWorker.removeAllListeners();
+                  rscWorker.terminate();
+                } catch {
                 }
-            }); // end deferStaticGeneration
-        },
-    };
+                rscWorker = void 0;
+              }
+            }
+          }
+          autoDiscoveredFiles = null;
+          serverManifest = void 0;
+        }
+      });
+    }
+  };
 };
+
+export { reactStaticPlugin };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.client.js","sources":["../../../plugin/react-static/plugin.client.ts"],"sourcesContent":["/**\n * plugin.client.ts\n *\n * PURPOSE: Client-side static plugin for React Server Components\n *\n * This module:\n * 1. Handles static site generation in the client environment\n * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering\n * 3. Generates both RSC and HTML files for static pages\n * 4. Integrates with Vite's build process\n *\n * Feature parity with main react-static plugin, but in reverse. Uses rsc-worker to render rsc, and main thread for html.\n * This is not the default behavior, but is supported for testing and custom app development purposes.\n * Additionally, this can make it easier to use the --app flag to build all the modules + static generation at once.\n */\n\nimport {\n  createLogger,\n  type ResolvedConfig,\n  type Manifest,\n  type ConfigEnv,\n} from \"vite\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport type {\n  BuildTiming,\n  VitePluginFn,\n  AutoDiscoveredFiles,\n} from \"../types.js\";\nimport type { OutputBundle } from \"rollup\";\nimport { renderPagesBatched } from \"./renderPagesBatched.js\";\nimport { performance } from \"node:perf_hooks\";\nimport { renderPage } from \"./renderPage.client.js\";\n\nimport { createWorker } from \"../worker/createWorker.js\";\nimport {\n  serializedOptions,\n  serializeResolvedConfig,\n} from \"../helpers/serializeUserOptions.js\";\nimport { getBundleManifest } from \"../helpers/getBundleManifest.js\";\n\nimport { handleError } from \"../error/handleError.js\";\nimport { shouldCausePanic } from \"../error/panicThresholdHandler.js\";\nimport { configurePreviewServer } from \"./configurePreviewServer.js\";\nimport { assertNonReactServer } from \"../config/getCondition.js\";\nimport { envPrefixFromConfig } from \"../config/envPrefixFromConfig.js\";\nimport { createWorkerStartupMetrics } from \"../metrics/createWorkerStartupMetrics.js\";\nimport { processCssFilesForPages } from \"./processCssFilesForPages.js\";\nimport { createBuildLoader } from \"./createBuildLoader.client.js\";\nimport { getNodeEnv } from \"../config/getNodeEnv.js\";\nimport { toError } from \"../error/toError.js\";\nimport {\n  addStaticManifest,\n  manifests,\n  getSharedManifestStore,\n} from \"../bundle/manifests.js\";\nimport { deferStaticGeneration } from \"../bundle/deferredStaticGeneration.js\";\nimport type { Worker } from \"node:worker_threads\";\nimport { resolveAutoDiscover } from \"../config/index.js\";\nimport { join } from \"node:path\";\n\nimport { baseURL } from \"../utils/envUrls.node.js\";\nimport { tryManifest } from \"../helpers/tryManifest.js\";\n// cssCollector removed - using filesystem-based CSS processing\n\nassertNonReactServer();\n\n/**\n * plugin.client.ts\n *\n * PURPOSE: Client-side static plugin for React Server Components\n *\n * This module:\n * 1. Handles static site generation in the client environment\n * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering\n * 3. Generates both RSC and HTML files for static pages\n * 4. Integrates with Vite's build process\n *\n * @param options\n * @returns\n */\nexport const reactStaticPlugin: VitePluginFn = function _reactStaticPlugin(\n  options\n) {\n  let logger: ReturnType<typeof createLogger>;\n  let autoDiscoveredFiles: AutoDiscoveredFiles | null = null;\n  let rscWorker: Worker | undefined = undefined;\n  let resolvedConfig: ResolvedConfig | null = null;\n  let serverManifest: Manifest | undefined = undefined;\n  let staticBundle: OutputBundle | undefined = undefined;\n  let serverBundle: OutputBundle | undefined = undefined;\n\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/client-static\",\n    enforce: \"post\",\n    apply: \"build\", // Apply to build mode\n    api: {\n      meta: { timing },\n    },\n    async config(_config, viteConfigEnv) {\n      configEnv = viteConfigEnv;\n    },\n    applyToEnvironment(partialEnvironment) {\n      // Client static plugin should apply to static environment (browser/ESM builds)\n      // This is where we want to bundle everything and filter out _virtual files\n      // Apply to both \"static\" and \"client\" environments - we'll handle which one runs static generation in closeBundle\n      const envName = partialEnvironment.name as \"client\" | \"server\" | \"ssr\" | \"static\";\n      if (\n        [\"static\", \"client\"].includes(envName)\n      ) {\n        return true;\n      }\n      return false;\n    },\n\n    async configResolved(config) {\n      timing.configResolved = performance.now();\n      logger = config.customLogger || createLogger();\n      resolvedConfig = config;\n\n      // Perform auto-discovery to populate autoDiscoveredFiles\n      const autoDiscoverResult = await resolveAutoDiscover({\n        config: config,\n        configEnv: configEnv || {\n          mode: config.mode,\n          command: config.command,\n          isSsrBuild: false,\n          isPreview: false,\n        },\n        userOptions,\n        logger,\n      });\n      if (autoDiscoverResult.type === \"error\") {\n        throw autoDiscoverResult.error;\n      }\n      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;\n      if(userOptions.verbose) {\n        logger?.info(`Auto-discovery ${autoDiscoverResult.type === \"success\" ? \"completed\" : \"skipped\"}`);\n      }\n    },\n\n    async buildStart() {\n      timing.buildStart = performance.now();\n      if(userOptions.verbose) {\n        logger?.info(\"[react-static-client] Build started\");\n      }\n\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            rscWorker?.terminate();\n          throw panicError;\n          }\n        }\n      }\n    },\n\n    async renderStart() {\n      timing.renderStart = performance.now();\n      if(userOptions.verbose) { \n        logger?.info(\"[react-static-client] Render started\");\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\n\n    async writeBundle(_options, bundle) {\n\n      // Capture manifests from all environments\n      try {\n        if (!autoDiscoveredFiles?.urlMap) {\n          return;\n        }\n\n        const bundleManifest = getBundleManifest<false>({\n          bundle,\n          normalizer: userOptions.normalizer,\n        });\n\n        // Store manifest based on environment\n        if (this.environment.name === \"static\") {\n          // Store in global manifest store for environment plugin access\n          addStaticManifest(bundleManifest);\n\n          staticBundle = bundle;\n        } else if (this.environment.name === \"client\") {\n          // Client build manifest (SSR modules) - stored globally now\n\n          if (manifests.static) {\n            const staticManifest = manifests.static;\n\n            // Update bundle filenames to match static manifest\n            for (const [, chunk] of Object.entries(bundle)) {\n              if (chunk.type === \"chunk\" && chunk.fileName) {\n                const normalized = userOptions.normalizer(chunk.fileName);\n                let value = normalized[1];\n                if (value.startsWith(userOptions.moduleBasePath)) {\n                  value = value.slice(userOptions.moduleBasePath.length);\n                }\n\n                const entry = staticManifest[value];\n                if (entry && entry.file !== chunk.fileName) {\n                  // Update the filename to match static manifest\n                  chunk.fileName = entry.file;\n                }\n              }\n            }\n          }\n        } else if (this.environment.name === \"server\") {\n          // Server build manifest (server components) - stored globally now\n          serverBundle = bundle;\n        }\n\n        // Skip the static generation here - it will happen in closeBundle\n        return;\n      } catch (error) {\n        const panicError = handleError({\n          error,\n          logger: logger,\n          panicThreshold: userOptions.panicThreshold,\n          context: \"writeBundle\",\n        });\n        if (panicError != null) {\n          throw panicError;\n        }\n      }\n    },\n\n    async closeBundle() {\n      const envName = this.environment.name;\n      const isSsr = this.environment.config.build?.ssr === true;\n      \n      if (userOptions.verbose) {\n        logger?.info(`[react-static-client] closeBundle called for environment: ${envName}, ssr: ${isSsr}`);\n      }\n      \n      // Only run static generation in the non-SSR client environment (static builds)\n      // Skip SSR client builds and server builds\n      if (envName === \"ssr\" || envName === \"server\" || isSsr) {\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Skipping static generation for environment: ${envName} (ssr: ${isSsr})`);\n        }\n        return;\n      }\n\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 (envName === \"static\" || (envName === \"client\" && !isSsr)) {\n        try {\n          const { rmSync, 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          // Clean up _virtual from client/static output directories only\n          // Don't clean up server/_virtual since we need dynamic-import-helper.js there\n          const outputDirs = [\n            join(resolvedOutDir, userOptions.build.static || \"static\"),\n            join(resolvedOutDir, userOptions.build.client || \"client\"),\n          ];\n          \n          for (const outDir of outputDirs) {\n            const virtualDir = join(outDir, \"_virtual\");\n            if (existsSync(virtualDir)) {\n              rmSync(virtualDir, { recursive: true, force: true });\n              if (userOptions.verbose) {\n                logger?.info(`[react-static-client] Cleaned up _virtual directory: ${virtualDir}`);\n              }\n            }\n          }\n        } catch (error) {\n          // Non-critical - log but don't fail the build\n          if (userOptions.verbose) {\n            logger?.warn(`[react-static-client] Failed to clean up _virtual directory: ${error}`);\n          }\n        }\n      }\n\n      // This runs after all writeBundle hooks are complete\n      // Run static generation in the non-SSR client environment (static builds)\n      // This could be \"static\" or \"client\" depending on how environments are configured\n      if (envName === \"ssr\" || envName === \"server\" || isSsr) {\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Skipping static generation - not in static environment (${envName}, ssr: ${isSsr})`);\n        }\n        return;\n      }\n\n      // Defer static generation to run after ALL environments complete their builds.\n      // This is necessary because we need the server manifest (from server env's writeBundle)\n      // to resolve function-based component paths like Root: (url) => 'src/CustomRoot.tsx'.\n      // The buildApp hook in createEnvironmentPlugin will call runDeferredStaticGeneration().\n      const closeBundleContext = this;\n      deferStaticGeneration(async () => {\n\n      try {\n        // Re-check autoDiscoveredFiles - it might not be set if configResolved didn't run\n        // or if it was cleared. Try to get it from stashed options if needed\n        if (!autoDiscoveredFiles) {\n          if (userOptions.verbose) {\n            logger?.warn(\"[react-static-client] autoDiscoveredFiles not set, attempting to re-discover\");\n          }\n          const { getStashedUserOptions, getEnvironmentId } = await import(\"../config/stashedOptionsState.js\");\n          const { getCondition } = await import(\"../config/getCondition.js\");\n          const envId = getEnvironmentId(getCondition(), resolvedConfig?.mode || \"production\");\n          const stashedOptions = getStashedUserOptions(envId);\n          if (stashedOptions && resolvedConfig) {\n            // Try to re-run auto-discovery if we have the config\n            const autoDiscoverResult = await resolveAutoDiscover({\n              config: resolvedConfig,\n              configEnv: configEnv || {\n                mode: resolvedConfig.mode || \"production\",\n                command: resolvedConfig.command || \"build\",\n                isSsrBuild: false,\n                isPreview: false,\n              },\n              userOptions,\n              logger,\n            });\n            if (autoDiscoverResult.type === \"success\") {\n              autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;\n              if (userOptions.verbose) {\n                logger?.info(`[react-static-client] Re-discovered ${autoDiscoveredFiles.urlMap.size} pages`);\n              }\n            } else {\n              if (userOptions.verbose) {\n                logger?.warn(`[react-static-client] Failed to re-discover pages: ${autoDiscoverResult.error}`);\n              }\n            }\n          }\n        }\n\n        if (\n          !autoDiscoveredFiles?.urlMap ||\n          autoDiscoveredFiles?.urlMap.size === 0\n        ) {\n          if (userOptions.verbose) {\n            logger?.warn(`[react-static-client] No pages to generate - urlMap is empty (size: ${autoDiscoveredFiles?.urlMap?.size || 0})`);\n            logger?.warn(`[react-static-client] autoDiscoveredFiles exists: ${!!autoDiscoveredFiles}, urlMap exists: ${!!autoDiscoveredFiles?.urlMap}`);\n          }\n          return;\n        }\n\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Starting static generation with ${autoDiscoveredFiles.urlMap.size} pages`);\n        }\n\n        // Check if we can access the shared manifest store\n        try {\n          if (userOptions.verbose) {\n            logger?.info(`[react-static-client] Attempting to get server manifest from shared state`);\n          }\n          const sharedState = getSharedManifestStore(closeBundleContext);\n          if (sharedState.server) {\n            serverManifest = sharedState.server;\n            if (userOptions.verbose) {\n              logger?.info(`[react-static-client] Got server manifest from shared state`);\n            }\n          } else {\n            throw new Error(\"No server manifest in shared state\");\n          }\n        } catch (error) {\n          if (userOptions.verbose) {\n            logger?.info(`[react-static-client] Failed to get server manifest from shared state, trying filesystem: ${error}`);\n          }\n          const serverManifestPath = join(\n            userOptions.build.outDir,\n            userOptions.build.server\n          );\n          const manifestPath =\n            (typeof resolvedConfig?.build.manifest === \"string\" \n              ? resolvedConfig.build.manifest \n              : \".vite/manifest.json\");\n\n          if (userOptions.verbose) {\n            logger?.info(`[react-static-client] Loading server manifest from: ${join(serverManifestPath, manifestPath)}`);\n          }\n\n          const serverManifestResult = await tryManifest({\n            root: userOptions.projectRoot,\n            outDir: serverManifestPath,\n            manifestPath: manifestPath,\n            ssrManifest: false,\n          });\n\n          if (serverManifestResult.type === \"error\") {\n            if (userOptions.verbose) {\n              logger?.warn(`[react-static-client] Failed to load server manifest: ${serverManifestResult.error}`);\n            }\n            // Use empty manifest as fallback - static generation can proceed without it\n            serverManifest = {};\n            if (userOptions.verbose) {\n              logger?.warn(`[react-static-client] Using empty server manifest as fallback`);\n            }\n          } else if (serverManifestResult.type === \"skip\") {\n            if (userOptions.verbose) {\n              logger?.warn(`[react-static-client] Server manifest not found, using empty manifest as fallback`);\n            }\n            // Use empty manifest as fallback - static generation can proceed without it\n            serverManifest = {};\n          } else {\n            serverManifest = serverManifestResult.manifest;\n            if (userOptions.verbose) {\n              logger?.info(`[react-static-client] Loaded server manifest from filesystem`);\n            }\n          }\n        }\n\n        // Load static manifest from filesystem for CSS path mapping\n\n        const staticManifestResult = await tryManifest({\n          root: userOptions.projectRoot,\n          outDir: join(userOptions.build.outDir, userOptions.build.static),\n          manifestPath: resolvedConfig?.build.manifest ?? \".vite/manifest.json\",\n          ssrManifest: false,\n        });\n        if (staticManifestResult.type === \"error\") {\n          throw staticManifestResult.error;\n        }\n        const staticManifest = staticManifestResult.manifest;\n\n        // Construct bootstrapModules like the server plugin does\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        // Create CSS props for each CSS file (same as server-static)\n        const { cssFilesByPage, globalCss } = processCssFilesForPages({\n          userOptions,\n          autoDiscoveredFiles,\n          serverManifest,\n          staticManifest,\n          bundle: staticBundle || {},\n          logger,\n        });\n\n        if (userOptions.verbose) {\n          for (const [route, cssMap] of cssFilesByPage.entries()) {\n            logger.info(\n              `[react-static-client] Route ${route}: ${cssMap.size} CSS files`\n            );\n            for (const [key, value] of cssMap.entries()) {\n              logger.info(\n                `[react-static-client]   CSS file: ${key} -> ${value.as} (${\n                  value.children ? \"inline\" : \"link\"\n                })`\n              );\n            }\n          }\n        }\n\n        const routes = Array.from(\n          autoDiscoveredFiles.urlMap.keys()\n        ) as string[];\n\n        // If no pages to generate, skip static generation\n        if (routes.length === 0) {\n          if (userOptions.verbose) {\n            logger?.info(\n              \"[react-static-client] No pages to generate, skipping static generation\"\n            );\n          }\n          return;\n        }\n\n        // Use the static manifest to ensure consistent module IDs between RSC stream and client build\n        // The static manifest contains the correct hashes that should be used for both builds\n        // (staticManifest already loaded above)\n\n        // Create a build loader for client mode (reuse server's sophisticated loader)\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Creating build loader`);\n        }\n        const buildLoader = createBuildLoader();\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Build loader created`);\n        }\n\n        // Create an RSC worker for generating RSC content\n        if (userOptions.verbose) {\n          logger?.info(\n            `[react-static-client] Creating RSC worker with path: ${userOptions.rscWorkerPath}`\n          );\n        }\n\n        const workerStartTime = performance.now();\n        let rscWorkerResult;\n        try {\n          rscWorkerResult = await createWorker({\n            projectRoot: userOptions.projectRoot,\n            workerPath: userOptions.rscWorkerPath,\n            currentCondition: \"react-client\",\n            reverseCondition: \"react-server\",\n            maxListeners: Math.max(routes.length * 3, 10), // Account for multiple listeners per route\n            envPrefix: envPrefixFromConfig(resolvedConfig as any),\n            logger: logger,\n            verbose: userOptions.verbose,\n            mode: getNodeEnv(),\n            workerData: {\n              userOptions: serializedOptions(userOptions, autoDiscoveredFiles),\n              resolvedConfig: serializeResolvedConfig(resolvedConfig as any),\n              configEnv: (() => {\n                const fallback = resolvedConfig\n                  ? {\n                      command: resolvedConfig.command,\n                      mode: resolvedConfig.mode,\n                      isSsrBuild: false,\n                      isPreview: false,\n                    }\n                  : undefined;\n                const finalConfigEnv = configEnv || fallback;\n\n                return finalConfigEnv;\n              })(),\n              serverManifest: serverManifest || {}, // Use server manifest for page component resolution\n              bundle: staticBundle || {}, // Use static bundle (client build) for page component resolution\n              staticBundle: staticBundle || {}, // Pass static bundle separately for path resolution\n\n              id: \"static-client-rsc-worker\",\n            },\n          });\n        } catch (workerError) {\n          if (userOptions.verbose) {\n            logger?.error(`[react-static-client] Error creating RSC worker: ${workerError}`);\n          }\n          throw workerError;\n        }\n\n        if (rscWorkerResult.type !== \"success\") {\n          const err = rscWorkerResult.error ?? new Error(`Failed to create RSC worker`);\n          if (userOptions.verbose) {\n            logger?.error(\n              `[react-static-client] RSC worker creation failed, throwing error`, { error: err }\n            );\n          }\n          throw err;\n        }\n\n        rscWorker = rscWorkerResult.worker;\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] RSC worker created successfully`);\n        }\n\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: \"rsc\", // This is the RSC worker for client-side static generation\n            startupTime: workerStartupTime,\n            fromMainThread: true,\n            fromRscWorker: false,\n            fromHtmlWorker: false,\n            description: `RSC worker startup for client-side static generation`,\n          });\n          userOptions.onMetrics(workerStartupMetric);\n        }\n\n        // Render pages using client-side renderer with RSC worker only\n        const { onEvent, onMetrics, ...handlerOptions } = userOptions;\n\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Extracted onEvent: ${typeof onEvent}, userOptions.onEvent: ${typeof userOptions.onEvent}`);\n        }\n\n        // Capture server bundle from onEvent if not already captured\n        if (!serverBundle && onEvent) {\n          // Create a temporary event handler to capture the server bundle\n          const originalOnEvent = onEvent;\n          const tempOnEvent = (event: any) => {\n            if (event.type === \"build.writeBundle.server\") {\n              serverBundle = event.data.bundle;\n              logger?.info(\n                \"[react-static-client] Captured server bundle from build event\"\n              );\n            }\n            // Call the original event handler\n            originalOnEvent(event);\n          };\n\n          // Replace the onEvent temporarily to capture the server bundle\n          userOptions.onEvent = tempOnEvent;\n        }\n\n        // Emit the static site generation start event\n        // Use the extracted onEvent if available, otherwise fall back to userOptions.onEvent\n        const eventHandler = onEvent || userOptions.onEvent;\n        if (typeof eventHandler === \"function\") {\n          try {\n            if (userOptions.verbose) {\n              logger?.info(`[react-static-client] Emitting build.ssg.start event`);\n            }\n            const r = eventHandler({\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: staticBundle || {},\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            }\n          }\n        } else if (userOptions.verbose) {\n          logger?.warn(`[react-static-client] No onEvent handler available to emit build.ssg.start`);\n        }\n\n        const renderPagesGenerator = renderPagesBatched(\n          routes,\n          {\n            ...handlerOptions, // Use the clean options instead of the original handlerOptions\n            worker: rscWorker, // Pass the RSC worker for RSC rendering only\n            rscWorker: rscWorker, // Pass the RSC worker for RSC rendering only\n            loader: buildLoader, // Use proper build loader instead of no-op\n            logger: logger,\n            autoDiscoveredFiles: autoDiscoveredFiles,\n            cssFilesByPage: cssFilesByPage, // Pass CSS files by page\n            serverPipeableStreamOptions: serverPipeableStreamOptions, // Pass server options to RSC worker\n            clientPipeableStreamOptions: clientPipeableStreamOptions, // Pass client options to RSC worker\n            globalCss: globalCss, // Pass global CSS\n            manifest: serverManifest || {}, // Server manifest for RSC worker\n            staticManifest: staticManifest, // Static manifest for consistent module IDs\n            onEvent: onEvent,\n            onMetrics: onMetrics, // Pass through the onMetrics callback (metric watcher)\n          },\n          renderPage\n        );\n\n        // Process the rendered pages\n        let finalResult: any = undefined;\n        try {\n          for await (const result of renderPagesGenerator) {\n            if (result.type === \"error\") {\n              if (userOptions.verbose) {\n                logger?.error(`[react-static-client] Render error: ${result.error}`);\n              }\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 (same as server plugin)\n            const firstError = result.failedRoutes.values().next().value;\n            if (\n              firstError != null &&\n              shouldCausePanic(firstError, {\n                panicThreshold: userOptions.panicThreshold,\n              })\n            ) {\n              // This should cause a panic, throw the error\n              throw firstError;\n            }\n            // For other panic thresholds, log warnings but continue\n            for (const [route, error] of result.failedRoutes) {\n              const err = error instanceof Error ? error : toError(error);\n              closeBundleContext.warn(\n                new Error(\n                  \"Failed to render route: \" +\n                    route +\n                    \"\\n\" +\n                    err.message +\n                    \"\\n\" +\n                    err.stack,\n                  { cause: err }\n                )\n              );\n            }\n          }\n\n            finalResult = result;\n          }\n        } catch (renderError) {\n          if (userOptions.verbose) {\n            logger?.error(`[react-static-client] Error during renderPages: ${renderError}`);\n          }\n          throw renderError;\n        }\n\n        if (!finalResult) {\n          const errorMsg = \"No render result produced\";\n          if (userOptions.verbose) {\n            logger?.error(`[react-static-client] ${errorMsg}`);\n          }\n          throw new Error(errorMsg);\n        }\n\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Render completed: ${finalResult.completedRoutes.size} pages, ${finalResult.failedRoutes?.size || 0} failed`);\n        }\n\n        // File writes are handled by renderPages, no need to do them here\n\n        // Calculate duration from timing\n        const duration = Math.round(\n          performance.now() - (timing.renderStart || timing.start)\n        );\n\n        closeBundleContext.info(\n          `Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`\n        );\n\n        if (process.env[\"NODE_ENV\"] !== \"production\") {\n          closeBundleContext.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\n        if (userOptions.verbose) {\n          logger?.info(\"[react-static-client] Static generation completed\");\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: staticBundle || {},\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.end)\",\n            });\n            if (eventPanicError != null) {\n              throw eventPanicError; // Re-throw to abort the build\n            }\n          }\n        }\n      } catch (error) {\n        const panicError = handleError({\n          error,\n          context: \"react-static-client\",\n          logger,\n          panicThreshold: userOptions.panicThreshold,\n        });\n\n        // Ensure graceful shutdown on error\n        if (rscWorker) {\n          const workerToCleanup = rscWorker;\n          try {\n            // Use graceful shutdown protocol even on error\n            await Promise.race([\n              new Promise<void>((resolve) => {\n                const timeoutId = setTimeout(() => {\n                  workerToCleanup.removeAllListeners();\n                  workerToCleanup.terminate();\n                  resolve();\n                }, 1000); // 1 second timeout for graceful shutdown\n\n                const messageHandler = (message: any) => {\n                  if (message.type === \"SHUTDOWN_COMPLETE\") {\n                    clearTimeout(timeoutId);\n                    workerToCleanup.removeListener(\"message\", messageHandler);\n                    resolve();\n                  }\n                };\n                workerToCleanup.on(\"message\", messageHandler);\n                workerToCleanup.postMessage({ type: \"SHUTDOWN\" });\n              }),\n            ]);\n            rscWorker = undefined;\n          } catch (cleanupError) {\n            logger.warn(`Failed to cleanup worker on error: ${cleanupError}`);\n            // Force terminate if graceful shutdown fails\n            try {\n              workerToCleanup.removeAllListeners();\n              workerToCleanup.terminate();\n            } catch (terminateError) {\n              // Ignore termination errors\n            }\n            rscWorker = 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      } finally {\n        // Graceful worker shutdown — runs on both success and error paths\n        if (rscWorker) {\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));\n\n                const shutdownMessageHandler = (message: any) => {\n                  if (message.type === \"SHUTDOWN_COMPLETE\") {\n                    clearTimeout(timeout);\n                    clearTimeout(backupTimeout);\n                    rscWorker?.removeListener(\n                      \"message\",\n                      shutdownMessageHandler\n                    );\n                    rscWorker?.removeAllListeners();\n                    resolve();\n                  }\n                };\n\n                rscWorker?.on(\"message\", shutdownMessageHandler);\n                rscWorker?.postMessage({\n                  type: \"SHUTDOWN\",\n                  id: \"*\",\n                });\n              }),\n            ]);\n          } catch {\n            // Shutdown protocol failed — force terminate below\n          } finally {\n            if (rscWorker) {\n              try {\n                (rscWorker as Worker).removeAllListeners();\n                (rscWorker as Worker).terminate();\n              } catch {\n                // Ignore termination errors\n              }\n              rscWorker = undefined;\n            }\n          }\n        }\n\n        // Reset any cached state to prevent issues in subsequent builds\n        autoDiscoveredFiles = null;\n        serverManifest = undefined;\n      }\n\n      }); // end deferStaticGeneration\n    },\n  };\n};\n"],"names":["join"],"mappings":"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"}