vite-plugin-react-server/dist/plugin/worker/rsc/messageHandler.server.js

Vite plugin for React Server Components (RSC)

/**
 * vite-plugin-react-server
 * Copyright (c) Nico Brinkkemper
 * MIT License
 */
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.server.js';
import { setMaxListenersOnPort } from '../../stream/setMaxListeners.js';
import { toError } from '../../error/toError.js';
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.server.js';
import { getRunner, getRpc } from './runnerInstance.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 { handleError } from '../../error/handleError.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 { createModuleResolutionMetrics } from '../../metrics/createModuleResolutionMetrics.js';

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,
    panicThreshold = "none",
    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}`;
        if (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 (verbose2) {
            logger2?.info(
              `[rsc-worker] Loaded and cached PageComponent from: ${pagePath}`
            );
            if (propsPath) {
              logger2?.info(`[rsc-worker] Loaded fresh pageProps from: ${propsPath}`);
              logger2?.info(`[rsc-worker] Loaded pageProps:`, pageProps);
            }
          }
        } else {
          const pageError = pageAndPropsResult.error ?? new Error(
            `[rsc-worker] Failed to load page module from ${pagePath}`
          );
          const panicError = handleError({
            error: pageError,
            logger: logger2,
            panicThreshold,
            critical: true,
            context: `rsc-worker: load page from ${pagePath}`,
            log: true
          });
          throw panicError ?? pageError;
        }
      } catch (error) {
        const panicError = handleError({
          error,
          logger: logger2,
          panicThreshold,
          critical: true,
          log: true
        });
        throw panicError ?? error;
      }
    }
    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;
          if (verbose2) {
            logger2?.info(
              `[rsc-worker] Loaded fresh 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 {
        const rootError = rootResult.error ?? new Error(
          `[rsc-worker] Failed to load Root component from ${rootPath}`
        );
        const panicError = handleError({
          error: rootError,
          logger: logger2,
          panicThreshold,
          critical: true,
          log: true
        });
        throw panicError ?? rootError;
      }
    }
  } 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 (verbose) {
      logger.info(
        `[rsc-worker] Received message: ${msg.type} for id: ${msg.id}`
      );
    }
    switch (msg.type) {
      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,
          panicThreshold: msg.options.panicThreshold,
          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 rpc = getRpc();
        if (rpc && msg.options.pagePath) {
          try {
            const cssFileUserOptions = getUserOptions();
            const collected = await rpc("collectCss", [msg.options.pagePath, projectRoot]) || [];
            for (const { id, code } of collected) {
              addCssFileContent(id, code, cssFileUserOptions);
            }
            if (verbose) {
              logger?.info(
                `[rsc-worker] runner CSS bridge: collected ${collected.length} file(s) for ${msg.options.pagePath}`
              );
            }
          } catch (err) {
            if (verbose) {
              logger?.warn(
                `[rsc-worker] runner CSS bridge failed: ${String(err)}`
              );
            }
          }
        }
        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":
        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 || []
        });
        if (verbose) {
          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`
          );
        }
        const runner = getRunner();
        if (runner) {
          runner.clearCache();
          if (verbose) {
            logger?.info(
              `[rsc-worker] HMR_UPDATE: runner cache cleared (trigger: ${filePath})`
            );
          }
        }
        headlessStreamErrors.clear();
        effectiveHandlers.onHmrUpdate(normalizedPath, msg.routes || []);
        return;
      case "ABORT":
        return;
      case "HMR_CLEANUP":
        hmrState.delete(msg.id);
        effectiveHandlers.onHmrAccept(msg.id, msg.routes || []);
        return;
      case "CSS_FILE":
        if (msg.id) {
          const cssFileUserOptions = getUserOptions();
          addCssFileContent(msg.id, msg.content, cssFileUserOptions);
        }
        effectiveHandlers.onCssFile?.(msg.id, msg.content);
        return;
      case "SERVER_MODULE":
        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));
          effectiveHandlers.onServerModule?.(id, path, module);
        } catch (error) {
          effectiveHandlers.onError(id, toError(error));
        }
        return;
      }
      case "SHUTDOWN": {
        effectiveHandlers.onShutdown?.(msg.id);
        if (parentPort) {
          sendMessage(
            {
              type: "SHUTDOWN_COMPLETE",
              id: msg.id
            },
            parentPort
          );
        }
        return;
      }
      default: {
        logger.info(`Unknown message: ${msg.type}`);
        return;
      }
    }
  } catch (error) {
    effectiveHandlers.onError("worker/rsc", toError(error));
    effectiveHandlers.onEnd?.("worker/rsc");
    effectiveHandlers.onShutdown?.("*");
  }
}

export { messageHandler };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"messageHandler.server.js","sources":["../../../../plugin/worker/rsc/messageHandler.server.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.server.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.server.js\";\nimport { getRunner, getRpc } from \"./runnerInstance.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 { handleError } from \"../../error/handleError.js\";\nimport type { PanicThreshold } from \"../../types.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  panicThreshold?: PanicThreshold;\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    panicThreshold = \"none\",\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    //\n    // bd-5xu (2026-04-30): we cache the Page component (a stable function from\n    // the source file) but NOT the props result. Props functions read mutable\n    // server state — DB rows, in-memory stores, request-scoped data — and a\n    // cross-request cache silently serves stale data after a server action\n    // mutates that state. The pre-bd-5xu code keyed pageProps by URL and only\n    // invalidated on file change, so e.g. deleting a todo via a server action\n    // was correctly persisted to the DB but the next /todos/index.rsc still\n    // returned the pre-delete cached props. dev:rsc didn't go through this\n    // worker path so it didn't repro there. Always reload props in dev.\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      if (propsPath && !resolvedPageProps) {\n        // Props are intentionally NOT cached across requests — see comment\n        // above. Drop any pre-existing cache entry from older versions, then\n        // fall through to the separate-load path be