vitest 4.0.0-beta.4 → 4.0.0-beta.6

package/dist/chunks/{worker.d.zjyR34Pb.d.ts → worker.d.D9QWnzAe.d.ts}

@@ -1,6 +1,7 @@
 import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
-import { a as SerializedConfig } from './config.d.DZo8c7fw.js';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.Bhm9oc0v.js';
+import { FetchFunctionOptions, FetchResult, EvaluatedModules } from 'vite/module-runner';
+import { a as SerializedConfig } from './config.d.CKNVOKm0.js';
+import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.2fYMoz3o.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
@@ -104,17 +105,11 @@ interface PromiseEntry {
 declare const setTimeout: typeof globalThis.setTimeout;
 
 interface RuntimeRPC {
-	fetch: (id: string, transformMode: TransformMode) => Promise<{
-		externalize?: string;
-		id?: string;
-	}>;
-	transform: (id: string, transformMode: TransformMode) => Promise<{
+	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions) => Promise<FetchResult | FetchCachedFileSystemResult>;
+	resolve: (id: string, importer: string | undefined, environment: string) => Promise<ResolveFunctionResult | null>;
+	transform: (id: string) => Promise<{
 		code?: string;
 	}>;
-	resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
-		external?: boolean | "absolute" | "relative";
-		id: string;
-	} | null>;
 	onUserConsoleLog: (log: UserConsoleLog) => void;
 	onUnhandledError: (err: unknown, type: string) => void;
 	onQueued: (file: File) => void;
@@ -134,7 +129,6 @@ interface RunnerRPC {
 type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
 interface ContextTestEnvironment {
 	name: string;
-	transformMode?: TransformMode;
 	options: Record<string, any> | null;
 }
 type TestExecutionMethod = "run" | "collect";
@@ -155,10 +149,19 @@ interface WorkerGlobalState {
 	rpc: WorkerRPC;
 	current?: Task;
 	filepath?: string;
+	metaEnv: {
+		[key: string]: any;
+		BASE_URL: string;
+		MODE: string;
+		DEV: boolean;
+		PROD: boolean;
+		SSR: boolean;
+	};
 	environment: Environment;
 	environmentTeardownRun?: boolean;
 	onCancel: Promise<CancelReason>;
-	moduleCache: Map<string, any>;
+	evaluatedModules: EvaluatedModules;
+	resolvingModules: Set<string>;
 	moduleExecutionInfo: Map<string, any>;
 	onCleanup: (listener: () => unknown) => void;
 	providedContext: Record<string, any>;

package/dist/chunks/{worker.d.C-1AbnVe.d.ts → worker.d.Db-UVmXc.d.ts}

@@ -1,5 +1,5 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.d.zjyR34Pb.js';
+import { C as ContextRPC } from './worker.d.D9QWnzAe.js';
 
 interface WorkerContext extends ContextRPC {
 	port: MessagePort;

package/dist/cli.js

@@ -1,13 +1,13 @@
-import { c as createCLI } from './chunks/cac.CY0IAxC4.js';
+import { c as createCLI } from './chunks/cac.WE-urWw5.js';
 import '@vitest/utils';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
-import './chunks/constants.CXzqaLmq.js';
-import './chunks/index.Bz6b0Ib7.js';
+import './chunks/constants.D_Q9UYh-.js';
+import './chunks/index.VNI-1z5c.js';
 import 'node:fs';
 import 'node:fs/promises';
-import './chunks/typechecker.CMNPqJOo.js';
+import './chunks/typechecker.Cd1wvxUM.js';
 import 'node:os';
 import 'node:perf_hooks';
 import '@vitest/utils/source-map';

package/dist/config.cjs

@@ -4,19 +4,14 @@ var os = require('node:os');
 var stdEnv = require('std-env');
 var vite = require('vite');
 
-// if changed, update also jsdocs and docs
-const defaultBrowserPort = 63315;
-const extraInlineDeps = [
-	/^(?!.*node_modules).*\.mjs$/,
-	/^(?!.*node_modules).*\.cjs\.js$/,
-	/vite\w*\/dist\/client\/env.mjs/
-];
-
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
 const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 (isNode || isDeno) && process.platform === "win32";
 (isNode || isDeno) && process.stdout?.isTTY && !stdEnv.isCI;
 
+// if changed, update also jsdocs and docs
+const defaultBrowserPort = 63315;
+
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
 const defaultExclude = ["**/node_modules/**", "**/.git/**"];
 // These are the generic defaults for coverage. Providers may also set some provider specific defaults.
@@ -98,4 +93,3 @@ exports.defaultExclude = defaultExclude;
 exports.defaultInclude = defaultInclude;
 exports.defineConfig = defineConfig;
 exports.defineProject = defineProject;
-exports.extraInlineDeps = extraInlineDeps;

package/dist/config.d.ts

@@ -1,29 +1,28 @@
 import { HookHandler, ConfigEnv, UserConfig } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.DWg40D2B.js';
-export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.DWg40D2B.js';
-import { V as VitestPluginContext } from './chunks/plugin.d.CLhMcYdD.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.DZo8c7fw.js';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.CqR9-CDJ.js';
+export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.CqR9-CDJ.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.DuiQJfUL.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.CKNVOKm0.js';
 import '@vitest/runner';
-import './chunks/environment.d.Bhm9oc0v.js';
 import '@vitest/utils';
+import './chunks/environment.d.2fYMoz3o.js';
 import 'node:stream';
 import 'node:console';
-import './chunks/browser.d.BRP8scJf.js';
-import './chunks/worker.d.zjyR34Pb.js';
+import './chunks/browser.d.Cawq_X_N.js';
+import './chunks/worker.d.D9QWnzAe.js';
+import 'vite/module-runner';
 import '@vitest/snapshot';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
 import '@vitest/pretty-format';
 import '@vitest/utils/diff';
-import 'vite-node';
 import 'chai';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.CNYjU4GF.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
 
@@ -43,7 +42,6 @@ declare module "vite" {
 }
 
 declare const defaultBrowserPort = 63315;
-declare const extraInlineDeps: RegExp[];
 
 declare const defaultInclude: string[];
 declare const defaultExclude: string[];
@@ -102,5 +100,5 @@ declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<Us
 declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
 declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
 
-export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, extraInlineDeps };
+export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject };
 export type { ViteUserConfigExport, ViteUserConfigFn, ViteUserConfigFnObject, ViteUserConfigFnPromise };

package/dist/config.js

@@ -1,6 +1,6 @@
-export { d as defaultBrowserPort, e as extraInlineDeps } from './chunks/constants.CXzqaLmq.js';
 export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.CXFFjsi8.js';
 export { mergeConfig } from 'vite';
+export { d as defaultBrowserPort } from './chunks/constants.D_Q9UYh-.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';

package/dist/coverage.d.ts

@@ -1,26 +1,25 @@
-import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, b as ReportContext } from './chunks/reporters.d.DWg40D2B.js';
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, b as ReportContext } from './chunks/reporters.d.CqR9-CDJ.js';
 import { TransformResult } from 'vite';
