fix(optimize-imports): only prefer react-server condition in RSC environment

SSR renders with the full React runtime and must not resolve react-server
export condition entries. Thread preferReactServer (env.name === 'rsc')
through resolveExportsValue and resolvePackageEntry, and key entryPathCache
by environment prefix to keep RSC and SSR barrel entries separate.

Author: james-elicx

packages/vinext/src/plugins/optimize-imports.ts

@@ -155,19 +155,24 @@ export const DEFAULT_OPTIMIZE_PACKAGES: string[] = [
 
 /**
  * Resolve a package.json exports value to a string entry path.
- * Prefers react-server → node → import → module → default conditions, recursing into
- * nested objects. The "react-server" condition is checked first because this plugin
- * targets RSC/SSR environments where packages like `react` and `react-dom` expose
- * RSC-compatible entry points under that condition.
+ * Prefers node → import → module → default conditions, recursing into nested objects.
+ * When `preferReactServer` is true (RSC environment), "react-server" is checked first
+ * so that packages like `react` and `react-dom` resolve their RSC-compatible entry points.
  */
-function resolveExportsValue(value: ExportsValue): string | null {
+function resolveExportsValue(value: ExportsValue, preferReactServer: boolean): string | null {
   if (typeof value === "string") return value;
   if (typeof value === "object" && value !== null) {
-    // Prefer ESM conditions in order; "react-server" first for RSC/SSR environments
-    for (const key of ["react-server", "node", "import", "module", "default"]) {
+    // In the RSC environment prefer "react-server" before standard conditions so that
+    // packages exposing RSC-only entry points (e.g. react, react-dom) are resolved
+    // to their server-compatible barrel. In the SSR environment the "react-server"
+    // condition must NOT be preferred — SSR renders with the full React runtime.
+    const conditions = preferReactServer
+      ? ["react-server", "node", "import", "module", "default"]
+      : ["node", "import", "module", "default"];
+    for (const key of conditions) {
       const nested = value[key];
       if (nested !== undefined) {
-        const resolved = resolveExportsValue(nested);
+        const resolved = resolveExportsValue(nested, preferReactServer);
         if (resolved) return resolved;
       }
     }
@@ -231,8 +236,14 @@ function resolvePackageInfo(packageName: string, projectRoot: string): PackageIn
 /**
  * Resolve a package name to its ESM entry file path.
  * Checks `exports["."]` → `module` → `main`, then falls back to require.resolve.
+ * Pass `preferReactServer: true` in the RSC environment to prefer the "react-server"
+ * export condition over "node"/"import" when resolving the barrel entry.
  */
-function resolvePackageEntry(packageName: string, projectRoot: string): string | null {
+function resolvePackageEntry(
+  packageName: string,
+  projectRoot: string,
+  preferReactServer: boolean,
+): string | null {
   try {
     const info = resolvePackageInfo(packageName, projectRoot);
     if (!info) return null;
@@ -244,7 +255,7 @@ function resolvePackageEntry(packageName: string, projectRoot: string): string |
       // the barrel entry point, not individual sub-module paths.
       const dotExport = pkgJson.exports["."];
       if (dotExport) {
-        const entryPath = resolveExportsValue(dotExport);
+        const entryPath = resolveExportsValue(dotExport, preferReactServer);
         if (entryPath) {
           return path.resolve(pkgDir, entryPath).split(path.sep).join("/");
         }
@@ -545,6 +556,9 @@ export function createOptimizeImportsPlugin(
         // dep optimizer which handles barrel imports correctly.
         const env = (this as { environment?: { name?: string } }).environment;
         if (env?.name === "client") return null;
+        // "react-server" export condition should only be preferred in the RSC environment.
+        // SSR renders with the full React runtime and must NOT resolve react-server entries.
+        const preferReactServer = env?.name === "rsc";
         // Skip virtual modules
         if (id.startsWith("\0")) return null;
 
@@ -580,10 +594,14 @@ export function createOptimizeImportsPlugin(
 
           // Build or retrieve the barrel export map for this package.
           // Cache the resolved entry path to avoid repeated FS work.
-          let barrelEntry: string | null | undefined = entryPathCache.get(importSource);
+          // The cache key includes the environment prefix because RSC resolves the
+          // "react-server" export condition while SSR uses the standard conditions —
+          // the same package can have different barrel entry paths in each environment.
+          const cacheKey = `${preferReactServer ? "rsc" : "ssr"}:${importSource}`;
+          let barrelEntry: string | null | undefined = entryPathCache.get(cacheKey);
           if (barrelEntry === undefined) {
-            barrelEntry = resolvePackageEntry(importSource, root);
-            entryPathCache.set(importSource, barrelEntry);
+            barrelEntry = resolvePackageEntry(importSource, root, preferReactServer);
+            entryPathCache.set(cacheKey, barrelEntry);
           }
           const exportMap = buildBarrelExportMap(
             importSource,

tests/optimize-imports.test.ts

@@ -646,4 +646,72 @@ describe("vinext:optimize-imports transform", () => {
     // Must use an absolute path, not a relative one
     expect(result!.code).not.toContain(`from "./`);
   });
+
+  it("prefers react-server export condition in RSC but not in SSR", async () => {
+    // Simulates a package (like react-dom) that exposes different barrel entries
+    // under "react-server" vs "import" export conditions.
+    // In the RSC environment the plugin should pick the react-server entry;
+    // in SSR it must use the standard import entry (SSR uses the full React runtime).
+    tmpDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "vinext-optimize-test-")));
+    fs.writeFileSync(
+      path.join(tmpDir, "package.json"),
+      JSON.stringify({ name: "test-app", type: "module" }),
+    );
+    const pkgDir = path.join(tmpDir, "node_modules", "antd");
+    fs.mkdirSync(pkgDir, { recursive: true });
+
+    // Package with diverging react-server vs import entries
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: "antd",
+        type: "module",
+        exports: {
+          ".": {
+            "react-server": "./rsc-index.js",
+            import: "./index.js",
+            default: "./index.js",
+          },
+        },
+        main: "./index.js",
+      }),
+    );
+    // RSC barrel: exports RscButton
+    fs.writeFileSync(path.join(pkgDir, "rsc-index.js"), `export { RscButton } from "./rsc-btn";`);
+    // Standard barrel: exports Button
+    fs.writeFileSync(path.join(pkgDir, "index.js"), `export { Button } from "./btn";`);
+
+    const plugin = createOptimizeImportsPlugin(
+      () => undefined,
+      () => tmpDir,
+    ) as Plugin;
+    const buildStartHook = unwrapHook((plugin as any).buildStart);
+    if (buildStartHook) await buildStartHook.call(plugin);
+    const transform = unwrapHook(plugin.transform)!;
+
+    // RSC environment: should use react-server entry → knows about RscButton
+    const rscCall = (code: string, id: string) =>
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      (transform as any).call({ ...plugin, environment: { name: "rsc" } }, code, id);
+    // SSR environment: should use import entry → knows about Button, not RscButton
+    const ssrCall = (code: string, id: string) =>
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      (transform as any).call({ ...plugin, environment: { name: "ssr" } }, code, id);
+
+    // RSC: RscButton is exported from the react-server barrel → rewrite succeeds
+    const rscResult = rscCall(`import { RscButton } from "antd";`, "/app/page.tsx");
+    expect(rscResult).not.toBeNull();
+    expect(rscResult!.code).not.toContain(`from "antd"`);
+    expect(rscResult!.code).toContain("rsc-btn");
+
+    // SSR: RscButton is NOT in the standard barrel → rewrite must be skipped
+    const ssrResultUnknown = ssrCall(`import { RscButton } from "antd";`, "/app/page.tsx");
+    expect(ssrResultUnknown).toBeNull();
+
+    // SSR: Button IS in the standard barrel → rewrite succeeds
+    const ssrResultKnown = ssrCall(`import { Button } from "antd";`, "/app/page.tsx");
+    expect(ssrResultKnown).not.toBeNull();
+    expect(ssrResultKnown!.code).not.toContain(`from "antd"`);
+    expect(ssrResultKnown!.code).toContain("btn");
+  });
 });