fix(rsc): convert vendored react-server-dom-webpack to ESM

The vendor-react-server-dom build plugin copies react-server-dom-webpack
into dist/vendor/ as raw CJS files. These files use require() and
module.exports which break on pure ESM runtimes (Cloudflare Workers,
Deno Deploy) where require() does not exist.

When a framework builds for Cloudflare Workers with resolve.noExternal
set to true, the CJS vendor files end up in the production bundle
verbatim, causing "require is not defined" and "exports is not defined"
at deploy time. This is hard to debug because it only affects ESM-only
runtimes in production builds; Node.js and dev mode work fine.

The fix adds an esbuild conversion step after the fs.cpSync in the
tsdown build config. For each CJS entry file (server.edge.js,
client.edge.js, client.browser.js, etc.), it:

1. Bundles with esbuild (format: esm, bundle: true) to inline the
   ./cjs/*.production.js require chain
2. Replaces __require("react") with top-level ESM imports (esbuild
   can not lift requires from __commonJS wrappers to import statements)
3. Removes the __require shim that references the require global
4. Extracts named exports from CJS exports.xxx patterns and generates
   proper ESM export var { ... } = default
5. Removes the now-unused cjs/ subdirectory

Session: ses_22b5a7d8affeczTeFI1DGoYPd5

Author: remorses

packages/plugin-rsc/package.json

@@ -59,6 +59,7 @@
     "@vitejs/plugin-react": "workspace:*",
     "@vitejs/test-dep-cjs-and-esm": "./test-dep/cjs-and-esm",
     "@vitejs/test-dep-cjs-falsy-primitive": "./test-dep/cjs-falsy-primitive",
+    "esbuild": "^0.28.0",
     "picocolors": "^1.1.1",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",

packages/plugin-rsc/tsdown.config.ts

@@ -1,4 +1,6 @@
 import fs from 'node:fs'
+import path from 'node:path'
+import { build } from 'esbuild'
 import { defineConfig } from 'tsdown'
 
 export default defineConfig({
@@ -31,7 +33,7 @@ export default defineConfig({
   plugins: [
     {
       name: 'vendor-react-server-dom',
-      buildStart() {
+      async buildStart() {
         fs.rmSync('./dist/vendor/', { recursive: true, force: true })
         fs.mkdirSync('./dist/vendor', { recursive: true })
         fs.cpSync(
@@ -43,7 +45,150 @@ export default defineConfig({
           recursive: true,
           force: true,
         })
+        // Convert CJS entry files to ESM so they work on pure ESM runtimes
+        // (Cloudflare Workers, Deno Deploy) where require() is not available.
+        // Without this, production builds that bundle vendor files (e.g. with
+        // resolve.noExternal: true) fail with "require is not defined".
+        await convertVendorToEsm('./dist/vendor/react-server-dom')
       },
     },
   ],
 }) as any
+
+// Convert CJS entry files in the vendor directory to ESM in-place using esbuild.
+// Each entry file (server.edge.js, client.edge.js, etc.) is a thin CJS wrapper
+// that require()s a ./cjs/*.production.js file. esbuild bundles them into
+// self-contained ESM with proper import/export statements.
+async function convertVendorToEsm(vendorDir: string) {
+  const entries = fs
+    .readdirSync(vendorDir)
+    .filter((f) => f.endsWith('.js'))
+    .filter((f) => {
+      const content = fs.readFileSync(path.join(vendorDir, f), 'utf-8')
+      return content.includes('require(') || content.includes('exports.')
+    })
+
+  for (const entry of entries) {
+    const entryPath = path.join(vendorDir, entry)
+    const content = fs.readFileSync(entryPath, 'utf-8')
+
+    let result
+    try {
+      result = await build({
+        entryPoints: [entryPath],
+        bundle: true,
+        format: 'esm',
+        write: false,
+        platform: 'neutral',
+        external: [
+          'react',
+          'react-dom',
+          'react/jsx-runtime',
+          'react/jsx-dev-runtime',
+          // Node.js built-ins for .node.js variants
+          'node:*',
+          'util',
+          'crypto',
+          'stream',
+          'async_hooks',
+        ],
+        define: { 'process.env.NODE_ENV': '"production"' },
+        sourcemap: false,
+        logLevel: 'silent',
+      })
+    } catch {
+      // node-register.js and plugin.js have complex deps; skip them
+      continue
+    }
+
+    let code = result.outputFiles[0]!.text
+
+    // esbuild can't lift require() calls from inside __commonJS wrappers to
+    // top-level ESM imports. Replace __require("react") etc. with references
+    // to top-level imports we inject at the top of the file.
+    const externalRequires = new Map<string, string>()
+    const externals = [
+      'react',
+      'react-dom',
+      'react/jsx-runtime',
+      'react/jsx-dev-runtime',
+    ]
+    code = code.replace(/__require\("([^"]+)"\)/g, (match, specifier) => {
+      if (!externals.includes(specifier)) return match
+      const varName =
+        externalRequires.get(specifier) ??
+        `__ext_${specifier.replace(/[^a-zA-Z0-9]/g, '_')}`
+      externalRequires.set(specifier, varName)
+      return varName
+    })
+    if (externalRequires.size > 0) {
+      const imports = Array.from(externalRequires.entries())
+        .map(([spec, varName]) => `import * as ${varName} from "${spec}";`)
+        .join('\n')
+      code = imports + '\n' + code
+    }
+
+    // Remove the __require shim (references `require` which doesn't exist
+    // in pure ESM runtimes like Cloudflare Workers)
+    if (!code.includes('__require(')) {
+      const lines = code.split('\n')
+      const startIdx = lines.findIndex((l) => l.startsWith('var __require ='))
+      if (startIdx >= 0) {
+        let endIdx = startIdx
+        for (let i = startIdx; i < lines.length; i++) {
+          if (lines[i]!.startsWith('});')) {
+            endIdx = i
+            break
+          }
+        }
+        lines.splice(startIdx, endIdx - startIdx + 1)
+        code = lines.join('\n')
+      }
+    }
+
+    // esbuild wraps CJS as `export default require_xxx()` (single default
+    // export). Downstream code uses named imports like
+    // `import { renderToReadableStream } from '...'`. Extract the named
+    // exports from the CJS source and re-export them from the default.
+    const namedExports = extractCjsExportNames(content, entryPath)
+    if (namedExports.length > 0) {
+      code = code.replace(
+        /^export default (.+);$/m,
+        [
+          `var __cjs_default__ = $1;`,
+          `export default __cjs_default__;`,
+          `export var { ${namedExports.join(', ')} } = __cjs_default__;`,
+        ].join('\n'),
+      )
+    }
+
+    fs.writeFileSync(entryPath, code)
+  }
+
+  // Remove the cjs/ subdirectory since entry files no longer reference it
+  fs.rmSync(path.join(vendorDir, 'cjs'), { recursive: true, force: true })
+}
+
+// Extract export names from CJS files by scanning for `exports.xxx = ` patterns.
+// Also reads the production CJS file referenced by conditional require() wrappers.
+function extractCjsExportNames(content: string, filePath: string): string[] {
+  const names = new Set<string>()
+  for (const m of content.matchAll(/exports\.(\w+)\s*=/g)) {
+    if (m[1] !== '__esModule') names.add(m[1]!)
+  }
+  const requireMatch = content.match(
+    /require\(['"](\.\/cjs\/[^'"]+\.production[^'"]*)['"]\)/,
+  )
+  if (requireMatch) {
+    try {
+      const cjsPath = path.resolve(path.dirname(filePath), requireMatch[1]!)
+      const cjsContent = fs.readFileSync(cjsPath, 'utf-8')
+      for (const m of cjsContent.matchAll(/exports\.(\w+)\s*=/g)) {
+        if (m[1] !== '__esModule') names.add(m[1]!)
+      }
+    } catch {
+      // fallback to names from the entry file
+    }
+  }
+  return Array.from(names)
+}