feat!: use module-runner instead of vite-node

.npmrc

@@ -3,4 +3,4 @@ strict-peer-dependencies=false
 provenance=true
 shell-emulator=true
 registry=https://registry.npmjs.org/
-VITE_NODE_DEPS_MODULE_DIRECTORIES=/node_modules/,/packages/
+VITEST_MODULE_DIRECTORIES=/node_modules/,/packages/

docs/advanced/runner.md

@@ -121,14 +121,14 @@ export default CustomRunner
 ```
 
 ::: warning
-Vitest also injects an instance of `ViteNodeRunner` as `__vitest_executor` property. You can use it to process files in `importFile` method (this is default behavior of `TestRunner` and `BenchmarkRunner`).
+Vitest also injects an instance of `ModuleRunner` from `vite/module-runner` as `moduleRunner` property. You can use it to process files in `importFile` method (this is default behavior of `TestRunner` and `BenchmarkRunner`).
 
-`ViteNodeRunner` exposes `executeId` method, which is used to import test files in a Vite-friendly environment. Meaning, it will resolve imports and transform file content at runtime so that Node can understand it:
+`ModuleRunner` exposes `import` method, which is used to import test files in a Vite-friendly environment. Meaning, it will resolve imports and transform file content at runtime so that Node can understand it:
 
 ```ts
 export default class Runner {
   async importFile(filepath: string) {
-    await this.__vitest_executor.executeId(filepath)
+    await this.moduleRunner.import(filepath)
   }
 }
 ```

docs/config/index.md

@@ -233,7 +233,7 @@ Handling for dependencies resolution.
 
 #### deps.optimizer {#deps-optimizer}
 
-- **Type:** `{ ssr?, web? }`
+- **Type:** `{ ssr?, client? }`
 - **See also:** [Dep Optimization Options](https://vitejs.dev/config/dep-optimization-options.html)
 
 Enable dependency optimization. If you have a lot of tests, this might improve their performance.
@@ -245,7 +245,7 @@ When Vitest encounters the external library listed in `include`, it will be bund
 - Your `alias` configuration is now respected inside bundled packages
 - Code in your tests is running closer to how it's running in the browser
 
-Be aware that only packages in `deps.optimizer?.[mode].include` option are bundled (some plugins populate this automatically, like Svelte). You can read more about available options in [Vite](https://vitejs.dev/config/dep-optimization-options.html) docs (Vitest doesn't support `disable` and `noDiscovery` options). By default, Vitest uses `optimizer.web` for `jsdom` and `happy-dom` environments, and `optimizer.ssr` for `node` and `edge` environments, but it is configurable by [`transformMode`](#testtransformmode).
+Be aware that only packages in `deps.optimizer?.[mode].include` option are bundled (some plugins populate this automatically, like Svelte). You can read more about available options in [Vite](https://vitejs.dev/config/dep-optimization-options.html) docs (Vitest doesn't support `disable` and `noDiscovery` options). By default, Vitest uses `optimizer.client` for `jsdom` and `happy-dom` environments, and `optimizer.ssr` for `node` and `edge` environments.
 
 This options also inherits your `optimizeDeps` configuration (for web Vitest will extend `optimizeDeps`, for ssr - `ssr.optimizeDeps`). If you redefine `include`/`exclude` option in `deps.optimizer` it will extend your `optimizeDeps` when running tests. Vitest automatically removes the same options from `include`, if they are listed in `exclude`.
 
@@ -260,15 +260,15 @@ You will not be able to edit your `node_modules` code for debugging, since the c
 
 Enable dependency optimization.
 
-#### deps.web  {#deps-web}
+#### deps.client  {#deps-client}
 
 - **Type:** `{ transformAssets?, ... }`
 
-Options that are applied to external files when transform mode is set to `web`. By default, `jsdom` and `happy-dom` use `web` mode, while `node` and `edge` environments use `ssr` transform mode, so these options will have no affect on files inside those environments.
+Options that are applied to external files when the environment is set to `client`. By default, `jsdom` and `happy-dom` use `client` environment, while `node` and `edge` environments use `ssr`, so these options will have no affect on files inside those environments.
 
 Usually, files inside `node_modules` are externalized, but these options also affect files in [`server.deps.external`](#server-deps-external).
 
-#### deps.web.transformAssets
+#### deps.client.transformAssets
 
 - **Type:** `boolean`
 - **Default:** `true`
@@ -281,7 +281,7 @@ This module will have a default export equal to the path to the asset, if no que
 At the moment, this option only works with [`vmThreads`](#vmthreads) and [`vmForks`](#vmforks) pools.
 :::
 
-#### deps.web.transformCss
+#### deps.client.transformCss
 
 - **Type:** `boolean`
 - **Default:** `true`
@@ -294,7 +294,7 @@ If CSS files are disabled with [`css`](#css) options, this option will just sile
 At the moment, this option only works with [`vmThreads`](#vmthreads) and [`vmForks`](#vmforks) pools.
 :::
 
-#### deps.web.transformGlobPattern
+#### deps.client.transformGlobPattern
 
 - **Type:** `RegExp | RegExp[]`
 - **Default:** `[]`
@@ -560,7 +560,7 @@ import type { Environment } from 'vitest'
 
 export default <Environment>{
   name: 'custom',
-  transformMode: 'ssr',
+  viteEnvironment: 'ssr',
   setup() {
     // custom setup
     return {
@@ -1676,28 +1676,6 @@ Will call [`vi.unstubAllEnvs`](/api/vi#vi-unstuballenvs) before each test.
 
 Will call [`vi.unstubAllGlobals`](/api/vi#vi-unstuballglobals) before each test.
 
-### testTransformMode {#testtransformmode}
-
- - **Type:** `{ web?, ssr? }`
-
- Determine the transform method for all modules imported inside a test that matches the glob pattern. By default, relies on the environment. For example, tests with JSDOM environment will process all files with `ssr: false` flag and tests with Node environment process all modules with `ssr: true`.
-
- #### testTransformMode.ssr
-
- - **Type:** `string[]`
- - **Default:** `[]`
-
- Use SSR transform pipeline for all modules inside specified tests.<br>
- Vite plugins will receive `ssr: true` flag when processing those files.
-
- #### testTransformMode&#46;web
-
- - **Type:** `string[]`
- - **Default:** `[]`
-
- First do a normal transform pipeline (targeting browser), then do a SSR rewrite to run the code in Node.<br>
- Vite plugins will receive `ssr: false` flag when processing those files.
-
 ### snapshotFormat<NonProjectOption />
 
 - **Type:** `PrettyFormatOptions`

docs/guide/environment.md

@@ -48,7 +48,7 @@ import type { Environment } from 'vitest/environments'
 
 export default <Environment>{
   name: 'custom',
-  transformMode: 'ssr',
+  viteEnvironment: 'ssr',
   // optional - only if you support "experimental-vm" pool
   async setupVM() {
     const vm = await import('node:vm')
@@ -74,7 +74,7 @@ export default <Environment>{
 ```
 
 ::: warning
