vite-plugin-react-server 0.3.0 → 0.3.4

package/src/options.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import type { ConfigEnv, ResolvedConfig, UserConfig } from "vite";
-import type { ResolvedUserOptions, StreamPluginOptions } from "./types.js";
+import type { ResolvedUserConfig, ResolvedUserOptions, StreamPluginOptions } from "./types.js";
+import type { InputOption } from "rollup";
 // Default configuration values
 export const DEFAULT_CONFIG = {
   FILE_REGEX: /\.(m|c)?(j|t)sx?$/,
@@ -14,9 +15,9 @@ export const DEFAULT_CONFIG = {
   CLIENT_ENTRY: "/src/client.tsx",
   PAGE_EXPORT: "Page",
   PROPS_EXPORT: "props",
-  // relative from plugin root
-  WORKER_PATH: "worker/worker.tsx",
-  LOADER_PATH: "worker/loader.ts",
+  // Use package name paths instead of relative paths
+  WORKER_PATH: "vite-plugin-react-server/worker",
+  LOADER_PATH: "vite-plugin-react-server/loader",
   RSC_EXTENSION: ".rsc",
   HTML: ({ children }: { children: any }) => children,
   COLLECT_CSS: true,
@@ -33,6 +34,10 @@ export const DEFAULT_CONFIG = {
     client: "dist/client",
     server: "dist/server",
   },
+  AUTO_DISCOVER: {
+    pagePattern: "**/*.page.tsx",
+    propsPattern: "**/*.props.ts",
+  },
 } as const;
 
 export const resolveConfig = <T extends ResolvedConfig>(
@@ -51,7 +56,7 @@ export const resolveConfig = <T extends ResolvedConfig>(
 
 export const resolveUserConfig = (
   condition: "react-client" | "react-server",
-  input: string[],
+  input: InputOption,
   config: UserConfig,
   configEnv: ConfigEnv,
   userOptions: ResolvedUserOptions
@@ -59,8 +64,7 @@ export const resolveUserConfig = (
   | { type: "error"; error: Error }
   | {
       type: "success";
-      userConfig: Required<Pick<UserConfig, "root" | "build" | "mode">> &
-        Omit<UserConfig, "root" | "build" | "mode">;
+      userConfig: ResolvedUserConfig;
     } => {
   const isReactServer = condition === "react-server";
   const isViteServer = configEnv.command === "serve";
@@ -74,14 +78,17 @@ export const resolveUserConfig = (
           ...config.build,
           rollupOptions: {
             ...config.build?.rollupOptions,
-            input: input
-          }
-        }
-      }
+            input: input,
+          },
+        },
+      };
     }
   }
 
