vite-plugin-react-server 0.3.0 → 0.3.3

package/src/assertServerCondition.ts

@@ -0,0 +1,13 @@
+function assertServerCondition<P extends typeof process>(p: P): asserts p is P & { env: { NODE_OPTIONS: string } } {
+    const nodeOptions = p.env['NODE_OPTIONS'];
+    if (!nodeOptions?.match(/--conditions[= ]react-server/)) {
+        if(!nodeOptions?.match(/--conditions/)) {
+            console.warn(`process.env['NODE_OPTIONS'] is missing \`--conditions\` flag, it should be like \`--conditions=react-server\` or \`--conditions react-server\`, but was ${JSON.stringify(process.env['NODE_OPTIONS'])}`);
+        }
+        if(!nodeOptions?.match(/react-server/)) {
+            throw new Error(`process.env['NODE_OPTIONS'] is missing \`react-server\` flag, it should be like \`--conditions=react-server\` or \`--conditions react-server\`, but was ${JSON.stringify(process.env['NODE_OPTIONS'])}`);
+        }
+    }
+    return undefined;
+  };
+assertServerCondition(process);

package/src/build/createBuildConfig.ts

@@ -1,62 +1,43 @@
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import type { InlineConfig } from "vite";
-import { DEFAULT_CONFIG } from "../options.js";
-import type { StreamPluginOptions } from "../types.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import type { ResolvedUserConfig, ResolvedUserOptions } from "../types.js";
+import type { InputOption } from "rollup";
+import { mergeInputs } from "./mergeInputs.js";
+import { createInputNormalizer } from "../helpers/inputNormalizer.js";
 
 type CreateBuildConfigOptions = {
+  input: InputOption;
+  userOptions:  ResolvedUserOptions;
+  userConfig: ResolvedUserConfig;
   root: string;
-  base: string;
-  outDir: string;
-  entries: string[];
-  options?: StreamPluginOptions;
+  moduleBaseExceptions: string[];
 };
 