-Vitest requires `transformMode` option on environment object. It should be equal to `ssr` or `web`. This value determines how plugins will transform source code. If it's set to `ssr`, plugin hooks will receive `ssr: true` when transforming or resolving files. Otherwise, `ssr` is set to `false`.
+Vitest requires `viteEnvironment` option on environment object (fallbacks to the Vitest environment name by default). It should be equal to `ssr`, `client` or any custom [Vite environment](https://vite.dev/guide/api-environment) name. This value determines which environment is used to process file.
 :::
 
 You also have access to default Vitest environments through `vitest/environments` entry:

docs/guide/migration.md

@@ -145,15 +145,31 @@ $ pnpm run test:dev math.test.ts
 ```
 :::
 
+### Replacing `vite-node` with [Module Runner](https://vite.dev/guide/api-environment-runtimes.html#modulerunner)
+
+Module Runner is a successor to `vite-node` implemented directly in Vite. Vitest now uses it directly instead of having a wrapper around Vite SSR handler. This means that certain features are no longer available:
+
+- `VITE_NODE_DEPS_MODULE_DIRECTORIES` environment variable was replaced with `VITEST_MODULE_DIRECTORIES`
+- Vitest no longer injects `__vitest_executor` into every [test runner](/advanced/runner). Instead, it injects `moduleRunner` which is an instance of [`ModuleRunner`](https://vite.dev/guide/api-environment-runtimes.html#modulerunner)
+- `vitest/execute` entry point was removed. It was always meant to be internal
+- [Custom environments](/guide/environment) no longer need to provide a `transformMode` property. Instead, provide `viteEnvironment`. If it is not provided, Vitest will use the environment name to transform files on the server (see [`server.environments`](https://vite.dev/guide/api-environment-instances.html))
+- `vite-node` is no longer a dependency of Vitest
+- `deps.optimizer.web` was renamed to [`deps.optimizer.client`](/config/#deps-optimizer-client). You can also use any custom names to apply optimizer configs when using other server environments
+
+Vite has its own externalization mechanism, but we decided to keep using the old one to reduce the amount of breaking changes. You can keep using [`server.deps`](/config/#server-deps) to inline or externalize packages.
+
+This update should not be noticeable unless you rely on advanced features mentioned above.
+
 ### Deprecated APIs are Removed
 
 Vitest 4.0 removes some deprecated APIs, including:
 
 - `poolMatchGlobs` config option. Use [`projects`](/guide/projects) instead.
 - `environmentMatchGlobs` config option. Use [`projects`](/guide/projects) instead.
 - `workspace` config option. Use [`projects`](/guide/projects) instead.
+- `deps.external`, `deps.inline`, `deps.fallbackCJS` config options. Use `server.deps.external`, `server.deps.inline`, or `server.deps.fallbackCJS` instead.
 
-This release also removes all deprecated types. This finally fixes an issue where Vitest accidentally pulled in `node` types (see [#5481](https://github.com/vitest-dev/vitest/issues/5481) and [#6141](https://github.com/vitest-dev/vitest/issues/6141)).
+This release also removes all deprecated types. This finally fixes an issue where Vitest accidentally pulled in `@types/node` (see [#5481](https://github.com/vitest-dev/vitest/issues/5481) and [#6141](https://github.com/vitest-dev/vitest/issues/6141)).
 
 ## Migrating from Jest {#jest}
 

packages/browser/src/client/tester/runner.ts

@@ -12,7 +12,7 @@ import {
 } from 'vitest/internal/browser'
 import { NodeBenchmarkRunner, VitestTestRunner } from 'vitest/runners'
 import { createStackString, parseStacktrace } from '../../../../utils/src/source-map'
-import { executor, getWorkerState } from '../utils'
+import { getWorkerState, moduleRunner } from '../utils'
 import { rpc } from './rpc'
 import { VitestBrowserSnapshotEnvironment } from './snapshot'
 
@@ -117,7 +117,7 @@ export function createBrowserRunner(
         await rpc().onAfterSuiteRun({
           coverage,
           testFiles: files.map(file => file.name),
-          transformMode: 'browser',
+          environment: '__browser__',
           projectName: this.config.name,
         })
       }
@@ -223,7 +223,7 @@ export async function initiateRunner(
 
   const BrowserRunner = createBrowserRunner(runnerClass, mocker, state, {
     takeCoverage: () =>
-      takeCoverageInsideWorker(config.coverage, executor),
+      takeCoverageInsideWorker(config.coverage, moduleRunner),
   })
   if (!config.snapshotOptions.snapshotEnvironment) {
     config.snapshotOptions.snapshotEnvironment = new VitestBrowserSnapshotEnvironment()
@@ -238,8 +238,8 @@ export async function initiateRunner(
   })
 
   const [diffOptions] = await Promise.all([
-    loadDiffConfig(config, executor as any),
-    loadSnapshotSerializers(config, executor as any),
+    loadDiffConfig(config, moduleRunner as any),
+    loadSnapshotSerializers(config, moduleRunner as any),
   ])
   runner.config.diffOptions = diffOptions
   getWorkerState().onFilterStackTrace = (stack: string) => {

packages/browser/src/client/tester/state.ts

@@ -25,14 +25,16 @@ const state: WorkerGlobalState = {
   config,
   environment: {
     name: 'browser',
-    transformMode: 'web',
+    viteEnvironment: 'client',
     setup() {
       throw new Error('Not called in the browser')
     },
   },
   onCleanup: fn => getBrowserState().cleanups.push(fn),
-  moduleCache: getBrowserState().moduleCache,
+  evaluatedModules: getBrowserState().evaluatedModules,
+  resolvingModules: getBrowserState().resolvingModules,
   moduleExecutionInfo: new Map(),
+  metaEnv: null as any,
   rpc: null as any,
   durations: {
     environment: 0,

packages/browser/src/client/tester/tester.ts

@@ -10,7 +10,7 @@ import {
   startTests,
   stopCoverageInsideWorker,
 } from 'vitest/internal/browser'
-import { executor, getBrowserState, getConfig, getWorkerState } from '../utils'
+import { getBrowserState, getConfig, getWorkerState, moduleRunner } from '../utils'
 import { setupDialogsSpy } from './dialog'
 import { setupConsoleLogSpy } from './logger'
 import { VitestBrowserClientMocker } from './mocker'
@@ -101,6 +101,7 @@ async function prepareTestEnvironment(options: PrepareOptions) {
 
   const state = getWorkerState()
 
+  state.metaEnv = import.meta.env
   state.onCancel = onCancel
   state.rpc = rpc as any
 
@@ -207,7 +208,7 @@ async function prepare(options: PrepareOptions) {
 
   await Promise.all([
     setupCommonEnv(config),
-    startCoverageInsideWorker(config.coverage, executor, { isolate: config.browser.isolate }),
+    startCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.browser.isolate }),
     (async () => {
       const VitestIndex = await import('vitest')
       Object.defineProperty(window, '__vitest_index__', {
@@ -249,7 +250,7 @@ async function cleanup() {
       .catch(error => unhandledError(error, 'Cleanup Error'))
   }
   state.environmentTeardownRun = true
-  await stopCoverageInsideWorker(config.coverage, executor, { isolate: config.browser.isolate }).catch((error) => {
+  await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.browser.isolate }).catch((error) => {
     return unhandledError(error, 'Coverage Error')
   })
 }

packages/browser/src/client/utils.ts

@@ -1,5 +1,5 @@
 import type { VitestRunner } from '@vitest/runner'
-import type { SerializedConfig, WorkerGlobalState } from 'vitest'
+import type { EvaluatedModules, SerializedConfig, WorkerGlobalState } from 'vitest'
 import type { IframeOrchestrator } from './orchestrator'
 import type { CommandsManager } from './tester/utils'
 
@@ -13,10 +13,10 @@ export async function importFs(id: string): Promise<any> {
   return getBrowserState().wrapModule(() => import(/* @vite-ignore */ name))
 }
 
-export const executor = {
+export const moduleRunner = {
   isBrowser: true,
 
-  executeId: (id: string): Promise<any> => {
+  import: (id: string): Promise<any> => {
     if (id[0] === '/' || id[1] === ':') {
       return importFs(id)
     }
@@ -65,7 +65,8 @@ export function ensureAwaited<T>(promise: (error?: Error) => Promise<T>): Promis
 export interface BrowserRunnerState {
   files: string[]
   runningFiles: string[]
-  moduleCache: Map<string, any>
+  resolvingModules: Set<string>
+  evaluatedModules: EvaluatedModules
   config: SerializedConfig
   provider: string
   runner: VitestRunner

packages/browser/src/node/rpc.ts

@@ -122,7 +122,7 @@ export function setupBrowserRpc(globalServer: ParentBrowserProject, defaultMocke
 
   function setupClient(project: TestProject, rpcId: string, ws: WebSocket) {
     const mockResolver = new ServerMockResolver(globalServer.vite, {
-      moduleDirectories: project.config.server?.deps?.moduleDirectories,
+      moduleDirectories: project.config?.deps?.moduleDirectories,
     })
     const mocker = project.browser?.provider.mocker
 

packages/coverage-istanbul/src/provider.ts

@@ -89,19 +89,19 @@ export class IstanbulCoverageProvider extends BaseCoverageProvider<ResolvedCover
     const start = debug.enabled ? performance.now() : 0
 
     const coverageMap = this.createCoverageMap()
-    let coverageMapByTransformMode = this.createCoverageMap()
+    let coverageMapByEnvironment = this.createCoverageMap()
 
     await this.readCoverageFiles<CoverageMap>({
       onFileRead(coverage) {
-        coverageMapByTransformMode.merge(coverage)
+        coverageMapByEnvironment.merge(coverage)
       },
       onFinished: async () => {
         // Source maps can change based on projectName and transform mode.
         // Coverage transform re-uses source maps so we need to separate transforms from each other.
-        const transformedCoverage = await transformCoverage(coverageMapByTransformMode)
+        const transformedCoverage = await transformCoverage(coverageMapByEnvironment)
         coverageMap.merge(transformedCoverage)
 
-        coverageMapByTransformMode = this.createCoverageMap()
+        coverageMapByEnvironment = this.createCoverageMap()
       },
       onDebug: debug,
     })

packages/coverage-v8/package.json

@@ -55,6 +55,7 @@
   },
   "dependencies": {
     "@bcoe/v8-coverage": "^1.0.2",
+    "@vitest/utils": "workspace:*",
     "ast-v8-to-istanbul": "^0.3.3",
     "debug": "catalog:",
     "istanbul-lib-coverage": "catalog:",
@@ -73,7 +74,6 @@
     "@types/istanbul-reports": "catalog:",
     "@vitest/browser": "workspace:*",
     "pathe": "catalog:",
-    "vite-node": "workspace:*",
     "vitest": "workspace:*"
   }
 }

packages/coverage-v8/src/index.ts

@@ -37,10 +37,12 @@ const mod: CoverageProviderModule = {
         try {
           const result = coverage.result
             .filter(filterResult)
-            .map(res => ({
-              ...res,
-              startOffset: options?.moduleExecutionInfo?.get(fileURLToPath(res.url))?.startOffset || 0,
-            }))
+            .map((res) => {
+              return {
+                ...res,
+                startOffset: options?.moduleExecutionInfo?.get(fileURLToPath(res.url))?.startOffset || 0,
+              }
+            })
 
           resolve({ result })
         }