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

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

@@ -3,227 +3,164 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-import { sendRscWorkerMessage } from './sendRscWorkerMessage.js';
-import { toError } from '../../error/toError.js';
-import { userOptions } from './userOptions.js';
-import { addCssFileContent, addModuleId } from './state.js';
-import { join } from 'path';
-import { ReactDOMServer } from '../../vendor/vendor.server.js';
-import { PassThrough } from 'node:stream';
+import { sendMessage } from '../sendMessage.js';
+import { serializeError } from '../../error/serializeError.js';
+import { serializeErrorInfo } from '../../error/serializeErrorInfo.js';
+import { MessagePortWritable } from '../../stream/MessagePortWritable.js';
 
-const serializeError = (error) => {
-  const err = toError(error);
+function createHandlers(fromWorker, toWorker) {
+  const messagePortWritable = fromWorker ? new MessagePortWritable(fromWorker, toWorker) : null;
   return {
-    message: err.message,
-    name: err.name,
-    stack: err.stack
-  };
-};
-const handlers = {
-  onError: (id, error, errorInfo) => {
-    sendRscWorkerMessage({
-      type: "ERROR",
-      id,
-      errorInfo,
-      error: serializeError(error)
-    });
-  },
-  onData: (id, data) => {
-    sendRscWorkerMessage({
-      type: "RSC_CHUNK",
-      id,
-      chunk: data
-    });
-  },
-  onEnd: (id) => {
-    sendRscWorkerMessage({
-      type: "RSC_END",
-      id
-    });
-  },
-  onMetrics: (id, metrics) => {
-    sendRscWorkerMessage({
-      type: "RSC_METRICS",
-      id,
-      metrics
-    });
-  },
-  onHmrAccept: (id, routes) => {
-    sendRscWorkerMessage({
-      type: "HMR_ACCEPT",
-      id,
-      routes
-    });
-  },
-  onHmrUpdate: (id, routes) => {
-    sendRscWorkerMessage({
-      type: "HMR_UPDATE",
-      id,
-      routes
-    });
-  },
-  onServerModule: (id, url, source) => {
-    addModuleId(id, url);
-    sendRscWorkerMessage({
-      type: "SERVER_MODULE",
-      id,
-      url,
-      source
-    });
-  },
-  onServerActionResponse: (id, result) => {
-    const stream = ReactDOMServer.renderToPipeableStream(
-      result && typeof result === "object" && "returnValue" in result ? result : {
-        type: "server-action-response",
-        returnValue: result
-      },
-      userOptions.moduleBasePath,
-      {
-        onError(error) {
-          sendRscWorkerMessage({
-            type: "ERROR",
-            id,
-            error: serializeError(error)
-          });
-        }
-      }
-    );
-    const passThrough = new PassThrough();
-    stream.pipe(passThrough);
-    passThrough.on("data", (chunk) => {
-      sendRscWorkerMessage({
-        type: "RSC_CHUNK",
-        id,
-        chunk
-      });
-    });
-    passThrough.on("end", () => {
-      sendRscWorkerMessage({
-        type: "RSC_END",
-        id
-      });
-    });
-    passThrough.on("error", (error) => {
-      sendRscWorkerMessage({
-        type: "ERROR",
-        id,
-        error: serializeError(error)
-      });
-    });
-  },
-  onServerAction: async (id, args) => {
-    try {
-      const [filePath, exportName] = id.split("#");
-      if (!filePath || !exportName) {
-        throw new Error(
-          `Invalid server action ID format: ${id}. Expected format: "path/to/file.ts#exportName"`
-        );
-      }
-      const actionPath = filePath.startsWith(userOptions.moduleBasePath) ? filePath.slice(userOptions.moduleBasePath.length) : filePath;
-      const fullPath = join(userOptions.projectRoot, actionPath);
-      const module = await import(fullPath);
-      const action = module[exportName];
-      if (typeof action !== "function") {
-        throw new Error(`Server action not found: ${id}`);
-      }
-      const result = await action(...args);
-      const stream = ReactDOMServer.renderToPipeableStream(
-        {
-          type: "server-action-response",
-          returnValue: result
-        },
-        userOptions.moduleBasePath,
-        {
-          onError(error) {
-            sendRscWorkerMessage({
-              type: "ERROR",
-              id,
-              error: serializeError(error)
-            });
-          }
-        }
-      );
-      const passThrough = new PassThrough();
-      stream.pipe(passThrough);
-      passThrough.on("data", (chunk) => {
-        sendRscWorkerMessage({
-          type: "RSC_CHUNK",
-          id,
-          chunk
+    onRscRender: (id) => {
+      if (toWorker) {
+        toWorker.postMessage({
+          type: "RSC_RENDER_START",
+          id
         });
-      });
-      passThrough.on("end", () => {
-        sendRscWorkerMessage({
-          type: "RSC_END",
+      } else {
+        sendMessage({
+          type: "RSC_RENDER_START",
           id
         });
-      });
-      passThrough.on("error", (error) => {
-        sendRscWorkerMessage({
+      }
+    },
+    onError: (id, error, errorInfo) => {
+      if (toWorker) {
+        toWorker.postMessage({
           type: "ERROR",
           id,
+          errorInfo: serializeErrorInfo(errorInfo),
           error: serializeError(error)
         });
-      });
-    } catch (error) {
-      const errorMessage = serializeError(error).message;
-      const stream = ReactDOMServer.renderToPipeableStream(
-        {
-          type: "server-action-response",
-          returnValue: { success: false, error: errorMessage }
-        },
-        userOptions.moduleBasePath,
-        {
-          onError(error2) {
-            sendRscWorkerMessage({
-              type: "ERROR",
-              id,
-              error: serializeError(error2)
-            });
-          }
-        }
-      );
-      const passThrough = new PassThrough();
-      stream.pipe(passThrough);
-      passThrough.on("data", (chunk) => {
-        sendRscWorkerMessage({
+      } else {
+        sendMessage({
+          type: "ERROR",
+          id,
+          errorInfo: serializeErrorInfo(errorInfo),
+          error: serializeError(error)
+        });
+      }
+    },
+    onShellError: (id, error) => {
+      if (toWorker) {
+        toWorker.postMessage({
+          type: "SHELL_ERROR",
+          id,
+          error: serializeError(error)
+        });
+      } else {
+        sendMessage({
+          type: "SHELL_ERROR",
+          id,
+          error: serializeError(error)
+        });
+      }
+    },
+    onData: (id, data) => {
+      if (messagePortWritable) ; else {
+        sendMessage({
           type: "RSC_CHUNK",
           id,
-          chunk
+          chunk: data
         });
-      });
-      passThrough.on("end", () => {
-        sendRscWorkerMessage({
+      }
+    },
+    onEnd: (id) => {
+      if (fromWorker) {
+        try {
+          fromWorker.postMessage(null);
+        } catch (error) {
+        }
+      }
+      if (toWorker) {
+        toWorker.postMessage({
           type: "RSC_END",
           id
         });
-      });
-      passThrough.on("error", (error2) => {
-        sendRscWorkerMessage({
-          type: "ERROR",
+      } else {
+        sendMessage({
+          type: "RSC_END",
+          id
+        });
+      }
+    },
+    onMetrics: (id, metrics) => {
+      if (metrics.type === "html" || metrics.type === "worker-startup" || metrics.type === "module-resolution") {
+        return;
+      }
+      if (toWorker) {
+        toWorker.postMessage({
+          type: "RSC_METRICS",
+          id,
+          metrics
+        });
+      } else {
+        sendMessage({
+          type: "RSC_METRICS",
           id,
-          error: serializeError(error2)
+          metrics
         });
+      }
+    },
+    // Expose the writable stream for direct piping in two-port mode
+    ...messagePortWritable && { getWritable: () => messagePortWritable },
+    onHmrAccept: (id, routes) => {
+      sendMessage({
+        type: "HMR_ACCEPT",
+        id,
+        routes
       });
-    }
-  },
-  onShutdown: (id) => {
-    sendRscWorkerMessage({
-      type: "SHUTDOWN_COMPLETE",
-      id
-    });
-  },
-  onCssFile: (id, code) => {
-    if (id) {
-      addCssFileContent(id, code, userOptions);
-      sendRscWorkerMessage({
+    },
+    onHmrUpdate: (id, routes) => {
+      sendMessage({
+        type: "HMR_UPDATE",
+        id,
+        routes
+      });
+    },
+    onShutdown: (id) => {
+      sendMessage({
+        type: "HMR_CLEANUP",
+        id
+      });
+    },
+    onCssFile: (id, code) => {
+      sendMessage({
         type: "CSS_FILE",
         id,
         content: code
       });
+    },
+    onCleanup: (id) => {
+      sendMessage({
+        type: "HMR_CLEANUP",
+        id
+      });
+    },
+    onShellReady: (id) => {
+      sendMessage({
+        type: "SHELL_READY",
+        id
+      });
+    },
+    onAllReady: (id) => {
+      sendMessage({
+        type: "RSC_END",
+        id
+      });
+    },
+    onServerActionResponse: (id, result, error) => {
+      sendMessage({
+        type: "SERVER_ACTION_RESPONSE",
+        id,
+        result,
+        // Only include error if it's truthy - prevents serializeError(undefined)
+        ...error ? { error } : {}
+      });
     }
-  }
-};
+  };
+}
+createHandlers();
 
-export { handlers };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"handlers.js","sources":["../../../../plugin/worker/rsc/handlers.ts"],"sourcesContent":["import { sendRscWorkerMessage } from \"./sendRscWorkerMessage.js\";\nimport type { StreamHandlers } from \"../types.js\";\nimport { toError } from \"../../error/toError.js\";\nimport { userOptions } from \"./userOptions.js\";\nimport { addCssFileContent, addModuleId } from \"./state.js\";\nimport { join } from \"path\";\nimport { ReactDOMServer } from \"../../vendor/vendor.server.js\";\nimport { PassThrough } from \"node:stream\";\n\n// Helper function to serialize errors for worker thread communication\nconst serializeError = (error: unknown) => {\n  const err = toError(error);\n  return {\n    message: err.message,\n    name: err.name,\n    stack: err.stack,\n  };\n};\n\nexport const handlers: Required<StreamHandlers> = {\n  onError: (id, error, errorInfo) => {\n    sendRscWorkerMessage({\n      type: \"ERROR\",\n      id: id,\n      errorInfo,\n      error: serializeError(error),\n    });\n  },\n  onData: (id, data) => {\n    sendRscWorkerMessage({\n      type: \"RSC_CHUNK\",\n      id: id,\n      chunk: data,\n    });\n  },\n  onEnd: (id) => {\n    sendRscWorkerMessage({\n      type: \"RSC_END\",\n      id: id,\n    });\n  },\n  onMetrics: (id, metrics) => {\n    sendRscWorkerMessage({\n      type: \"RSC_METRICS\",\n      id: id,\n      metrics,\n    });\n  },\n  onHmrAccept: (id, routes) => {\n    sendRscWorkerMessage({\n      type: \"HMR_ACCEPT\",\n      id: id,\n      routes: routes,\n    });\n  },\n  onHmrUpdate: (id, routes) => {\n    sendRscWorkerMessage({\n      type: \"HMR_UPDATE\",\n      id: id,\n      routes: routes,\n    });\n  },\n  onServerModule: (id, url, source) => {\n    addModuleId(id, url);\n    sendRscWorkerMessage({\n      type: \"SERVER_MODULE\",\n      id,\n      url,\n      source,\n    });\n  },\n  onServerActionResponse: (id, result) => {\n    const stream = ReactDOMServer.renderToPipeableStream(\n      result && typeof result === \"object\" && \"returnValue\" in result\n        ? result\n        : {\n            type: \"server-action-response\",\n            returnValue: result,\n          },\n      userOptions.moduleBasePath,\n      {\n        onError(error: Error) {\n          sendRscWorkerMessage({\n            type: \"ERROR\",\n            id,\n            error: serializeError(error),\n          });\n        },\n      }\n    );\n\n    const passThrough = new PassThrough();\n    stream.pipe(passThrough);\n\n    passThrough.on(\"data\", (chunk) => {\n      sendRscWorkerMessage({\n        type: \"RSC_CHUNK\",\n        id,\n        chunk,\n      });\n    });\n\n    passThrough.on(\"end\", () => {\n      sendRscWorkerMessage({\n        type: \"RSC_END\",\n        id,\n      });\n    });\n\n    passThrough.on(\"error\", (error) => {\n      sendRscWorkerMessage({\n        type: \"ERROR\",\n        id,\n        error: serializeError(error),\n      });\n    });\n  },\n  onServerAction: async (id, args) => {\n    try {\n      // Parse the server action ID to get the file path and export name\n      const [filePath, exportName] = id.split(\"#\");\n      if (!filePath || !exportName) {\n        throw new Error(\n          `Invalid server action ID format: ${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(userOptions.moduleBasePath)\n        ? filePath.slice(userOptions.moduleBasePath.length)\n        : filePath;\n      const fullPath = join(userOptions.projectRoot, actionPath);\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: ${id}`);\n      }\n\n      // Execute the server action\n      const result = await action(...args);\n\n      // Send success response using RSC stream\n      const stream = ReactDOMServer.renderToPipeableStream(\n        {\n          type: \"server-action-response\",\n          returnValue: result,\n        },\n        userOptions.moduleBasePath,\n        {\n          onError(error: Error) {\n            sendRscWorkerMessage({\n              type: \"ERROR\",\n              id,\n              error: serializeError(error),\n            });\n          },\n        }\n      );\n\n      const passThrough = new PassThrough();\n      stream.pipe(passThrough);\n\n      passThrough.on(\"data\", (chunk) => {\n        sendRscWorkerMessage({\n          type: \"RSC_CHUNK\",\n          id,\n          chunk,\n        });\n      });\n\n      passThrough.on(\"end\", () => {\n        sendRscWorkerMessage({\n          type: \"RSC_END\",\n          id,\n        });\n      });\n\n      passThrough.on(\"error\", (error) => {\n        sendRscWorkerMessage({\n          type: \"ERROR\",\n          id,\n          error: serializeError(error),\n        });\n      });\n    } catch (error: unknown) {\n      const errorMessage = serializeError(error).message;\n      // Send error response using RSC stream\n      const stream = ReactDOMServer.renderToPipeableStream(\n        {\n          type: \"server-action-response\",\n          returnValue: { success: false, error: errorMessage },\n        },\n        userOptions.moduleBasePath,\n        {\n          onError(error: Error) {\n            sendRscWorkerMessage({\n              type: \"ERROR\",\n              id,\n              error: serializeError(error),\n            });\n          },\n        }\n      );\n\n      const passThrough = new PassThrough();\n      stream.pipe(passThrough);\n\n      passThrough.on(\"data\", (chunk) => {\n        sendRscWorkerMessage({\n          type: \"RSC_CHUNK\",\n          id,\n          chunk,\n        });\n      });\n\n      passThrough.on(\"end\", () => {\n        sendRscWorkerMessage({\n          type: \"RSC_END\",\n          id,\n        });\n      });\n\n      passThrough.on(\"error\", (error) => {\n        sendRscWorkerMessage({\n          type: \"ERROR\",\n          id,\n          error: serializeError(error),\n        });\n      });\n    }\n  },\n  onShutdown: (id: string) => {\n    // Send SHUTDOWN_COMPLETE message to signal that shutdown is complete\n    sendRscWorkerMessage({\n      type: \"SHUTDOWN_COMPLETE\",\n      id: id,\n    });\n  },\n  onCssFile: (id, code) => {\n    if (id) {\n      // Add to CSS registry\n      addCssFileContent(id, code, userOptions);\n\n      // Send CSS file message\n      sendRscWorkerMessage({\n        type: \"CSS_FILE\",\n        id,\n        content: code,\n      });\n    }\n  },\n};\n"],"names":["error"],"mappings":"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"}
+export { createHandlers };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"handlers.js","sources":["../../../../plugin/worker/rsc/handlers.ts"],"sourcesContent":["import type { ServerStreamHandlers } from \"../types.js\";\nimport { sendMessage } from \"../sendMessage.js\";\nimport { serializeError } from \"../../error/serializeError.js\";\nimport { serializeErrorInfo } from \"../../error/serializeErrorInfo.js\";\nimport { MessagePortWritable } from \"../../stream/MessagePortWritable.js\";\nimport type { MessagePort } from \"node:worker_threads\";\n\n/**\n * Creates handlers for two-port communication: fromWorker for streaming data out, toWorker for control messages in\n * Following zero-copy streaming pattern: fromWorker (worker → main), toWorker (main → worker)\n */\nexport function createHandlers(fromWorker?: MessagePort, toWorker?: MessagePort): ServerStreamHandlers {\n  // Create writable stream for fromWorker if available\n  const messagePortWritable = fromWorker ? new MessagePortWritable(fromWorker, toWorker) : null;\n  return {\n    onRscRender: (id) => {\n      if (toWorker) {\n        toWorker.postMessage({\n          type: \"RSC_RENDER_START\",\n          id: id,\n        });\n      } else {\n        sendMessage({\n          type: \"RSC_RENDER_START\",\n          id: id,\n        });\n      }\n    },\n    onError: (id, error, errorInfo) => {\n      if (toWorker) {\n        toWorker.postMessage({\n          type: \"ERROR\",\n          id: id,\n          errorInfo: serializeErrorInfo(errorInfo),\n          error: serializeError(error),\n        });\n      } else {\n        sendMessage({\n          type: \"ERROR\",\n          id: id,\n          errorInfo: serializeErrorInfo(errorInfo),\n          error: serializeError(error),\n        });\n      }\n    },\n    onShellError: (id, error) => {\n      if (toWorker) {\n        toWorker.postMessage({\n          type: \"SHELL_ERROR\",\n          id: id,\n          error: serializeError(error),\n        });\n      } else {\n        sendMessage({\n          type: \"SHELL_ERROR\",\n          id: id,\n          error: serializeError(error),\n        });\n      }\n    },\n    onData: (id, data) => {\n      // In two-port mode, data goes through the writable stream\n      // In single-port mode, use the old message approach\n      if (messagePortWritable) {\n        // Data is handled by piping to messagePortWritable\n        // This method is called but the actual data flow is through the stream\n      } else {\n        sendMessage({\n          type: \"RSC_CHUNK\",\n          id: id,\n          chunk: data,\n        });\n      }\n    },\n    onEnd: (id) => {\n      // Mirror HTML worker pattern: send null through fromWorker, then END through toWorker\n      if (fromWorker) {\n        try {\n          fromWorker.postMessage(null);\n        } catch (error) {\n          // Port may be closed, ignore\n        }\n      }\n      \n      if (toWorker) {\n        toWorker.postMessage({\n          type: \"RSC_END\",\n          id: id,\n        });\n      } else {\n        sendMessage({\n          type: \"RSC_END\",\n          id: id,\n        });\n      }\n    },\n    onMetrics: (id, metrics) => {\n      if (metrics.type === \"html\" || metrics.type === \"worker-startup\" || metrics.type === \"module-resolution\") {\n        return;\n      }\n      if (toWorker) {\n        toWorker.postMessage({\n          type: \"RSC_METRICS\",\n          id: id,\n          metrics: metrics as any,\n        });\n      } else {\n        sendMessage({\n          type: \"RSC_METRICS\",\n          id: id,\n          metrics: metrics as any,\n        });\n      }\n    },\n    // Expose the writable stream for direct piping in two-port mode\n    ...(messagePortWritable && { getWritable: () => messagePortWritable }),\n    onHmrAccept: (id, routes) => {\n      sendMessage({\n        type: \"HMR_ACCEPT\",\n        id: id,\n        routes: routes,\n      });\n    },\n    onHmrUpdate: (id, routes) => {\n      sendMessage({\n        type: \"HMR_UPDATE\",\n        id: id,\n        routes: routes,\n      });\n    },\n    onShutdown: (id) => {\n      sendMessage({\n        type: \"HMR_CLEANUP\",\n        id: id,\n      });\n    },\n    onCssFile: (id, code) => {\n      sendMessage({\n        type: \"CSS_FILE\",\n        id: id,\n        content: code,\n      });\n    },\n    onCleanup: (id) => {\n      sendMessage({\n        type: \"HMR_CLEANUP\",\n        id: id,\n      });\n    },\n    onShellReady: (id) => {\n      sendMessage({\n        type: \"SHELL_READY\",\n        id: id,\n      });\n    },\n    onAllReady: (id) => {\n      sendMessage({\n        type: \"RSC_END\",\n        id: id,\n      });\n    },\n    onServerActionResponse: (id, result, error) => {\n      sendMessage({\n        type: \"SERVER_ACTION_RESPONSE\",\n        id: id,\n        result: result,\n        // Only include error if it's truthy - prevents serializeError(undefined)\n        ...(error ? { error } : {}),\n      });\n    },\n  };\n}\n\n// Default handlers for backward compatibility\nexport const handlers = createHandlers();"],"names":[],"mappings":"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"}

package/dist/plugin/worker/rsc/hydrateRscRenderMessage.d.ts

@@ -0,0 +1,118 @@
+import type { HtmlComponentType, PageComponentType, PagePropOpt, ResolvedUserOptions, RootComponentType } from "../../types.js";
+import type { Logger } from "vite";
+import type { RscRenderMessage } from "./types.js";
+import type { React } from "../../vendor/vendor.server.js";
+/**
+ * Main function that hydrates an RSC render message with all necessary context
+ *
+ * This function orchestrates the process of preparing a render message for execution
+ * by validating, resolving URLs, merging defaults, and setting up components and loaders.
+ */
+export declare function hydrateRscRenderMessage({ message, pageProps, PageComponent, RootComponent, HtmlComponent, userOptions, logger, manifest, }: {
+    message: RscRenderMessage;
+    pageProps: PagePropOpt;
+    PageComponent: PageComponentType<PagePropOpt>;
+    RootComponent: RootComponentType | typeof React.Fragment;
+    HtmlComponent: HtmlComponentType | typeof React.Fragment | undefined;
+    userOptions: ResolvedUserOptions;
+    logger: Logger;
+    manifest: Record<string, {
+        file: string;
+    } | string>;
+}, { userOptions: defaultUserOptions }?: any): {
+    url: string;
+    pageProps: any;
+    RootComponent: import("react").ExoticComponent<import("react").FragmentProps> | RootComponentType;
+    HtmlComponent: import("react").ExoticComponent<import("react").FragmentProps> | HtmlComponentType<any, any, any, any> | HtmlComponentType;
+    PageComponent: PageComponentType<any>;
+    loader: import("../../types.js").GenericModuleLoader;
+    normalizer: import("../../types.js").InputNormalizer;
+    moduleID: ((id: string, sourceContent?: string) => string) | undefined;
+    logger: Logger;
+    autoDiscover: Required<import("../../types.js").AutoDiscoverConfig>;
+    onMetrics: undefined;
+    cssFiles: Map<string, import("../../types.js").StyleCssProps | import("../../types.js").LinkCssProps> & Map<string, import("../../types.js").CssContent>;
+    globalCss: Map<string, import("../../types.js").StyleCssProps | import("../../types.js").LinkCssProps> & Map<string, import("../../types.js").CssContent>;
+    build: {
+        pages: string[];
+        client: string;
+        server: string;
+        static: string;
+        outDir: string;
+        assetsDir: string;
+        preserveModulesRoot: boolean;
+        rscOutputPath: string;
+        htmlOutputPath: string;
+    };
+    as?: keyof import("react").JSX.IntrinsicElements | import("react").JSXElementConstructor<any> | undefined;
+    children?: import("react").ReactNode;
+    manifest: import("vite").Manifest;
+    server?: import("vite").ViteDevServer | undefined;
+    css: import("../../types.js").RootOptions<boolean>;
+    worker?: import("worker_threads").Worker | undefined;
+    dev: Pick<ResolvedUserOptions["dev"], "useHtmlWorker" | "useRscWorker">;
+    htmlWorkerPath: string;
+    rscWorkerPath: string;
+    htmlTimeout: number;
+    fileWriteTimeout: number;
+    workerShutdownTimeout: number;
+    clientPipeableStreamOptions?: import("react-dom/server").RenderToPipeableStreamOptions | undefined;
+    components?: {
+        Html?: HtmlComponentType<any, keyof import("react").JSX.IntrinsicElements | import("react").JSXElementConstructor<any>, boolean | undefined, import("react").ReactNode> | undefined;
+        Root?: RootComponentType<any, keyof import("react").JSX.IntrinsicElements | import("react").JSXElementConstructor<any>, boolean | undefined, import("react").ReactNode> | undefined;
+        Page?: PageComponentType<any, import("react").ReactNode> | undefined;
+    } | undefined;
+    reuseHeadlessStreamId?: string | undefined;
+    headlessStreamElements?: Map<string, {
+        PageComponent: any;
+        errored: boolean;
+    }> | undefined;
+    signal?: AbortSignal | undefined;
+    staticManifest?: import("vite").Manifest | undefined;
+    serverManifest?: import("vite").Manifest | undefined;
+    clientManifest?: import("vite").Manifest | undefined;
+    rscWorker?: import("worker_threads").Worker | undefined;
+    htmlWorker?: import("worker_threads").Worker | undefined;
+    importedCss?: Set<string> | undefined;
+    rscStream?: import("stream").Readable | undefined;
+    htmlStream?: import("stream").Readable | undefined;
+    metrics?: import("../../types.js").StreamMetrics | undefined;
+    resolvedPageProps?: Record<string, unknown>;
+    dataPort: MessagePort;
+    controlPort: MessagePort;
+    options: Omit<import("../../types.js").CreateHandlerOptions<ResolvedUserOptions>, "onEvent" | "onMetrics" | "loader" | "build" | "autoDiscover" | "normalizer" | "moduleID" | "url" | "logger"> & {
+        cssFiles?: Map<string, import("../../types.js").CssContent>;
+        globalCss?: Map<string, import("../../types.js").CssContent>;
+        url?: string;
+        build: Omit<import("../../types.js").CreateHandlerOptions<ResolvedUserOptions>["build"], "entryFileNames" | "chunkFileNames" | "assetFileNames" | "pages"> & {
+            pages: string[];
+        };
+        PageComponent?: any;
+        pageProps?: any;
+        RootComponent?: any;
+        HtmlComponent?: any;
+        resolvedPageProps?: Record<string, unknown>;
+    };
+    type: "INIT";
+    id: string;
+    route: string;
+    pagePath: string;
+    propsPath: string | undefined;
+    rootPath: string | undefined;
+    htmlPath: string | undefined;
+    rootExportName: string;
+    htmlExportName: string;
+    pageExportName: string;
+    propsExportName: string;
+    projectRoot: string;
+    moduleRootPath: string;
+    moduleBaseURL: string;
+    moduleBasePath: string;
+    moduleBase: string;
+    serverPipeableStreamOptions: any;
+    verbose: boolean;
+    rscTimeout: number;
+    panicThreshold: import("../../types.js").PanicThreshold;
+    publicOrigin: string;
+};
+//# sourceMappingURL=hydrateRscRenderMessage.d.ts.map

package/dist/plugin/worker/rsc/hydrateRscRenderMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrateRscRenderMessage.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/rsc/hydrateRscRenderMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,+BAA+B,CAAC;AA4B3D;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,EACE,OAAO,EACP,SAAS,EACT,aAAa,EACb,aAAa,EACb,aAAa,EACb,WAAW,EACX,MAAM,EACN,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,gBAAgB,CAAC;IAC1B,SAAS,EAAE,WAAW,CAAC;IACvB,aAAa,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAC9C,aAAa,EAAE,iBAAiB,GAAG,OAAO,KAAK,CAAC,QAAQ,CAAC;IACzD,aAAa,EAAE,iBAAiB,GAAG,OAAO,KAAK,CAAC,QAAQ,GAAG,SAAS,CAAC;IACrE,WAAW,EAAE,mBAAmB,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,CAAC;CACrD,EAED,EAAE,WAAW,EAAE,kBAAuB,EAAE,GAAE,GAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA+CJ,CAAC;iBAEzC,CAAR;WAIM,CAAC;;;;qBAA0Q,CAAC;iBAAoB,CAAC;qBAAwB,CAAC;qBAAwB,CAAC;yBAA+G,CAAC;;;;;;;;;;;;;;;;;;;;;;;EADxc"}

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

@@ -0,0 +1,61 @@
+import { createRscWorkerLoader } from "./createRscWorkerLoader.js";
+import { validateRscRenderMessage, resolveRenderUrl, mergeMessageWithDefaults, resolveWithDefaultRootAndHtml, logRenderStart, } from "../../helpers/index.js";
+/**
+ * Creates the RSC worker loader with necessary configuration
+ */
+function createLoader(verbose, logger, projectRoot, build, manifest) {
+    return createRscWorkerLoader({
+        verbose,
+        logger,
+        projectRoot,
+        build,
+        manifest,
+    });
+}
+/**
+ * Main function that hydrates an RSC render message with all necessary context
+ *
+ * This function orchestrates the process of preparing a render message for execution
+ * by validating, resolving URLs, merging defaults, and setting up components and loaders.
+ */
+export function hydrateRscRenderMessage({ message, pageProps, PageComponent, RootComponent, HtmlComponent, userOptions, logger, manifest, }, 
+// defaults
+{ userOptions: defaultUserOptions = {} } = {}) {
+    // Step 1: Validate the message type
+    validateRscRenderMessage(message);
+    // Step 2: Resolve the URL for this render operation
+    const url = resolveRenderUrl(message, userOptions);
+    // Step 3: Merge message values with defaults
+    const mergedValues = mergeMessageWithDefaults(message, defaultUserOptions);
+    // Step 4: Log render start if verbose
+    logRenderStart(mergedValues.route, mergedValues.verbose, logger, "rsc-worker");
+    // Step 5: Resolve components with fallbacks
+    const { RootComponent: resolvedRootComponent, HtmlComponent: resolvedHtmlComponent } = resolveWithDefaultRootAndHtml(RootComponent, HtmlComponent);
+    // Step 6: Create the loader
+    const loader = createLoader(mergedValues.verbose, logger, mergedValues.projectRoot, mergedValues.build, manifest);
+    // Step 7: Return the fully hydrated render context
+    return {
+        ...mergedValues,
+        url,
+        pageProps,
+        RootComponent: resolvedRootComponent,
+        HtmlComponent: resolvedHtmlComponent,
+        PageComponent,
+        loader,
+        normalizer: userOptions.normalizer,
+        moduleID: userOptions.moduleID,
+        logger,
+        autoDiscover: userOptions.autoDiscover,
+        onMetrics: undefined,
+        // Preserve CSS-related properties from the original message
+        cssFiles: message.options.cssFiles,
+        globalCss: message.options.globalCss,
+        // Ensure build.pages is a string array for worker compatibility
+        build: {
+            ...mergedValues.build,
+            pages: Array.isArray(mergedValues.build.pages)
+                ? mergedValues.build.pages
+                : [],
+        },
+    };
+}

package/dist/plugin/worker/rsc/messageHandler.d.ts

@@ -1,3 +1,3 @@
 import type { RscWorkerInputMessage } from "./types.js";
-export declare function messageHandler(msg: RscWorkerInputMessage, port?: import("worker_threads").MessagePort | null): Promise<void>;
+export declare function messageHandler(msg: RscWorkerInputMessage): Promise<void>;
 //# sourceMappingURL=messageHandler.d.ts.map

package/dist/plugin/worker/rsc/messageHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messageHandler.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/rsc/messageHandler.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAexD,wBAAsB,cAAc,CAClC,GAAG,EAAE,qBAAqB,EAC1B,IAAI,8CAAa,iBAmFlB"}
+{"version":3,"file":"messageHandler.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/rsc/messageHandler.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AAulBpB,wBAAsB,cAAc,CAClC,GAAG,EAAE,qBAAqB,iBAmtB3B"}