vite-plugin-react-server 1.2.0-alpha.1 → 1.2.1

package/dist/plugin/worker/rsc/messageHandler.js

@@ -3,95 +3,973 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-import { parentPort, workerData } from 'node:worker_threads';
-import { activeStreams, hmrState } from './state.js';
-import { handleRender } from './handleRender.js';
+import { workerData, parentPort } from 'node:worker_threads';
+import { PassThrough } from 'node:stream';
+import { createLogger } from 'vite';
+import { join, relative } from 'node:path';
+import { createRscWorkerLoader } from './createRscWorkerLoader.js';
+import { handleRscRender } from './handleRscRender.js';
+import { setMaxListenersOnPort } from '../../stream/setMaxListeners.js';
 import { toError } from '../../error/toError.js';
-import { handlers } from './handlers.js';
-import { join } from 'node:path';
+import { decodeReply } from 'react-server-dom-esm/server';
+import { createHandlers } from './handlers.js';
+import { addModuleId, addCssFileContent, hmrState, clearAllCachedComponents, cssFiles, isModuleInvalidated, hasCachedComponent, getCachedComponent, clearCachedComponent, cacheComponent } from './state.js';
+import { processInlineCssForState, combineCssFiles } from '../../helpers/createUnifiedCssProcessor.js';
+import { routeToURL } from '../../utils/routeToURL.js';
+import { DEFAULT_CONFIG } from '../../config/defaults.js';
+import { resolvePageAndProps } from '../../helpers/resolvePageAndProps.js';
+import { resolveComponent } from '../../helpers/resolveComponent.js';
+import { Root } from '../../components/root.js';
+import { workerUserOptions } from './workerUserOptions.js';
+import { hydrateUserOptions } from '../../helpers/hydrateUserOptions.js';
+import { React } from '../../vendor/vendor.server.js';
 import { sendMessage } from '../sendMessage.js';
-import { createLogger } from 'vite';
-import { logError } from '../../error/logError.js';
+import { createModuleResolutionMetrics } from '../../metrics/createModuleResolutionMetrics.js';
 
