fix(vm): don't reuse scripts across vite environments (#11395)

Signed-off-by: Martin Oehlert <453360+MO2k4@users.noreply.github.com>
Co-authored-by: Martin Oehlert <453360+MO2k4@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

Author: MO2k4

packages/vitest/src/runtime/moduleRunner/moduleEvaluator.ts

@@ -30,14 +30,22 @@ const isWindows = process.platform === 'win32'
 // holds no per-context state (Vite rewrites dynamic imports to
 // `__vite_ssr_dynamic_import__`, so no per-context import callback is baked
 // in) — only its evaluation has to happen per context. Keyed by module id
-// (`mock:` ids stay distinct from their originals).
+// (`mock:` ids stay distinct from their originals) and Vite environment: one
+// worker can run files of different environments, which transform the same id
+// differently.
 const vmInlineScriptCache = new Map<string, vm.Script>()
 
-function getVmInlineScript(id: string, wrappedCode: string, options: vm.ScriptOptions): vm.Script {
-  let script = vmInlineScriptCache.get(id)
+function getVmInlineScript(
+  environment: string,
+  id: string,
+  wrappedCode: string,
+  options: vm.ScriptOptions,
+): vm.Script {
+  const key = `${environment}:${id}`
+  let script = vmInlineScriptCache.get(key)
   if (!script) {
     script = new vm.Script(wrappedCode, options)
-    vmInlineScriptCache.set(id, script)
+    vmInlineScriptCache.set(key, script)
   }
   return script
 }
@@ -49,6 +57,7 @@ export interface VitestModuleEvaluatorOptions {
   injectCjsGlobals?: boolean | undefined
   moduleExecutionInfo?: ModuleExecutionInfo
   getCurrentTestFilepath?: () => string | undefined
+  getEnvironmentName?: () => string
   compiledFunctionArgumentsNames?: string[]
   compiledFunctionArgumentsValues?: unknown[]
   getterTracker?: GetterTracker
@@ -411,7 +420,12 @@ export class VitestModuleEvaluator implements ModuleEvaluator {
 
     try {
       const initModule = this.vm
-        ? getVmInlineScript(module.id, wrappedCode, options).runInContext(this.vm.context)
+        ? getVmInlineScript(
+            this.options.getEnvironmentName?.() ?? '',
+            module.id,
+            wrappedCode,
+            options,
+          ).runInContext(this.vm.context)
         : vm.runInThisContext(wrappedCode, options)
 
       await initModule(...argumentsValues)

packages/vitest/src/runtime/moduleRunner/startVitestModuleRunner.ts

@@ -117,6 +117,7 @@ export function startVitestModuleRunner(options: ContextModuleRunnerOptions): Vi
         return state().config.injectCjsGlobals
       },
       getCurrentTestFilepath: () => state().filepath,
+      getEnvironmentName: environment,
       getterTracker: state().getterTracker,
     })
 

test/e2e/test/vm-threads.test.ts

@@ -66,6 +66,52 @@ test.for(['vmThreads', 'vmForks'] as const)(
   },
 )
 
+// the same module is transformed differently by the client (jsdom) and ssr
+// (node) environments, so a worker running both must not reuse one's script
+// (env names are interpolated so they don't set this file's own environment)
+test.for(['vmThreads', 'vmForks'] as const)(
+  '%s does not share compiled modules between vite environments',
+  async (pool) => {
+    const { stderr, exitCode } = await runInlineTests({
+      'env.js': `export const env = '__ENV__'`,
+      'client.test.js': `
+          // @vitest-environment ${'jsdom'}
+          import { expect, test } from 'vitest'
+          import { env } from './env.js'
+
+          test('client', () => {
+            expect(env).toBe('client')
+          })
+        `,
+      'ssr.test.js': `
+          // @vitest-environment ${'node'}
+          import { expect, test } from 'vitest'
+          import { env } from './env.js'
+
+          test('ssr', () => {
+            expect(env).toBe('ssr')
+          })
+        `,
+      'vitest.config.js': `
+          export default {
+            plugins: [{
+              name: 'env-name',
+              transform(code, id) {
+                if (id.endsWith('env.js')) {
+                  return code.replace('__ENV__', this.environment.name)
+                }
+              },
+            }],
+            test: { pool: '${pool}', maxWorkers: 1 },
+          }
+        `,
+    })
+
+    expect(stderr).toBe('')
+    expect(exitCode).toBe(0)
+  },
+)
+
 // vm pools resolve `isolate` to false (isolation comes from a fresh VM
 // context per run request), which used to trigger the "single non-isolated
 // worker receives all files at once" batching with `maxWorkers: 1` — all