+
 export function createBuildConfig({
   root,
-  base,
-  outDir,
-  entries,
-  options,
+  input,
+  userOptions,
+  userConfig,
+  moduleBaseExceptions
 }: CreateBuildConfigOptions) {
-  // Transform entries into proper input format with unique keys
-  const entryInputs = Object.fromEntries(
-    entries.map((entry) => {
-      // Get the path relative to root
-      const relativePath = entry.replace(root + "/", "");
-      // Create a unique key based on the full path
-      const key = relativePath.replace(/\.[^/.]+$/, ""); // Remove extension
-
-      return [key, entry];
-    })
-  );
-
-  const workerPath = options?.workerPath
-    ? resolve(root, options.workerPath)
-    : resolve(__dirname, "..", DEFAULT_CONFIG.WORKER_PATH);
+  const { output, input: inputConfig, ...restRollupOptions } =
+    userConfig.build.rollupOptions ?? {};
 
-  const loaderPath = options?.loaderPath
-    ? resolve(root, options.loaderPath)
-    : resolve(__dirname, "..", DEFAULT_CONFIG.LOADER_PATH);
+  let mergedInputs = mergeInputs(input, inputConfig);
 
+  let inputNormalizer = createInputNormalizer({
+    root,
+  });
+  if(typeof mergedInputs === 'object' && mergedInputs != null) {
+    mergedInputs = Object.fromEntries(Object.entries(mergedInputs).map(inputNormalizer));
+  }
   const config: InlineConfig = {
     configFile: false,
-    root,
-    base,
+    ...userConfig,
     build: {
-      target: "node18",
-      ssr: true,
-      ssrEmitAssets: false,
-      manifest: true,
-      ssrManifest: true,
-      outDir,
+      ...userConfig.build,
       rollupOptions: {
-        input: {
-          ...entryInputs,
-          worker: workerPath,
-          loader: loaderPath,
-        },
+        input: mergedInputs,
         output: {
           format: "esm",
           preserveModules: true,
@@ -65,7 +46,9 @@ export function createBuildConfig({
           entryFileNames: "[name].js",
           chunkFileNames: "[name].js",
           assetFileNames: "[name][extname]",
+          ...output,
         },
+        ...restRollupOptions,
       },
     },
   };

package/src/build/mergeInputs.ts

@@ -0,0 +1,42 @@
+import type { InputOption } from "rollup";
+
+export const mergeAsArray = (entries: InputOption) => {
+  return Array.isArray(entries)
+    ? entries
+    : typeof entries === "object" && entries != null
+    ? Object.values(entries)
+    : typeof entries === "string"
+    ? [entries]
+    : [];
+};
+export const mergeAsObject = (entries: InputOption) => {
+  return Array.isArray(entries)
+    ? Object.fromEntries(entries.map((entry) => [entry, entry]))
+    : typeof entries === "object" && entries != null
+    ? entries
+    : typeof entries === "string"
+    ? { [entries]: entries }
+    : {};
+};
+
+export const mergeInputs = (
+  input: InputOption,
+  input2: InputOption | undefined
+) => {
+  if (!input2) return input;
+  return Array.isArray(input)
+    ? [...input, ...mergeAsArray(input2)]
+    : typeof input === "string"
+    ? [input, ...mergeAsArray(input2)]
+    : input != null && typeof input2 === "object" && input2 != null
+    ? { ...input, ...mergeAsObject(input2) }
+    : input != null
+    ? input
+    : Array.isArray(input2)
+    ? input2
+    : typeof input2 === "object" && input2 != null
+    ? input2
+    : typeof input2 === "string"
+    ? input2
+    : [];
+};

package/src/helpers/inputNormalizer.ts

@@ -0,0 +1,22 @@
+import { relative } from "node:path";
+
+type NormalizedInputOptions = {
+  // will automatically remove this part
+  root?: string;
+};
+
+export const createInputNormalizer =
+  (
+    {
+      root = process.cwd(),
+    }: NormalizedInputOptions = {} as NormalizedInputOptions
+  ) =>
+  ([key, path]: [string, string]) =>
+    [
+      key,
+      path.startsWith(root)
+        ? relative(root, path)
+        : path.startsWith("/")
+        ? path
+        : `/${path}`,
+    ];

package/src/helpers/normalizedRelativePath.ts

@@ -4,56 +4,56 @@ type NormalizedRelativePathOptions = {
   // will automatically remove this part
   root: string;
   // will automatically see this as a optional extra part of the rootDir that will be removed
-  outDir: string | string[];
+  outDir: string;
   // will ensure it always starts with this path, if it does not it will be added
   moduleBase: string;
   // will ensure it never starts with a leading /, which in some cases is needed (vite entry), other cases it is not for example from project root /
   noLeadingSlash: boolean;
+  // will ensure it never ends with a trailing /
+  noTrailingSlash: boolean;
+  // allowed exception to moduleBase rules
+  moduleBaseExceptions: string[];
 };
 
 export const createNormalizedRelativePath = (
   options: NormalizedRelativePathOptions = {
     root: process.cwd(),
-    outDir: ["dist", "build"],
+    outDir: "dist",
     moduleBase: "src",
     noLeadingSlash: false,
+    noTrailingSlash: false,
+    moduleBaseExceptions: [],
   }
 ) => {
-  const base =
+  let base =
     options.noLeadingSlash && options.moduleBase.startsWith("/")
       ? options.moduleBase.slice(1)
       : options.moduleBase;
-  const removeOutDir = Array.isArray(options.outDir)
-    ? (path: string) =>
-        (options.outDir as string[])
-          .map((dir) => path.startsWith(dir))
-          .some((v) => v)
-          ? path.slice(options.outDir[0].length)
-          : path
-    : (path: string) =>
-        (options.outDir as string) === path
-          ? path.slice(options.outDir.length)
-          : path;
+  if (options.noTrailingSlash && base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  const removeOutDir = (path: string) =>
+    (options.outDir as string) === path
+      ? path.slice(options.outDir.length)
+      : path;
 
   const removeRoot = (path: string) => {
-    const normalized = normalizePath(path);
-    const relative = normalized.startsWith(options.root)
-      ? normalized.slice(options.root.length)
-      : normalized;
+    const relative = path.startsWith(options.root)
+      ? path.slice(options.root.length)
+      : path;
     return relative;
   };
 
   const ensureModuleBase = (path: string) => {
+    let transformed = path;
     if (options.noLeadingSlash && path.startsWith("/")) {
-      return path.slice(1);
+      transformed = path.slice(1);
     }
-    if (!path.startsWith(base)) {
-      throw new Error(
-        `Path ${path} does not start with module base ${base}, this will not work down the line.`
-      );
+    if (options.noTrailingSlash && transformed.endsWith("/")) {
+      transformed = transformed.slice(0, -1);
     }
-    return path;
+    return transformed;
   };
 
-  return (path: string) => ensureModuleBase(removeOutDir(removeRoot(path)));
+  return (path: string) => ensureModuleBase(removeOutDir(removeRoot(normalizePath(path))));
 };

package/src/helpers/tryManifest.ts

@@ -1,13 +1,20 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import type { Manifest } from "vite";
 
-type TryManifestOptions = {
+type TryManifestOptions<SSR extends boolean> = {
   root: string;
   outDir: string;
-  ssrManifest: boolean;
+  ssrManifest: SSR;
 };
 
-export function tryManifest(options: TryManifestOptions) {
+export function tryManifest<SSR extends boolean>(options: TryManifestOptions<SSR>): {
+  type: "success";
+  manifest: SSR extends true ? Record<string, string[]> : Manifest;
+} | {
+  type: "error";
+  error: Error;
+} {
   const manifestPath = resolve(
     options.root,
     options.outDir,
@@ -15,9 +22,16 @@ export function tryManifest(options: TryManifestOptions) {
     options.ssrManifest ? "ssr-manifest.json" : "manifest.json"
   );
   try {
-    return JSON.parse(readFileSync(manifestPath, "utf-8"));
+    const result=  JSON.parse(readFileSync(manifestPath, "utf-8"));
+    return {
+      type: "success",
+      manifest: result,
+    }
   } catch (e) {
     console.log("No manifest found", manifestPath);
-    return null;
+    return {
+      type: "error",
+      error: e as Error,
+    }
   }
 }

package/src/html/createPageLoader.ts

@@ -71,6 +71,8 @@ export const createPageLoader = ({
     outDir,
     moduleBase,
     noLeadingSlash: true,
+    noTrailingSlash: true,
+    moduleBaseExceptions: [],
   });
   return async (id: string) => {
     const normalizedId = pathNormalizer(id);

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 ''",