-const isTestEnv = process.env["VITEST"] || process.env["NODE_ENV"] === "test";
-const isDevEnv = process.env["NODE_ENV"] !== "production";
-const logger = createLogger(workerData.resolvedConfig.logLevel ?? "info");
-async function messageHandler(msg, port = parentPort) {
+const logger = createLogger(workerData.resolvedConfig?.logLevel ?? "info");
+const verbose = workerData.userOptions.verbose ?? false;
+process.on("uncaughtException", (error) => {
+  if (verbose) {
+    logger?.error(`[RSC-WORKER] Uncaught exception: ${error.message}`, {
+      error
+    });
+  }
+  if (parentPort) {
+    parentPort.postMessage({
+      type: "ERROR",
+      id: "uncaught-exception",
+      error: {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      },
+      context: "Uncaught Exception in RSC Worker"
+    });
+  }
+  process.exit(1);
+});
+const renderStates = /* @__PURE__ */ new Map();
+let fallbackUserOptions = null;
+function getUserOptions(renderId) {
+  if (renderId && renderStates.has(renderId)) {
+    const renderState = renderStates.get(renderId);
+    if (renderState.initialized) {
+      return renderState.userOptions;
+    }
+  }
+  if (fallbackUserOptions) {
+    return fallbackUserOptions;
+  }
+  const userOptionsResult = hydrateUserOptions(workerData.userOptions);
+  if (userOptionsResult.type === "error") {
+    throw userOptionsResult.error;
+  }
+  fallbackUserOptions = userOptionsResult.userOptions;
+  if (verbose) {
+    logger?.info(
+      `[FALLBACK] Using fallback userOptions for renderId: ${renderId || "none"}`
+    );
+    logger?.info(
+      `[FALLBACK] fallbackUserOptions.build: ${JSON.stringify(
+        fallbackUserOptions.build
+      )}`
+    );
+  }
+  return fallbackUserOptions;
+}
+function setRenderUserOptions(renderId, userOptions) {
+  renderStates.set(renderId, {
+    userOptions,
+    initialized: true
+  });
+}
+function cleanupRenderState(renderId) {
+  renderStates.delete(renderId);
+}
+const activeRenders = /* @__PURE__ */ new Map();
+const activeStreamsByRoute = /* @__PURE__ */ new Map();
+const headlessStreamElements = /* @__PURE__ */ new Map();
+const headlessStreamErrors = /* @__PURE__ */ new Map();
+function cleanupRender(id) {
+  const rscStream = activeRenders.get(id);
+  if (rscStream) {
+    rscStream.destroy();
+    activeRenders.delete(id);
+    for (const [route, streamId] of activeStreamsByRoute.entries()) {
+      if (streamId === id) {
+        activeStreamsByRoute.delete(route);
+        break;
+      }
+    }
+  }
+  cleanupRenderState(id);
+}
+function clearHeadlessError(route) {
+  headlessStreamErrors.delete(route);
+}
+async function loadComponentsWithCache(options) {
+  const {
+    pagePath,
+    propsPath,
+    rootPath,
+    htmlPath,
+    pageExportName = "Page",
+    propsExportName = "props",
+    rootExportName = "Root",
+    htmlExportName = "Html",
+    url,
+    loader,
+    verbose: verbose2,
+    logger: logger2,
+    resolvedPageProps
+  } = options;
+  const normalizeUrlForCache = (urlStr) => {
+    if (urlStr.includes(".")) return urlStr;
+    return urlStr.endsWith("/") ? urlStr : urlStr + "/";
+  };
+  const normalizedUrl = normalizeUrlForCache(url);
+  let PageComponent;
+  let pageProps = resolvedPageProps;
+  let RootComponent;
+  let HtmlComponent;
+  if (verbose2) {
+    logger2?.info(
+      `[loadComponentsWithCache] pagePath=${pagePath}, propsPath=${propsPath}, url=${url}`
+    );
+  }
+  if (pagePath) {
+    if (verbose2) {
+      logger2?.info(
+        `[loadComponentsWithCache] Loading page and props for pagePath=${pagePath}`
+      );
+    }
+    const pageId = `${pagePath}#${pageExportName}`;
+    const isPageInvalidated = isModuleInvalidated(pagePath);
+    let needToLoadProps = false;
+    if (hasCachedComponent(pageId) && !isPageInvalidated) {
+      PageComponent = getCachedComponent(pageId);
+      if (verbose2) {
+        logger2?.info(
+          `[rsc-worker] Using cached Page component from: ${pagePath}`
+        );
+      }
+      if (propsPath && !resolvedPageProps) {
+        const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;
+        const isPropsInvalidated = isModuleInvalidated(propsPath);
+        if (hasCachedComponent(propsId) && !isPropsInvalidated) {
+          pageProps = getCachedComponent(propsId);
+          if (verbose2) {
+            logger2?.info(
+              `[rsc-worker] Using cached pageProps from: ${propsPath} for URL: ${url}`
+            );
+          }
+        } else {
+          if (isPropsInvalidated && hasCachedComponent(propsId)) {
+            clearCachedComponent(propsId);
+          }
+          needToLoadProps = true;
+        }
+      } else if (resolvedPageProps) {
+        if (verbose2) {
+          logger2?.info(
+            `[rsc-worker] Using pre-resolved pageProps from main thread: ${Object.keys(resolvedPageProps).length} keys`
+          );
+        }
+      }
+    } else {
+      if (isPageInvalidated && hasCachedComponent(pageId)) {
+        clearCachedComponent(pageId);
+        if (verbose2) {
+          logger2?.info(
+            `[rsc-worker] Cleared invalidated Page component cache: ${pagePath}`
+          );
+        }
+      }
+      if (propsPath && isPageInvalidated) {
+        const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;
+        if (hasCachedComponent(propsId)) {
+          clearCachedComponent(propsId);
+        }
+      }
+      try {
+        const pageAndPropsResult = await resolvePageAndProps({
+          pagePath,
+          propsPath,
+          pageExportName,
+          propsExportName,
+          url: normalizedUrl,
+          loader,
+          verbose: verbose2 || false,
+          logger: logger2
+        });
+        if (verbose2) {
+          logger2?.info(
+            `[loadComponentsWithCache] pageAndPropsResult for ${pagePath}:`,
+            pageAndPropsResult
+          );
+        }
+        if (pageAndPropsResult.type === "success") {
+          PageComponent = pageAndPropsResult.PageComponent;
+          if (!resolvedPageProps) {
+            pageProps = pageAndPropsResult.pageProps;
+          }
+          cacheComponent(pageId, PageComponent);
+          if (propsPath) {
+            const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;
+            cacheComponent(propsId, pageProps);
+          }
+          if (verbose2) {
+            logger2?.info(
+              `[rsc-worker] Loaded and cached PageComponent from: ${pagePath}`
+            );
+            if (propsPath) {
+              logger2?.info(
+                `[rsc-worker] Loaded and cached pageProps from: ${propsPath}`
+              );
+            }
+            if (verbose2) {
+              logger2?.info(`[rsc-worker] Loaded pageProps:`, pageProps);
+            }
+          }
+        } else {
+          if (verbose2) {
+            logger2?.warn(
+              `[rsc-worker] Failed to load page and props: ${pageAndPropsResult.error?.message}`
+            );
+          }
+          PageComponent = React.Fragment;
+          pageProps = {};
+        }
+      } catch (error) {
+        if (verbose2) {
+          logger2?.error(
+            `[loadComponentsWithCache] Failed to resolve page and props for ${pagePath}`,
+            { error }
+          );
+        }
+        PageComponent = React.Fragment;
+        pageProps = {};
+      }
+    }
+    if (needToLoadProps && propsPath) {
+      if (verbose2) {
+        logger2?.info(
+          `[rsc-worker] Loading props separately for URL: ${url} (Page was cached)`
+        );
+      }
+      try {
+        const pageAndPropsResult = await resolvePageAndProps({
+          pagePath,
+          propsPath,
+          pageExportName,
+          propsExportName,
+          url: normalizedUrl,
+          loader,
+          verbose: verbose2 || false,
+          logger: logger2
+        });
+        if (pageAndPropsResult.type === "success") {
+          pageProps = pageAndPropsResult.pageProps;
+          const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;
+          cacheComponent(propsId, pageProps);
+          if (verbose2) {
+            logger2?.info(
+              `[rsc-worker] Loaded and cached pageProps for URL: ${url}`
+            );
+          }
+        } else {
+          if (verbose2) {
+            logger2?.warn(
+              `[rsc-worker] Failed to load props for URL ${url}: ${pageAndPropsResult.error?.message}`
+            );
+          }
+          pageProps = {};
+        }
+      } catch (error) {
+        if (verbose2) {
+          logger2?.error(
+            `[rsc-worker] Error loading props for URL ${url}`,
+            { error }
+          );
+        }
+        pageProps = {};
+      }
+    }
+  }
+  if (rootPath) {
+    const rootId = `${rootPath}#${rootExportName}`;
+    const isRootInvalidated = isModuleInvalidated(rootPath);
+    if (hasCachedComponent(rootId) && !isRootInvalidated) {
+      RootComponent = getCachedComponent(rootId);
+      if (verbose2) {
+        logger2?.info(
+          `[rsc-worker] Using cached Root component from: ${rootPath}`
+        );
+      }
+    } else {
+      if (isRootInvalidated && hasCachedComponent(rootId)) {
+        clearCachedComponent(rootId);
+        if (verbose2) {
+          logger2?.info(
+            `[rsc-worker] Cleared invalidated Root component cache: ${rootPath}`
+          );
+        }
+      }
+      const rootResult = await resolveComponent({
+        componentPath: rootPath,
+        exportName: rootExportName,
+        loader
+      });
+      if (rootResult.type === "success") {
+        RootComponent = rootResult.component;
+        cacheComponent(rootId, RootComponent);
+        if (verbose2) {
+          logger2?.info(
+            `[rsc-worker] Loaded and cached Root component from: ${rootPath}`
+          );
+          logger2?.info(
+            `[rsc-worker] Root component type: ${typeof RootComponent}, isSymbol: ${typeof RootComponent === "symbol"}, keys: ${RootComponent ? Object.keys(RootComponent) : "null"}`
+          );
+        }
+      } else {
+        if (verbose2) {
+          logger2?.warn(
+            `[rsc-worker] Failed to load Root component: ${rootResult.error?.message}`
+          );
+        }
+        RootComponent = React.Fragment;
+      }
+    }
+  } else {
+    RootComponent = Root;
+    if (verbose2) {
+      logger2?.info(`[rsc-worker] Using built-in default Root component`);
+    }
+  }
+  if (verbose2) {
+    logger2?.info(`[rsc-worker] Html component resolution: htmlPath='${htmlPath}' (type: ${typeof htmlPath})`);
+  }
+  if (htmlPath === "") {
+    HtmlComponent = React.Fragment;
+    if (verbose2) {
+      logger2?.info(`[rsc-worker] Using headless Html component (empty string)`);
+    }
+  } else if (htmlPath === void 0) {
+    if (verbose2) {
+      logger2?.info(`[rsc-worker] htmlPath is undefined, using default Html component`);
+    }
+    try {
+      const { Html } = await import('../../components/html.js');
+      HtmlComponent = Html;
+      if (verbose2) {
+        logger2?.info(`[rsc-worker] Successfully loaded default Html component`);
+      }
+    } catch (error) {
+      logger2?.warn(
+        `[rsc-worker] Error loading default Html component: ${error instanceof Error ? error.message : String(error)}`
+      );
+      HtmlComponent = React.Fragment;
+    }
+  } else if (htmlPath) {
+    if (verbose2) {
+      logger2?.info(`[rsc-worker] Attempting to load custom Html component from: ${htmlPath}`);
+    }
+    const htmlId = `${htmlPath}#${htmlExportName}`;
+    const isHtmlInvalidated = isModuleInvalidated(htmlPath);
+    if (hasCachedComponent(htmlId) && !isHtmlInvalidated) {
+      HtmlComponent = getCachedComponent(htmlId);
+      if (verbose2) {
+        logger2?.info(
+          `[rsc-worker] Using cached Html component from: ${htmlPath}`
+        );
+      }
+    } else {
+      if (isHtmlInvalidated && hasCachedComponent(htmlId)) {
+        clearCachedComponent(htmlId);
+        if (verbose2) {
+          logger2?.info(
+            `[rsc-worker] Cleared invalidated Html component cache: ${htmlPath}`
+          );
+        }
+      }
+      if (verbose2) {
+        logger2?.info(`[rsc-worker] Component not cached, calling resolveComponent with path: ${htmlPath}, exportName: ${htmlExportName}`);
+      }
+      const htmlResult = await resolveComponent({
+        componentPath: htmlPath,
+        exportName: htmlExportName,
+        loader
+      });
+      if (htmlResult.type === "success") {
+        HtmlComponent = htmlResult.component;
+        cacheComponent(htmlId, HtmlComponent);
+        if (verbose2) {
+          logger2?.info(
+            `[rsc-worker] Loaded and cached Html component from: ${htmlPath}`
+          );
+        }
+      } else {
+        if (verbose2) {
+          logger2?.warn(
+            `[rsc-worker] Failed to load Html component from ${htmlPath}: ${htmlResult.error?.message || "Unknown error"}`
+          );
+          logger2?.warn(`[rsc-worker] Html resolution error details:`, htmlResult.error);
+        }
+        HtmlComponent = React.Fragment;
+      }
+    }
+  } else {
+    try {
+      const { Html } = await import('../../components/html.js');
+      HtmlComponent = Html;
+      if (verbose2) {
+        logger2?.info(`[rsc-worker] Using default Html component`);
+      }
+    } catch (error) {
+      logger2?.warn(
+        `[rsc-worker] Error loading default Html component: ${error}`
+      );
+    }
+  }
+  return { PageComponent, pageProps, RootComponent, HtmlComponent };
+}
+let storedFromWorker;
+let storedToWorker;
+async function messageHandler(msg) {
+  if (msg.type === "INIT") {
+    storedFromWorker = msg.dataPort;
+    storedToWorker = msg.controlPort;
+    if (storedFromWorker) {
+      setMaxListenersOnPort(storedFromWorker, 500);
+    }
+    if (storedToWorker) {
+      setMaxListenersOnPort(storedToWorker, 500);
+    }
+  }
+  const effectiveHandlers = createHandlers(storedFromWorker, storedToWorker);
   try {
-    if (!port) {
-      throw new Error("No port found");
+    if (verbose) {
+      logger.info(
+        `[rsc-worker] Received message: ${msg.type} for id: ${msg.id}`
+      );
     }
     switch (msg.type) {
-      case "RSC_RENDER":
-        return await handleRender(msg, handlers, logger);
-      case "SERVER_ACTION":
-        return handlers.onServerAction(msg.id, msg.args);
+      case "INIT":
+        const currentStreamId = msg.options.id || msg.id;
+        const renderUserOptions = workerUserOptions(msg.options);
+        setRenderUserOptions(currentStreamId, renderUserOptions);
+        if (verbose) {
+          logger?.info(
+            `[INIT] Set render state for renderId: ${currentStreamId}`
+          );
+          logger?.info(
+            `[INIT] renderUserOptions.build: ${JSON.stringify(
+              renderUserOptions.build
+            )}`
+          );
+        }
+        const userOptions = renderUserOptions;
+        cleanupRender(currentStreamId);
+        const isHeadless = msg.options.htmlPath === "";
+        const rscVariant = isHeadless ? "rsc-headless" : "rsc-full";
+        if (verbose) {
+          logger.info(
+            `[rsc-worker] Processing ${rscVariant} render for route: ${msg.options.route} with ID: ${currentStreamId}`
+          );
+        }
+        const rscStream = msg.rscStream || new PassThrough();
+        activeRenders.set(currentStreamId, rscStream);
+        const moduleResolutionStartTime = performance.now();
+        const projectRoot = msg.options.projectRoot || userOptions.projectRoot || workerData.userOptions?.projectRoot || process.cwd();
+        const buildConfig = {
+          server: msg.options.build?.server || userOptions.build?.server || DEFAULT_CONFIG.BUILD.server,
+          client: msg.options.build?.client || userOptions.build?.client || DEFAULT_CONFIG.BUILD.client,
+          static: msg.options.build?.static || userOptions.build?.static || DEFAULT_CONFIG.BUILD.static,
+          outDir: msg.options.build?.outDir || userOptions.build?.outDir || DEFAULT_CONFIG.BUILD.outDir,
+          assetsDir: msg.options.build?.assetsDir || userOptions.build?.assetsDir || DEFAULT_CONFIG.BUILD.assetsDir,
+          rscOutputPath: msg.options.build?.rscOutputPath || userOptions.build?.rscOutputPath || DEFAULT_CONFIG.BUILD.rscOutputPath,
+          htmlOutputPath: msg.options.build?.htmlOutputPath || userOptions.build?.htmlOutputPath || DEFAULT_CONFIG.BUILD.htmlOutputPath,
+          preserveModulesRoot: msg.options.build?.preserveModulesRoot || userOptions.build?.preserveModulesRoot || DEFAULT_CONFIG.BUILD.preserveModulesRoot
+        };
+        const serverManifest = workerData.serverManifest || msg.options.manifest || {};
+        if (verbose) {
+          logger?.info(
+            `[rsc-worker:${msg.options.route}] 
+msg.options.build: ${JSON.stringify(msg.options.build)}
+msg.options.route
+userOptions.build: ${JSON.stringify(userOptions.build)}
+final buildConfig: ${JSON.stringify(buildConfig)}`
+          );
+        }
+        const loader = createRscWorkerLoader({
+          verbose: msg.options.verbose ?? workerData.userOptions.verbose,
+          logger,
+          projectRoot,
+          manifest: serverManifest,
+          build: buildConfig
+          // bundle: workerData.bundle || {},
+        });
+        const url = msg.options.url || routeToURL(
+          msg.options.route,
+          userOptions.moduleBaseURL,
+          userOptions.build?.rscOutputPath ?? DEFAULT_CONFIG.BUILD.rscOutputPath
+        );
+        if (verbose) {
+          logger?.info(`[rsc-worker:messageHandler] Component paths for route ${msg.options.route}:`);
+          logger?.info(`  pagePath: ${msg.options.pagePath}`);
+          logger?.info(`  propsPath: ${msg.options.propsPath}`);
+          logger?.info(`  rootPath: ${msg.options.rootPath}`);
+          logger?.info(`  htmlPath: ${msg.options.htmlPath}`);
+        }
+        const { PageComponent, pageProps, RootComponent, HtmlComponent } = await loadComponentsWithCache({
+          pagePath: msg.options.pagePath,
+          propsPath: msg.options.propsPath,
+          rootPath: msg.options.rootPath,
+          htmlPath: msg.options.htmlPath,
+          pageExportName: msg.options.pageExportName ?? userOptions.pageExportName,
+          propsExportName: msg.options.propsExportName ?? userOptions.propsExportName,
+          rootExportName: msg.options.rootExportName ?? userOptions.rootExportName,
+          htmlExportName: msg.options.htmlExportName ?? userOptions.htmlExportName,
+          url,
+          loader,
+          verbose,
+          logger,
+          resolvedPageProps: msg.options.resolvedPageProps
+          // Pre-resolved from main thread
+        });
+        if (verbose) {
+          logger.info(
+            `[rsc-worker] Loaded components for route ${msg.options.route}:`
+          );
+          logger.info(`[rsc-worker] - PageComponent: ${typeof PageComponent}`);
+          logger.info(`[rsc-worker] - pageProps: ${JSON.stringify(pageProps)}`);
+          logger.info(`[rsc-worker] - RootComponent: ${typeof RootComponent}`);
+          logger.info(`[rsc-worker] - HtmlComponent: ${typeof HtmlComponent}`);
+        }
+        const moduleResolutionTime = performance.now() - moduleResolutionStartTime;
+        if (effectiveHandlers.onMetrics) {
+          const moduleResolutionMetric = createModuleResolutionMetrics({
+            route: msg.options.route,
+            workerType: "rsc",
+            resolutionTime: moduleResolutionTime,
+            fromMainThread: false,
+            fromRscWorker: true,
+            fromHtmlWorker: false,
+            description: `Module resolution for route ${msg.options.route}`
+          });
+          effectiveHandlers.onMetrics(msg.id, moduleResolutionMetric);
+        }
+        const messageCssFiles = new Map(msg.options.cssFiles || []);
+        processInlineCssForState(
+          messageCssFiles,
+          addCssFileContent,
+          userOptions
+        );
+        const combinedCssFiles = combineCssFiles(cssFiles, messageCssFiles);
+        const handlerOptions = {
+          route: msg.options.route,
+          url,
+          pageProps,
+          PageComponent,
+          RootComponent,
+          HtmlComponent,
+          cssFiles: combinedCssFiles,
+          globalCss: msg.options.globalCss ?? /* @__PURE__ */ new Map(),
+          manifest: msg.options.manifest || {},
+          projectRoot: userOptions.projectRoot || workerData.userOptions?.projectRoot || process.cwd(),
+          moduleBase: userOptions.moduleBase || workerData.userOptions?.moduleBase || DEFAULT_CONFIG.MODULE_BASE,
+          moduleBasePath: userOptions.moduleBasePath || workerData.userOptions?.moduleBasePath || DEFAULT_CONFIG.MODULE_BASE_PATH,
+          moduleBaseURL: userOptions.moduleBaseURL || workerData.userOptions?.moduleBaseURL || DEFAULT_CONFIG.MODULE_BASE_URL,
+          moduleRootPath: userOptions.moduleRootPath || workerData.userOptions?.moduleRootPath,
+          verbose: msg.options.verbose || verbose,
+          logger,
+          panicThreshold: msg.options.panicThreshold || "none",
+          rscTimeout: msg.options.rscTimeout,
+          serverPipeableStreamOptions: (() => {
+            const options = msg.options.serverPipeableStreamOptions || workerData.userOptions?.serverPipeableStreamOptions;
+            if (verbose) {
+              logger.info(
+                `[rsc-worker] ${isHeadless ? "Headless" : "Full"} stream serverPipeableStreamOptions: ${JSON.stringify(
+                  options
+                )}`
+              );
+            }
+            return options;
+          })()
+        };
+        let result;
+        const headlessError = headlessStreamErrors.get(msg.options.route);
+        const shouldUseFallback = headlessError && !isHeadless;
+        if (isHeadless) {
+          headlessStreamErrors.delete(msg.options.route);
+        }
+        const shouldReuseElements = !isHeadless && msg.options.reuseHeadlessStreamId;
+        let reusableElements = null;
+        if (shouldReuseElements && msg.options.reuseHeadlessStreamId) {
+          reusableElements = headlessStreamElements.get(
+            msg.options.reuseHeadlessStreamId
+          );
+          if (verbose) {
+            if (reusableElements) {
+              logger.info(
+                `[rsc-worker] Found reusable elements from headless stream ${msg.options.reuseHeadlessStreamId}`
+              );
+            } else if (msg.options.reuseHeadlessStreamId) {
+              logger.info(
+                `[rsc-worker] No reusable elements found for headless stream ${msg.options.reuseHeadlessStreamId}`
+              );
+            }
+          }
+        }
+        const isStaticGeneration = msg.options.build && (msg.options.build.outDir || msg.options.build.static);
+        if (verbose) {
+          logger.info(
+            `[rsc-worker] Route: ${msg.options.route}, isHeadless: ${isHeadless}, isStaticGeneration: ${isStaticGeneration}`
+          );
+          logger.info(
+            `[rsc-worker] msg.options.build: ${JSON.stringify(
+              msg.options.build
+            )}`
+          );
+        }
+        if (shouldUseFallback) {
+          if (verbose) {
+            logger.info(
+              `[rsc-worker] Using fallback components due to previous error: ${headlessError.message}`
+            );
+          }
+          const fallbackHandlerOptions = {
+            ...handlerOptions,
+            PageComponent: React.Fragment
+            // Keep the original HtmlComponent to ensure bootstrapScripts are rendered
+          };
+          result = handleRscRender(
+            {
+              ...fallbackHandlerOptions,
+              id: currentStreamId,
+              reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId
+            },
+            effectiveHandlers,
+            void 0,
+            headlessStreamElements,
+            headlessStreamErrors
+          );
+        } else {
+          try {
+            if (isHeadless) {
+              if (verbose) {
+                logger.info(
+                  `[rsc-worker] Creating headless RSC stream for route ${msg.options.route} (no HTML wrapper)`
+                );
+              }
+              const headlessHandlerOptions = {
+                ...handlerOptions,
+                HtmlComponent: React.Fragment
+                // Headless RSC - no HTML wrapper
+              };
+              result = handleRscRender(
+                {
+                  ...headlessHandlerOptions,
+                  id: currentStreamId,
+                  reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId
+                },
+                effectiveHandlers,
+                void 0,
+                headlessStreamElements,
+                headlessStreamErrors
+              );
+            } else {
+              if (shouldReuseElements && reusableElements) {
+                if (verbose) {
+                  logger.info(
+                    `[rsc-worker] Creating full RSC stream with reused elements from headless stream for route ${msg.options.route}`
+                  );
+                }
+                const reuseHandlerOptions = {
+                  ...handlerOptions,
+                  PageComponent: () => reusableElements
+                  // Reuse the headless stream's elements
+                };
+                result = handleRscRender(
+                  {
+                    ...reuseHandlerOptions,
+                    id: currentStreamId,
+                    reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId
+                  },
+                  effectiveHandlers,
+                  void 0,
+                  headlessStreamElements,
+                  headlessStreamErrors
+                );
+              } else {
+                if (verbose) {
+                  logger.info(
+                    `[rsc-worker] Creating full RSC stream for route ${msg.options.route} (no element reuse)`
+                  );
+                }
+                result = handleRscRender(
+                  {
+                    ...handlerOptions,
+                    id: currentStreamId,
+                    reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId
+                  },
+                  effectiveHandlers,
+                  void 0,
+                  headlessStreamElements,
+                  headlessStreamErrors
+                );
+              }
+            }
+          } catch (error) {
+            if (verbose) {
+              logger.warn(
+                `[rsc-worker] Original PageComponent failed during creation for route ${msg.options.route}: ${error}`
+              );
+            }
+            const fallbackHandlerOptions = {
+              ...handlerOptions,
+              PageComponent: React.Fragment
+              // Keep the original HtmlComponent to ensure bootstrapScripts are rendered
+            };
+            result = handleRscRender(
+              {
+                ...fallbackHandlerOptions,
+                id: currentStreamId,
+                reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId
+              },
+              effectiveHandlers,
+              void 0,
+              headlessStreamElements,
+              headlessStreamErrors
+            );
+          }
+        }
+        if (verbose) {
+          logger.info(
+            `[rsc-worker] Processing single-use stream ${currentStreamId} for route: ${msg.options.route}`
+          );
+        }
+        clearHeadlessError(msg.options.route);
+        return result;
+      case "RESOLVE_COMPONENTS": {
+        const resolutionStartTime = performance.now();
+        const resolveUserOptions = getUserOptions(msg.id);
+        try {
+          if (verbose) {
+            logger.info(
+              `[rsc-worker] Resolving components for route: ${msg.route}`
+            );
+            logger.info(`[rsc-worker] pagePath: ${msg.pagePath}`);
+            logger.info(`[rsc-worker] propsPath: ${msg.propsPath}`);
+            logger.info(`[rsc-worker] rootPath: ${msg.rootPath}`);
+            logger.info(`[rsc-worker] htmlPath: ${msg.htmlPath}`);
+          }
+          if (verbose) {
+            logger?.info(
+              `[rsc-worker:${msg.route}] pagePath=${msg.pagePath}, propsPath=${msg.propsPath}`
+            );
+          }
+          const buildConfig2 = {
+            server: resolveUserOptions.build?.server || "server",
+            client: resolveUserOptions.build?.client || "client",
+            static: resolveUserOptions.build?.static || "static",
+            outDir: resolveUserOptions.build?.outDir || "dist"
+          };
+          if (verbose) {
+            logger?.info(
+              `[RESOLVE_COMPONENTS] Using outDir: ${buildConfig2.outDir}`
+            );
+            logger?.info(
+              `[RESOLVE_COMPONENTS] renderId: ${msg.id}, hasRenderState: ${renderStates.has(msg.id)}`
+            );
+            if (renderStates.has(msg.id)) {
+              const renderState = renderStates.get(msg.id);
+              logger?.info(
+                `[RESOLVE_COMPONENTS] renderState.initialized: ${renderState.initialized}`
+              );
+              logger?.info(
+                `[RESOLVE_COMPONENTS] renderState.userOptions.build: ${JSON.stringify(
+                  renderState.userOptions.build
+                )}`
+              );
+            }
+          }
+          const loader2 = createRscWorkerLoader({
+            verbose,
+            logger,
+            projectRoot: workerData.userOptions?.projectRoot,
+            manifest: workerData.serverManifest || {},
+            build: buildConfig2
+          });
+          await loadComponentsWithCache({
+            pagePath: msg.pagePath,
+            propsPath: msg.propsPath,
+            rootPath: msg.rootPath,
+            htmlPath: msg.htmlPath,
+            pageExportName: msg.pageExportName || "default",
+            propsExportName: msg.propsExportName || "props",
+            rootExportName: msg.rootExportName || "Root",
+            htmlExportName: msg.htmlExportName || "Html",
+            url: `/${msg.route}`,
+            // Simple URL for component resolution
+            loader: loader2,
+            verbose,
+            logger
+          });
+          const resolutionTime = performance.now() - resolutionStartTime;
+          if (verbose) {
+            logger.info(
+              `[rsc-worker] Components resolved for route: ${msg.route} in ${resolutionTime.toFixed(2)}ms`
+            );
+          }
+          const response = {
+            type: "COMPONENTS_RESOLVED",
+            id: msg.id,
+            route: msg.route,
+            resolutionTime
+          };
+          parentPort?.postMessage(response);
+        } catch (error) {
+          logger.error(
+            `[rsc-worker] Failed to resolve components for route ${msg.route}: ${error}`
+          );
+          effectiveHandlers.onError(msg.id, toError(error), {
+            route: msg.route,
+            context: `Component resolution failed for route ${msg.route}`
+          });
+        }
+        return;
+      }
+      case "SERVER_ACTION": {
+        try {
+          const serverActionUserOptions = getUserOptions();
+          const [filePath2, exportName] = msg.id.split("#");
+          if (!filePath2 || !exportName) {
+            throw new Error(
+              `Invalid server action ID format: ${msg.id}. Expected format: "path/to/file.ts#exportName"`
+            );
+          }
+          const actionPath = filePath2.startsWith(
+            serverActionUserOptions.moduleBasePath
+          ) ? filePath2.slice(serverActionUserOptions.moduleBasePath.length) : filePath2;
+          const fullPath = join(
+            workerData.userOptions?.projectRoot,
+            actionPath
+          );
+          const module = await import(fullPath);
+          const action = module[exportName];
+          if (typeof action !== "function") {
+            throw new Error(`Server action not found: ${msg.id}`);
+          }
+          let decodedArgs = msg.args;
+          if (msg.args.length === 1 && typeof msg.args[0] === "string") {
+            try {
+              const moduleBasePath = serverActionUserOptions.moduleBasePath ?? "/";
+              decodedArgs = await decodeReply(msg.args[0], moduleBasePath);
+              if (verbose) {
+                logger?.info(`[rsc-worker] Decoded server action args: ${JSON.stringify(decodedArgs)}`);
+              }
+            } catch {
+              if (verbose) {
+                logger?.info(`[rsc-worker] Using raw server action args`);
+              }
+            }
+          }
+          const result2 = await action(...decodedArgs);
+          effectiveHandlers.onServerActionResponse?.(msg.id, result2);
+        } catch (error) {
+          const errorMessage = toError(error).message;
+          effectiveHandlers.onServerActionResponse?.(
+            msg.id,
+            void 0,
+            errorMessage
+          );
+        }
+        return;
+      }
       case "INITIALIZED_REACT_LOADER":
       case "INITIALIZED_CSS_LOADER":
       case "INITIALIZED_ENV_LOADER":
         return;
       case "HMR_UPDATE":
-        hmrState.set(msg.id, {
+        const filePath = msg.path || msg.id;
+        const hmrProjectRoot = workerData.userOptions?.projectRoot || process.cwd();
+        const normalizedPath = filePath.startsWith(hmrProjectRoot) ? relative(hmrProjectRoot, filePath) : filePath;
+        hmrState.set(normalizedPath, {
           timestamp: msg.timestamp || Date.now(),
           invalidated: true,
           routes: msg.routes || []
         });
-        handlers.onHmrUpdate(msg.id, msg.routes || []);
+        logger?.info(
+          `[rsc-worker] HMR_UPDATE: Invalidated module ${normalizedPath} (from ${filePath})`
+        );
+        if (headlessStreamElements.size > 0) {
+          if (verbose) {
+            logger?.info(
+              `[rsc-worker] HMR_UPDATE: Clearing ${headlessStreamElements.size} cached headless stream elements`
+            );
+          }
+          headlessStreamElements.clear();
+        }
+        clearAllCachedComponents();
+        if (verbose) {
+          logger?.info(
+            `[rsc-worker] HMR_UPDATE: Cleared all cached components from temporaryReferences`
+          );
+        }
+        headlessStreamErrors.clear();
+        effectiveHandlers.onHmrUpdate(normalizedPath, msg.routes || []);
+        return;
+      case "ABORT":
         return;
       case "HMR_CLEANUP":
         hmrState.delete(msg.id);
-        handlers.onHmrAccept(msg.id, msg.routes || []);
+        effectiveHandlers.onHmrAccept(msg.id, msg.routes || []);
         return;
       case "CSS_FILE":
-        handlers.onCssFile(msg.id, msg.content);
+        if (msg.id) {
+          const cssFileUserOptions = getUserOptions();
+          addCssFileContent(msg.id, msg.content, cssFileUserOptions);
+        }
+        effectiveHandlers.onCssFile?.(msg.id, msg.content);
         return;
       case "SERVER_MODULE":
-        handlers.onServerModule(msg.id, msg.url, msg.source);
+        addModuleId(msg.id, msg.url);
+        effectiveHandlers.onServerModule?.(msg.id, msg.url, msg.source);
         return;
       case "MODULE_REQUEST": {
         const { id, path } = msg;
         try {
-          const module = await import(join(workerData.userOptions.projectRoot, path));
-          handlers.onServerModule(id, path, module);
+          const module = await import(join(workerData.userOptions?.projectRoot, path));
+          effectiveHandlers.onServerModule?.(id, path, module);
         } catch (error) {
-          handlers.onError(id, toError(error));
+          effectiveHandlers.onError(id, toError(error));
         }
         return;
       }
       case "SHUTDOWN": {
-        if (msg.id === "*") {
-          activeStreams.forEach((stream, renderId) => {
-            stream.end();
-            activeStreams.delete(renderId);
-          });
-          parentPort?.removeAllListeners();
-        } else {
-          activeStreams.delete(msg.id);
+        effectiveHandlers.onShutdown?.(msg.id);
+        if (parentPort) {
+          sendMessage(
+            {
+              type: "SHUTDOWN_COMPLETE",
+              id: msg.id
+            },
+            parentPort
+          );
         }
-        handlers.onShutdown(msg.id);
         return;
       }
       default: {
-        console.log("Unknown message", msg);
+        logger.info(`Unknown message: ${msg.type}`);
         return;
       }
     }
   } catch (error) {
-    const err = toError(error);
-    if (parentPort) {
-      sendMessage({
-        type: "ERROR",
-        id: "rsc-worker",
-        error: err
-      }, port);
-    }
-    if (!isDevEnv || isTestEnv) {
-      throw err;
-    } else {
-      logError(err, logger);
-    }
+    effectiveHandlers.onError("worker/rsc", toError(error));
+    effectiveHandlers.onShutdown?.("*");
   }
 }
 
 export { messageHandler };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"messageHandler.js","sources":["../../../../plugin/worker/rsc/messageHandler.tsx"],"sourcesContent":["import { parentPort } from \"node:worker_threads\";\nimport { activeStreams, hmrState } from \"./state.js\";\nimport { handleRender } from \"./handleRender.js\";\nimport type { RscWorkerInputMessage } from \"./types.js\";\nimport { toError } from \"../../error/toError.js\";\nimport { handlers } from \"./handlers.js\";\nimport { join } from \"node:path\";\nimport { workerData } from \"node:worker_threads\";\nimport { sendMessage } from \"../sendMessage.js\";\nimport { createLogger } from \"vite\";\nimport { logError } from \"../../error/logError.js\";\n\n// In test mode, we want errors to propagate up immediately\nconst isTestEnv = process.env[\"VITEST\"] || process.env[\"NODE_ENV\"] === \"test\";\nconst isDevEnv = process.env[\"NODE_ENV\"] !== \"production\";\n\nconst logger = createLogger(workerData.resolvedConfig.logLevel ?? 'info');\n\nexport async function messageHandler(\n  msg: RscWorkerInputMessage,\n  port = parentPort\n) {\n  try {\n    if (!port) {\n      throw new Error(\"No port found\");\n    }\n    switch (msg.type) {\n      case \"RSC_RENDER\":\n        return await handleRender(msg, handlers, logger);\n      case \"SERVER_ACTION\":\n        return handlers.onServerAction(msg.id, msg.args);\n      case \"INITIALIZED_REACT_LOADER\":\n      case \"INITIALIZED_CSS_LOADER\":\n      case \"INITIALIZED_ENV_LOADER\":\n        return;\n      case \"HMR_UPDATE\":\n        // Mark the module as invalidated\n        hmrState.set(msg.id, {\n          timestamp: msg.timestamp || Date.now(),\n          invalidated: true,\n          routes: msg.routes || [],\n        });\n        // Notify the main thread that we've processed the update\n        handlers.onHmrUpdate(msg.id, msg.routes || []);\n        return;\n      case \"HMR_CLEANUP\":\n        // Clear the invalidation state\n        hmrState.delete(msg.id);\n        // Notify the main thread that we've processed the cleanup\n        handlers.onHmrAccept(msg.id, msg.routes || []);\n        return;\n      case \"CSS_FILE\":\n        handlers.onCssFile(msg.id, msg.content);\n        return;\n      case \"SERVER_MODULE\":\n        handlers.onServerModule(msg.id, msg.url, msg.source);\n        return;\n      case \"MODULE_REQUEST\": {\n        const { id, path } = msg;\n        try {\n          const module = await import(join(workerData.userOptions.projectRoot, path));\n          handlers.onServerModule(id, path, module);\n        } catch (error) {\n          handlers.onError(id, toError(error));\n        }\n        return;\n      }\n      case \"SHUTDOWN\": {\n        // If id is \"*\", clean up all render states\n        if (msg.id === \"*\") {\n          activeStreams.forEach((stream, renderId) => {\n            stream.end();\n            activeStreams.delete(renderId);\n          });\n          parentPort?.removeAllListeners();\n        } else {\n          activeStreams.delete(msg.id);\n        }\n        handlers.onShutdown(msg.id);\n        return;\n      }\n      default: {\n        console.log(\"Unknown message\", msg);\n        return;\n      }\n    }\n  } catch (error) {\n    const err = toError(error);\n    // In dev mode, try to send error message before exiting\n    if (parentPort) {\n      sendMessage({\n        type: \"ERROR\",\n        id: \"rsc-worker\",\n        error: err,\n      }, port);\n    }\n    if (!isDevEnv || isTestEnv) {\n      // In test mode or production mode, just throw the error to fail fast\n      throw err;\n    } else {\n      logError(err, logger);\n    }\n  }\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"messageHandler.js","sources":["../../../../plugin/worker/rsc/messageHandler.tsx"],"sourcesContent":["import { parentPort, workerData } from \"node:worker_threads\";\nimport { PassThrough } from \"node:stream\";\nimport { createLogger } from \"vite\";\nimport { join, relative } from \"node:path\";\nimport { createRscWorkerLoader } from \"./createRscWorkerLoader.js\";\nimport { handleRscRender } from \"./handleRscRender.js\";\nimport { setMaxListenersOnPort } from \"../../stream/setMaxListeners.js\";\nimport type {\n  RscWorkerInputMessage,\n  ComponentsResolvedMessage,\n} from \"./types.js\";\nimport { toError } from \"../../error/toError.js\";\n// Import decodeReply for server action argument decoding\nimport { decodeReply } from \"react-server-dom-esm/server\";\n\nimport { createHandlers } from \"./handlers.js\";\nimport {\n  addCssFileContent,\n  addModuleId,\n  cssFiles,\n  hmrState,\n  cacheComponent,\n  getCachedComponent,\n  hasCachedComponent,\n  clearCachedComponent,\n  isModuleInvalidated,\n  clearAllCachedComponents,\n} from \"./state.js\";\nimport {\n  combineCssFiles,\n  processInlineCssForState,\n} from \"../../helpers/createUnifiedCssProcessor.js\";\nimport { routeToURL } from \"../../utils/routeToURL.js\";\nimport { DEFAULT_CONFIG } from \"../../config/defaults.js\";\nimport { resolvePageAndProps } from \"../../helpers/resolvePageAndProps.js\";\nimport { resolveComponent } from \"../../helpers/resolveComponent.js\";\nimport { Root as DefaultRoot } from \"../../components/root.js\";\nimport { workerUserOptions } from \"./workerUserOptions.js\";\nimport { hydrateUserOptions } from \"../../helpers/hydrateUserOptions.js\";\nimport { React } from \"../../vendor/vendor.server.js\";\nimport { sendMessage } from \"../sendMessage.js\";\nimport { createModuleResolutionMetrics } from \"../../metrics/createModuleResolutionMetrics.js\";\n\nconst logger = createLogger(workerData.resolvedConfig?.logLevel ?? \"info\");\nconst verbose = workerData.userOptions.verbose ?? false;\n\n// Add uncaught exception handler to catch React rendering errors\nprocess.on(\"uncaughtException\", (error) => {\n  if (verbose) {\n    logger?.error(`[RSC-WORKER] Uncaught exception: ${error.message}`, {\n      error,\n    });\n  }\n\n  // Send error through control port if we have active handlers\n  if (parentPort) {\n    parentPort.postMessage({\n      type: \"ERROR\",\n      id: \"uncaught-exception\",\n      error: {\n        message: error.message,\n        stack: error.stack,\n        name: error.name,\n      },\n      context: \"Uncaught Exception in RSC Worker\",\n    });\n  }\n\n  // Exit the worker with error code\n  process.exit(1);\n});\n\n// Render state to track user options per render ID\nconst renderStates = new Map<\n  string,\n  {\n    userOptions: any;\n    initialized: boolean;\n  }\n>();\n\n// Cache for fallback user options to avoid re-hydrating\nlet fallbackUserOptions: any = null;\n\n// Helper function to get user options for a specific render\nfunction getUserOptions(renderId?: string) {\n  // If we have a render ID and it's initialized, use the render-specific options\n  if (renderId && renderStates.has(renderId)) {\n    const renderState = renderStates.get(renderId)!;\n    if (renderState.initialized) {\n      return renderState.userOptions;\n    }\n  }\n\n  // Use cached fallback if available\n  if (fallbackUserOptions) {\n    return fallbackUserOptions;\n  }\n\n  // Fallback to workerData userOptions if no render-specific options are available\n  const userOptionsResult = hydrateUserOptions(workerData.userOptions);\n  if (userOptionsResult.type === \"error\") {\n    throw userOptionsResult.error;\n  }\n  // Cache the result\n  fallbackUserOptions = userOptionsResult.userOptions;\n  if (verbose) {\n    logger?.info(\n      `[FALLBACK] Using fallback userOptions for renderId: ${\n        renderId || \"none\"\n      }`\n    );\n    logger?.info(\n      `[FALLBACK] fallbackUserOptions.build: ${JSON.stringify(\n        fallbackUserOptions.build\n      )}`\n    );\n  }\n  return fallbackUserOptions;\n}\n\n// Helper function to set user options for a specific render\nfunction setRenderUserOptions(renderId: string, userOptions: any) {\n  renderStates.set(renderId, {\n    userOptions,\n    initialized: true,\n  });\n}\n\n// Helper function to cleanup render state\nfunction cleanupRenderState(renderId: string) {\n  renderStates.delete(renderId);\n}\n\n// Track active renders - store the RSC stream for each unique render (id)\nconst activeRenders = new Map<string, PassThrough>();\n\n// Global variable to store the correct build configuration from INIT case\n// let correctBuildConfig: any = null;\n\n// Track active streams by route for reuse\nconst activeStreamsByRoute = new Map<string, string>(); // route -> streamId\n\n// Track headless stream elements by stream ID for reuse in full streams\nconst headlessStreamElements = new Map<string, any>(); // streamId -> React elements\n\n// Track headless stream errors by route for full stream error propagation\nconst headlessStreamErrors = new Map<string, Error>(); // route -> error\n\n\nfunction cleanupRender(id: string) {\n  const rscStream = activeRenders.get(id);\n  if (rscStream) {\n    rscStream.destroy();\n    activeRenders.delete(id);\n\n    // Clean up route mapping\n    for (const [route, streamId] of activeStreamsByRoute.entries()) {\n      if (streamId === id) {\n        activeStreamsByRoute.delete(route);\n        break;\n      }\n    }\n\n    // Clean up reusable elements only if we know which headless stream this full stream consumed\n    // The caller should tell us which headless stream to clean up, not infer from ID patterns\n    // Note: Element cleanup should be handled explicitly by the stream reuse system\n  }\n\n  // Clean up render state\n  cleanupRenderState(id);\n}\n\nfunction clearHeadlessError(route: string) {\n  headlessStreamErrors.delete(route);\n}\n\n/**\n * Helper function to load components with caching\n */\nasync function loadComponentsWithCache(options: {\n  pagePath?: string;\n  propsPath?: string;\n  rootPath?: string;\n  htmlPath?: string;\n  pageExportName?: string;\n  propsExportName?: string;\n  rootExportName?: string;\n  htmlExportName?: string;\n  url: string;\n  loader: any;\n  verbose?: boolean;\n  logger?: any;\n  resolvedPageProps?: Record<string, unknown>;  // Pre-resolved props from main thread\n}) {\n  const {\n    pagePath,\n    propsPath,\n    rootPath,\n    htmlPath,\n    pageExportName = \"Page\",\n    propsExportName = \"props\",\n    rootExportName = \"Root\",\n    htmlExportName = \"Html\",\n    url,\n    loader,\n    verbose,\n    logger,\n    resolvedPageProps,\n  } = options;\n  \n  // Normalize URL for cache key - ensure trailing slash for folder routes\n  // This ensures /8mmc/levels and /8mmc/levels/ use the same cache key\n  const normalizeUrlForCache = (urlStr: string): string => {\n    // Don't add trailing slash to paths with file extensions\n    if (urlStr.includes('.')) return urlStr;\n    return urlStr.endsWith('/') ? urlStr : urlStr + '/';\n  };\n  const normalizedUrl = normalizeUrlForCache(url);\n\n  let PageComponent: any;\n  let pageProps: any = resolvedPageProps;  // Use pre-resolved props if available\n  let RootComponent: any;\n  let HtmlComponent: any;\n\n  // Load page and props using the unified helper\n  if (verbose) {\n    logger?.info(\n      `[loadComponentsWithCache] pagePath=${pagePath}, propsPath=${propsPath}, url=${url}`\n    );\n  }\n  if (pagePath) {\n    if (verbose) {\n      logger?.info(\n        `[loadComponentsWithCache] Loading page and props for pagePath=${pagePath}`\n      );\n    }\n    \n    // CRITICAL: Check if Page module is invalidated before using cache\n    const pageId = `${pagePath}#${pageExportName}`;\n    const isPageInvalidated = isModuleInvalidated(pagePath);\n    \n    // Track if we need to load props separately (when Page is cached but props for this URL aren't)\n    let needToLoadProps = false;\n    \n    // Check cache first, but only if not invalidated\n    if (hasCachedComponent(pageId) && !isPageInvalidated) {\n      PageComponent = getCachedComponent(pageId);\n      if (verbose) {\n        logger?.info(\n          `[rsc-worker] Using cached Page component from: ${pagePath}`\n        );\n      }\n      \n      // Also check props cache if propsPath exists (skip if resolvedPageProps provided)\n      // CRITICAL: Include URL in cache key for props - dynamic routes return different props per URL\n      if (propsPath && !resolvedPageProps) {\n        const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;\n        const isPropsInvalidated = isModuleInvalidated(propsPath);\n        if (hasCachedComponent(propsId) && !isPropsInvalidated) {\n          pageProps = getCachedComponent(propsId);\n          if (verbose) {\n            logger?.info(\n              `[rsc-worker] Using cached pageProps from: ${propsPath} for URL: ${url}`\n            );\n          }\n        } else {\n          // Props invalidated or not cached for this URL - need to reload\n          if (isPropsInvalidated && hasCachedComponent(propsId)) {\n            clearCachedComponent(propsId);\n          }\n          // Mark that we need to load props separately\n          needToLoadProps = true;\n        }\n      } else if (resolvedPageProps) {\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] Using pre-resolved pageProps from main thread: ${Object.keys(resolvedPageProps).length} keys`\n          );\n        }\n      }\n    } else {\n      // Page invalidated or not cached - need to reload\n      if (isPageInvalidated && hasCachedComponent(pageId)) {\n        clearCachedComponent(pageId);\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] Cleared invalidated Page component cache: ${pagePath}`\n          );\n        }\n      }\n      \n      // Also clear props cache if page is invalidated\n      if (propsPath && isPageInvalidated) {\n        const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;\n        if (hasCachedComponent(propsId)) {\n          clearCachedComponent(propsId);\n        }\n      }\n      \n      // Reload page and props\n      try {\n        const pageAndPropsResult = await resolvePageAndProps({\n          pagePath,\n          propsPath,\n          pageExportName,\n          propsExportName,\n          url: normalizedUrl,\n          loader,\n          verbose: verbose || false,\n          logger,\n        });\n\n        if (verbose) {\n          logger?.info(\n            `[loadComponentsWithCache] pageAndPropsResult for ${pagePath}:`,\n            pageAndPropsResult\n          );\n        }\n\n        if (pageAndPropsResult.type === \"success\") {\n          PageComponent = pageAndPropsResult.PageComponent;\n          // Use pre-resolved props from main thread if available, otherwise use loaded props\n          if (!resolvedPageProps) {\n            pageProps = pageAndPropsResult.pageProps;\n          }\n\n          // Cache the components\n          cacheComponent(pageId, PageComponent);\n\n          if (propsPath) {\n            // CRITICAL: Include URL in cache key for props - dynamic routes return different props per URL\n            const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;\n            cacheComponent(propsId, pageProps);\n          }\n\n          if (verbose) {\n            logger?.info(\n              `[rsc-worker] Loaded and cached PageComponent from: ${pagePath}`\n            );\n            if (propsPath) {\n              logger?.info(\n                `[rsc-worker] Loaded and cached pageProps from: ${propsPath}`\n              );\n            }\n            if (verbose) {\n              logger?.info(`[rsc-worker] Loaded pageProps:`, pageProps);\n            }\n          }\n        } else {\n          // Handle component resolution failure gracefully (same as server environment)\n          if (verbose) {\n            logger?.warn(\n              `[rsc-worker] Failed to load page and props: ${pageAndPropsResult.error?.message}`\n            );\n          }\n          // Use React.Fragment as fallback (same as server environment)\n          PageComponent = React.Fragment;\n          pageProps = {};\n        }\n      } catch (error) {\n        if (verbose) {\n          logger?.error(\n            `[loadComponentsWithCache] Failed to resolve page and props for ${pagePath}`,\n            { error }\n          );\n        }\n        // Handle error gracefully - use fallback components\n        PageComponent = React.Fragment;\n        pageProps = {};\n      }\n    }\n    \n    // If Page was cached but props for this URL weren't, load props separately\n    if (needToLoadProps && propsPath) {\n      if (verbose) {\n        logger?.info(\n          `[rsc-worker] Loading props separately for URL: ${url} (Page was cached)`\n        );\n      }\n      try {\n        const pageAndPropsResult = await resolvePageAndProps({\n          pagePath,\n          propsPath,\n          pageExportName,\n          propsExportName,\n          url: normalizedUrl,\n          loader,\n          verbose: verbose || false,\n          logger,\n        });\n        \n        if (pageAndPropsResult.type === \"success\") {\n          pageProps = pageAndPropsResult.pageProps;\n          \n          // Cache the props for this URL\n          const propsId = `${propsPath}#${propsExportName}@${normalizedUrl}`;\n          cacheComponent(propsId, pageProps);\n          \n          if (verbose) {\n            logger?.info(\n              `[rsc-worker] Loaded and cached pageProps for URL: ${url}`\n            );\n          }\n        } else {\n          if (verbose) {\n            logger?.warn(\n              `[rsc-worker] Failed to load props for URL ${url}: ${pageAndPropsResult.error?.message}`\n            );\n          }\n          pageProps = {};\n        }\n      } catch (error) {\n        if (verbose) {\n          logger?.error(\n            `[rsc-worker] Error loading props for URL ${url}`,\n            { error }\n          );\n        }\n        pageProps = {};\n      }\n    }\n  }\n\n  // Load Root component\n  if (rootPath) {\n    const rootId = `${rootPath}#${rootExportName}`;\n    // CRITICAL: Check if module is invalidated before using cache\n    // This ensures file changes are picked up immediately\n    const isRootInvalidated = isModuleInvalidated(rootPath);\n    if (hasCachedComponent(rootId) && !isRootInvalidated) {\n      RootComponent = getCachedComponent(rootId);\n      if (verbose) {\n        logger?.info(\n          `[rsc-worker] Using cached Root component from: ${rootPath}`\n        );\n      }\n    } else {\n      // Clear cache if invalidated\n      if (isRootInvalidated && hasCachedComponent(rootId)) {\n        clearCachedComponent(rootId);\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] Cleared invalidated Root component cache: ${rootPath}`\n          );\n        }\n      }\n      const rootResult = await resolveComponent({\n        componentPath: rootPath,\n        exportName: rootExportName,\n        loader,\n      });\n\n      if (rootResult.type === \"success\") {\n        RootComponent = rootResult.component;\n        cacheComponent(rootId, RootComponent);\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] Loaded and cached Root component from: ${rootPath}`\n          );\n          logger?.info(\n            `[rsc-worker] Root component type: ${typeof RootComponent}, isSymbol: ${typeof RootComponent === 'symbol'}, keys: ${RootComponent ? Object.keys(RootComponent) : 'null'}`\n          );\n        }\n      } else {\n        // Handle component resolution failure gracefully (same as server environment)\n        if (verbose) {\n          logger?.warn(\n            `[rsc-worker] Failed to load Root component: ${rootResult.error?.message}`\n          );\n        }\n        // Use React.Fragment as fallback (same as server environment)\n        RootComponent = React.Fragment;\n      }\n    }\n  } else {\n    // No rootPath provided - use built-in default Root component\n    RootComponent = DefaultRoot;\n    if (verbose) {\n      logger?.info(`[rsc-worker] Using built-in default Root component`);\n    }\n  }\n\n  // Load Html component\n  if (verbose) {\n    logger?.info(`[rsc-worker] Html component resolution: htmlPath='${htmlPath}' (type: ${typeof htmlPath})`);\n  }\n  \n  if (htmlPath === \"\") {\n    HtmlComponent = React.Fragment; // Empty string = explicitly headless (no HTML wrapper)\n    if (verbose) {\n      logger?.info(`[rsc-worker] Using headless Html component (empty string)`);\n    }\n  } else if (htmlPath === undefined) {\n    // undefined = use default HTML component\n    if (verbose) {\n      logger?.info(`[rsc-worker] htmlPath is undefined, using default Html component`);\n    }\n    try {\n      const { Html } = await import(\"../../components/html.js\");\n      HtmlComponent = Html;\n      if (verbose) {\n        logger?.info(`[rsc-worker] Successfully loaded default Html component`);\n      }\n    } catch (error) {\n      logger?.warn(\n        `[rsc-worker] Error loading default Html component: ${\n          error instanceof Error ? error.message : String(error)\n        }`\n      );\n      HtmlComponent = React.Fragment; // Fallback to headless if default fails\n    }\n  } else if (htmlPath) {\n    if (verbose) {\n      logger?.info(`[rsc-worker] Attempting to load custom Html component from: ${htmlPath}`);\n    }\n    const htmlId = `${htmlPath}#${htmlExportName}`;\n    // CRITICAL: Check if module is invalidated before using cache\n    const isHtmlInvalidated = isModuleInvalidated(htmlPath);\n    if (hasCachedComponent(htmlId) && !isHtmlInvalidated) {\n      HtmlComponent = getCachedComponent(htmlId);\n      if (verbose) {\n        logger?.info(\n          `[rsc-worker] Using cached Html component from: ${htmlPath}`\n        );\n      }\n    } else {\n      // Clear cache if invalidated\n      if (isHtmlInvalidated && hasCachedComponent(htmlId)) {\n        clearCachedComponent(htmlId);\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] Cleared invalidated Html component cache: ${htmlPath}`\n          );\n        }\n      }\n      if (verbose) {\n        logger?.info(`[rsc-worker] Component not cached, calling resolveComponent with path: ${htmlPath}, exportName: ${htmlExportName}`);\n      }\n      const htmlResult = await resolveComponent({\n        componentPath: htmlPath,\n        exportName: htmlExportName,\n        loader,\n      });\n\n      if (htmlResult.type === \"success\") {\n        HtmlComponent = htmlResult.component;\n        cacheComponent(htmlId, HtmlComponent);\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] Loaded and cached Html component from: ${htmlPath}`\n          );\n        }\n      } else {\n        // Handle component resolution failure gracefully (same as server environment)\n        if (verbose) {\n          logger?.warn(\n            `[rsc-worker] Failed to load Html component from ${htmlPath}: ${htmlResult.error?.message || 'Unknown error'}`\n          );\n          logger?.warn(`[rsc-worker] Html resolution error details:`, htmlResult.error);\n        }\n        // Use React.Fragment as fallback (same as server environment)\n        HtmlComponent = React.Fragment;\n      }\n    }\n  } else {\n    // Use default Html component\n    try {\n      const { Html } = await import(\"../../components/html.js\");\n      HtmlComponent = Html;\n      if (verbose) {\n        logger?.info(`[rsc-worker] Using default Html component`);\n      }\n    } catch (error) {\n      logger?.warn(\n        `[rsc-worker] Error loading default Html component: ${error}`\n      );\n    }\n  }\n\n  return { PageComponent, pageProps, RootComponent, HtmlComponent };\n}\n\n/**\n * Main message handler for RSC worker thread.\n *\n * **Purpose**: Processes messages from the main thread and handles RSC stream creation,\n * component resolution, and error handling in the worker thread.\n *\n * **Key Responsibilities**:\n * - **Component Resolution**: Loads and caches React components for routes\n * - **RSC Stream Creation**: Creates React Server Component streams using ReactDOMServer\n * - **Error Handling**: Catches React rendering errors and communicates them to main thread\n * - **Stream Reuse**: Manages headless stream element reuse for performance optimization\n * - **Lifecycle Management**: Handles worker initialization, shutdown, and cleanup\n *\n * **Error Handling Strategy**:\n * - React rendering errors are caught by ReactDOMServer.onError callback\n * - Errors are sent to main thread via control port with context information\n * - Uncaught exceptions are handled by process.on('uncaughtException') handler\n * - Main thread decides panic behavior based on panicThreshold configuration\n *\n * @param msg - Message from main thread (INIT, RESOLVE_COMPONENTS, SHUTDOWN, etc.)\n * @param port - MessagePort for communication (defaults to parentPort)\n */\n// Store ports for consistent two-port communication\nlet storedFromWorker: any;\nlet storedToWorker: any;\n\nexport async function messageHandler(\n  msg: RscWorkerInputMessage\n) {\n  // Store ports from INIT message for consistent two-port communication\n  if (msg.type === \"INIT\") {\n    storedFromWorker = msg.dataPort;    // dataPort: worker → main (for streaming data out)\n    storedToWorker = msg.controlPort;   // controlPort: main → worker (for control messages in)\n    \n    // Increase max listeners on transferred ports to prevent warnings\n    // Each request creates a new MessagePortWritable that adds listeners to these ports\n    if (storedFromWorker) {\n      setMaxListenersOnPort(storedFromWorker, 500);\n    }\n    if (storedToWorker) {\n      setMaxListenersOnPort(storedToWorker, 500);\n    }\n  }\n\n  // Create handlers for two-port communication using stored ports\n  const effectiveHandlers = createHandlers(storedFromWorker, storedToWorker);\n\n  try {\n    if (verbose) {\n      logger.info(\n        `[rsc-worker] Received message: ${msg.type} for id: ${msg.id}`\n      );\n    }\n\n    switch (msg.type) {\n      case \"INIT\":\n        // Use the ID from options if provided, otherwise fall back to msg.id\n        const currentStreamId = msg.options.id || msg.id;\n\n        // Initialize render-specific user options from init message\n        const renderUserOptions = workerUserOptions(msg.options);\n        setRenderUserOptions(currentStreamId, renderUserOptions);\n        if (verbose) {\n          logger?.info(\n            `[INIT] Set render state for renderId: ${currentStreamId}`\n          );\n          logger?.info(\n            `[INIT] renderUserOptions.build: ${JSON.stringify(\n              renderUserOptions.build\n            )}`\n          );\n        }\n\n        // Cache user options to avoid repeated getUserOptions calls\n        const userOptions = renderUserOptions;\n\n        // Clean up any previous render for this id\n        cleanupRender(currentStreamId);\n\n        // Determine if this is a headless RSC stream (no HTML wrapper)\n        // undefined = use default HTML component, \"\" = explicitly headless\n        const isHeadless = msg.options.htmlPath === \"\";\n        const rscVariant = isHeadless ? \"rsc-headless\" : \"rsc-full\";\n\n        if (verbose) {\n          logger.info(\n            `[rsc-worker] Processing ${rscVariant} render for route: ${msg.options.route} with ID: ${currentStreamId}`\n          );\n        }\n\n        // Create a new PassThrough stream for this render, or use the one provided\n        const rscStream = (msg as any).rscStream || new PassThrough();\n        activeRenders.set(currentStreamId, rscStream);\n\n        // Start measuring module resolution time from first module load\n        const moduleResolutionStartTime = performance.now();\n\n        // Load modules (page, props, and components together) - same as server environment\n        const projectRoot = msg.options.projectRoot || userOptions.projectRoot || workerData.userOptions?.projectRoot || process.cwd();\n        const buildConfig = {\n          server:\n            msg.options.build?.server || userOptions.build?.server || DEFAULT_CONFIG.BUILD.server,\n          client:\n            msg.options.build?.client || userOptions.build?.client || DEFAULT_CONFIG.BUILD.client,\n          static:\n            msg.options.build?.static || userOptions.build?.static || DEFAULT_CONFIG.BUILD.static,\n          outDir:\n            msg.options.build?.outDir || userOptions.build?.outDir || DEFAULT_CONFIG.BUILD.outDir,\n          assetsDir: \n            msg.options.build?.assetsDir || userOptions.build?.assetsDir || DEFAULT_CONFIG.BUILD.assetsDir,\n          rscOutputPath:\n            msg.options.build?.rscOutputPath || userOptions.build?.rscOutputPath || DEFAULT_CONFIG.BUILD.rscOutputPath,\n          htmlOutputPath:\n            msg.options.build?.htmlOutputPath || userOptions.build?.htmlOutputPath || DEFAULT_CONFIG.BUILD.htmlOutputPath,\n          preserveModulesRoot: \n            msg.options.build?.preserveModulesRoot || userOptions.build?.preserveModulesRoot || DEFAULT_CONFIG.BUILD.preserveModulesRoot,\n        };\n        const serverManifest = workerData.serverManifest || msg.options.manifest || {};\n\n        // Always log build config for debugging\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker:${msg.options.route}] \nmsg.options.build: ${JSON.stringify(msg.options.build)}\nmsg.options.route\nuserOptions.build: ${JSON.stringify(userOptions.build)}\nfinal buildConfig: ${JSON.stringify(buildConfig)}`\n          );\n        }\n        const loader = createRscWorkerLoader({\n          verbose: msg.options.verbose ?? workerData.userOptions.verbose,\n          logger,\n          projectRoot,\n          manifest: serverManifest,\n          build: buildConfig,\n          // bundle: workerData.bundle || {},\n        });\n\n        const url =\n          msg.options.url ||\n          routeToURL(\n            msg.options.route,\n            userOptions.moduleBaseURL,\n            userOptions.build?.rscOutputPath ??\n              DEFAULT_CONFIG.BUILD.rscOutputPath\n          );\n\n        // Load components using the unified helper function\n        if (verbose) {\n          logger?.info(`[rsc-worker:messageHandler] Component paths for route ${msg.options.route}:`);\n          logger?.info(`  pagePath: ${msg.options.pagePath}`);\n          logger?.info(`  propsPath: ${msg.options.propsPath}`);\n          logger?.info(`  rootPath: ${msg.options.rootPath}`);\n          logger?.info(`  htmlPath: ${msg.options.htmlPath}`);\n        }\n\n        const { PageComponent, pageProps, RootComponent, HtmlComponent } =\n          await loadComponentsWithCache({\n            pagePath: msg.options.pagePath,\n            propsPath: msg.options.propsPath,\n            rootPath: msg.options.rootPath,\n            htmlPath: msg.options.htmlPath,\n            pageExportName:\n              msg.options.pageExportName ?? userOptions.pageExportName,\n            propsExportName:\n              msg.options.propsExportName ?? userOptions.propsExportName,\n            rootExportName:\n              msg.options.rootExportName ?? userOptions.rootExportName,\n            htmlExportName:\n              msg.options.htmlExportName ?? userOptions.htmlExportName,\n            url,\n            loader,\n            verbose,\n            logger,\n            resolvedPageProps: msg.options.resolvedPageProps,  // Pre-resolved from main thread\n          });\n\n        if (verbose) {\n          logger.info(\n            `[rsc-worker] Loaded components for route ${msg.options.route}:`\n          );\n          logger.info(`[rsc-worker] - PageComponent: ${typeof PageComponent}`);\n          logger.info(`[rsc-worker] - pageProps: ${JSON.stringify(pageProps)}`);\n          logger.info(`[rsc-worker] - RootComponent: ${typeof RootComponent}`);\n          logger.info(`[rsc-worker] - HtmlComponent: ${typeof HtmlComponent}`);\n        }\n\n        // Emit module resolution metric after components are loaded\n        const moduleResolutionTime =\n          performance.now() - moduleResolutionStartTime;\n        if (effectiveHandlers.onMetrics) {\n          const moduleResolutionMetric = createModuleResolutionMetrics({\n            route: msg.options.route,\n            workerType: \"rsc\",\n            resolutionTime: moduleResolutionTime,\n            fromMainThread: false,\n            fromRscWorker: true,\n            fromHtmlWorker: false,\n            description: `Module resolution for route ${msg.options.route}`,\n          });\n          effectiveHandlers.onMetrics(msg.id, moduleResolutionMetric);\n        }\n\n        // Process CSS files using unified CSS processor\n        const messageCssFiles = new Map(msg.options.cssFiles || []);\n\n        // Process inline CSS for stateful system using unified helper\n        processInlineCssForState(\n          messageCssFiles,\n          addCssFileContent,\n          userOptions\n        );\n\n        // Combine stateful CSS with message CSS using unified helper\n        const combinedCssFiles = combineCssFiles(cssFiles, messageCssFiles);\n\n        // Create handler options exactly like server environment\n        const handlerOptions = {\n          route: msg.options.route,\n          url,\n          pageProps,\n          PageComponent,\n          RootComponent,\n          HtmlComponent,\n          cssFiles: combinedCssFiles,\n          globalCss: msg.options.globalCss ?? new Map(),\n          manifest: msg.options.manifest || {},\n          projectRoot:\n            userOptions.projectRoot ||\n            workerData.userOptions?.projectRoot ||\n            process.cwd(),\n          moduleBase:\n            userOptions.moduleBase ||\n            workerData.userOptions?.moduleBase ||\n            DEFAULT_CONFIG.MODULE_BASE,\n          moduleBasePath:\n            userOptions.moduleBasePath ||\n            workerData.userOptions?.moduleBasePath ||\n            DEFAULT_CONFIG.MODULE_BASE_PATH,\n          moduleBaseURL:\n            userOptions.moduleBaseURL ||\n            workerData.userOptions?.moduleBaseURL ||\n            DEFAULT_CONFIG.MODULE_BASE_URL,\n          moduleRootPath:\n            userOptions.moduleRootPath ||\n            workerData.userOptions?.moduleRootPath,\n          verbose: msg.options.verbose || verbose,\n          logger,\n          panicThreshold: msg.options.panicThreshold || \"none\",\n          rscTimeout: msg.options.rscTimeout,\n          serverPipeableStreamOptions: (() => {\n            // Both headless and full streams should use the constructed serverPipeableStreamOptions with bootstrapModules\n            const options =\n              msg.options.serverPipeableStreamOptions ||\n              workerData.userOptions?.serverPipeableStreamOptions;\n\n            if (verbose) {\n              logger.info(\n                `[rsc-worker] ${\n                  isHeadless ? \"Headless\" : \"Full\"\n                } stream serverPipeableStreamOptions: ${JSON.stringify(\n                  options\n                )}`\n              );\n            }\n\n            return options;\n          })(),\n        };\n\n        // Use handleRscRender for proper worker-side rendering\n        let result: void;\n\n        // Check if there was a headless error for this route\n        const headlessError = headlessStreamErrors.get(msg.options.route);\n        const shouldUseFallback = headlessError && !isHeadless;\n\n        // If this is a headless stream, we need to track any errors that occur\n        // so that subsequent full streams can use fallback components\n        if (isHeadless) {\n          // Clear any previous error for this route when starting a new headless stream\n          headlessStreamErrors.delete(msg.options.route);\n        }\n\n        // Check if we should reuse elements from a previous headless stream\n        const shouldReuseElements =\n          !isHeadless && msg.options.reuseHeadlessStreamId;\n        let reusableElements = null;\n\n        if (shouldReuseElements && msg.options.reuseHeadlessStreamId) {\n          // Look up elements directly by the headless stream ID\n          reusableElements = headlessStreamElements.get(\n            msg.options.reuseHeadlessStreamId\n          );\n          if (verbose) {\n            if (reusableElements) {\n              logger.info(\n                `[rsc-worker] Found reusable elements from headless stream ${msg.options.reuseHeadlessStreamId}`\n              );\n            } else if (msg.options.reuseHeadlessStreamId) {\n              logger.info(\n                `[rsc-worker] No reusable elements found for headless stream ${msg.options.reuseHeadlessStreamId}`\n              );\n            }\n          }\n        }\n\n        const isStaticGeneration =\n          msg.options.build &&\n          (msg.options.build.outDir || msg.options.build.static);\n\n        if (verbose) {\n          logger.info(\n            `[rsc-worker] Route: ${msg.options.route}, isHeadless: ${isHeadless}, isStaticGeneration: ${isStaticGeneration}`\n          );\n          logger.info(\n            `[rsc-worker] msg.options.build: ${JSON.stringify(\n              msg.options.build\n            )}`\n          );\n        }\n\n        if (shouldUseFallback) {\n          if (verbose) {\n            logger.info(\n              `[rsc-worker] Using fallback components due to previous error: ${headlessError.message}`\n            );\n          }\n          // Create a fallback handler with React.Fragment for PageComponent but keep original HtmlComponent\n          const fallbackHandlerOptions = {\n            ...handlerOptions,\n            PageComponent: React.Fragment,\n            // Keep the original HtmlComponent to ensure bootstrapScripts are rendered\n          };\n          result = handleRscRender(\n            {\n              ...fallbackHandlerOptions,\n              id: currentStreamId,\n              reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId,\n            },\n            effectiveHandlers,\n            undefined,\n            headlessStreamElements,\n            headlessStreamErrors\n          );\n        } else {\n          try {\n            if (isHeadless) {\n              // Headless stream: use HtmlComponent: React.Fragment (no HTML wrapper) but keep RootComponent\n              if (verbose) {\n                logger.info(\n                  `[rsc-worker] Creating headless RSC stream for route ${msg.options.route} (no HTML wrapper)`\n                );\n              }\n\n              const headlessHandlerOptions = {\n                ...handlerOptions,\n                HtmlComponent: React.Fragment, // Headless RSC - no HTML wrapper\n              };\n\n              result = handleRscRender(\n                {\n                  ...headlessHandlerOptions,\n                  id: currentStreamId,\n                  reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId,\n                },\n                effectiveHandlers,\n                undefined,\n                headlessStreamElements,\n                headlessStreamErrors\n              );\n            } else {\n              // Full stream: reuse elements from headless stream if available\n              if (shouldReuseElements && reusableElements) {\n                if (verbose) {\n                  logger.info(\n                    `[rsc-worker] Creating full RSC stream with reused elements from headless stream for route ${msg.options.route}`\n                  );\n                }\n\n                // Create handler options that reuse the headless stream's elements\n                const reuseHandlerOptions = {\n                  ...handlerOptions,\n                  PageComponent: (() => reusableElements) as any, // Reuse the headless stream's elements\n                };\n\n                result = handleRscRender(\n                  {\n                    ...reuseHandlerOptions,\n                    id: currentStreamId,\n                    reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId,\n                  },\n                  effectiveHandlers,\n                  undefined,\n                  headlessStreamElements,\n                  headlessStreamErrors\n                );\n              } else {\n                // No reusable elements - create normal full stream\n                if (verbose) {\n                  logger.info(\n                    `[rsc-worker] Creating full RSC stream for route ${msg.options.route} (no element reuse)`\n                  );\n                }\n                result = handleRscRender(\n                  {\n                    ...handlerOptions,\n                    id: currentStreamId,\n                    reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId,\n                  },\n                  effectiveHandlers,\n                  undefined,\n                  headlessStreamElements,\n                  headlessStreamErrors\n                );\n              }\n            }\n          } catch (error) {\n            // Handle error the same way as server environment - create fallback with React.Fragment\n            if (verbose) {\n              logger.warn(\n                `[rsc-worker] Original PageComponent failed during creation for route ${msg.options.route}: ${error}`\n              );\n            }\n\n            // Create a fallback handler with React.Fragment for PageComponent but keep original HtmlComponent\n            const fallbackHandlerOptions = {\n              ...handlerOptions,\n              PageComponent: React.Fragment,\n              // Keep the original HtmlComponent to ensure bootstrapScripts are rendered\n            };\n\n            result = handleRscRender(\n              {\n                ...fallbackHandlerOptions,\n                id: currentStreamId,\n                reuseHeadlessStreamId: msg.options.reuseHeadlessStreamId,\n              },\n              effectiveHandlers,\n              undefined,\n              headlessStreamElements,\n              headlessStreamErrors\n            );\n          }\n        }\n\n        // Do not automatically track streams for reuse\n        // Only full streams that explicitly request reuse of a headless stream will trigger reuse logic\n        if (verbose) {\n          logger.info(\n            `[rsc-worker] Processing single-use stream ${currentStreamId} for route: ${msg.options.route}`\n          );\n        }\n\n        // Clear any previous error for this route\n        clearHeadlessError(msg.options.route);\n\n        // handleRscRender handles everything internally including error handling\n\n        // handleRscRender handles everything internally including error handling and control messages\n\n        return result;\n      case \"RESOLVE_COMPONENTS\": {\n        const resolutionStartTime = performance.now();\n\n        // Cache user options to avoid repeated getUserOptions calls\n        const resolveUserOptions = getUserOptions(msg.id);\n\n        try {\n          if (verbose) {\n            logger.info(\n              `[rsc-worker] Resolving components for route: ${msg.route}`\n            );\n            logger.info(`[rsc-worker] pagePath: ${msg.pagePath}`);\n            logger.info(`[rsc-worker] propsPath: ${msg.propsPath}`);\n            logger.info(`[rsc-worker] rootPath: ${msg.rootPath}`);\n            logger.info(`[rsc-worker] htmlPath: ${msg.htmlPath}`);\n          }\n          if (verbose) {\n            logger?.info(\n              `[rsc-worker:${msg.route}] pagePath=${msg.pagePath}, propsPath=${msg.propsPath}`\n            );\n          }\n\n          // Create loader for component resolution with correct build config\n          // Use the render-specific build config from the INIT case\n          const buildConfig = {\n            server: resolveUserOptions.build?.server || \"server\",\n            client: resolveUserOptions.build?.client || \"client\",\n            static: resolveUserOptions.build?.static || \"static\",\n            outDir: resolveUserOptions.build?.outDir || \"dist\",\n          };\n\n          // Debug log to see what outDir we're using\n          if (verbose) {\n            logger?.info(\n              `[RESOLVE_COMPONENTS] Using outDir: ${buildConfig.outDir}`\n            );\n            logger?.info(\n              `[RESOLVE_COMPONENTS] renderId: ${\n                msg.id\n              }, hasRenderState: ${renderStates.has(msg.id)}`\n            );\n            if (renderStates.has(msg.id)) {\n              const renderState = renderStates.get(msg.id)!;\n              logger?.info(\n                `[RESOLVE_COMPONENTS] renderState.initialized: ${renderState.initialized}`\n              );\n              logger?.info(\n                `[RESOLVE_COMPONENTS] renderState.userOptions.build: ${JSON.stringify(\n                  renderState.userOptions.build\n                )}`\n              );\n            }\n          }\n\n          const loader = createRscWorkerLoader({\n            verbose: verbose,\n            logger,\n            projectRoot: workerData.userOptions?.projectRoot,\n            manifest: workerData.serverManifest || {},\n            build: buildConfig,\n          });\n\n          // Load components using the unified helper function (caching is handled internally)\n          await loadComponentsWithCache({\n            pagePath: msg.pagePath,\n            propsPath: msg.propsPath,\n            rootPath: msg.rootPath,\n            htmlPath: msg.htmlPath,\n            pageExportName: msg.pageExportName || \"default\",\n            propsExportName: msg.propsExportName || \"props\",\n            rootExportName: msg.rootExportName || \"Root\",\n            htmlExportName: msg.htmlExportName || \"Html\",\n            url: `/${msg.route}`, // Simple URL for component resolution\n            loader,\n            verbose,\n            logger,\n          });\n\n          const resolutionTime = performance.now() - resolutionStartTime;\n\n          if (verbose) {\n            logger.info(\n              `[rsc-worker] Components resolved for route: ${\n                msg.route\n              } in ${resolutionTime.toFixed(2)}ms`\n            );\n          }\n\n          // Send success response (without the actual components)\n          const response: ComponentsResolvedMessage = {\n            type: \"COMPONENTS_RESOLVED\",\n            id: msg.id,\n            route: msg.route,\n            resolutionTime,\n          };\n\n          parentPort?.postMessage(response);\n        } catch (error) {\n          logger.error(\n            `[rsc-worker] Failed to resolve components for route ${msg.route}: ${error}`\n          );\n\n          // Always send error to main thread - let main thread decide panic status\n          effectiveHandlers.onError(msg.id, toError(error), {\n            route: msg.route,\n            context: `Component resolution failed for route ${msg.route}`,\n          });\n        }\n        return;\n      }\n      case \"SERVER_ACTION\": {\n        try {\n          // Cache user options to avoid repeated getUserOptions calls\n          const serverActionUserOptions = getUserOptions();\n\n          // Parse the server action ID to get the file path and export name\n          const [filePath, exportName] = msg.id.split(\"#\");\n          if (!filePath || !exportName) {\n            throw new Error(\n              `Invalid server action ID format: ${msg.id}. Expected format: \"path/to/file.ts#exportName\"`\n            );\n          }\n          // Convert the server action ID to a file path\n          const actionPath = filePath.startsWith(\n            serverActionUserOptions.moduleBasePath\n          )\n            ? filePath.slice(serverActionUserOptions.moduleBasePath.length)\n            : filePath;\n          const fullPath = join(\n            workerData.userOptions?.projectRoot,\n            actionPath\n          );\n\n          // Load the server action module\n          const module = await import(fullPath);\n          const action = module[exportName];\n\n          if (typeof action !== \"function\") {\n            throw new Error(`Server action not found: ${msg.id}`);\n          }\n\n          // Decode args if they're in React's encoded format\n          let decodedArgs = msg.args;\n          if (msg.args.length === 1 && typeof msg.args[0] === \"string\") {\n            // Might be React's encoded format - try to decode\n            try {\n              const moduleBasePath = serverActionUserOptions.moduleBasePath ?? \"/\";\n              decodedArgs = await decodeReply(msg.args[0], moduleBasePath);\n              if (verbose) {\n                logger?.info(`[rsc-worker] Decoded server action args: ${JSON.stringify(decodedArgs)}`);\n              }\n            } catch {\n              // Not encoded format, use as-is\n              if (verbose) {\n                logger?.info(`[rsc-worker] Using raw server action args`);\n              }\n            }\n          }\n\n          // Execute the server action\n          const result = await action(...decodedArgs);\n\n          // Send success response\n          effectiveHandlers.onServerActionResponse?.(msg.id, result);\n        } catch (error: unknown) {\n          const errorMessage = toError(error).message;\n          // Send error response\n          effectiveHandlers.onServerActionResponse?.(\n            msg.id,\n            undefined,\n            errorMessage\n          );\n        }\n        return;\n      }\n      case \"INITIALIZED_REACT_LOADER\":\n      case \"INITIALIZED_CSS_LOADER\":\n      case \"INITIALIZED_ENV_LOADER\":\n        return;\n      case \"HMR_UPDATE\":\n        // Normalize the path - use path if provided (full path), otherwise use id (normalized path)\n        const filePath = (msg as any).path || msg.id;\n        const hmrProjectRoot = workerData.userOptions?.projectRoot || process.cwd();\n        const normalizedPath = filePath.startsWith(hmrProjectRoot)\n          ? relative(hmrProjectRoot, filePath)\n          : filePath;\n        \n        // Mark the module as invalidated\n        hmrState.set(normalizedPath, {\n          timestamp: (msg as any).timestamp || Date.now(),\n          invalidated: true,\n          routes: (msg as any).routes || [],\n        });\n        \n        // Always log HMR updates for debugging\n        logger?.info(\n          `[rsc-worker] HMR_UPDATE: Invalidated module ${normalizedPath} (from ${filePath})`\n        );\n        \n        // CRITICAL: Clear ALL caches when files change\n        // This ensures fresh components are loaded instead of cached ones\n        \n        // Clear headless stream elements cache\n        if (headlessStreamElements.size > 0) {\n          if (verbose) {\n            logger?.info(\n              `[rsc-worker] HMR_UPDATE: Clearing ${headlessStreamElements.size} cached headless stream elements`\n            );\n          }\n          headlessStreamElements.clear();\n        }\n        \n        // Clear all component caches (temporaryReferences)\n        // This is critical because Node.js caches ES modules, and even if we reload,\n        // the component cache might still have the old component\n        clearAllCachedComponents();\n        if (verbose) {\n          logger?.info(\n            `[rsc-worker] HMR_UPDATE: Cleared all cached components from temporaryReferences`\n          );\n        }\n        \n        // Also clear headless stream errors since we're reloading\n        headlessStreamErrors.clear();\n        \n        // Notify the main thread that we've processed the update\n        effectiveHandlers.onHmrUpdate(normalizedPath, (msg as any).routes || []);\n        return;\n      case \"ABORT\":\n        // Abort the stream\n        // activeStreams.get(msg.id)?.emit(\"abort\"); // This line was removed as per the new_code\n        return;\n      case \"HMR_CLEANUP\":\n        // Clear the invalidation state\n        hmrState.delete(msg.id);\n        // Notify the main thread that we've processed the cleanup\n        effectiveHandlers.onHmrAccept(msg.id, msg.routes || []);\n        return;\n      case \"CSS_FILE\":\n        if (msg.id) {\n          // Cache user options to avoid repeated getUserOptions calls\n          const cssFileUserOptions = getUserOptions();\n          // Add to CSS registry\n          addCssFileContent(msg.id, msg.content, cssFileUserOptions);\n        }\n        effectiveHandlers.onCssFile?.(msg.id, msg.content);\n        return;\n      case \"SERVER_MODULE\":\n        addModuleId(msg.id, msg.url);\n        effectiveHandlers.onServerModule?.(msg.id, msg.url, msg.source);\n        return;\n      case \"MODULE_REQUEST\": {\n        const { id, path } = msg;\n        try {\n          const module = await import(\n            join(workerData.userOptions?.projectRoot, path)\n          );\n          effectiveHandlers.onServerModule?.(id, path, module);\n        } catch (error) {\n          effectiveHandlers.onError(id, toError(error));\n        }\n        return;\n      }\n    case \"SHUTDOWN\": {\n        effectiveHandlers.onShutdown?.(msg.id);\n        // Send SHUTDOWN_COMPLETE message to signal that shutdown is complete\n        if (parentPort) {\n          sendMessage(\n            {\n              type: \"SHUTDOWN_COMPLETE\",\n              id: msg.id,\n            },\n            parentPort\n          );\n        }\n        return;\n      }\n      default: {\n        logger.info(`Unknown message: ${msg.type}`);\n        return;\n      }\n    }\n  } catch (error) {\n    // Just communicate the error directly - let the main thread handle panic threshold logic\n    effectiveHandlers.onError(\"worker/rsc\", toError(error));\n    // Always send SHUTDOWN_COMPLETE to prevent hanging\n    effectiveHandlers.onShutdown?.(\"*\");\n  }\n}\n"],"names":["verbose","logger","DefaultRoot","buildConfig","loader","filePath","result"],"mappings":"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"}