-import { A as AfterSuiteRunMeta } from './chunks/environment.d.Bhm9oc0v.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.d.2fYMoz3o.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import 'node:stream';
 import 'node:console';
-import './chunks/browser.d.BRP8scJf.js';
-import './chunks/worker.d.zjyR34Pb.js';
-import './chunks/config.d.DZo8c7fw.js';
+import './chunks/browser.d.Cawq_X_N.js';
+import './chunks/worker.d.D9QWnzAe.js';
+import 'vite/module-runner';
+import './chunks/config.d.CKNVOKm0.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import '@vitest/utils/diff';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
-import 'vite-node';
 import 'chai';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.CNYjU4GF.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
 
@@ -46,7 +45,7 @@ interface ResolvedThreshold {
 * "project-b": ...
 * ```
 */
-type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["transformMode"], {
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["environment"], {
 	[TestFilenames: string]: string;
 }>>;
 declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"istanbul" | "v8">> {
@@ -75,12 +74,12 @@ declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"ista
 	}>;
 	resolveOptions(): Options;
 	clean(clean?: boolean): Promise<void>;
-	onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+	onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void;
 	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
 		/** Callback invoked with a single coverage result */
 		onFileRead: (data: CoverageType) => void;
 		/** Callback invoked once all results of a project for specific transform mode are read */
-		onFinished: (project: Vitest["projects"][number], transformMode: AfterSuiteRunMeta["transformMode"]) => Promise<void>;
+		onFinished: (project: Vitest["projects"][number], environment: string) => Promise<void>;
 		onDebug: ((...logs: any[]) => void) & {
 			enabled: boolean;
 		};

package/dist/coverage.js

@@ -1,17 +1,16 @@
-export { B as BaseCoverageProvider } from './chunks/coverage.C84l9G-M.js';
+export { B as BaseCoverageProvider } from './chunks/coverage.BPRS6xgn.js';
 import 'node:fs';
 import 'node:path';
+import '@vitest/utils';
 import 'pathe';
 import 'picomatch';
 import 'tinyglobby';
 import 'tinyrainbow';
-import 'vite-node/utils';
 import './chunks/defaults.CXFFjsi8.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:crypto';
-import '@vitest/utils';
 import 'node:module';
 import 'node:process';
 import 'node:fs/promises';
@@ -20,16 +19,16 @@ import 'node:assert';
 import 'node:v8';
 import 'node:util';
 import 'vite';
-import './chunks/constants.CXzqaLmq.js';
+import './chunks/constants.D_Q9UYh-.js';
 import 'node:tty';
 import 'node:events';
 import './chunks/index.Bgo3tNWt.js';
 import 'tinypool';
-import './chunks/typechecker.CMNPqJOo.js';
+import './chunks/typechecker.Cd1wvxUM.js';
 import 'node:perf_hooks';
 import '@vitest/utils/source-map';
 import 'tinyexec';
 import './path.js';
 import '@vitest/runner/utils';
 import 'node:worker_threads';
-import './chunks/coverage.DVF1vEu8.js';
+import './chunks/coverage.D_JHT54q.js';

package/dist/environments.d.ts

@@ -1,5 +1,5 @@
-import { E as Environment } from './chunks/environment.d.Bhm9oc0v.js';
-export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.Bhm9oc0v.js';
+import { E as Environment } from './chunks/environment.d.2fYMoz3o.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.2fYMoz3o.js';
 
 declare const environments: {
 	"node": Environment;

package/dist/environments.js

@@ -1,2 +1,2 @@
-export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.CmSc2RE5.js';
+export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.BG0gqZH-.js';
 import 'node:console';

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { S as SerializedTestSpecification } from './chunks/browser.d.BRP8scJf.js';
-export { B as BrowserTesterOptions } from './chunks/browser.d.BRP8scJf.js';
-import './chunks/global.d.DAhT2emn.js';
+import { S as SerializedTestSpecification } from './chunks/browser.d.Cawq_X_N.js';
+export { B as BrowserTesterOptions } from './chunks/browser.d.Cawq_X_N.js';
+import './chunks/global.d.K6uBQHzY.js';
 import { File, TestAnnotation, TaskResultPack, TaskEventPack, TaskPopulated } from '@vitest/runner';
 export { CancelReason, HookCleanupCallback, HookListener, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-import { a as BirpcReturn } from './chunks/worker.d.zjyR34Pb.js';
-export { C as ContextRPC, c as ContextTestEnvironment, b as RunnerRPC, R as RuntimeRPC, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.zjyR34Pb.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.DZo8c7fw.js';
-export { b as RuntimeConfig, S as SerializedCoverageConfig } from './chunks/config.d.DZo8c7fw.js';
-import { b as Awaitable, U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/environment.d.Bhm9oc0v.js';
-export { A as AfterSuiteRunMeta } from './chunks/environment.d.Bhm9oc0v.js';
+import { a as BirpcReturn } from './chunks/worker.d.D9QWnzAe.js';
+export { C as ContextRPC, c as ContextTestEnvironment, b as RunnerRPC, R as RuntimeRPC, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.D9QWnzAe.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.CKNVOKm0.js';
+export { b as RuntimeConfig, S as SerializedCoverageConfig } from './chunks/config.d.CKNVOKm0.js';
+import { b as Awaitable, U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/environment.d.2fYMoz3o.js';
+export { A as AfterSuiteRunMeta } from './chunks/environment.d.2fYMoz3o.js';
 import { ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, Matchers } from '@vitest/expect';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
@@ -20,6 +20,7 @@ export { ExpectTypeOf, expectTypeOf } from 'expect-type';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
 export { ParsedStack, SerializedError, TestError } from '@vitest/utils';
 export { DiffOptions } from '@vitest/utils/diff';
+export { EvaluatedModules } from 'vite/module-runner';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';

package/dist/index.js

@@ -1,18 +1,19 @@
-export { c as createExpect, a as expect, i as inject, v as vi, b as vitest } from './chunks/vi.CA0EPI9Y.js';
-export { b as bench } from './chunks/benchmark.CYdenmiT.js';
-export { a as assertType } from './chunks/index.D1_MsKEt.js';
+export { c as createExpect, a as expect, i as inject, v as vi, b as vitest } from './chunks/vi.BfdOiD4j.js';
+export { b as bench } from './chunks/benchmark.UW6Ezvxy.js';
+export { a as assertType } from './chunks/index.AR8aAkCC.js';
 export { expectTypeOf } from 'expect-type';
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+export { EvaluatedModules } from 'vite/module-runner';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/expect';
 import '@vitest/runner/utils';
-import './chunks/utils.XdZDrNZV.js';
+import './chunks/utils.C7__0Iv5.js';
 import '@vitest/utils';
 import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
-import './chunks/date.Bq6ZW5rf.js';
+import './chunks/date.-jtEtIeV.js';

package/dist/module-evaluator.d.ts

@@ -0,0 +1,12 @@
+import 'vite/module-runner';
+export { b as VitestModuleEvaluator, a as VitestModuleEvaluatorOptions, c as createImportMetaEnvProxy, g as getDefaultRequestStubs, i as isPrimitive, u as unwrapId, w as wrapId } from './chunks/moduleRunner.d.8kKUsuDg.js';
+import 'node:vm';
+import './chunks/worker.d.D9QWnzAe.js';
+import '@vitest/runner';
+import './chunks/config.d.CKNVOKm0.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/utils/diff';
+import './chunks/environment.d.2fYMoz3o.js';
+import '@vitest/mocker';
+import './chunks/mocker.d.BE_2ls6u.js';

package/dist/module-evaluator.js

@@ -0,0 +1,276 @@
+import { isBuiltin, createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { isAbsolute } from 'pathe';
+import { ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey } from 'vite/module-runner';
+
+const performanceNow = performance.now.bind(performance);
+class ModuleDebug {
+	executionStack = [];
+	startCalculateModuleExecutionInfo(filename, startOffset) {
+		const startTime = performanceNow();
+		return this.executionStack.push({
+			filename,
+			startTime,
+			subImportTime: 0
+		}), () => {
+			const duration = performanceNow() - startTime, currentExecution = this.executionStack.pop();
+			if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+			const selfTime = duration - currentExecution.subImportTime;
+			if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+			return {
+				startOffset,
+				duration,
+				selfTime
+			};
+		};
+	}
+}
+
+const isWindows = process.platform === "win32";
+class VitestModuleEvaluator {
+	stubs = {};
+	env = createImportMetaEnvProxy();
+	vm;
+	compiledFunctionArgumentsNames;
+	compiledFunctionArgumentsValues = [];
+	primitives;
+	debug = new ModuleDebug();
+	constructor(vmOptions, options = {}) {
+		if (this.options = options, this.vm = vmOptions, this.stubs = getDefaultRequestStubs(vmOptions?.context), options.compiledFunctionArgumentsNames) this.compiledFunctionArgumentsNames = options.compiledFunctionArgumentsNames;
+		if (options.compiledFunctionArgumentsValues) this.compiledFunctionArgumentsValues = options.compiledFunctionArgumentsValues;
+		if (vmOptions) this.primitives = vm.runInContext("({ Object, Proxy, Reflect })", vmOptions.context);
+		else this.primitives = {
+			Object,
+			Proxy,
+			Reflect
+		};
+	}
+	convertIdToImportUrl(id) {
+		// TODO: vitest returns paths for external modules, but Vite returns file://
+		// unfortunetly, there is a bug in Vite where ID is resolved incorrectly, so we can't return files until the fix is merged
+		// https://github.com/vitejs/vite/pull/20449
+		if (!isWindows || isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id)) return id;
+		const [filepath, query] = id.split("?");
+		return query ? `${pathToFileURL(filepath).toString()}?${query}` : pathToFileURL(filepath).toString();
+	}
+	async runExternalModule(id) {
+		if (id in this.stubs) return this.stubs[id];
+		const file = this.convertIdToImportUrl(id), namespace = this.vm ? await this.vm.externalModulesExecutor.import(file) : await import(file);
+		if (!this.shouldInterop(file, namespace)) return namespace;
+		const { mod, defaultExport } = interopModule(namespace), { Proxy, Reflect } = this.primitives, proxy = new Proxy(mod, {
+			get(mod, prop) {
+				return prop === "default" ? defaultExport : mod[prop] ?? defaultExport?.[prop];
+			},
+			has(mod, prop) {
+				return prop === "default" ? defaultExport !== void 0 : prop in mod || defaultExport && prop in defaultExport;
+			},
+			getOwnPropertyDescriptor(mod, prop) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+				if (descriptor) return descriptor;
+				if (prop === "default" && defaultExport !== void 0) return {
+					value: defaultExport,
+					enumerable: true,
+					configurable: true
+				};
+			}
+		});
+		return proxy;
+	}
+	async runInlinedModule(context, code, module) {
+		context.__vite_ssr_import_meta__.env = this.env;
+		const { Reflect, Proxy, Object } = this.primitives, exportsObject = context[ssrModuleExportsKey], SYMBOL_NOT_DEFINED = Symbol("not defined");
+		let moduleExports = SYMBOL_NOT_DEFINED;
+		// this proxy is triggered only on exports.{name} and module.exports access
+		// inside the module itself. imported module is always "exports"
+		const cjsExports = new Proxy(exportsObject, {
+			get: (target, p, receiver) => {
+				return Reflect.has(target, p) ? Reflect.get(target, p, receiver) : Reflect.get(Object.prototype, p, receiver);
+			},
+			getPrototypeOf: () => Object.prototype,
+			set: (_, p, value) => {
+				// treat "module.exports =" the same as "exports.default =" to not have nested "default.default",
+				// so "exports.default" becomes the actual module
+				if (p === "default" && this.shouldInterop(module.file, { default: value }) && cjsExports !== value) return exportAll(cjsExports, value), exportsObject.default = value, true;
+				if (!Reflect.has(exportsObject, "default")) exportsObject.default = {};
+				// returns undefined, when accessing named exports, if default is not an object
+				// but is still present inside hasOwnKeys, this is Node behaviour for CJS
+				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) return defineExport(exportsObject, p, () => void 0), true;
+				if (!isPrimitive(exportsObject.default)) exportsObject.default[p] = value;
+				if (p !== "default") defineExport(exportsObject, p, () => value);
+				return true;
+			}
+		}), moduleProxy = {
+			set exports(value) {
+				exportAll(cjsExports, value), exportsObject.default = value, moduleExports = value;
+			},
+			get exports() {
+				return cjsExports;
+			}
+		}, meta = context[ssrImportMetaKey], testFilepath = this.options.getCurrentTestFilepath?.();
+		if (testFilepath === module.file) {
+			const globalNamespace = this.vm?.context || globalThis;
+			Object.defineProperty(meta, "vitest", { get: () => globalNamespace.__vitest_index__ });
+		}
+		const filename = meta.filename, dirname = meta.dirname, require = this.createRequire(filename), argumentsList = [
+			ssrModuleExportsKey,
+			ssrImportMetaKey,
+			ssrImportKey,
+			ssrDynamicImportKey,
+			ssrExportAllKey,
+			"__vite_ssr_exportName__",
+			"__filename",
+			"__dirname",
+			"module",
+			"exports",
+			"require"
+		];
+		if (this.compiledFunctionArgumentsNames) argumentsList.push(...this.compiledFunctionArgumentsNames);
+		// add 'use strict' since ESM enables it by default
+		const codeDefinition = `'use strict';async (${argumentsList.join(",")})=>{{`, wrappedCode = `${codeDefinition}${code}\n}}`, options = {
+			filename: module.file || filename,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		}, finishModuleExecutionInfo = this.debug.startCalculateModuleExecutionInfo(filename, codeDefinition.length);
+		try {
+			const initModule = this.vm ? vm.runInContext(wrappedCode, this.vm.context, options) : vm.runInThisContext(wrappedCode, options), dynamicRequest = async (dep, options) => {
+				return dep = String(dep), dep[0] === "#" ? context[ssrDynamicImportKey](wrapId(dep), options) : context[ssrDynamicImportKey](dep, options);
+			};
+			await initModule(
+				context[ssrModuleExportsKey],
+				context[ssrImportMetaKey],
+				context[ssrImportKey],
+				dynamicRequest,
+				context[ssrExportAllKey],
+				// vite 7 support, remove when vite 7+ is supported
+				context.__vite_ssr_exportName__ || ((name, getter) => Object.defineProperty(exportsObject, name, {
+					enumerable: true,
+					configurable: true,
+					get: getter
+				})),
+				filename,
+				dirname,
+				moduleProxy,
+				cjsExports,
+				require,
+				...this.compiledFunctionArgumentsValues
+			);
+		} finally {
+			// moduleExecutionInfo needs to use Node filename instead of the normalized one
+			// because we rely on this behaviour in coverage-v8, for example
+			this.options.moduleExecutionInfo?.set(filename, finishModuleExecutionInfo());
+		}
+	}
+	createRequire(filename) {
+		return filename.startsWith("\0") || !isAbsolute(filename) ? () => ({}) : this.vm ? this.vm.externalModulesExecutor.createRequire(filename) : createRequire(filename);
+	}
+	shouldInterop(path, mod) {
+		// never interop ESM modules
+		// TODO: should also skip for `.js` with `type="module"`
+		return this.options.interopDefault === false ? false : !path.endsWith(".mjs") && "default" in mod;
+	}
+}
+function createImportMetaEnvProxy() {
+	// packages/vitest/src/node/plugins/index.ts:146
+	const booleanKeys = [
+		"DEV",
+		"PROD",
+		"SSR"
+	];
+	return new Proxy(process.env, {
+		get(_, key) {
+			return typeof key === "string" ? booleanKeys.includes(key) ? !!process.env[key] : process.env[key] : void 0;
+		},
+		set(_, key, value) {
+			if (typeof key !== "string") return true;
+			if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
+			else process.env[key] = value;
+			return true;
+		}
+	});
+}
+function updateStyle(id, css) {
+	if (typeof document === "undefined") return;
+	const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (element) {
+		element.textContent = css;
+		return;
+	}
+	const head = document.querySelector("head"), style = document.createElement("style");
+	style.setAttribute("type", "text/css"), style.setAttribute("data-vite-dev-id", id), style.textContent = css, head?.appendChild(style);
+}
+function removeStyle(id) {
+	if (typeof document === "undefined") return;
+	const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (sheet) document.head.removeChild(sheet);
+}
+const defaultClientStub = {
+	injectQuery: (id) => id,
+	createHotContext: () => {
+		return {
+			accept: () => {},
+			prune: () => {},
+			dispose: () => {},
+			decline: () => {},
+			invalidate: () => {},
+			on: () => {},
+			send: () => {}
+		};
+	},
+	updateStyle: () => {},
+	removeStyle: () => {}
+};
+function getDefaultRequestStubs(context) {
+	if (!context) {
+		const clientStub = {
+			...defaultClientStub,
+			updateStyle,
+			removeStyle
+		};
+		return { "/@vite/client": clientStub };
+	}
+	const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(defaultClientStub);
+	return { "/@vite/client": clientStub };
+}
+function exportAll(exports, sourceModule) {
+	if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+		for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {
+			defineExport(exports, key, () => sourceModule[key]);
+		} catch {}
+	}
+}
+// keep consistency with Vite on how exports are defined
+function defineExport(exports, key, value) {
+	Object.defineProperty(exports, key, {
+		enumerable: true,
+		configurable: true,
+		get: value
+	});
+}
+function isPrimitive(v) {
+	const isObject = typeof v === "object" || typeof v === "function";
+	return !isObject || v == null;
+}
+function interopModule(mod) {
+	if (isPrimitive(mod)) return {
+		mod: { default: mod },
+		defaultExport: mod
+	};
+	let defaultExport = "default" in mod ? mod.default : mod;
+	if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+		if (mod = defaultExport, "default" in defaultExport) defaultExport = defaultExport.default;
+	}
+	return {
+		mod,
+		defaultExport
+	};
+}
+const VALID_ID_PREFIX = `/@id/`, NULL_BYTE_PLACEHOLDER = `__x00__`;
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+
+export { VitestModuleEvaluator, createImportMetaEnvProxy, getDefaultRequestStubs, isPrimitive, unwrapId, wrapId };

package/dist/module-runner.js

@@ -0,0 +1,15 @@
+export { VitestModuleEvaluator } from './module-evaluator.js';
+export { a as VITEST_VM_CONTEXT_SYMBOL, V as VitestModuleRunner, s as startVitestModuleRunner } from './chunks/startModuleRunner.C8TW8zTN.js';
+export { g as getWorkerState } from './chunks/utils.C7__0Iv5.js';
+import 'node:module';
+import 'node:url';
+import 'node:vm';
+import 'pathe';
+import 'vite/module-runner';
+import 'node:fs';
+import '@vitest/utils';
+import './path.js';
+import 'node:path';
+import '@vitest/utils/error';
+import '@vitest/mocker';
+import './chunks/moduleTransport.I-bgQy0S.js';