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

package/dist/plugin/worker/createWorker.js

@@ -7,12 +7,60 @@ import { Worker } from 'node:worker_threads';
 import { getNodePath, getMode } from '../config/getPaths.js';
 import { getCondition } from '../config/getCondition.js';
 import { join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { pluginRoot } from '../root.js';
-import * as React from 'react';
 import { DEFAULT_CONFIG } from '../config/defaults.js';
 import { createLogger } from 'vite';
+import { handleError } from '../error/handleError.js';
 import { toError } from '../error/toError.js';
 
+const activeWorkers = /* @__PURE__ */ new Set();
+async function shutdownAllWorkers(timeout = 1e3) {
+  if (activeWorkers.size === 0) return;
+  const shutdownPromises = Array.from(activeWorkers).map((worker) => {
+    return new Promise((resolve) => {
+      let messageHandler;
+      const timeoutId = setTimeout(() => {
+        worker.removeListener("message", messageHandler);
+        worker.removeAllListeners();
+        try {
+          worker.terminate();
+        } catch (error) {
+        }
+        activeWorkers.delete(worker);
+        resolve();
+      }, timeout);
+      messageHandler = (message) => {
+        if (message.type === "SHUTDOWN_COMPLETE") {
+          clearTimeout(timeoutId);
+          worker.removeListener("message", messageHandler);
+          worker.removeAllListeners();
+          activeWorkers.delete(worker);
+          resolve();
+        }
+      };
+      worker.on("message", messageHandler);
+      try {
+        worker.postMessage({
+          type: "SHUTDOWN",
+          id: "*"
+        });
+      } catch (error) {
+        clearTimeout(timeoutId);
+        worker.removeListener("message", messageHandler);
+        worker.removeAllListeners();
+        try {
+          worker.terminate();
+        } catch (terminateError) {
+        }
+        activeWorkers.delete(worker);
+        resolve();
+      }
+    });
+  });
+  await Promise.all(shutdownPromises);
+  activeWorkers.clear();
+}
 const createWorker = async function _createWorker(options) {
   const {
     projectRoot = process.cwd(),
@@ -35,64 +83,134 @@ const createWorker = async function _createWorker(options) {
   const id = reverseCondition === "react-server" ? "worker/rsc" : "worker/html";
   let workerPathWithDefault = typeof workerPath === "string" ? workerPath : void 0;
   if (!workerPathWithDefault) {
-    workerPathWithDefault = join(pluginRoot, id);
+    const isProduction = mode === "production";
+    const workerFileName = reverseCondition === "react-server" ? `rsc-worker.${isProduction ? "production" : "development"}.js` : `html-worker.${isProduction ? "production" : "development"}.js`;
+    const sourcePath = join(pluginRoot, id, workerFileName);
+    if (verbose) {
+      logger.info(
+        `[create:${id}] Checking paths - Source: ${sourcePath}, PluginRoot: ${pluginRoot}`
+      );
+    }
+    if (!existsSync(sourcePath)) {
+      throw new Error(
+        `[create:${id}] Worker file doesn't exist: ${sourcePath}`
+      );
+    } else {
+      workerPathWithDefault = sourcePath;
+      if (verbose) {
+        logger.info(`[create:${id}] Using source worker path: ${sourcePath}`);
+      }
+    }
   }
   if (!workerPathWithDefault.startsWith("/")) {
     workerPathWithDefault = join("./", workerPathWithDefault);
   }
   const workerData = {
-    userOptions: options.workerData.userOptions,
-    resolvedConfig: options.workerData.resolvedConfig,
-    reactVersion: options.workerData.reactVersion ?? React.version,
+    ...options.workerData,
     id: options.workerData.id ?? id
   };
   try {
-    const isTestEnv = process.env["VITEST"] || process.env["NODE_ENV"] === "test";
-    const nodeEnv = isTestEnv ? "test" : mode;
+    if (verbose) {
+      logger.info(
+        `[create:${id}] workerData.userOptions.build:
+${JSON.stringify(workerData.userOptions?.build)}
+
+Call stack: ${new Error().stack?.split("\n").slice(1, 4).join("\n")}
+Creating worker with path: ${workerPathWithDefault}
+Node environment: ${mode}
+Current condition: ${currentCondition}, Reverse condition: ${reverseCondition}`
+      );
+    }
+    const stripConditionsFromArgv = (argv) => {
+      const out = [];
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--conditions" || arg === "-C") {
+          i++;
+          continue;
+        }
+        if (arg.startsWith("--conditions=")) {
+          continue;
+        }
+        out.push(arg);
+      }
+      return out;
+    };
+    const computedExecArgv = [
+      ...stripConditionsFromArgv(process.execArgv || []),
+      "--conditions",
+      reverseCondition
+    ];
+    if (verbose) {
+      logger.info(
+        `[create:${id}] Setting up worker with reverse condition: ${reverseCondition}`
+      );
+      logger.info(
+        `[create:${id}] Computed execArgv: ${JSON.stringify(computedExecArgv)}`
+      );
+      logger.info(
+        `[create:${id}] Current NODE_OPTIONS: ${process.env["NODE_OPTIONS"]}`
+      );
+    }
     const env = {
+      // Inherit all existing environment variables
+      ...process.env,
+      // Override with our specific variables
       [envPrefix + "DEV"]: mode === "development" ? "1" : "0",
       [envPrefix + "MODE"]: mode,
       [envPrefix + "PROD"]: mode === "production" ? "1" : "0",
       [envPrefix + "SSR"]: "true",
-      [envPrefix + "BASE_URL"]: workerData.userOptions.moduleBaseURL ?? "",
-      [envPrefix + "PUBLIC_ORIGIN"]: workerData.userOptions.publicOrigin ?? "",
-      NODE_ENV: nodeEnv,
+      [envPrefix + "BASE_URL"]: workerData.userOptions?.moduleBaseURL ?? "",
+      [envPrefix + "PUBLIC_ORIGIN"]: workerData.userOptions?.publicOrigin ?? "",
+      NODE_ENV: process.env["NODE_ENV"] ?? "production",
       NODE_PATH: nodePath,
-      NODE_OPTIONS: process.env["NODE_OPTIONS"]?.includes(reverseCondition) ? process.env["NODE_OPTIONS"] : process.env["NODE_OPTIONS"]?.includes(currentCondition) ? process.env["NODE_OPTIONS"]?.replace(
+      // Ensure NODE_OPTIONS has the correct condition
+      NODE_OPTIONS: process.env["NODE_OPTIONS"]?.includes(reverseCondition) ? process.env["NODE_OPTIONS"] : currentCondition != null && process.env["NODE_OPTIONS"]?.includes(currentCondition) ? process.env["NODE_OPTIONS"]?.replaceAll(
         currentCondition,
         reverseCondition
       ) : `${process.env["NODE_OPTIONS"] ?? ""} --conditions ${reverseCondition}`,
       HTML_CHUNK_SIZE: htmlChunkSize.toString()
     };
+    if (verbose) {
+      logger.info(
+        `[create:${id}] Worker NODE_OPTIONS will be: ${env.NODE_OPTIONS}`
+      );
+      logger.info(
+        `[create:${id}] Environment variables: ${Object.keys(env).join(", ")}`
+      );
+      logger.info(`[create:${id}] execArgv: ${computedExecArgv.join(" ")}`);
+    }
     const worker = new Worker(workerPathWithDefault, {
       env,
+      execArgv: computedExecArgv,
       resourceLimits,
       workerData,
       transferList
     });
+    activeWorkers.add(worker);
     worker.setMaxListeners(maxListeners);
+    if (verbose) {
+      logger.info(
+        `[create:${id}] Worker created, waiting for READY message...`
+      );
+    }
     return await new Promise(
       (resolve, reject) => {
         const workerType = reverseCondition === "react-server" ? "rsc" : "html";
-        const startupTimeout = workerType === "rsc" ? options.workerData.userOptions.rscWorkerStartupTimeout : options.workerData.userOptions.htmlWorkerStartupTimeout;
+        const startupTimeout = workerType === "rsc" ? options.workerData.userOptions?.rscWorkerStartupTimeout : options.workerData.userOptions?.htmlWorkerStartupTimeout;
         const timeout = setTimeout(() => {
           reject({ type: "error", error: new Error("Worker ready timeout") });
         }, startupTimeout);
         const exitHandler = (code) => {
           clearTimeout(timeout);
           worker.removeListener("message", messageHandler);
-          worker.removeListener("exit", exitHandler);
-          if (code === 0) {
-            resolve({
-              type: "skip",
-              reason: "Worker exited with code 0",
-              workerPath: workerPathWithDefault
-            });
-          } else {
-            const error = `[create:${id}] exited with code ${code}`;
-            resolve({
-              type: "skip",
-              reason: error,
+          activeWorkers.delete(worker);
+          if (code !== 0) {
+            reject({
+              type: "error",
+              error: new Error(
+                `[create:${id}] Worker exited with code ${code}`
+              ),
               workerPath: workerPathWithDefault
             });
           }
@@ -100,19 +218,19 @@ const createWorker = async function _createWorker(options) {
         const messageHandler = (msg) => {
           if (verbose)
             logger.info(`[create:${id}] Initial worker message ${msg.type}`);
-          if (msg.type === "READY") {
+          if (msg.type === "READY" && msg.id === id) {
             if (verbose)
               logger.info(`[create:${id}] Worker running for ${msg.env}`);
             clearTimeout(timeout);
             worker.removeListener("message", messageHandler);
             worker.removeListener("exit", exitHandler);
-            if (msg.env !== nodeEnv) {
+            if (msg.env !== mode) {
               if (verbose)
                 logger.info(`[create:${id}] Worker environment mismatch.`);
               reject({
                 type: "error",
                 error: new Error(
-                  `Worker environment mismatch: ${msg.env} !== ${nodeEnv}`
+                  `Worker environment mismatch: ${msg.env} !== ${mode}`
                 ),
                 workerPath: workerPathWithDefault
               });
@@ -126,16 +244,75 @@ const createWorker = async function _createWorker(options) {
         };
         worker.once("message", messageHandler);
         worker.once("exit", exitHandler);
+        worker.on("error", (err) => {
+          activeWorkers.delete(worker);
+          if (verbose && err != null) {
+            logger.error(
+              `[create:${id}] Worker error: ${err.message}.
+${err.stack}`,
+              { error: err }
+            );
+          }
+          const panicError = handleError({
+            error: err,
+            logger,
+            panicThreshold: workerData.userOptions?.panicThreshold,
+            critical: false,
+            context: `Worker thread error for route ${id}`
+          });
+          if (panicError != null) {
+            if (verbose) {
+              logger.error(
+                `[create:${id}] Panic error detected: ${panicError.message}`,
+                { error: panicError }
+              );
+            }
+            reject({
+              type: "error",
+              error: err,
+              workerPath: workerPathWithDefault
+            });
+          }
+          reject({
+            type: "error",
+            error: new Error("Worker thread error", { cause: err }),
+            workerPath: workerPathWithDefault
+          });
+        });
       }
     );
   } catch (error) {
+    if (verbose) {
+      logger.error(
+        `[create:${id}] Caught error during worker creation: ${toError(error).message}`,
+        { error: error instanceof Error ? error : new Error(String(error)) }
+      );
+    }
+    const panicError = handleError({
+      error,
+      logger,
+      panicThreshold: workerData.userOptions?.panicThreshold,
+      critical: false});
+    if (panicError != null) {
+      if (verbose) {
+        logger.error(
+          `[create:${id}] Panic error in catch block: ${panicError.message}`,
+          { error: panicError }
+        );
+      }
+      return {
+        type: "error",
+        error: panicError,
+        workerPath: workerPathWithDefault
+      };
+    }
     return {
       type: "error",
-      error: toError(error),
+      error: error instanceof Error ? error : new Error(String(error)),
       workerPath: workerPathWithDefault
     };
   }
 };
 
-export { createWorker };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createWorker.js","sources":["../../../plugin/worker/createWorker.ts"],"sourcesContent":["import {\n  Worker,\n  type ResourceLimits,\n  type TransferListItem,\n} from \"node:worker_threads\";\nimport { getMode, getNodePath } from \"../config/getPaths.js\";\nimport { getCondition } from \"../config/getCondition.js\";\nimport { join } from \"node:path\";\nimport { pluginRoot } from \"../root.js\";\nimport * as React from \"react\";\nimport { DEFAULT_CONFIG } from \"../config/defaults.js\";\nimport { createLogger, type Logger } from \"vite\";\nimport type { HtmlWorkerOutputMessage } from \"./html/types.js\";\nimport type { RscWorkerOutputMessage } from \"./rsc/types.js\";\nimport { toError } from \"../error/toError.js\";\nimport type {\n  SerializedResolvedConfig,\n  SerializedUserOptions,\n} from \"../types.js\";\n\ntype CreateWorkerSuccess = {\n  type: \"success\";\n  workerPath: string;\n  reason?: never;\n  error?: never;\n  worker: Worker;\n};\n\ntype CreateWorkerError = {\n  type: \"error\";\n  workerPath: string;\n  error: Error;\n  worker?: never;\n  reason?: never;\n};\n\ntype CreateWorkerSkip = {\n  type: \"skip\";\n  reason: string;\n  workerPath: string;\n  worker?: never;\n  error?: never;\n};\n\nexport type CreateWorkerReturn =\n  | CreateWorkerSuccess\n  | CreateWorkerError\n  | CreateWorkerSkip;\n\nexport type CreateWorkerOptions = {\n  projectRoot?: string;\n  currentCondition?: \"react-server\" | \"react-client\";\n  nodePath?: string;\n  nodeOptions?: string[];\n  envPrefix?: string;\n  mode?: \"production\" | \"development\";\n  reverseCondition?: string;\n  maxListeners?: number;\n  workerPath?: string;\n  resourceLimits?: ResourceLimits;\n  typescript?: boolean;\n  htmlChunkSize?: number; // Size of HTML chunks in bytes\n  workerData: {\n    userOptions: SerializedUserOptions;\n    resolvedConfig: SerializedResolvedConfig;\n    reactVersion?: string;\n    id?: string;\n  };\n  transferList?: TransferListItem[];\n  logger?: Logger;\n  verbose?: boolean;\n};\n\nexport type CreateWorkerFn = (\n  options: CreateWorkerOptions\n) => Promise<CreateWorkerReturn>;\n\nexport const createWorker: CreateWorkerFn = async function _createWorker(\n  options\n) {\n  const {\n    projectRoot = process.cwd(),\n    nodePath = getNodePath(projectRoot),\n    currentCondition = getCondition(),\n    envPrefix = DEFAULT_CONFIG.ENV_PREFIX,\n    reverseCondition = currentCondition === \"react-server\"\n      ? \"react-client\"\n      : \"react-server\",\n    maxListeners = 100,\n    mode = getMode(),\n    workerPath,\n    resourceLimits = {\n      maxOldGenerationSizeMb: 128,\n      maxYoungGenerationSizeMb: 64,\n    },\n    htmlChunkSize = 8 * 1024,\n    transferList = [],\n    logger = createLogger(),\n    verbose = false,\n  } = options;\n  const id = reverseCondition === \"react-server\" ? \"worker/rsc\" : \"worker/html\";\n  let workerPathWithDefault =\n    typeof workerPath === \"string\" ? workerPath : undefined;\n  if (!workerPathWithDefault) {\n    workerPathWithDefault = join(pluginRoot, id);\n  }\n  if (!workerPathWithDefault.startsWith(\"/\")) {\n    workerPathWithDefault = join(\"./\", workerPathWithDefault);\n  }\n  // Ensure worker uses the same React version\n  const workerData = {\n    userOptions: options.workerData.userOptions,\n    resolvedConfig: options.workerData.resolvedConfig,\n    reactVersion: options.workerData.reactVersion ?? React.version,\n    id: options.workerData.id ?? id,\n  };\n\n  try {\n    // Ensure consistent NODE_ENV between main thread and worker\n    const isTestEnv =\n      process.env[\"VITEST\"] || process.env[\"NODE_ENV\"] === \"test\";\n    const nodeEnv = isTestEnv ? \"test\" : mode;\n\n    const env = {\n      [envPrefix + \"DEV\"]: mode === \"development\" ? \"1\" : \"0\",\n      [envPrefix + \"MODE\"]: mode,\n      [envPrefix + \"PROD\"]: mode === \"production\" ? \"1\" : \"0\",\n      [envPrefix + \"SSR\"]: \"true\",\n      [envPrefix + \"BASE_URL\"]: workerData.userOptions.moduleBaseURL ?? \"\",\n      [envPrefix + \"PUBLIC_ORIGIN\"]: workerData.userOptions.publicOrigin ?? \"\",\n      NODE_ENV: nodeEnv,\n      NODE_PATH: nodePath,\n      NODE_OPTIONS: process.env[\"NODE_OPTIONS\"]?.includes(reverseCondition)\n        ? process.env[\"NODE_OPTIONS\"]\n        : process.env[\"NODE_OPTIONS\"]?.includes(currentCondition)\n        ? process.env[\"NODE_OPTIONS\"]?.replace(\n            currentCondition,\n            reverseCondition\n          )\n        : `${\n            process.env[\"NODE_OPTIONS\"] ?? \"\"\n          } --conditions ${reverseCondition}`,\n      HTML_CHUNK_SIZE: htmlChunkSize.toString(),\n    };\n\n    // Create worker with proper environment and loaders\n    const worker = new Worker(workerPathWithDefault, {\n      env,\n      resourceLimits,\n      workerData,\n      transferList,\n    });\n\n    worker.setMaxListeners(maxListeners);\n\n    // Wait for worker to be ready\n    return await new Promise<CreateWorkerSuccess | CreateWorkerSkip>(\n      (resolve, reject) => {\n        // Use appropriate timeout based on worker type\n        const workerType = reverseCondition === \"react-server\" ? \"rsc\" : \"html\";\n        const startupTimeout = workerType === \"rsc\" \n          ? options.workerData.userOptions.rscWorkerStartupTimeout \n          : options.workerData.userOptions.htmlWorkerStartupTimeout;\n        \n        const timeout = setTimeout(() => {\n          reject({ type: \"error\", error: new Error(\"Worker ready timeout\") });\n        }, startupTimeout);\n        const exitHandler = (code: number) => {\n          clearTimeout(timeout);\n          worker.removeListener(\"message\", messageHandler);\n          worker.removeListener(\"exit\", exitHandler);\n          if (code === 0) {\n            resolve({\n              type: \"skip\",\n              reason: \"Worker exited with code 0\",\n              workerPath: workerPathWithDefault,\n            } satisfies CreateWorkerSkip);\n          } else {\n            const error = `[create:${id}] exited with code ${code}`;\n            resolve({\n              type: \"skip\",\n              reason: error,\n              workerPath: workerPathWithDefault,\n            } satisfies CreateWorkerSkip);\n          }\n        };\n        const messageHandler = (\n          msg: HtmlWorkerOutputMessage | RscWorkerOutputMessage\n        ) => {\n          if (verbose)\n            logger.info(`[create:${id}] Initial worker message ${msg.type}`);\n          if (msg.type === \"READY\") {\n            if (verbose)\n              logger.info(`[create:${id}] Worker running for ${msg.env}`);\n            clearTimeout(timeout);\n            worker.removeListener(\"message\", messageHandler);\n            worker.removeListener(\"exit\", exitHandler);\n            if (msg.env !== nodeEnv) {\n              if (verbose)\n                logger.info(`[create:${id}] Worker environment mismatch.`);\n              reject({\n                type: \"error\",\n                error: new Error(\n                  `Worker environment mismatch: ${msg.env} !== ${nodeEnv}`\n                ),\n                workerPath: workerPathWithDefault,\n              } satisfies CreateWorkerError);\n            }\n            resolve({\n              type: \"success\",\n              worker,\n              workerPath: workerPathWithDefault,\n            } satisfies CreateWorkerSuccess);\n          }\n        };\n        worker.once(\"message\", messageHandler);\n        worker.once(\"exit\", exitHandler);\n      }\n    );\n  } catch (error) {\n    return {\n      type: \"error\",\n      error: toError(error),\n      workerPath: workerPathWithDefault,\n    };\n  }\n};\n"],"names":[],"mappings":"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"}
+export { createWorker, shutdownAllWorkers };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createWorker.js","sources":["../../../plugin/worker/createWorker.ts"],"sourcesContent":["import {\n  Worker,\n  type ResourceLimits,\n  type TransferListItem,\n  type MessagePort,\n} from \"node:worker_threads\";\nimport type { ConfigEnv } from \"vite\";\nimport { getMode, getNodePath } from \"../config/getPaths.js\";\nimport { getCondition } from \"../config/getCondition.js\";\nimport { join } from \"node:path\";\nimport { existsSync } from \"node:fs\";\nimport { pluginRoot } from \"../root.js\";\nimport { DEFAULT_CONFIG } from \"../config/defaults.js\";\nimport { createLogger, type Logger } from \"vite\";\nimport type { HtmlWorkerOutputMessage } from \"./html/types.js\";\nimport type { RscWorkerOutputMessage } from \"./rsc/types.js\";\nimport type {\n  SerializedResolvedConfig,\n  SerializedUserOptions,\n} from \"../types.js\";\nimport type { Manifest } from \"vite\";\nimport type { OutputBundle } from \"rollup\";\nimport { handleError } from \"../error/handleError.js\";\nimport { toError } from \"../error/toError.js\";\n\n// Global worker registry for graceful shutdown\nconst activeWorkers = new Set<Worker>();\n\n// Graceful shutdown function using the existing SHUTDOWN protocol\nexport async function shutdownAllWorkers(timeout: number = 1000): Promise<void> {\n  if (activeWorkers.size === 0) return;\n\n  const shutdownPromises = Array.from(activeWorkers).map(worker => {\n    return new Promise<void>((resolve) => {\n      let messageHandler: ((message: any) => void) | undefined;\n      \n      const timeoutId = setTimeout(() => {\n        worker.removeListener(\"message\", messageHandler!);\n        worker.removeAllListeners();\n        try {\n          worker.terminate();\n        } catch (error) {\n          // Ignore termination errors\n        }\n        activeWorkers.delete(worker);\n        resolve();\n      }, timeout);\n\n      messageHandler = (message: any) => {\n        if (message.type === \"SHUTDOWN_COMPLETE\") {\n          clearTimeout(timeoutId);\n          worker.removeListener(\"message\", messageHandler!);\n          worker.removeAllListeners();\n          activeWorkers.delete(worker);\n          resolve();\n        }\n      };\n\n      worker.on(\"message\", messageHandler);\n      \n      // Send graceful shutdown message\n      try {\n        worker.postMessage({\n          type: \"SHUTDOWN\",\n          id: \"*\",\n        });\n      } catch (error) {\n        // If we can't send the message, force terminate\n        clearTimeout(timeoutId);\n        worker.removeListener(\"message\", messageHandler!);\n        worker.removeAllListeners();\n        try {\n          worker.terminate();\n        } catch (terminateError) {\n          // Ignore termination errors\n        }\n        activeWorkers.delete(worker);\n        resolve();\n      }\n    });\n  });\n\n  await Promise.all(shutdownPromises);\n  activeWorkers.clear();\n}\n\n\ntype CreateWorkerSuccess = {\n  type: \"success\";\n  workerPath: string;\n  reason?: never;\n  error?: never;\n  worker: Worker;\n};\n\ntype CreateWorkerError = {\n  type: \"error\";\n  workerPath: string;\n  error: Error | null;\n  worker?: never;\n  reason?: never;\n};\n\ntype CreateWorkerSkip = {\n  type: \"skip\";\n  reason: string;\n  workerPath: string;\n  worker?: never;\n  error?: never;\n};\n\nexport type CreateWorkerReturn =\n  | CreateWorkerSuccess\n  | CreateWorkerError\n  | CreateWorkerSkip;\n\nexport type CreateWorkerOptions = {\n  projectRoot?: string;\n  currentCondition?: \"react-server\" | \"react-client\";\n  nodePath?: string;\n  nodeOptions?: string[];\n  envPrefix?: string;\n  mode?: \"production\" | \"development\" | \"test\";\n  reverseCondition?: string;\n  maxListeners?: number;\n  workerPath?: string;\n  resourceLimits?: ResourceLimits;\n  typescript?: boolean;\n  htmlChunkSize?: number; // Size of HTML chunks in bytes\n  workerData: {\n    userOptions?: SerializedUserOptions;\n    resolvedConfig?: SerializedResolvedConfig;\n    configEnv?: ConfigEnv;\n    reactVersion?: string;\n    id?: string;\n    serverManifest?: Manifest;\n    bundle?: OutputBundle;\n    staticBundle?: OutputBundle;\n    serverPipeableStreamOptions?: any;\n    clientPipeableStreamOptions?: any;\n    hmrPort?: MessagePort;\n  };\n  transferList?: TransferListItem[];\n  logger?: Logger;\n  verbose?: boolean;\n};\n\nexport type CreateWorkerFn = (\n  options: CreateWorkerOptions\n) => Promise<CreateWorkerReturn>;\n\nexport const createWorker: CreateWorkerFn = async function _createWorker(\n  options\n) {\n  const {\n    projectRoot = process.cwd(),\n    nodePath = getNodePath(projectRoot),\n    currentCondition = getCondition(),\n    envPrefix = DEFAULT_CONFIG.ENV_PREFIX,\n    reverseCondition = currentCondition === \"react-server\"\n      ? \"react-client\"\n      : \"react-server\",\n    maxListeners = 100,\n    mode = getMode(),\n    workerPath,\n    resourceLimits = {\n      maxOldGenerationSizeMb: 128,\n      maxYoungGenerationSizeMb: 64,\n    },\n    htmlChunkSize = 8 * 1024,\n    transferList = [],\n    logger = createLogger(),\n    verbose = false,\n  } = options;\n  const id = reverseCondition === \"react-server\" ? \"worker/rsc\" : \"worker/html\";\n  let workerPathWithDefault =\n    typeof workerPath === \"string\" ? workerPath : undefined;\n  if (!workerPathWithDefault) {\n    // Use the default worker paths that include the full filename\n    const isProduction = mode === \"production\";\n    const workerFileName =\n      reverseCondition === \"react-server\"\n        ? `rsc-worker.${isProduction ? \"production\" : \"development\"}.js`\n        : `html-worker.${isProduction ? \"production\" : \"development\"}.js`;\n\n    // Try source directory first\n    const sourcePath = join(pluginRoot, id, workerFileName);\n\n    // Always log the paths for debugging\n    if (verbose) {\n      logger.info(\n        `[create:${id}] Checking paths - Source: ${sourcePath}, PluginRoot: ${pluginRoot}`\n      );\n    }\n\n    // If source path doesn't exist, try built directory\n    if (!existsSync(sourcePath)) {\n      throw new Error(\n        `[create:${id}] Worker file doesn't exist: ${sourcePath}`\n      );\n      // const builtPath = join(pluginRoot.replace(\"/plugin/\", \"/dist/plugin/\"), id, workerFileName);\n      // logger.info(`[create:${id}] Source path doesn't exist, checking built path: ${builtPath}`);\n\n      // if (existsSync(builtPath)) {\n      //   workerPathWithDefault = builtPath;\n      //   logger.info(`[create:${id}] Using built worker path: ${builtPath}`);\n      // } else {\n      //   workerPathWithDefault = sourcePath; // Fallback to source path for error message\n      //   logger.info(`[create:${id}] Neither source nor built path exists. Source: ${sourcePath}, Built: ${builtPath}`);\n      // }\n    } else {\n      workerPathWithDefault = sourcePath;\n      if (verbose) {\n        logger.info(`[create:${id}] Using source worker path: ${sourcePath}`);\n      }\n    }\n  }\n  if (!workerPathWithDefault.startsWith(\"/\")) {\n    workerPathWithDefault = join(\"./\", workerPathWithDefault);\n  }\n  // Ensure worker uses the same React version\n  const workerData = {\n    ...options.workerData,\n    id: options.workerData.id ?? id,\n  };\n\n  try {\n    // Ensure consistent NODE_ENV between main thread and worker\n\n    if (verbose) {\n      logger.info(\n        `[create:${id}] workerData.userOptions.build:\n${JSON.stringify(workerData.userOptions?.build)}\n\nCall stack: ${new Error().stack?.split(\"\\n\").slice(1, 4).join(\"\\n\")}\nCreating worker with path: ${workerPathWithDefault}\nNode environment: ${mode}\nCurrent condition: ${currentCondition}, Reverse condition: ${reverseCondition}`\n      );\n    }\n\n    // Compute execArgv for the worker with exactly one --conditions flag\n    const stripConditionsFromArgv = (argv: string[]) => {\n      const out: string[] = [];\n      for (let i = 0; i < argv.length; i++) {\n        const arg = argv[i];\n        if (arg === \"--conditions\" || arg === \"-C\") {\n          i++; // skip value\n          continue;\n        }\n        if (arg.startsWith(\"--conditions=\")) {\n          continue;\n        }\n        out.push(arg);\n      }\n      return out;\n    };\n    const computedExecArgv = [\n      ...stripConditionsFromArgv(process.execArgv || []),\n      \"--conditions\",\n      reverseCondition,\n    ];\n\n    // Always log the condition setup for debugging\n    if (verbose) {\n      logger.info(\n        `[create:${id}] Setting up worker with reverse condition: ${reverseCondition}`\n      );\n      logger.info(\n        `[create:${id}] Computed execArgv: ${JSON.stringify(computedExecArgv)}`\n      );\n      logger.info(\n        `[create:${id}] Current NODE_OPTIONS: ${process.env[\"NODE_OPTIONS\"]}`\n      );\n    }\n\n    const env = {\n      // Inherit all existing environment variables\n      ...process.env,\n\n      // Override with our specific variables\n      [envPrefix + \"DEV\"]: mode === \"development\" ? \"1\" : \"0\",\n      [envPrefix + \"MODE\"]: mode,\n      [envPrefix + \"PROD\"]: mode === \"production\" ? \"1\" : \"0\",\n      [envPrefix + \"SSR\"]: \"true\",\n      [envPrefix + \"BASE_URL\"]: workerData.userOptions?.moduleBaseURL ?? \"\",\n      [envPrefix + \"PUBLIC_ORIGIN\"]: workerData.userOptions?.publicOrigin ?? \"\",\n      NODE_ENV: process.env[\"NODE_ENV\"] ?? \"production\",\n      NODE_PATH: nodePath,\n\n      // Ensure NODE_OPTIONS has the correct condition\n      NODE_OPTIONS: process.env[\"NODE_OPTIONS\"]?.includes(reverseCondition)\n        ? process.env[\"NODE_OPTIONS\"]\n        : currentCondition != null &&\n          process.env[\"NODE_OPTIONS\"]?.includes(currentCondition)\n        ? process.env[\"NODE_OPTIONS\"]?.replaceAll(\n            currentCondition,\n            reverseCondition\n          )\n        : `${\n            process.env[\"NODE_OPTIONS\"] ?? \"\"\n          } --conditions ${reverseCondition}`,\n      HTML_CHUNK_SIZE: htmlChunkSize.toString(),\n    };\n\n    if (verbose) {\n      // Always log the NODE_OPTIONS for debugging\n      logger.info(\n        `[create:${id}] Worker NODE_OPTIONS will be: ${env.NODE_OPTIONS}`\n      );\n      logger.info(\n        `[create:${id}] Environment variables: ${Object.keys(env).join(\", \")}`\n      );\n      logger.info(`[create:${id}] execArgv: ${computedExecArgv.join(\" \")}`);\n    }\n\n    // Create worker with proper environment and loaders\n    const worker = new Worker(workerPathWithDefault, {\n      env,\n      execArgv: computedExecArgv,\n      resourceLimits,\n      workerData,\n      transferList,\n    });\n\n    // Register worker for graceful shutdown\n    activeWorkers.add(worker);\n\n    worker.setMaxListeners(maxListeners);\n\n    if (verbose) {\n      logger.info(\n        `[create:${id}] Worker created, waiting for READY message...`\n      );\n    }\n\n    return await new Promise<CreateWorkerSuccess | CreateWorkerSkip>(\n      (resolve, reject) => {\n        // Use appropriate timeout based on worker type\n        const workerType = reverseCondition === \"react-server\" ? \"rsc\" : \"html\";\n        const startupTimeout =\n          workerType === \"rsc\"\n            ? options.workerData.userOptions?.rscWorkerStartupTimeout\n            : options.workerData.userOptions?.htmlWorkerStartupTimeout;\n\n        const timeout = setTimeout(() => {\n          reject({ type: \"error\", error: new Error(\"Worker ready timeout\") });\n        }, startupTimeout);\n        const exitHandler = (code: number) => {\n          clearTimeout(timeout);\n          worker.removeListener(\"message\", messageHandler);\n          // Remove worker from registry when it exits\n          activeWorkers.delete(worker);\n          // Do not remove exit handler here, let it fire if needed\n          if (code !== 0) {\n            reject({\n              type: \"error\",\n              error: new Error(\n                `[create:${id}] Worker exited with code ${code}`\n              ),\n              workerPath: workerPathWithDefault,\n            });\n          }\n        };\n        const messageHandler = (\n          msg: RscWorkerOutputMessage | HtmlWorkerOutputMessage\n        ) => {\n          if (verbose)\n            logger.info(`[create:${id}] Initial worker message ${msg.type}`);\n          if (msg.type === \"READY\" && msg.id === id) {\n            if (verbose)\n              logger.info(`[create:${id}] Worker running for ${msg.env}`);\n            clearTimeout(timeout);\n            worker.removeListener(\"message\", messageHandler);\n            worker.removeListener(\"exit\", exitHandler);\n            if (msg.env !== mode) {\n              if (verbose)\n                logger.info(`[create:${id}] Worker environment mismatch.`);\n              reject({\n                type: \"error\",\n                error: new Error(\n                  `Worker environment mismatch: ${msg.env} !== ${mode}`\n                ),\n                workerPath: workerPathWithDefault,\n              } satisfies CreateWorkerError);\n            }\n            resolve({\n              type: \"success\",\n              worker,\n              workerPath: workerPathWithDefault,\n            } satisfies CreateWorkerSuccess);\n          }\n        };\n        worker.once(\"message\", messageHandler);\n        worker.once(\"exit\", exitHandler);\n        worker.on(\"error\", (err) => {\n          // Remove worker from registry on error\n          activeWorkers.delete(worker);\n          \n          if (verbose && err != null) {\n            logger.error(\n              `[create:${id}] Worker error: ${err.message}.\\n${err.stack}`,\n              { error: err }\n            );\n          }\n          const panicError = handleError({\n            error: err,\n            logger: logger,\n            panicThreshold: workerData.userOptions?.panicThreshold,\n            critical: false,\n            context: `Worker thread error for route ${id}`,\n          });\n          if (panicError != null) {\n            if (verbose) {\n              logger.error(\n                `[create:${id}] Panic error detected: ${panicError.message}`,\n                { error: panicError }\n              );\n            }\n            reject({\n              type: \"error\",\n              error: err,\n              workerPath: workerPathWithDefault,\n            });\n          }\n          reject({\n            type: \"error\",\n            error: new Error(\"Worker thread error\", { cause: err }),\n            workerPath: workerPathWithDefault,\n          });\n        });\n      }\n    );\n  } catch (error) {\n    if (verbose) {\n      logger.error(\n        `[create:${id}] Caught error during worker creation: ${\n          toError(error).message\n        }`,\n        { error: error instanceof Error ? error : new Error(String(error)) }\n      );\n    }\n    const panicError = handleError({\n      error: error,\n      logger: logger,\n      panicThreshold: workerData.userOptions?.panicThreshold,\n      critical: false,\n      context: `Worker thread error for route ${id}`,\n    });\n    if (panicError != null) {\n      if (verbose) {\n        logger.error(\n          `[create:${id}] Panic error in catch block: ${panicError.message}`,\n          { error: panicError }\n        );\n      }\n      return {\n        type: \"error\",\n        error: panicError,\n        workerPath: workerPathWithDefault,\n      };\n    }\n    return {\n      type: \"error\",\n      error: error instanceof Error ? error : new Error(String(error)),\n      workerPath: workerPathWithDefault,\n    };\n  }\n};\n"],"names":[],"mappings":"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"}

package/dist/plugin/worker/html/handleHtmlRender.d.ts

@@ -0,0 +1,14 @@
+import type { HandleHtmlRenderFn } from "./types.js";
+/**
+ * Handle the render of an HTML stream from RSC chunks, creates the stream once and pipes directly.
+ *
+ * This html render expects all components as a serialized rsc stream.
+ *
+ * It does not have to resolve components, it just renders the html.
+ *
+ * @param handlerOptions
+ * @param handlers
+ * @param logger
+ */
+export declare const handleHtmlRender: HandleHtmlRenderFn;
+//# sourceMappingURL=handleHtmlRender.d.ts.map

package/dist/plugin/worker/html/handleHtmlRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHtmlRender.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/html/handleHtmlRender.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAWrD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,kBA2N9B,CAAC"}

package/dist/plugin/worker/html/handleHtmlRender.js

@@ -0,0 +1,190 @@
+import { workerData } from "node:worker_threads";
+import { join } from "node:path";
+import { handleError } from "../../error/handleError.js";
+import { assertNonReactServer } from "../../config/getCondition.js";
+// Import React DOM Client for RSC stream processing
+import { createFromNodeStream } from "../../stream/createFromNodeStream.client.js";
+import { createModuleResolutionMetrics } from "../../metrics/createModuleResolutionMetrics.js";
+import { ReactDOMServer } from "../../vendor/vendor.client.js";
+assertNonReactServer();
+/**
+ * Handle the render of an HTML stream from RSC chunks, creates the stream once and pipes directly.
+ *
+ * This html render expects all components as a serialized rsc stream.
+ *
+ * It does not have to resolve components, it just renders the html.
+ *
+ * @param handlerOptions
+ * @param handlers
+ * @param logger
+ */
+export const handleHtmlRender = function _handleHtmlRender(handlerOptions, handlers) {
+    const { route, id = route, rscStream, // Use the RSC stream id passed from the main thread
+    moduleRootPath, moduleBaseURL, moduleBasePath, verbose, logger, projectRoot, } = handlerOptions;
+    try {
+        if (verbose) {
+            logger.info(`[html-worker:${route}] Creating HTML stream (${id})`);
+        }
+        if (!rscStream) {
+            throw new Error("RSC stream is required for HTML rendering");
+        }
+        // Convert RSC stream to React elements using ReactDOMClient.createFromNodeStream
+        //
+        // IMPORTANT: ReactDOMClient comes from react-server-dom-esm/client.node
+        // We have reverse-engineered our own types for this (plugin/types/react-server-dom-esm.d.ts)
+        // because there's no official @types package for react-server-dom-esm
+        //
+        // ACTUAL SIGNATURE FROM SOURCE CODE (patches/react-server-dom-esm+0.0.1.patch:9437):
+        // exports.createFromNodeStream = function (stream, moduleRootPath, moduleBaseURL, options)
+        //
+        // This takes 4 parameters:
+        // 1. stream: NodeJS.ReadableStream - the RSC stream
+        // 2. moduleRootPath: string - the module root path for resolving client modules
+        // 3. moduleBaseURL: string - the module base URL for resolving client modules
+        // 4. options: object - optional configuration (encodeFormAction, nonce, etc.)
+        // Construct the correct moduleRootPath using the projectRoot + moduleBasePath
+        let resolvedModuleRootPath = moduleRootPath || "";
+        if (typeof resolvedModuleRootPath !== "string") {
+            throw new Error("moduleRootPath is required");
+        }
+        else if (!resolvedModuleRootPath.startsWith(projectRoot)) {
+            resolvedModuleRootPath = join(projectRoot, resolvedModuleRootPath);
+        }
+        if (!resolvedModuleRootPath.endsWith(moduleBasePath)) {
+            resolvedModuleRootPath = resolvedModuleRootPath + moduleBasePath;
+        }
+        if (moduleBasePath === "" && !resolvedModuleRootPath.endsWith("/")) {
+            resolvedModuleRootPath = `${resolvedModuleRootPath}/`;
+        }
+        if (verbose) {
+            logger.info(`[html-worker:${route}] Final resolvedModuleRootPath: ${resolvedModuleRootPath}`);
+        }
+        // Start measuring module resolution time
+        const moduleResolutionStartTime = performance.now();
+        // Note: Module resolution metric will be emitted in onAllReady callback
+        if (verbose) {
+            logger.info(`[html-worker:${route}] Starting HTML render for route: ${route}`);
+        }
+        if (!rscStream.readable) {
+            throw new Error("RSC stream is not readable");
+        }
+        // Convert RSC stream to React elements using createFromNodeStream (like client-side)
+        const result = createFromNodeStream({
+            rscStream: rscStream,
+            moduleRootPath: resolvedModuleRootPath,
+            moduleBasePath: moduleBasePath,
+            moduleBaseURL: moduleBaseURL,
+            logger,
+        });
+        const mergedPipeableStreamOptions = {
+            ...workerData.userOptions?.clientPipeableStreamOptions,
+            ...handlerOptions.clientPipeableStreamOptions,
+        };
+        // Render React elements to HTML stream using ReactDOMServer.renderToPipeableStream
+        if (verbose) {
+            logger.info(`[html-worker:${route}] clientPipeableStreamOptions: ${JSON.stringify(mergedPipeableStreamOptions)}`);
+        }
+        // Create the stream once and pipe directly with onData
+        const { pipe } = ReactDOMServer.renderToPipeableStream(result.children, {
+            ...mergedPipeableStreamOptions,
+            onShellReady() {
+                if (verbose) {
+                    logger.info(`[html-worker:${route}] Shell ready, starting to pipe HTML`);
+                }
+                if (handlers.onShellReady) {
+                    handlers.onShellReady(route);
+                }
+                if (mergedPipeableStreamOptions?.onShellReady) {
+                    mergedPipeableStreamOptions.onShellReady();
+                }
+            },
+            onAllReady() {
+                if (verbose) {
+                    logger.info(`[html-worker:${route}] All ready, HTML rendering complete`);
+                }
+                // Calculate module resolution time
+                const moduleResolutionTime = performance.now() - moduleResolutionStartTime;
+                // Send metrics
+                if (handlers.onMetrics) {
+                    const moduleResolutionMetric = createModuleResolutionMetrics({
+                        route,
+                        workerType: "html",
+                        resolutionTime: moduleResolutionTime,
+                        fromMainThread: false,
+                        fromRscWorker: false,
+                        fromHtmlWorker: true,
+                        description: `Module resolution for route ${route}`,
+                    });
+                    handlers.onMetrics(route, moduleResolutionMetric);
+                }
+                if (handlers.onAllReady) {
+                    handlers.onAllReady(route);
+                }
+                if (mergedPipeableStreamOptions?.onAllReady) {
+                    mergedPipeableStreamOptions.onAllReady();
+                }
+            },
+            onError(error, errorInfo) {
+                if (verbose) {
+                    logger.error(`[html-worker:${route}] React rendering error: ${error}`);
+                }
+                handlers.onError(route, error, errorInfo);
+                if (handlers.onError) {
+                    handlers.onError(route, error, errorInfo);
+                }
+                if (mergedPipeableStreamOptions?.onError) {
+                    mergedPipeableStreamOptions.onError(error, errorInfo);
+                }
+            },
+        });
+        // Create a custom writable stream that pipes directly to onData
+        const customWritable = {
+            write(chunk, _encoding, callback) {
+                handlers.onData(id, chunk);
+                if (callback)
+                    callback();
+            },
+            end(chunk, _encoding, callback) {
+                if (chunk) {
+                    handlers.onData(id, chunk);
+                }
+                handlers.onEnd(id);
+                if (callback)
+                    callback();
+            },
+            on() { }, // No-op for event listeners
+            once() { }, // No-op for event listeners
+            emit() { return false; }, // No-op for event emitters
+        };
+        // Pipe the React stream directly to our custom writable
+        pipe(customWritable);
+        // Set up RSC stream error handling
+        rscStream.on("error", (error) => {
+            if (verbose) {
+                logger.error(`[html-worker:${route}] RSC stream error: ${error}`);
+            }
+            handlers.onError(id, error, {
+                componentStack: undefined,
+                digest: undefined,
+            });
+        });
+    }
+    catch (error) {
+        if (verbose) {
+            logger.error(`[html-worker:${route}] Error in handleHtmlRender: ${error}`);
+        }
+        const panicError = handleError({
+            error: error,
+            logger: logger,
+            panicThreshold: workerData.userOptions?.panicThreshold,
+            context: `HTML worker error for route ${route}`,
+        });
+        if (panicError != null) {
+            handlers.onError(id, panicError, {
+                componentStack: undefined,
+                digest: undefined,
+            });
+        }
+        throw error;
+    }
+};