-  if (typeof config.build?.assetsDir === 'string' && userOptions.assetsDir !== config.build?.assetsDir) {
+  if (
+    typeof config.build?.assetsDir === "string" &&
+    userOptions.assetsDir !== config.build?.assetsDir
+  ) {
     return {
       type: "error",
       error: new Error(
@@ -111,7 +118,7 @@ export const resolveUserConfig = (
             : "react-server condition was not set. Please use `NODE_OPTIONS='--conditions react-server' vite build --ssr`"
         ),
       };
-    } else if (!configEnv.isSsrBuild && configEnv.command !== 'serve') {
+    } else if (!configEnv.isSsrBuild && configEnv.command !== "serve") {
       return {
         type: "error",
         error: new Error(
@@ -122,7 +129,16 @@ export const resolveUserConfig = (
   }
 
   const { root: configRoot, mode: configMode, ...configRest } = config;
-  const { outDir: configOutDir, assetsDir: configAssetsDir, ssr: configSsr, manifest: configManifest, ssrManifest: configSsrManifest, target: configTarget, ...configBuildRest } = config.build ?? {};
+  const {
+    outDir: configOutDir,
+    assetsDir: configAssetsDir,
+    ssr: configSsr,
+    manifest: configManifest,
+    ssrManifest: configSsrManifest,
+    ssrEmitAssets: configSsrEmitAssets,
+    target: configTarget,
+    ...configBuildRest
+  } = config.build ?? {};
 
   return {
     type: "success",
@@ -135,6 +151,7 @@ export const resolveUserConfig = (
         ssr: configSsr ?? isReactServer,
         manifest: configManifest ?? true,
         ssrManifest: configSsrManifest ?? true,
+        ssrEmitAssets: configSsrEmitAssets ?? true,
         target: configTarget ?? "es2020",
         outDir:
           typeof configOutDir === "string"
@@ -146,7 +163,7 @@ export const resolveUserConfig = (
           typeof configAssetsDir === "string"
             ? configAssetsDir
             : isReactServer
-            ? ''
+            ? ""
             : DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
       },
     },
@@ -156,37 +173,63 @@ export const resolveUserConfig = (
 export const resolveOptions = (
   options: StreamPluginOptions
 ):
-  | { type: "error"; error: Error }
   | {
       type: "success";
       userOptions: ResolvedUserOptions;
+    }
+  | {
+      type: "error";
+      error: Error;
     } => {
-  const projectRoot = options.projectRoot ?? process.cwd();
+  const {
+    workerPath: optionsWorkerPath,
+    loaderPath: optionsLoaderPath,
+    projectRoot: optionsProjectRoot,
+    moduleBase: optionsModuleBase,
+    moduleBasePath: optionsModuleBasePath,
+    moduleBaseURL: optionsModuleBaseURL,
+    build: optionsBuild,
+    Page: optionsPage,
+    props: optionsProps,
+    Html: optionsHtml,
+    pageExportName: optionsPageExportName,
+    propsExportName: optionsPropsExportName,
+    collectCss: optionsCollectCss,
+    collectAssets: optionsCollectAssets,
+    assetsDir: optionsAssetsDir,
+    clientEntry: optionsClientEntry,
+    serverOutDir: optionsServerOutDir,
+    clientOutDir: optionsClientOutDir,
+    autoDiscover: optionsAutoDiscover,
+    moduleBaseExceptions: optionsModuleBaseExceptions,
+    ...restOptions
+  } = options;
+  const projectRoot = optionsProjectRoot ?? process.cwd();
   /** the module base can be assumed to not have a leading slash */
   const moduleBase =
-    typeof options.moduleBase === "string"
-      ? options.moduleBase.startsWith(path.sep)
-        ? options.moduleBase.slice(path.sep.length)
-        : options.moduleBase
+    typeof optionsModuleBase === "string"
+      ? optionsModuleBase.startsWith(path.sep)
+        ? optionsModuleBase.slice(path.sep.length)
+        : optionsModuleBase
       : DEFAULT_CONFIG.MODULE_BASE;
 
   if (
-    typeof options.moduleBase === "string" &&
-    options.moduleBase !== moduleBase
+    typeof optionsModuleBase === "string" &&
+    optionsModuleBase !== moduleBase
   ) {
     return {
       type: "error",
       error: new Error(
-        `moduleBase ${options.moduleBase} is invalid, should be like ${moduleBase}`
+        `moduleBase ${optionsModuleBase} is invalid, should be like ${moduleBase}`
       ),
     };
   }
 
   const moduleBasePath =
-    typeof options.moduleBasePath === "string"
-      ? !options.moduleBasePath.startsWith(path.sep)
-        ? `${path.sep}${options.moduleBasePath}`
-        : options.moduleBasePath
+    typeof optionsModuleBasePath === "string"
+      ? !optionsModuleBasePath.startsWith(path.sep)
+        ? `${path.sep}${optionsModuleBasePath}`
+        : optionsModuleBasePath
       : `${path.sep}${moduleBase}`;
 
   if (!moduleBasePath.includes(moduleBase)) {
@@ -199,10 +242,10 @@ export const resolveOptions = (
   }
 
   const moduleBaseURL =
-    typeof options.moduleBaseURL === "string"
-      ? !options.moduleBaseURL.endsWith(moduleBasePath)
-        ? path.join(options.moduleBaseURL, moduleBasePath)
-        : options.moduleBaseURL
+    typeof optionsModuleBaseURL === "string"
+      ? !optionsModuleBaseURL.endsWith(moduleBasePath)
+        ? path.join(optionsModuleBaseURL, moduleBasePath)
+        : optionsModuleBaseURL
       : moduleBasePath;
 
   if (!moduleBaseURL.includes(moduleBasePath)) {
@@ -215,41 +258,70 @@ export const resolveOptions = (
   }
 
   if (
-    typeof options.moduleBaseURL === "string" &&
-    options.moduleBaseURL !== moduleBaseURL
+    typeof optionsModuleBaseURL === "string" &&
+    optionsModuleBaseURL !== moduleBaseURL
   ) {
     return {
       type: "error",
       error: new Error(
-        `moduleBaseURL ${options.moduleBaseURL} is invalid, should be like ${moduleBaseURL}`
+        `moduleBaseURL ${optionsModuleBaseURL} is invalid, should be like ${moduleBaseURL}`
       ),
     };
   }
 
-  const build = options.build
+  const build = optionsBuild
     ? {
-        client: options.build.client ?? DEFAULT_CONFIG.BUILD.client,
-        pages: options.build.pages ?? DEFAULT_CONFIG.BUILD.pages,
-        server: options.build.server ?? DEFAULT_CONFIG.BUILD.server,
+        client: optionsBuild.client ?? DEFAULT_CONFIG.BUILD.client,
+        pages: optionsBuild.pages ?? DEFAULT_CONFIG.BUILD.pages,
+        server: optionsBuild.server ?? DEFAULT_CONFIG.BUILD.server,
       }
     : DEFAULT_CONFIG.BUILD;
 
+  const autoDiscover =
+    typeof optionsAutoDiscover === "object"
+      ? {
+          pagePattern:
+            typeof optionsAutoDiscover.pagePattern === "string"
+              ? optionsAutoDiscover.pagePattern
+              : DEFAULT_CONFIG.AUTO_DISCOVER.pagePattern,
+          propsPattern:
+            typeof optionsAutoDiscover.propsPattern === "string"
+              ? optionsAutoDiscover.propsPattern
+              : DEFAULT_CONFIG.AUTO_DISCOVER.propsPattern,
+        }
+      : DEFAULT_CONFIG.AUTO_DISCOVER;
+
+  const workerPath = typeof optionsWorkerPath === "string" ? optionsWorkerPath : DEFAULT_CONFIG.WORKER_PATH;
+  const loaderPath = typeof optionsLoaderPath === "string" ? optionsLoaderPath : DEFAULT_CONFIG.LOADER_PATH;
   return {
     type: "success",
     userOptions: {
+      ...DEFAULT_CONFIG,
+      ...restOptions,
       moduleBase,
       moduleBasePath,
       moduleBaseURL,
       build,
-      Page: options.Page ?? DEFAULT_CONFIG.PAGE,
-      props: options.props ?? DEFAULT_CONFIG.PROPS,
-      Html: options.Html ?? DEFAULT_CONFIG.HTML,
-      pageExportName: options.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT,
-      propsExportName: options.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT,
-      collectCss: options.collectCss ?? DEFAULT_CONFIG.COLLECT_CSS,
-      collectAssets: options.collectAssets ?? DEFAULT_CONFIG.COLLECT_ASSETS,
+      Page: optionsPage ?? DEFAULT_CONFIG.PAGE,
+      props: optionsProps ?? DEFAULT_CONFIG.PROPS,
+      Html: optionsHtml ?? DEFAULT_CONFIG.HTML,
+      pageExportName: optionsPageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT,
+      propsExportName: optionsPropsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT,
+      collectCss: optionsCollectCss ?? DEFAULT_CONFIG.COLLECT_CSS,
+      collectAssets: optionsCollectAssets ?? DEFAULT_CONFIG.COLLECT_ASSETS,
       projectRoot: projectRoot,
-      assetsDir: options.assetsDir ?? DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
+      assetsDir: optionsAssetsDir ?? DEFAULT_CONFIG.CLIENT_ASSETS_DIR,
+      workerPath: workerPath,
+      loaderPath: loaderPath,
+      clientEntry: optionsClientEntry ?? DEFAULT_CONFIG.CLIENT_ENTRY,
+      serverOutDir: optionsServerOutDir ?? DEFAULT_CONFIG.BUILD.server,
+      clientOutDir: optionsClientOutDir ?? DEFAULT_CONFIG.BUILD.client,
+      autoDiscover: autoDiscover,
+      moduleBaseExceptions: [
+        workerPath,
+        loaderPath,
+        ...(optionsModuleBaseExceptions ?? []),
+      ],
     } satisfies ResolvedUserOptions,
   };
 };

package/src/plugin.ts

@@ -1,31 +1,5 @@
-import { resolveOptions } from "./options.js";
-import { viteReactClientTransformPlugin } from "./transformer/index.js";
-import { preserveDirectives } from "./transformer/preserveDirectives.js";
-import type { StreamPluginOptions } from "./types.js";
+import "./assertServerCondition.js";
+export { reactStreamPlugin } from "./react-server/plugin.js";
 
-export const getCondition = (options: { env?: typeof process.env } = {}) => {
-  const nodeOptions = options?.env?.['NODE_OPTIONS'] ?? process.env['NODE_OPTIONS'];
-  return nodeOptions?.match(/--conditions=react-server/) ? "server" : "client";
-};
-
-export const reactStreamPlugin = async (options: StreamPluginOptions) => {
-  const condition = getCondition();
-  try {
-    const resolvedOptions = resolveOptions(options);
-    if (resolvedOptions.type === "error") {
-      throw resolvedOptions.error;
-    }
-    options = resolvedOptions.userOptions;
-  } catch (error) {
-    throw new Error(
-      `[vite:react-stream:${condition}] ${(error as Error).message}`
-    );
-  }
-  return condition === "server"
-    ? [
-        (await import(`./react-server/plugin.js`)).reactStreamPlugin(options),
-        viteReactClientTransformPlugin(),
-        preserveDirectives(),
-      ]
-    : [(await import(`./react-client/plugin.js`)).reactStreamPlugin(options)];
-};
+// the main plugin is version is the server version, if you want the client version, use the `vite-plugin-react-server/client` import
+// this is because the workflow assumes main thread = react server condition

package/src/react-server/createSsrHandler.ts

@@ -30,7 +30,7 @@ export function createSsrHandler(
   const worker = new Worker(
     options?.workerPath
       ? resolve(server.config.root, options?.workerPath)
-      : resolve(__dirname, "..", DEFAULT_CONFIG.WORKER_PATH),
+      : DEFAULT_CONFIG.WORKER_PATH,
     {
       env: {
         NODE_OPTIONS: "--conditions ''",

package/src/react-server/plugin.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import type { ServerResponse } from "node:http";
-import { resolve as resolvePath } from "node:path";
+import { join, relative, resolve, resolve as resolvePath } from "node:path";
 import { performance } from "node:perf_hooks";
 import { Worker } from "node:worker_threads";
 import type { Plugin as RollupPlugin } from "rollup";
@@ -21,15 +21,18 @@ import type { BuildTiming, ReactStreamPluginMeta } from "../types.js";
 import { type StreamPluginOptions } from "../types.js";
 import { createWorker } from "../worker/createWorker.js";
 import { createHandler } from "./createHandler.js";
+import { tryManifest } from "../helpers/tryManifest.js";
+import { createNormalizedRelativePath } from "../helpers/normalizedRelativePath.js";
 
-let pageSet: Set<string>;
-let pageMap: Map<string, string>;
+let files: Awaited<ReturnType<typeof checkFilesExist>>;
+let env: Awaited<ReturnType<typeof getEnv>>;
 let worker: Worker;
 let config: ResolvedConfig;
 let cssModules = new Set<string>();
 let clientComponents = new Map<string, string>();
 let define: Record<string, string>;
 let buildCssFiles = new Set<string>();
+let root: string = process.cwd();
 
 interface BuildStats {
   htmlFiles: number;
@@ -127,7 +130,7 @@ export async function reactStreamPlugin(
               propsExportName: userOptions.propsExportName,
               moduleBase: userOptions.moduleBase,
               moduleBasePath: userOptions.moduleBasePath,
-              projectRoot: server.config.root,
+              projectRoot: server.config.root ?? userOptions.projectRoot,
             },
             {
               cssFiles: Array.from(cssModules),
@@ -148,39 +151,70 @@ export async function reactStreamPlugin(
 
     async config(config, configEnv): Promise<UserConfig> {
       const resolvedPages = await resolvePages(userOptions.build.pages);
-      if(resolvedPages.type === 'error') {
+      if (resolvedPages.type === "error") {
         throw resolvedPages.error;
       }
       const { pages } = resolvedPages;
+      env = getEnv(config, configEnv);
+      define = env.define;
+      files = await checkFilesExist(
+        pages,
+        userOptions,
+        config.root ?? userOptions.projectRoot
+      );
+      root = config.root ?? userOptions.projectRoot;
       const resolvedConfig = resolveUserConfig(
         "react-server",
-        pages,
+        [...pages, userOptions.workerPath, userOptions.loaderPath],
         config,
         configEnv,
         userOptions
       );
-      if(resolvedConfig.type === "error") {
+      if (resolvedConfig.type === "error") {
         throw resolvedConfig.error;
       }
       const { userConfig } = resolvedConfig;
+      console.log({
+        worker: userOptions.workerPath,
+        loader: userOptions.loaderPath,
+      });
+      const entriesClient = Object.fromEntries([
+        ...Array.from(files.pageMap.entries()).map(([key, value]) => [
+          key,
+          relative(root, value),
+        ]),
+        ...Array.from(files.propsMap.entries()).map(([key, value]) => [
+          key,
+          relative(root, value),
+        ]),
+      ]);
+      const entriesResolved = Object.fromEntries(
+        (Object.entries(entriesClient) as [string, string][]).map(
+          ([key, entry]) => {
+            if (typeof entry !== "string") {
+              return [key, entry];
+            }
 
-      const envResult = getEnv(userConfig, configEnv);
-      const files = await checkFilesExist(pages, userOptions, userConfig.root);
-      pageSet = files.pageSet;
-      pageMap = files.pageMap;
-      define = envResult.define;
-      const entries = Array.from(
-        new Set([
-          ...Array.from(files.pageSet.values()),
-          ...Array.from(files.propsSet.values()),
-        ]).values()
+            return [key, entry];
+          }
+        )
       );
+      const serverEntries = {
+        ...entriesResolved,
+        ["worker/worker"]: userOptions.workerPath,
+        ["worker/loader"]: userOptions.loaderPath,
+      };
 
       const buildConfig = createBuildConfig({
-        root: config.root ?? process.cwd(),
-        base: config.base ?? envResult.publicUrl,
-        outDir: config.build?.outDir ?? "dist/server",
-        entries,
+        input: serverEntries,
+        userConfig: userConfig,
+        userOptions: userOptions,
+        root,
+        moduleBaseExceptions: [
+          userOptions.workerPath,
+          userOptions.loaderPath,
+          ...userOptions.moduleBaseExceptions,
+        ],
       });
       return {
         ...buildConfig,
@@ -192,44 +226,70 @@ export async function reactStreamPlugin(
       timing.buildStart = performance.now();
     },
     async closeBundle() {
-      if(!config) return;
+      if (!config) return;
       console.log("RSC CLOSE BUNDLE CALLED");
-      if (!pageSet?.size) return;
+      if (!files.pageSet.size) return;
       timing.renderStart = performance.now();
 
       try {
-        const manifest = JSON.parse(
-          readFileSync(
-            resolvePath(
-              config.root,
-              config.build.outDir,
-              ".vite",
-              "manifest.json"
-            ),
-            "utf-8"
-          )
-        ) as Manifest;
-        const clientManifest = JSON.parse(
-          readFileSync(
-            resolvePath(
-              config.root,
-              userOptions.build.client,
-              ".vite",
-              "manifest.json"
-            ),
-            "utf-8"
-          )
-        ) as Manifest;
+        const resolvedServerManifest = tryManifest({
+          root,
+          outDir: userOptions.build.server,
+          ssrManifest: false,
+        });
+        if (resolvedServerManifest.type === "error") {
+          console.error(
+            "[vite-react-stream] Server Build failed, can not build without a server manifest. Please set `manifest: true` in your vite config.",
+            resolvedServerManifest.error
+          );
+          return;
+        }
+        const { manifest: serverManifest } = resolvedServerManifest;
+
+        // get worker path from server manifest
+        const workerPath =
+          serverManifest[userOptions.workerPath]?.file ??
+          serverManifest[relative(root, userOptions.workerPath)]?.file ??
+          serverManifest[
+            relative(
+              join(root, userOptions.build.server),
+              userOptions.workerPath
+            )
+          ]?.file;
+        if (!workerPath) {
+          console.log(serverManifest, userOptions.build.server);
+          throw new Error(
+            `Worker path not found in server manifest, tried: ${userOptions.workerPath}, ${relative(root, userOptions.workerPath)}, ${join(root, userOptions.build.server, userOptions.workerPath)}`
+          );
+        }
+        console.log("workerPath", workerPath);
+        // client
+        const resolvedClientManifest = tryManifest({
+          root,
+          outDir: userOptions.build.client,
+          ssrManifest: false,
+        });
+        if (resolvedClientManifest.type === "error") {
+          console.error(
+            "[vite-react-stream] Server Build failed, can not build without a client manifest. Make sure to run the client build before the server build and set `manifest: true` in your vite config.",
+            resolvedClientManifest.error
+          );
+          return;
+        }
+        const { manifest: clientManifest } = resolvedClientManifest;
+
         // Create a single worker for all routes
         if (!worker)
-          worker = await createWorker(
-            config.root,
-            config.build.outDir,
-            "worker.js",
-            process.env["NODE_ENV"] === "development" ? "development" : "production"
-          );
+          worker = await createWorker({
+            workerPath: join(root, userOptions.build.server, workerPath),
+            nodePath: process.env["NODE_PATH"] ?? resolve(root, "node_modules"),
+            mode:
+              process.env["NODE_ENV"] === "development"
+                ? "development"
+                : "production",
+          });
         // this is based on the user config - the routes should lead to a page and props but the rendering is agnostic of that
-        const routes = Array.from(pageMap.keys());
+        const routes = Array.from(files.pageMap.keys());
         const indexEntry = clientManifest["index.html"];
         if (!indexEntry) {
           throw new Error("root /index.html not found");
@@ -250,19 +310,19 @@ export async function reactStreamPlugin(
             moduleBase: userOptions.moduleBase,
             moduleBasePath: userOptions.moduleBasePath,
             moduleBaseURL: userOptions.moduleBaseURL,
-            projectRoot: config.root,
+            projectRoot: root,
           },
           worker: worker,
-          manifest: clientManifest as Manifest,
+          manifest: clientManifest,
           loader: createPageLoader({
-            manifest,
+            manifest: clientManifest,
             root: config.root,
             outDir: config.build.outDir,
             moduleBase: userOptions.moduleBase,
             alwaysRegisterServer: false,
             alwaysRegisterClient: false,
             registerServer: [],
-            registerClient: Object.keys(clientManifest).filter(
+            registerClient: Object.keys(resolvedClientManifest).filter(
               (key) =>
                 key.endsWith(".client.tsx") && clientManifest[key].isEntry
             ),

package/src/types.ts

@@ -1,9 +1,11 @@
 import type {
   AliasOptions,
+  BuildOptions,
   Connect,
   Logger,
   Manifest,
   ModuleGraph,
+  UserConfig,
   ViteDevServer,
 } from "vite";
 
@@ -35,8 +37,23 @@ export type ResolvedUserOptions = Required<
     | "collectCss"
     | "collectAssets"
     | "assetsDir"
+    | "workerPath"
+    | "loaderPath"
+    | "clientEntry"
+    | "serverOutDir"
+    | "clientOutDir"
+    | "moduleBaseExceptions"
   >
-> & { build: NonNullable<Required<StreamPluginOptions["build"]>> };
+> & {
+  build: NonNullable<Required<StreamPluginOptions["build"]>>;
+  autoDiscover: NonNullable<Required<StreamPluginOptions["autoDiscover"]>>;
+};
+
+export type ResolvedUserConfig = Required<Pick<UserConfig, "root" | "mode">> &
+  Omit<UserConfig, "root" | "mode" | "build"> & {
+  build: Required<Pick<BuildOptions, "target" | "outDir" | "assetsDir" | "ssr" | "ssrEmitAssets" | "ssrManifest" | "manifest">> &
+    Partial<Omit<BuildOptions, "target" | "outDir" | "assetsDir" | "ssr" | "ssrEmitAssets" | "ssrManifest" | "manifest">>;
+};
 
 export interface StreamPluginOptions {
   projectRoot?: string;
@@ -70,6 +87,7 @@ export interface StreamPluginOptions {
   collectCss?: boolean;
   collectAssets?: boolean;
   build?: BuildConfig;
+  moduleBaseExceptions?: string[];
 }
 
 export interface CreateHandlerOptions<T = any> {

package/src/worker/createWorker.ts

@@ -1,23 +1,28 @@
-import { resolve } from "node:path";
+import { join } from "node:path";
 import { Worker } from "node:worker_threads";
 
+type CreateWorkerOptions = {
+  workerPath: string;
+  nodePath: string;
+  mode: "production" | "development";
+  workerOptions?: WorkerOptions;
+};
+
 export async function createWorker(
-  projectRoot: string,
-  outDir: string,
-  fileName: string,
-  mode: "production" | "development"
+  options: CreateWorkerOptions
 ) {
+  const { workerPath, nodePath, mode, workerOptions } = options;
   console.log("[Worker] Creating worker...");
-  const workerPath = resolve(projectRoot, outDir, fileName);
   console.log("[Worker] Worker path:", workerPath);
 
   try {
     const worker = new Worker(workerPath, {
       env: {
         NODE_OPTIONS: "",
-        NODE_PATH: resolve(projectRoot, "node_modules"),
         NODE_ENV: mode,
+        NODE_PATH: nodePath,
       },
+      ...workerOptions,
     });
     worker.setMaxListeners(1000);