fix(rsc): handle conflict names from export * in use client and use server modules

packages/plugin-rsc/e2e/basic.test.ts

@@ -376,6 +376,27 @@ function defineTest(f: Fixture) {
     )
   })
 
+  test('use server export all @js', async ({ page }) => {
+    await page.goto(f.url())
+    await waitForHydration(page)
+
+    await expect(page.getByTestId('test-action-export-all-server')).toHaveText(
+      'export-all-server-to-server: 0',
+    )
+    await page.getByTestId('test-action-export-all-server').click()
+    await expect(page.getByTestId('test-action-export-all-server')).toHaveText(
+      'export-all-server-to-server: 1',
+    )
+
+    await expect(page.getByTestId('test-action-export-all-client')).toHaveText(
+      'export-all-server-to-client: ?',
+    )
+    await page.getByTestId('test-action-export-all-client').click()
+    await expect(page.getByTestId('test-action-export-all-client')).toHaveText(
+      'export-all-server-to-client: export-all-client',
+    )
+  })
+
   test('useActionState with jsx @js', async ({ page }) => {
     await page.goto(f.url())
     await waitForHydration(page)
@@ -1874,7 +1895,7 @@ function defineTest(f: Fixture) {
     )
   })
 
-  test('export *', async ({ page }) => {
+  test('export all', async ({ page }) => {
     await page.goto(f.url())
     await waitForHydration(page)
     await expect(page.getByTestId('test-export-all')).toHaveText(

packages/plugin-rsc/examples/basic/src/routes/action-export-all/action-impl.ts

@@ -0,0 +1,13 @@
+let serverValue = 0
+
+export async function readExportAllServerValue() {
+  return serverValue
+}
+
+export async function incrementExportAllServerValue() {
+  serverValue++
+}
+
+export async function getExportAllClientValue() {
+  return 'export-all-client'
+}

packages/plugin-rsc/examples/basic/src/routes/action-export-all/actions.ts

@@ -0,0 +1,3 @@
+'use server'
+
+export * from './action-impl'

packages/plugin-rsc/examples/basic/src/routes/action-export-all/client.tsx

@@ -0,0 +1,19 @@
+'use client'
+
+import React from 'react'
+import { getExportAllClientValue } from './actions'
+
+export function TestActionExportAllClient() {
+  const [result, setResult] = React.useState('?')
+
+  return (
+    <button
+      data-testid="test-action-export-all-client"
+      onClick={async () => {
+        setResult(await getExportAllClientValue())
+      }}
+    >
+      export-all-server-to-client: {result}
+    </button>
+  )
+}

packages/plugin-rsc/examples/basic/src/routes/action-export-all/server.tsx

@@ -0,0 +1,18 @@
+import {
+  incrementExportAllServerValue,
+  readExportAllServerValue,
+} from './actions'
+import { TestActionExportAllClient } from './client'
+
+export function TestActionExportAll() {
+  return (
+    <>
+      <form action={incrementExportAllServerValue}>
+        <button data-testid="test-action-export-all-server">
+          export-all-server-to-server: {readExportAllServerValue()}
+        </button>
+      </form>
+      <TestActionExportAllClient />
+    </>
+  )
+}

packages/plugin-rsc/examples/basic/src/routes/root.tsx

@@ -9,6 +9,7 @@ import {
   TestServerActionBindMember,
 } from './action-bind/server'
 import { TestServerActionError } from './action-error/server'
+import { TestActionExportAll } from './action-export-all/server'
 import {
   TestActionFromClient,
   TestNonFormActionArgs,
@@ -101,6 +102,7 @@ export function Root(props: { url: URL }) {
         <TestReplayConsoleLogs url={props.url} />
         <TestSuspense url={props.url} />
         <TestActionFromClient />
+        <TestActionExportAll />
         <TestUseActionState />
         <TestNonFormActionError />
         <TestNonFormActionArgs />

packages/plugin-rsc/src/plugin.ts

@@ -65,12 +65,13 @@ import {
 } from './plugins/vite-utils'
 import {
   type TransformWrapExportFilter,
-  extractNames,
   hasDirective,
   transformDirectiveProxyExport,
+  transformExpandExportAll,
   transformServerActionServer,
   transformWrapExport,
   findDirectives,
+  type TransformExpandExportAllContext,
 } from './transforms'
 import { generateEncryptionKey, toBase64 } from './utils/encryption-utils'
 import { createRpcServer } from './utils/rpc'
@@ -1376,141 +1377,26 @@ function globalAsyncLocalStoragePlugin(): Plugin[] {
   ]
 }
 
-// Strip TS/JSX so `parseAstAsync` can read the result. Prefer oxc when
-// available (Vite 8+); fall back to esbuild for older Vite versions.
-async function transformSourceForExportScan(
-  code: string,
-  filename: string,
-): Promise<string | undefined> {
-  const v = vite as Partial<{
-    transformWithOxc: (
-      code: string,
-      filename: string,
-      options?: { sourcemap?: boolean },
-    ) => Promise<{ code: string }>
-    transformWithEsbuild: (
-      code: string,
-      filename: string,
-      options?: { sourcemap?: boolean },
-    ) => Promise<{ code: string }>
-  }>
-  const transform = v.transformWithOxc ?? v.transformWithEsbuild
-  if (!transform) return undefined
-  const result = await transform(code, filename, { sourcemap: false })
-  return result.code
-}
-
-// Recursively collect the named exports of a module (following `export * from`
-// chains), so that the RSC `use client`/`use server` proxy transforms can
-// expand bare `export *` re-exports into explicit named re-exports before
-// proxy generation. The pure proxy transform cannot do this on its own because
-// the names live in another file.
-async function collectExportNames(
+function createTransformExpandExportAllContext(
   ctx: Rollup.TransformPluginContext,
-  resolvedId: string,
-  seen: Set<string>,
-): Promise<string[]> {
-  if (seen.has(resolvedId)) return []
-  seen.add(resolvedId)
-
-  // Read the source from disk and strip TS/JSX so the AST walk below sees
-  // standard ESM exports. We don't go through `this.load` /
-  // `transformRequest` here — in dev they return module-runner output
-  // (`__vite_ssr_exportName__(...)`) the walker can't read, and on build
-  // there's no practical benefit over reading the source directly for the
-  // simple TS/JSX modules we care about.
-  let moduleCode: string | undefined
-  try {
-    const raw = await fs.promises.readFile(resolvedId, 'utf-8')
-    moduleCode = await transformSourceForExportScan(raw, resolvedId)
-  } catch {
-    return []
-  }
-  if (!moduleCode) return []
-
-  let ast: Awaited<ReturnType<typeof parseAstAsync>>
-  try {
-    ast = await parseAstAsync(moduleCode)
-  } catch {
-    return []
-  }
-
-  const names: string[] = []
-  for (const node of ast.body) {
-    if (node.type === 'ExportNamedDeclaration') {
-      if (node.declaration) {
-        if (
-          node.declaration.type === 'FunctionDeclaration' ||
-          node.declaration.type === 'ClassDeclaration'
-        ) {
-          if (node.declaration.id) names.push(node.declaration.id.name)
-        } else if (node.declaration.type === 'VariableDeclaration') {
-          for (const decl of node.declaration.declarations) {
-            names.push(...extractNames(decl.id))
-          }
-        }
-      } else {
-        for (const spec of node.specifiers) {
-          if (
-            spec.exported.type === 'Identifier' &&
-            spec.exported.name !== 'default'
-          ) {
-            names.push(spec.exported.name)
-          }
-        }
-      }
-    } else if (node.type === 'ExportAllDeclaration') {
-      if (node.exported?.type === 'Identifier') {
-        names.push(node.exported.name)
-      } else if (node.source) {
-        const subResolved = await ctx.resolve(
-          node.source.value as string,
-          resolvedId,
-        )
-        if (subResolved) {
-          names.push(...(await collectExportNames(ctx, subResolved.id, seen)))
-        }
-      }
-    }
-  }
-  return names
-}
-
-async function expandExportAllDeclarations(
-  ctx: Rollup.TransformPluginContext,
-  ast: Awaited<ReturnType<typeof parseAstAsync>>,
-  code: string,
-  id: string,
-): Promise<{
-  code: string
-  ast: Awaited<ReturnType<typeof parseAstAsync>>
-} | null> {
-  const targets = ast.body.filter(
-    (n) => n.type === 'ExportAllDeclaration' && !n.exported,
-  )
-  if (targets.length === 0) return null
-
-  const output = new MagicString(code)
-  for (const node of targets) {
-    if (node.type !== 'ExportAllDeclaration') continue
-    const source = node.source.value as string
-    const resolved = await ctx.resolve(source, id)
-    if (!resolved) continue
-    const names = await collectExportNames(ctx, resolved.id, new Set())
-    if (names.length === 0) {
-      output.remove(node.start, node.end)
-    } else {
-      output.update(
-        node.start,
-        node.end,
-        `export { ${names.join(', ')} } from ${JSON.stringify(source)};`,
-      )
-    }
+): TransformExpandExportAllContext {
+  return {
+    resolve: async (source, importer) => {
+      return (await ctx.resolve(source, importer))?.id
+    },
+    load: async (id) => {
+      // Read the source from disk and strip TS/JSX so the AST walk sees
+      // standard ESM exports. We don't go through `this.load` /
+      // `transformRequest` here — in dev they return module-runner output
+      // (`__vite_ssr_exportName__(...)`) the walker can't read, and on build
+      // there's no practical benefit over reading the source directly for the
+      // simple TS/JSX modules we care about.
+      const raw = await fs.promises.readFile(id, 'utf-8')
+      const transform = vite.transformWithOxc ?? vite.transformWithEsbuild
+      const result = await transform(raw, id, { sourcemap: false })
+      return parseAstAsync(result.code)
+    },
   }
-  if (!output.hasChanged()) return null
-  const newCode = output.toString()
-  const newAst = await parseAstAsync(newCode)
-  return { code: newCode, ast: newAst }
 }
 
 function vitePluginUseClient(
@@ -1580,15 +1466,15 @@ function vitePluginUseClient(
             }
           }
 
-          const expanded = await expandExportAllDeclarations(
-            this,
-            ast,
+          const expanded = await transformExpandExportAll({
             code,
-            id,
-          )
+            ast,
+            importer: id,
+            ...createTransformExpandExportAllContext(this),
+          })
           if (expanded) {
             code = expanded.code
-            ast = expanded.ast
+            ast = await parseAstAsync(code)
           }
 
           let importId: string
@@ -2065,15 +1951,15 @@ function vitePluginUseServer(
           }
           let ast = await parseAstAsync(code)
           if (hasDirective(ast.body, 'use server')) {
-            const expanded = await expandExportAllDeclarations(
-              this,
-              ast,
+            const expanded = await transformExpandExportAll({
               code,
-              id,
-            )
+              ast,
+              importer: id,
+              ...createTransformExpandExportAllContext(this),
+            })
             if (expanded) {
               code = expanded.code
-              ast = expanded.ast
+              ast = await parseAstAsync(code)
             }
           }