vite-plugin-react-server 1.4.1 → 1.4.3

package/dist/plugin/environments/createEnvironmentPlugin.js

@@ -1,257 +1,229 @@
-import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
-import { resolveUserConfig } from "../config/resolveUserConfig.js";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { handleError } from "../error/handleError.js";
-import { createDefaultModuleID } from "../config/createModuleID.js";
-import { createLogger } from "vite";
-import { join } from "node:path";
-import { DEFAULT_LOADER_CONFIG } from "../config/defaults.js";
-import { runDeferredStaticGeneration } from "../bundle/deferredStaticGeneration.js";
 /**
- * Creates a plugin that ensures consistent hash generation across environments
- * by using the original source file content as the basis for hash generation.
-
-*/
-// Note: Path normalization should be handled in the file naming functions, not in writeBundle
-/**
- * Environment Configuration Plugin
- *
- * This plugin configures Vite Environment API environments for React Server Components.
- * It's separate from the env plugin which handles process environment variables.
- *
- * Environment mapping:
- * - client (Vite client = browser) → dist/client (React client components - real implementations)
- * - ssr (Vite SSR = SSR-safe) → dist/static (SSR-compatible static files)
- * - server (custom) → dist/server (React server components with registerClientReference)
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
  */
-export const createEnvironmentPlugin = (options) => {
-    const environmentPlugin = {
-        name: "vite:plugin-react-server/environments",
-        enforce: "pre",
-        async config(config, configEnv) {
-            // Resolve plugin options
-            const resolvedOptionsResult = resolveOptions(options);
-            if (resolvedOptionsResult.type === "error") {
-                throw resolvedOptionsResult.error;
-            }
-            const userOptions = resolvedOptionsResult.userOptions;
-            // Add transformer plugins at the Vite level with proper environment filtering
-            if (!config.plugins) {
-                config.plugins = [];
-            }
-            // Note: Transformer is now added via orchestrator, so skip adding it here
-            // to avoid duplicates and ensure proper registration
-            // Note: Hash coordination is handled by the sequential build approach
-            // Each environment will use the manifest from the previous build
-            // Set up logger and moduleID
-            const logger = config.customLogger || createLogger();
-            if (typeof userOptions.moduleID !== "function") {
-                userOptions.moduleID = createDefaultModuleID(userOptions, configEnv, userOptions.loader?.mode);
-            }
-            // Always override the moduleID function to ensure it has the forTransformer logic
-            if (!userOptions.loader) {
-                userOptions.loader = DEFAULT_LOADER_CONFIG;
-            }
-            userOptions.loader.moduleID = createDefaultModuleID(userOptions, configEnv, userOptions.loader?.mode);
-            // Run auto-discovery once to get all files - we don't need separate calls since
-            // the file discovery process is identical, only the organization differs
-            const autoDiscoverResult = await resolveAutoDiscover({
-                config,
-                configEnv,
-                userOptions,
-                logger,
-            });
-            if (autoDiscoverResult.type === "error") {
-                const panicError = handleError({
-                    error: autoDiscoverResult.error,
-                    logger,
-                    context: "createEnvironmentPlugin(autoDiscover)",
-                    panicThreshold: userOptions.panicThreshold,
-                    critical: true, // Auto-discovery is critical for environment setup
-                });
-                if (panicError != null) {
-                    throw panicError;
+import { resolveAutoDiscover } from '../config/autoDiscover/resolveAutoDiscover.js';
+import { resolveUserConfig } from '../config/resolveUserConfig.js';
+import { resolveOptions } from '../config/resolveOptions.js';
+import { handleError } from '../error/handleError.js';
+import { createDefaultModuleID } from '../config/createModuleID.js';
+import { createLogger } from 'vite';
+import { join } from 'node:path';
+import { DEFAULT_LOADER_CONFIG } from '../config/defaults.js';
+import { runDeferredStaticGeneration } from '../bundle/deferredStaticGeneration.js';
+
+const createEnvironmentPlugin = (options) => {
+  const environmentPlugin = {
+    name: "vite:plugin-react-server/environments",
+    enforce: "pre",
+    async config(config, configEnv) {
+      const resolvedOptionsResult = resolveOptions(options);
+      if (resolvedOptionsResult.type === "error") {
+        throw resolvedOptionsResult.error;
+      }
+      const userOptions = resolvedOptionsResult.userOptions;
+      if (!config.plugins) {
+        config.plugins = [];
+      }
+      const logger = config.customLogger || createLogger();
+      if (typeof userOptions.moduleID !== "function") {
+        userOptions.moduleID = createDefaultModuleID(
+          userOptions,
+          configEnv,
+          userOptions.loader?.mode
+        );
+      }
+      if (!userOptions.loader) {
+        userOptions.loader = DEFAULT_LOADER_CONFIG;
+      }
+      userOptions.loader.moduleID = createDefaultModuleID(
+        userOptions,
+        configEnv,
+        userOptions.loader?.mode
+      );
+      const autoDiscoverResult = await resolveAutoDiscover({
+        config,
+        configEnv,
+        userOptions,
+        logger
+      });
+      if (autoDiscoverResult.type === "error") {
+        const panicError = handleError({
+          error: autoDiscoverResult.error,
+          logger,
+          panicThreshold: userOptions.panicThreshold,
+          critical: true
+          // Auto-discovery is critical for environment setup
+        });
+        if (panicError != null) {
+          throw panicError;
+        } else {
+          throw new Error("Cannot continue without auto-discovery");
+        }
+      }
+      const autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
+      const allEnvironmentConfigs = [
+        {
+          name: "client",
+          condition: "react-client",
+          ssr: false,
+          outDir: join(userOptions.build.outDir, userOptions.build.static)
+        },
+        {
+          name: "ssr",
+          condition: "react-client",
+          ssr: true,
+          outDir: join(userOptions.build.outDir, userOptions.build.client)
+        },
+        {
+          name: "server",
+          condition: "react-server",
+          ssr: true,
+          outDir: join(userOptions.build.outDir, userOptions.build.server)
+        }
+      ];
+      const availableEnvironments = userOptions.availableEnvironments || ["client", "ssr", "server"];
+      const environmentConfigs = allEnvironmentConfigs.filter(
+        (config2) => availableEnvironments.includes(config2.name)
+      );
+      const environments = {};
+      const sortedEnvConfigs = environmentConfigs;
+      for (const envConfig of sortedEnvConfigs) {
+        const configResult = resolveUserConfig({
+          condition: envConfig.condition,
+          config,
+          configEnv,
+          userOptions,
+          autoDiscoveredFiles,
+          ssr: envConfig.ssr
+        });
+        if (configResult.type === "error") {
+          const panicError = handleError({
+            error: configResult.error,
+            logger,
+            context: `createEnvironmentPlugin(${envConfig.name}Config)`,
+            panicThreshold: userOptions.panicThreshold,
+            critical: true
+          });
+          if (panicError != null) {
+            throw panicError;
+          } else {
+            throw new Error(
+              `Cannot continue without ${envConfig.name} environment configuration`
+            );
+          }
+        }
+        const userConfig = configResult.userConfig;
+        if (userOptions.verbose) {
+          logger?.info(
+            `${envConfig.name} environment rollup inputs: ${JSON.stringify(
+              userConfig.build.rollupOptions.input,
+              null,
+              2
+            )}`
+          );
+          logger?.info(
+            `${envConfig.name} environment output preserveModulesRoot: ${JSON.stringify(
+              userConfig.build.rollupOptions.output,
+              null,
+              2
+            )}`
+          );
+        }
+        if (userOptions.verbose) {
+          logger?.info(
+            `${envConfig.name} userConfig.resolve: ${JSON.stringify(
+              userConfig.resolve,
+              null,
+              2
+            )}`
+          );
+          logger?.info(
+            `${envConfig.name} userConfig.build.rollupOptions.external: ${JSON.stringify(
+              userConfig.build.rollupOptions.external,
+              null,
+              2
+            )}`
+          );
+        }
+        const legacyBuild = userOptions.strategy?.legacyBuilder && !config?.builder;
+        const implicitSsr = userOptions.strategy?.mainThreadCondition === "react-server" && userOptions.strategy?.legacyBuilder;
+        const implicitViteBuildName = userOptions.strategy?.legacyBuilder && !config.build?.ssr ? "client" : "ssr";
+        const consumer = legacyBuild ? implicitViteBuildName === "ssr" ? "server" : "client" : envConfig.name === "server" || envConfig.name === "ssr" ? "server" : "client";
+        environments[envConfig.name] = {
+          keepProcessEnv: envConfig.name === "server" ? true : false,
+          define: userConfig.define,
+          consumer,
+          resolve: {
+            ...userConfig.resolve,
+            // IMPORTANT: Map externals from resolveUserConfig (rollupOptions.external) to Environment API format
+            // In Environment API, externals go in resolve.external, not build.rollupOptions.external
+            // For static builds (browser/ESM): don't externalize anything - bundle everything to avoid _virtual files
+            // For client/server builds (SSR): externalize as configured
+            external: (() => {
+              const isStaticBuild = envConfig.name === "static" || !envConfig.ssr && envConfig.name === "client";
+              if (isStaticBuild) {
+                return [];
+              }
+              return Array.isArray(userConfig.build.rollupOptions.external) ? userConfig.build.rollupOptions.external.filter(
+                (item) => typeof item === "string"
+              ) : [];
+            })()
+          },
+          build: {
+            ...userConfig.build,
+            ssr: envConfig.name === "server" ? true : legacyBuild ? implicitSsr : envConfig.name === "ssr",
+            target: userConfig.build.target,
+            // Remove externals from rollupOptions since they should be in resolve.external for Environment API
+            rollupOptions: {
+              ...userConfig.build.rollupOptions,
+              external: void 0,
+              // Remove external from rollupOptions, it's now in resolve.external
+              // Set preserveModules in the output configuration, not at the top level
+              output: (() => {
+                const output = userConfig.build.rollupOptions.output;
+                if (Array.isArray(output)) {
+                  const pluginOutput = output.find((o) => o && typeof o === "object" && "preserveModulesRoot" in o);
+                  if (pluginOutput) {
+                    return pluginOutput;
+                  }
+                  if (output.length > 0) {
+                    return output[0];
+                  }
                 }
-                else {
-                    // If handleError returns null but this is critical, we can't continue
-                    throw new Error("Cannot continue without auto-discovery");
+                if (output && typeof output === "object" && !Array.isArray(output)) {
+                  const hasPreserveModulesRoot = "preserveModulesRoot" in output;
+                  if (hasPreserveModulesRoot) {
+                    return output;
+                  } else {
+                    const preserveModulesRootString = userOptions.build.preserveModulesRoot === false ? userOptions.moduleBase : void 0;
+                    return { ...output, preserveModulesRoot: preserveModulesRootString };
+                  }
                 }
+                return output;
+              })()
             }
-            // Get the auto-discovered files (safe to access since we checked for errors above)
-            const autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
-            // Define environment configurations
-            const allEnvironmentConfigs = [
-                {
-                    name: "client",
-                    condition: "react-client",
-                    ssr: false,
-                    outDir: join(userOptions.build.outDir, userOptions.build.static),
-                },
-                {
-                    name: "ssr",
-                    condition: "react-client",
-                    ssr: true,
-                    outDir: join(userOptions.build.outDir, userOptions.build.client),
-                },
-                {
-                    name: "server",
-                    condition: "react-server",
-                    ssr: true,
-                    outDir: join(userOptions.build.outDir, userOptions.build.server),
-                },
-            ];
-            // Filter environments based on availableEnvironments from orchestrator
-            const availableEnvironments = userOptions
-                .availableEnvironments || ["client", "ssr", "server"];
-            const environmentConfigs = allEnvironmentConfigs.filter((config) => availableEnvironments.includes(config.name));
-            // Resolve all environment configurations using resolveUserConfig
-            const environments = {};
-            // Sort environments to process static first (to establish hashes)
-            // Use the environment configs as-is
-            const sortedEnvConfigs = environmentConfigs;
-            for (const envConfig of sortedEnvConfigs) {
-                const configResult = resolveUserConfig({
-                    condition: envConfig.condition,
-                    config,
-                    configEnv,
-                    userOptions,
-                    autoDiscoveredFiles,
-                    ssr: envConfig.ssr,
-                });
-                if (configResult.type === "error") {
-                    const panicError = handleError({
-                        error: configResult.error,
-                        logger,
-                        context: `createEnvironmentPlugin(${envConfig.name}Config)`,
-                        panicThreshold: userOptions.panicThreshold,
-                        critical: true,
-                    });
-                    if (panicError != null) {
-                        throw panicError;
-                    }
-                    else {
-                        throw new Error(`Cannot continue without ${envConfig.name} environment configuration`);
-                    }
-                }
-                // Map the resolved user config to Environment API compatible options
-                const userConfig = configResult.userConfig;
-                // Log the rollup inputs for this environment (only in verbose mode)
-                if (userOptions.verbose) {
-                    logger?.info(`${envConfig.name} environment rollup inputs: ${JSON.stringify(userConfig.build.rollupOptions.input, null, 2)}`);
-                    logger?.info(`${envConfig.name} environment output preserveModulesRoot: ${JSON.stringify(userConfig.build.rollupOptions.output, null, 2)}`);
-                }
-                // Debug: Log what resolveUserConfig provided
-                if (userOptions.verbose) {
-                    logger?.info(`${envConfig.name} userConfig.resolve: ${JSON.stringify(userConfig.resolve, null, 2)}`);
-                    logger?.info(`${envConfig.name} userConfig.build.rollupOptions.external: ${JSON.stringify(userConfig.build.rollupOptions.external, null, 2)}`);
-                }
-                // detect if legacy build or not
-                const legacyBuild = userOptions.strategy?.legacyBuilder && !config?.builder;
-                const implicitSsr = userOptions.strategy?.mainThreadCondition === "react-server" &&
-                    userOptions.strategy?.legacyBuilder;
-                // this follows vite's logic for legacy builds
-                const implicitViteBuildName = userOptions.strategy?.legacyBuilder && !config.build?.ssr
-                    ? "client"
-                    : "ssr";
-                const consumer = legacyBuild
-                    ? implicitViteBuildName === "ssr"
-                        ? "server"
-                        : "client"
-                    : envConfig.name === "server" || envConfig.name === "ssr"
-                        ? "server"
-                        : "client";
-                // Note: Path normalization should be handled in the file naming functions
-                environments[envConfig.name] = {
-                    keepProcessEnv: envConfig.name === "server" ? true : false,
-                    define: userConfig.define,
-                    consumer: consumer,
-                    resolve: {
-                        ...userConfig.resolve,
-                        // IMPORTANT: Map externals from resolveUserConfig (rollupOptions.external) to Environment API format
-                        // In Environment API, externals go in resolve.external, not build.rollupOptions.external
-                        // For static builds (browser/ESM): don't externalize anything - bundle everything to avoid _virtual files
-                        // For client/server builds (SSR): externalize as configured
-                        external: (() => {
-                            const isStaticBuild = envConfig.name === "static" || (!envConfig.ssr && envConfig.name === "client");
-                            if (isStaticBuild) {
-                                // For static builds, don't externalize anything (bundle everything)
-                                return [];
-                            }
-                            // For SSR builds, use configured externals
-                            return Array.isArray(userConfig.build.rollupOptions.external)
-                                ? userConfig.build.rollupOptions.external.filter((item) => typeof item === "string")
-                                : [];
-                        })(),
-                    },
-                    build: {
-                        ...userConfig.build,
-                        ssr: envConfig.name === "server"
-                            ? true
-                            : legacyBuild
-                                ? implicitSsr
-                                : envConfig.name === "ssr",
-                        target: userConfig.build.target,
-                        // Remove externals from rollupOptions since they should be in resolve.external for Environment API
-                        rollupOptions: {
-                            ...userConfig.build.rollupOptions,
-                            external: undefined, // Remove external from rollupOptions, it's now in resolve.external
-                            // Set preserveModules in the output configuration, not at the top level
-                            output: (() => {
-                                const output = userConfig.build.rollupOptions.output;
-                                // Handle array output configuration - extract the plugin output that contains preserveModulesRoot
-                                if (Array.isArray(output)) {
-                                    const pluginOutput = output.find(o => o && typeof o === 'object' && 'preserveModulesRoot' in o);
-                                    if (pluginOutput) {
-                                        return pluginOutput;
-                                    }
-                                    // If no pluginOutput found, use the first output configuration
-                                    if (output.length > 0) {
-                                        return output[0];
-                                    }
-                                }
-                                // Ensure preserveModulesRoot is always present in the output configuration
-                                if (output && typeof output === 'object' && !Array.isArray(output)) {
-                                    // Check if the property exists in the object (not just checking the value)
-                                    const hasPreserveModulesRoot = 'preserveModulesRoot' in output;
-                                    if (hasPreserveModulesRoot) {
-                                        // Property exists, preserve the preserveModules value from the output (don't override it)
-                                        // This is critical for static builds where preserveModules: false is set
-                                        return output; // Return as-is, preserveModules is already set correctly
-                                    }
-                                    else {
-                                        // Property missing, add it based on user options
-                                        const preserveModulesRootString = userOptions.build.preserveModulesRoot === false
-                                            ? userOptions.moduleBase
-                                            : undefined;
-                                        return { ...output, preserveModulesRoot: preserveModulesRootString };
-                                    }
-                                }
-                                return output;
-                            })(),
-                        },
-                    },
-                };
+          }
+        };
+      }
+      return {
+        root: userOptions.projectRoot,
+        ...config,
+        environments,
+        builder: {
+          async buildApp(builder) {
+            for (const environment of Object.values(builder.environments)) {
+              await builder.build(environment);
             }
-            // Return the configuration with all environments
-            // Build order: client → ssr → server → static generation (step 4)
-            // Server build runs LAST so dist/client exists when HTML rendering references client components
-            // Static generation is deferred to run after ALL environments complete (needs server manifest)
-            return {
-                root: userOptions.projectRoot,
-                ...config,
-                environments,
-                builder: {
-                    async buildApp(builder) {
-                        // Build all environments in definition order
-                        for (const environment of Object.values(builder.environments)) {
-                            await builder.build(environment);
-                        }
-                        // Step 4: Run deferred static generation now that all manifests are available
-                        await runDeferredStaticGeneration();
-                    },
-                },
-            };
-        },
-    };
-    return environmentPlugin;
+            await runDeferredStaticGeneration();
+          }
+        }
+      };
+    }
+  };
+  return environmentPlugin;
 };
+
+export { createEnvironmentPlugin };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createEnvironmentPlugin.js","sources":["../../../plugin/environments/createEnvironmentPlugin.ts"],"sourcesContent":["import type { Plugin, UserConfig, ViteBuilder } from \"vite\";\nimport type { VitePluginFn } from \"../types.js\";\n\nimport { resolveAutoDiscover } from \"../config/autoDiscover/resolveAutoDiscover.js\";\nimport { resolveUserConfig } from \"../config/resolveUserConfig.js\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { createDefaultModuleID } from \"../config/createModuleID.js\";\nimport { createLogger } from \"vite\";\nimport { join } from \"node:path\";\nimport { DEFAULT_LOADER_CONFIG } from \"../config/defaults.js\";\nimport { runDeferredStaticGeneration } from \"../bundle/deferredStaticGeneration.js\";\n\n/**\n * Creates a plugin that ensures consistent hash generation across environments\n * by using the original source file content as the basis for hash generation.\n\n*/\n// Note: Path normalization should be handled in the file naming functions, not in writeBundle\n\n/**\n * Environment Configuration Plugin\n *\n * This plugin configures Vite Environment API environments for React Server Components.\n * It's separate from the env plugin which handles process environment variables.\n *\n * Environment mapping:\n * - client (Vite client = browser) → dist/client (React client components - real implementations)\n * - ssr (Vite SSR = SSR-safe) → dist/static (SSR-compatible static files)\n * - server (custom) → dist/server (React server components with registerClientReference)\n */\nexport const createEnvironmentPlugin: VitePluginFn = (options): Plugin => {\n  const environmentPlugin: Plugin = {\n    name: \"vite:plugin-react-server/environments\",\n    enforce: \"pre\",\n\n    async config(config: UserConfig, configEnv) {\n      // Resolve plugin options\n      const resolvedOptionsResult = resolveOptions(options);\n      if (resolvedOptionsResult.type === \"error\") {\n        throw resolvedOptionsResult.error;\n      }\n      const userOptions = resolvedOptionsResult.userOptions;\n\n      // Add transformer plugins at the Vite level with proper environment filtering\n      if (!config.plugins) {\n        config.plugins = [];\n      }\n\n      // Note: Transformer is now added via orchestrator, so skip adding it here\n      // to avoid duplicates and ensure proper registration\n\n      // Note: Hash coordination is handled by the sequential build approach\n      // Each environment will use the manifest from the previous build\n\n      // Set up logger and moduleID\n      const logger = config.customLogger || createLogger();\n      if (typeof userOptions.moduleID !== \"function\") {\n        userOptions.moduleID = createDefaultModuleID(\n          userOptions,\n          configEnv,\n          userOptions.loader?.mode\n        );\n      }\n      // Always override the moduleID function to ensure it has the forTransformer logic\n      if (!userOptions.loader) {\n        userOptions.loader = DEFAULT_LOADER_CONFIG;\n      }\n      userOptions.loader.moduleID = createDefaultModuleID(\n        userOptions,\n        configEnv,\n        userOptions.loader?.mode\n      );\n\n      // Run auto-discovery once to get all files - we don't need separate calls since\n      // the file discovery process is identical, only the organization differs\n      const autoDiscoverResult = await resolveAutoDiscover({\n        config,\n        configEnv,\n        userOptions,\n        logger,\n      });\n\n      if (autoDiscoverResult.type === \"error\") {\n        const panicError = handleError({\n          error: autoDiscoverResult.error,\n          logger,\n          context: \"createEnvironmentPlugin(autoDiscover)\",\n          panicThreshold: userOptions.panicThreshold,\n          critical: true, // Auto-discovery is critical for environment setup\n        });\n        if (panicError != null) {\n          throw panicError;\n        } else {\n          // If handleError returns null but this is critical, we can't continue\n          throw new Error(\"Cannot continue without auto-discovery\");\n        }\n      }\n\n      // Get the auto-discovered files (safe to access since we checked for errors above)\n      const autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles!;\n\n      // Define environment configurations\n      const allEnvironmentConfigs = [\n        {\n          name: \"client\",\n          condition: \"react-client\" as const,\n          ssr: false,\n          outDir: join(userOptions.build.outDir, userOptions.build.static),\n        },\n        {\n          name: \"ssr\",\n          condition: \"react-client\" as const,\n          ssr: true,\n          outDir: join(userOptions.build.outDir, userOptions.build.client),\n        },\n        {\n          name: \"server\",\n          condition: \"react-server\" as const,\n          ssr: true,\n          outDir: join(userOptions.build.outDir, userOptions.build.server),\n        },\n      ];\n\n      // Filter environments based on availableEnvironments from orchestrator\n\n      const availableEnvironments = (userOptions as any)\n        .availableEnvironments || [\"client\", \"ssr\", \"server\"];\n\n      const environmentConfigs = allEnvironmentConfigs.filter((config) =>\n        availableEnvironments.includes(config.name)\n      );\n\n\n      // Resolve all environment configurations using resolveUserConfig\n      const environments: Record<string, import(\"vite\").EnvironmentOptions> =\n        {};\n\n      // Sort environments to process static first (to establish hashes)\n      // Use the environment configs as-is\n      const sortedEnvConfigs = environmentConfigs;\n\n      for (const envConfig of sortedEnvConfigs) {\n        const configResult = resolveUserConfig({\n          condition: envConfig.condition,\n          config,\n          configEnv,\n          userOptions,\n          autoDiscoveredFiles,\n          ssr: envConfig.ssr,\n        });\n\n        if (configResult.type === \"error\") {\n          const panicError = handleError({\n            error: configResult.error,\n            logger,\n            context: `createEnvironmentPlugin(${envConfig.name}Config)`,\n            panicThreshold: userOptions.panicThreshold,\n            critical: true,\n          });\n          if (panicError != null) {\n            throw panicError;\n          } else {\n            throw new Error(\n              `Cannot continue without ${envConfig.name} environment configuration`\n            );\n          }\n        }\n\n        // Map the resolved user config to Environment API compatible options\n        const userConfig = configResult.userConfig;\n\n        // Log the rollup inputs for this environment (only in verbose mode)\n        if (userOptions.verbose) {\n          logger?.info(\n            `${envConfig.name} environment rollup inputs: ${JSON.stringify(\n              userConfig.build.rollupOptions.input,\n              null,\n              2\n            )}`\n          );\n          logger?.info(\n            `${\n              envConfig.name\n            } environment output preserveModulesRoot: ${JSON.stringify(\n              userConfig.build.rollupOptions.output,\n              null,\n              2\n            )}`\n          );\n        }\n\n        // Debug: Log what resolveUserConfig provided\n        if (userOptions.verbose) {\n          logger?.info(\n            `${envConfig.name} userConfig.resolve: ${JSON.stringify(\n              userConfig.resolve,\n              null,\n              2\n            )}`\n          );\n          logger?.info(\n            `${\n              envConfig.name\n            } userConfig.build.rollupOptions.external: ${JSON.stringify(\n              userConfig.build.rollupOptions.external,\n              null,\n              2\n            )}`\n          );\n        }\n        // detect if legacy build or not\n        const legacyBuild = userOptions.strategy?.legacyBuilder && !config?.builder;\n        const implicitSsr =\n          userOptions.strategy?.mainThreadCondition === \"react-server\" &&\n          userOptions.strategy?.legacyBuilder;\n        // this follows vite's logic for legacy builds\n        const implicitViteBuildName =\n          userOptions.strategy?.legacyBuilder && !config.build?.ssr\n            ? \"client\"\n            : \"ssr\";\n        const consumer = legacyBuild\n          ? implicitViteBuildName === \"ssr\"\n            ? \"server\"\n            : \"client\"\n          : envConfig.name === \"server\" || envConfig.name === \"ssr\"\n          ? \"server\"\n          : \"client\";\n\n        // Note: Path normalization should be handled in the file naming functions\n        environments[envConfig.name] = {\n          keepProcessEnv: envConfig.name === \"server\" ? true : false,\n          define: userConfig.define,\n          consumer: consumer,\n          resolve: {\n            ...userConfig.resolve,\n            // IMPORTANT: Map externals from resolveUserConfig (rollupOptions.external) to Environment API format\n            // In Environment API, externals go in resolve.external, not build.rollupOptions.external\n            // For static builds (browser/ESM): don't externalize anything - bundle everything to avoid _virtual files\n            // For client/server builds (SSR): externalize as configured\n            external: (() => {\n              const isStaticBuild = envConfig.name === \"static\" || (!envConfig.ssr && envConfig.name === \"client\");\n              if (isStaticBuild) {\n                // For static builds, don't externalize anything (bundle everything)\n                return [];\n              }\n              // For SSR builds, use configured externals\n              return Array.isArray(userConfig.build.rollupOptions.external)\n                ? userConfig.build.rollupOptions.external.filter(\n                    (item): item is string => typeof item === \"string\"\n                  )\n                : [];\n            })(),\n          },\n          build: {\n            ...userConfig.build,\n            ssr:\n              envConfig.name === \"server\"\n                ? true\n                : legacyBuild\n                ? implicitSsr\n                : envConfig.name === \"ssr\",\n            target: userConfig.build.target,\n            // Remove externals from rollupOptions since they should be in resolve.external for Environment API\n            rollupOptions: {\n              ...userConfig.build.rollupOptions,\n              external: undefined, // Remove external from rollupOptions, it's now in resolve.external\n              // Set preserveModules in the output configuration, not at the top level\n              output: (() => {\n                const output = userConfig.build.rollupOptions.output;\n                \n                // Handle array output configuration - extract the plugin output that contains preserveModulesRoot\n                if (Array.isArray(output)) {\n                  const pluginOutput = output.find(o => o && typeof o === 'object' && 'preserveModulesRoot' in o);\n                  if (pluginOutput) {\n                    return pluginOutput;\n                  }\n                  // If no pluginOutput found, use the first output configuration\n                  if (output.length > 0) {\n                    return output[0];\n                  }\n                }\n                \n                // Ensure preserveModulesRoot is always present in the output configuration\n                if (output && typeof output === 'object' && !Array.isArray(output)) {\n                  // Check if the property exists in the object (not just checking the value)\n                  const hasPreserveModulesRoot = 'preserveModulesRoot' in output;\n                  \n                  if (hasPreserveModulesRoot) {\n                    // Property exists, preserve the preserveModules value from the output (don't override it)\n                    // This is critical for static builds where preserveModules: false is set\n                    return output; // Return as-is, preserveModules is already set correctly\n                  } else {\n                    // Property missing, add it based on user options\n                    const preserveModulesRootString = userOptions.build.preserveModulesRoot === false\n                      ? userOptions.moduleBase\n                      : undefined;\n                    return { ...output, preserveModulesRoot: preserveModulesRootString };\n                  }\n                }\n                \n                return output;\n              })(),\n            },\n          },\n        };\n      }\n\n      // Return the configuration with all environments\n      // Build order: client → ssr → server → static generation (step 4)\n      // Server build runs LAST so dist/client exists when HTML rendering references client components\n      // Static generation is deferred to run after ALL environments complete (needs server manifest)\n      return {\n        root: userOptions.projectRoot,\n        ...config,\n        environments,\n        builder: {\n          async buildApp(builder: ViteBuilder) {\n            // Build all environments in definition order\n            for (const environment of Object.values(builder.environments)) {\n              await builder.build(environment);\n            }\n            // Step 4: Run deferred static generation now that all manifests are available\n            await runDeferredStaticGeneration();\n          },\n        },\n      };\n    },\n  };\n\n  return environmentPlugin;\n};\n"],"names":["config"],"mappings":"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"}

package/dist/plugin/error/index.d.ts

@@ -1,7 +1,6 @@
 export { toError } from "./toError.js";
 export { logError } from "./logError.js";
-export { enhanceError, createContextualError } from "./enhanceError.js";
 export { handleError } from "./handleError.js";
 export { shouldPanic, PANIC_SYMBOL, isPanic } from "./shouldPanic.js";
-export { assertPanic } from "./assertPanic.js";
+export { shouldCausePanic, handlePanicThreshold, isPanicError } from "./panicThresholdHandler.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/plugin/error/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/plugin/error/index.js

@@ -5,8 +5,7 @@
  */
 export { toError } from './toError.js';
 export { logError } from './logError.js';
-export { createContextualError, enhanceError } from './enhanceError.js';
 export { handleError } from './handleError.js';
 export { PANIC_SYMBOL, isPanic, shouldPanic } from './shouldPanic.js';
-export { assertPanic } from './assertPanic.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OyJ9
+export { handlePanicThreshold, isPanicError, shouldCausePanic } from './panicThresholdHandler.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7In0=

package/dist/plugin/error/panicThresholdHandler.js

@@ -3,11 +3,22 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-import { shouldPanic } from './shouldPanic.js';
+import { isPanic, shouldPanic } from './shouldPanic.js';
 
 function shouldCausePanic(error, options) {
   return shouldPanic(error, options.panicThreshold, options.critical);
 }
+function handlePanicThreshold(error, options) {
+  if (shouldCausePanic(error, options)) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    err[Symbol.for("vite-plugin-react-server.panic")] = true;
+    return err;
+  }
+  return null;
+}
+function isPanicError(error) {
+  return isPanic(error);
+}
 
-export { shouldCausePanic };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+export { handlePanicThreshold, isPanicError, shouldCausePanic };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/error/setupGlobalErrorHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupGlobalErrorHandler.d.ts","sourceRoot":"","sources":["../../../plugin/error/setupGlobalErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAIpB,eAAO,MAAM,uBAAuB,EAAE,yBAkDnC,CAAC;AAEJ,eAAO,MAAM,yBAAyB,EAAE,2BAWrC,CAAC"}
+{"version":3,"file":"setupGlobalErrorHandler.d.ts","sourceRoot":"","sources":["../../../plugin/error/setupGlobalErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAMpB,eAAO,MAAM,uBAAuB,EAAE,yBA0CnC,CAAC;AAEJ,eAAO,MAAM,yBAAyB,EAAE,2BAgBrC,CAAC"}