fix: tag warm-modules snapshot with moduleType for injectCjsGlobals

The `fetchWarmModules` fast path serves inline modules to fresh workers
without the `moduleType` tag the direct-fetch path attaches (#10709).
With `injectCjsGlobals: false` the evaluator injects the CommonJS scope
only into modules tagged `moduleType: 'cjs'`, so a CommonJS dependency
read back from the snapshot evaluated without `require`/`module`/
`__dirname` and threw "require is not defined" — the first file worked
(direct fetch) while every later file served from the snapshot failed.

Recompute the tag in `fetchWarmModules` with the same `detectModuleType`
the direct-fetch path uses, gated on `injectCjsGlobals === false` so the
default path pays nothing.

Author: sheremet-va

packages/vitest/src/node/pools/rpc.ts

@@ -4,11 +4,13 @@ import type { RuntimeRPC } from '../../types/rpc'
 import type { TestProject } from '../project'
 import type { ResolveSnapshotPathHandlerContext } from '../types/config'
 import { existsSync, mkdirSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { cleanUrl } from '@vitest/utils/helpers'
 import { isBuiltin, toBuiltin } from '../../utils/modules'
 import { handleRollupError } from '../environments/fetchModule'
 import { normalizeResolvedIdToUrl } from '../environments/normalizeUrl'
+import { detectModuleType } from '../resolver'
 
 interface MethodsOptions {
   cacheFs?: boolean
@@ -26,6 +28,16 @@ interface MethodsOptions {
 // together with the resolver that produced them.
 const warmExternals = new WeakMap<ViteDevServer, Record<string, FetchResult>>()
 
+// `detectModuleType` only reads the original source in the ambiguous case where
+// the transformed code both looks like ESM and mentions a CommonJS variable;
+// mirror the guard `ModuleFetcher.sourceLoader` uses for virtual modules
+function warmSourceLoader(file: string | null): (() => Promise<string | null>) | undefined {
+  if (!file || file.startsWith('\x00') || file.startsWith('virtual:')) {
+    return undefined
+  }
+  return () => readFile(file, 'utf-8').then(source => source, () => null)
+}
+
 export function createMethodsRPC(project: TestProject, methodsOptions: MethodsOptions = {}): RuntimeRPC {
   const vitest = project.vitest
   const cacheFs = methodsOptions.cacheFs ?? false
@@ -84,6 +96,14 @@ export function createMethodsRPC(project: TestProject, methodsOptions: MethodsOp
         throw new Error(`The environment ${environmentName} was not defined in the Vite config.`)
       }
 
+      // with `injectCjsGlobals: false` the evaluator injects the CommonJS
+      // variables only into modules the server tagged `moduleType: 'cjs'`. that
+      // tag is produced by the per-module `fetch`, which the warm snapshot
+      // bypasses, so it has to be recomputed here — otherwise a CommonJS module
+      // served from the snapshot evaluates without `require`/`module`/`__dirname`
+      // and throws. the detection is skipped entirely on the default path.
+      const detectType = project.config.injectCjsGlobals === false
+
       const warm: Record<string, FetchResult | FetchCachedFileSystemResult> = Object.create(null)
 
       // walk the import graphs of the requested files instead of dumping the
@@ -126,6 +146,9 @@ export function createMethodsRPC(project: TestProject, methodsOptions: MethodsOp
           tmp,
           url: node.url,
           invalidate: false,
+          moduleType: detectType
+            ? await detectModuleType(node.file, transformResult.code, warmSourceLoader(node.file))
+            : undefined,
         }
         warm[node.url] = entry
         if (node.id !== node.url) {

test/e2e/test/config/injectCjsGlobals.test.ts

@@ -63,6 +63,50 @@ test.for(pools)('inlined ".cjs" modules keep the module scope when injectCjsGlob
   expect(exitCode).toBe(0)
 })
 
+test('cjs dep served from the warm-modules snapshot keeps the module scope when injectCjsGlobals is disabled', async () => {
+  // the `fetchWarmModules` fast path hands a module the server already
+  // transformed to a fresh worker without the per-module `fetch` that tags its
+  // `moduleType`. that tag is what tells the evaluator to inject the CommonJS
+  // scope when `injectCjsGlobals` is disabled, so the snapshot has to carry it.
+  // isolate + sequential files make the ordering deterministic: the first file
+  // transforms and caches the dependency (direct fetch), every later file reads
+  // it back from the snapshot — without the tag those files throw
+  // "require is not defined" while the first one still passes.
+  const structure: Record<string, string> = {
+    'package.json': '{ "type": "module" }',
+    'cjs-dep.cjs': ts`
+      const path = require('node:path')
+      module.exports = {
+        answer: 42,
+        base: path.basename(__filename),
+        dir: typeof __dirname,
+      }
+    `,
+  }
+  for (const name of ['a', 'b', 'c', 'd']) {
+    structure[`${name}.test.js`] = ts`
+      import { expect, test } from 'vitest'
+      import cjs from './cjs-dep.cjs'
+
+      test('cjs module keeps its scope', () => {
+        expect(cjs.answer).toBe(42)
+        expect(cjs.base).toBe('cjs-dep.cjs')
+        expect(cjs.dir).toBe('string')
+        expect(typeof module).toBe('undefined')
+      })
+    `
+  }
+  const { stderr, exitCode } = await runInlineTests(structure, {
+    pool: 'forks',
+    isolate: true,
+    fileParallelism: false,
+    injectCjsGlobals: false,
+    experimental: { fsModuleCache: true },
+  })
+  expect(stderr).toBe('')
+  expect(exitCode).toBe(0)
+})
+
 test('".js" modules without ESM syntax are detected as commonjs in a typeless package', async () => {
   const { stderr, exitCode } = await runInlineTests({
     'package.json': '{}',