vitest 4.0.8 → 4.0.10

package/dist/chunks/{index.DAL392Ss.js → index.0kCJoeWi.js}

@@ -7,7 +7,7 @@ function defaultSerialize(i) {
 const defaultDeserialize = defaultSerialize;
 const { clearTimeout, setTimeout } = globalThis;
 const random = Math.random.bind(Math);
-function createBirpc(functions, options) {
+function createBirpc($functions, options) {
   const {
     post,
     on,
@@ -20,83 +20,100 @@ function createBirpc(functions, options) {
     bind = "rpc",
     timeout = DEFAULT_TIMEOUT
   } = options;
-  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  let $closed = false;
+  const _rpcPromiseMap = /* @__PURE__ */ new Map();
   let _promiseInit;
-  let closed = false;
+  async function _call(method, args, event, optional) {
+    if ($closed)
+      throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+    const req = { m: method, a: args, t: TYPE_REQUEST };
+    if (optional)
+      req.o = true;
+    const send = async (_req) => post(serialize(_req));
+    if (event) {
+      await send(req);
+      return;
+    }
+    if (_promiseInit) {
+      try {
+        await _promiseInit;
+      } finally {
+        _promiseInit = void 0;
+      }
+    }
+    let { promise, resolve, reject } = createPromiseWithResolvers();
+    const id = nanoid();
+    req.i = id;
+    let timeoutId;
+    async function handler(newReq = req) {
+      if (timeout >= 0) {
+        timeoutId = setTimeout(() => {
+          try {
+            const handleResult = options.onTimeoutError?.(method, args);
+            if (handleResult !== true)
+              throw new Error(`[birpc] timeout on calling "${method}"`);
+          } catch (e) {
+            reject(e);
+          }
+          _rpcPromiseMap.delete(id);
+        }, timeout);
+        if (typeof timeoutId === "object")
+          timeoutId = timeoutId.unref?.();
+      }
+      _rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
+      await send(newReq);
+      return promise;
+    }
+    try {
+      if (options.onRequest)
+        await options.onRequest(req, handler, resolve);
+      else
+        await handler();
+    } catch (e) {
+      if (options.onGeneralError?.(e) !== true)
+        throw e;
+      return;
+    } finally {
+      clearTimeout(timeoutId);
+      _rpcPromiseMap.delete(id);
+    }
+    return promise;
+  }
+  const $call = (method, ...args) => _call(method, args, false);
+  const $callOptional = (method, ...args) => _call(method, args, false, true);
+  const $callEvent = (method, ...args) => _call(method, args, true);
+  const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
+  const builtinMethods = {
+    $call,
+    $callOptional,
+    $callEvent,
+    $callRaw,
+    $rejectPendingCalls,
+    get $closed() {
+      return $closed;
+    },
+    $close,
+    $functions
+  };
   const rpc = new Proxy({}, {
     get(_, method) {
-      if (method === "$functions")
-        return functions;
-      if (method === "$close")
-        return close;
-      if (method === "$rejectPendingCalls") {
-        return rejectPendingCalls;
-      }
-      if (method === "$closed")
-        return closed;
-      if (method === "then" && !eventNames.includes("then") && !("then" in functions))
+      if (Object.prototype.hasOwnProperty.call(builtinMethods, method))
+        return builtinMethods[method];
+      if (method === "then" && !eventNames.includes("then") && !("then" in $functions))
         return void 0;
-      const sendEvent = async (...args) => {
-        await post(serialize({ m: method, a: args, t: TYPE_REQUEST }));
-      };
+      const sendEvent = (...args) => _call(method, args, true);
       if (eventNames.includes(method)) {
         sendEvent.asEvent = sendEvent;
         return sendEvent;
       }
-      const sendCall = async (...args) => {
-        if (closed)
-          throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-        if (_promiseInit) {
-          try {
-            await _promiseInit;
-          } finally {
-            _promiseInit = void 0;
-          }
-        }
-        let { promise, resolve, reject } = createPromiseWithResolvers();
-        const id = nanoid();
-        let timeoutId;
-        const _req = { m: method, a: args, i: id, t: TYPE_REQUEST };
-        async function handler(req = _req) {
-          if (timeout >= 0) {
-            timeoutId = setTimeout(() => {
-              try {
-                const handleResult = options.onTimeoutError?.(method, args);
-                if (handleResult !== true)
-                  throw new Error(`[birpc] timeout on calling "${method}"`);
-              } catch (e) {
-                reject(e);
-              }
-              rpcPromiseMap.delete(id);
-            }, timeout);
-            if (typeof timeoutId === "object")
-              timeoutId = timeoutId.unref?.();
-          }
-          rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
-          await post(serialize(req));
-          return promise;
-        }
-        try {
-          if (options.onRequest)
-            await options.onRequest(_req, handler, resolve);
-          else
-            await handler();
-        } catch (e) {
-          clearTimeout(timeoutId);
-          rpcPromiseMap.delete(id);
-          if (options.onGeneralError?.(e) !== true)
-            throw e;
-          return;
-        }
-        return promise;
-      };
+      const sendCall = (...args) => _call(method, args, false);
       sendCall.asEvent = sendEvent;
       return sendCall;
     }
   });
-  function close(customError) {
-    closed = true;
-    rpcPromiseMap.forEach(({ reject, method }) => {
+  function $close(customError) {
+    $closed = true;
+    _rpcPromiseMap.forEach(({ reject, method }) => {
       const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
       if (customError) {
         customError.cause ??= error;
@@ -104,18 +121,18 @@ function createBirpc(functions, options) {
       }
       reject(error);
     });
-    rpcPromiseMap.clear();
+    _rpcPromiseMap.clear();
     off(onMessage);
   }
-  function rejectPendingCalls(handler) {
-    const entries = Array.from(rpcPromiseMap.values());
+  function $rejectPendingCalls(handler) {
+    const entries = Array.from(_rpcPromiseMap.values());
     const handlerResults = entries.map(({ method, reject }) => {
       if (!handler) {
         return reject(new Error(`[birpc]: rejected pending call "${method}".`));
       }
       return handler({ method, reject });
     });
-    rpcPromiseMap.clear();
+    _rpcPromiseMap.clear();
     return handlerResults;
   }
   async function onMessage(data, ...extra) {
@@ -128,14 +145,16 @@ function createBirpc(functions, options) {
       return;
     }
     if (msg.t === TYPE_REQUEST) {
-      const { m: method, a: args } = msg;
+      const { m: method, a: args, o: optional } = msg;
       let result, error;
-      const fn = await (resolver ? resolver(method, functions[method]) : functions[method]);
+      let fn = await (resolver ? resolver(method, $functions[method]) : $functions[method]);
+      if (optional)
+        fn ||= () => void 0;
       if (!fn) {
         error = new Error(`[birpc] function "${method}" not found`);
       } else {
         try {
-          result = await fn.apply(bind === "rpc" ? rpc : functions, args);
+          result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
         } catch (e) {
           error = e;
         }
@@ -166,7 +185,7 @@ function createBirpc(functions, options) {
       }
     } else {
       const { i: ack, r: result, e: error } = msg;
-      const promise = rpcPromiseMap.get(ack);
+      const promise = _rpcPromiseMap.get(ack);
       if (promise) {
         clearTimeout(promise.timeoutId);
         if (error)
@@ -174,7 +193,7 @@ function createBirpc(functions, options) {
         else
           promise.resolve(result);
       }
-      rpcPromiseMap.delete(ack);
+      _rpcPromiseMap.delete(ack);
     }
   }
   _promiseInit = on(onMessage);

package/dist/chunks/{index.op2Re5rn.js → index.B8lJfb0J.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.kotH7DY7.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName, s as separator } from './index.BYek7GgP.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils/helpers';
 

package/dist/chunks/{index.kotH7DY7.js → index.BYek7GgP.js}

@@ -527,7 +527,6 @@ class BaseReporter {
 	onInit(ctx) {
 		this.ctx = ctx;
 		this.ctx.logger.printBanner();
-		this.start = performance$1.now();
 	}
 	log(...messages) {
 		this.ctx.logger.log(...messages);
@@ -538,6 +537,10 @@ class BaseReporter {
 	relative(path) {
 		return relative(this.ctx.config.root, path);
 	}
+	onTestRunStart(_specifications) {
+		this.start = performance$1.now();
+		this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
+	}
 	onTestRunEnd(testModules, unhandledErrors, _reason) {
 		const files = testModules.map((testModule) => testModule.task);
 		const errors = [...unhandledErrors];
@@ -712,8 +715,6 @@ class BaseReporter {
 		if (this.ctx.configOverride.testNamePattern) this.log(BADGE_PADDING + c.dim(" Test name pattern: ") + c.blue(String(this.ctx.configOverride.testNamePattern)));
 		this.log("");
 		for (const testModule of this.failedUnwatchedFiles) this.printTestModule(testModule);
-		this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
-		this.start = performance$1.now();
 	}
 	onUserConsoleLog(log, taskState) {
 		if (!this.shouldLog(log, taskState)) return;
@@ -1287,6 +1288,7 @@ class DefaultReporter extends BaseReporter {
 			if (this.renderSucceed === void 0) this.renderSucceed = !!this.renderSucceed;
 			if (this.renderSucceed !== true) this.renderSucceed = specifications.length <= 1;
 		}
+		super.onTestRunStart(specifications);
 		this.summary?.onTestRunStart(specifications);
 	}
 	onTestRunEnd(testModules, unhandledErrors, reason) {

package/dist/chunks/{index.Dc3xnDvT.js → index.D4KonVSU.js}

@@ -2,7 +2,7 @@ import { resolve, isAbsolute, dirname, join } from 'node:path';
 import { existsSync } from 'node:fs';
 import 'node:module';
 import 'node:url';
-import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers.D26ty3Ew.js';
 import require$$0 from 'readline';
 import require$$0$1 from 'events';
 
@@ -3025,9 +3025,9 @@ var hasRequiredPrompts$2;
 function requirePrompts$2 () {
 	if (hasRequiredPrompts$2) return prompts$2;
 	hasRequiredPrompts$2 = 1;
-	(function (exports) {
+	(function (exports$1) {
 
-		const $ = exports;
+		const $ = exports$1;
 
 		const el = requireElements$1();
 
@@ -5993,8 +5993,8 @@ var hasRequiredPrompts$1;
 function requirePrompts$1 () {
 	if (hasRequiredPrompts$1) return prompts$1;
 	hasRequiredPrompts$1 = 1;
-	(function (exports) {
-		const $ = exports;
+	(function (exports$1) {
+		const $ = exports$1;
 		const el = requireElements();
 		const noop = v => v;
 

package/dist/chunks/{index.DIFZf73e.js → index.DZ-mI_Nm.js}

@@ -1,4 +1,4 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.Bgcdy3bQ.js';
+import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.BiaV1qII.js';
 import { b as bench } from './benchmark.B3N2zMcH.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from 'expect-type';

package/dist/chunks/{index.BY4-tcno.js → index.Dua7TZg_.js}

@@ -1,8 +1,8 @@
 import { chai } from '@vitest/expect';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.LGjNSzXp.js';
-import { r as rpc } from './rpc.BUV7uWKJ.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.BOzbXE3x.js';
+import { r as rpc } from './rpc.BytlcPfC.js';
 import { g as getWorkerState } from './utils.DvEY5TfP.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.ClrAtjMv.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.BPErLMrw.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);

package/dist/chunks/{index.DfKyPFVi.js → index.QWbK7rHY.js}

@@ -431,7 +431,7 @@ var jsdom = {
 		NodeBlob_ = globalThis.Blob;
 		NodeRequest_ = globalThis.Request;
 		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
-		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
+		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false, ...restOptions } = jsdom;
 		let virtualConsole;
 		if (console && globalThis.console) {
 			virtualConsole = new VirtualConsole();
@@ -499,7 +499,7 @@ var jsdom = {
 		NodeBlob_ = globalThis.Blob;
 		NodeRequest_ = globalThis.Request;
 		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
-		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
+		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false, ...restOptions } = jsdom;
 		let virtualConsole;
 		if (console && globalThis.console) {
 			virtualConsole = new VirtualConsole();
@@ -547,6 +547,9 @@ function createCompatRequest(utils) {
 				super(input, compatInit);
 			} else super(...args);
 		}
+		static [Symbol.hasInstance](instance) {
+			return instance instanceof NodeRequest_;
+		}
 	};
 }
 function createJSDOMCompatURL(utils) {
@@ -558,6 +561,9 @@ function createJSDOMCompatURL(utils) {
 			}
 			return URL.createObjectURL(blob);
 		}
+		static [Symbol.hasInstance](instance) {
+			return instance instanceof URL;
+		}
 	};
 }
 function createCompatUtils(window) {
@@ -587,7 +593,7 @@ function patchAddEventListener(window) {
 	const originalAddEventListener = window.EventTarget.prototype.addEventListener;
 	window.EventTarget.prototype.addEventListener = function addEventListener(type, callback, options) {
 		if (typeof options === "object" && options.signal != null) {
-			const { signal,...otherOptions } = options;
+			const { signal, ...otherOptions } = options;
 			// - this happens because AbortSignal is provided by Node.js,
 			// but jsdom APIs require jsdom's AbortSignal, while Node APIs
 			// (like fetch and Request) require a Node.js AbortSignal

package/dist/chunks/init-forks.BZSlxfwV.js

@@ -0,0 +1,32 @@
+import { i as init } from './init.Cz2kTB9a.js';
+
+if (!process.send) throw new Error("Expected worker to be run in node:child_process");
+// Store globals in case tests overwrite them
+const processExit = process.exit.bind(process);
+const processSend = process.send.bind(process);
+const processOn = process.on.bind(process);
+const processOff = process.off.bind(process);
+const processRemoveAllListeners = process.removeAllListeners.bind(process);
+// Work-around for nodejs/node#55094
+if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
+function workerInit(options) {
+	const { runTests } = options;
+	init({
+		post: (v) => processSend(v),
+		on: (cb) => processOn("message", cb),
+		off: (cb) => processOff("message", cb),
+		teardown: () => processRemoveAllListeners("message"),
+		runTests: (state) => executeTests("run", state),
+		collectTests: (state) => executeTests("collect", state),
+		setup: options.setup
+	});
+	async function executeTests(method, state) {
+		try {
+			await runTests(method, state);
+		} finally {
+			process.exit = processExit;
+		}
+	}
+}
+
+export { workerInit as w };

package/dist/chunks/{init-threads.Cm4OCIWA.js → init-threads.CwE2n-Bv.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.DMDG-idf.js';
+import { i as init } from './init.Cz2kTB9a.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.DMDG-idf.js → init.Cz2kTB9a.js}

@@ -3,10 +3,10 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.BOmUtLIO.js';
-import { e as environments } from './index.DfKyPFVi.js';
+import { b as VitestTransport } from './startModuleRunner.DLjmA_wU.js';
+import { e as environments } from './index.QWbK7rHY.js';
 import { serializeError } from '@vitest/utils/error';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BUV7uWKJ.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BytlcPfC.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';

package/dist/chunks/{moduleRunner.d.CzOZ_4wC.d.ts → moduleRunner.d.BxT-OjLR.d.ts}

@@ -2,7 +2,7 @@ import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import * as viteModuleRunner from 'vite/module-runner';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
-import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.DadbA89M.js';
+import { R as RuntimeRPC, e as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.ZGohxCEd.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
 

package/dist/chunks/{plugin.d.D4RrtywJ.d.ts → plugin.d.C6KrdvNG.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.Da1D1VbQ.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.keG-yFSu.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;

package/dist/chunks/{reporters.d.Da1D1VbQ.d.ts → reporters.d.keG-yFSu.d.ts}

@@ -1,13 +1,13 @@
 import { TaskMeta, Suite, File, TestAnnotation, ImportDuration, Test, Task, TaskResultPack, FileSpecification, CancelReason, SequenceSetupFiles, SequenceHooks } from '@vitest/runner';
 import { TestError, SerializedError, Arrayable, ParsedStack, Awaitable } from '@vitest/utils';
-import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, d as ContextTestEnvironment, f as WorkerTestEnvironment, g as WorkerExecuteContext, L as LabelColor } from './worker.d.DadbA89M.js';
+import { A as AfterSuiteRunMeta, U as UserConsoleLog, P as ProvidedContext, d as ContextTestEnvironment, f as WorkerTestEnvironment, g as WorkerExecuteContext, L as LabelColor } from './worker.d.ZGohxCEd.js';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, ViteDevServer, Plugin, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { BrowserCommands } from 'vitest/browser';
 import { B as BrowserTraceViewMode, S as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.BTfZNUu9.js';
-import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.DTTM2PTh.js';
+import { S as SerializedTestSpecification, B as BrowserTesterOptions } from './browser.d.DnU_kh8a.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -1325,7 +1325,7 @@ declare class Vitest {
 	/**
 	* Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
 	*/
-	onCancel(fn: (reason: CancelReason) => Awaitable<void>): void;
+	onCancel(fn: (reason: CancelReason) => Awaitable<void>): () => void;
 	/**
 	* Register a handler that will be called when the server is closed.
 	*/
@@ -1965,6 +1965,7 @@ declare abstract class BaseReporter implements Reporter {
 	log(...messages: any): void;
 	error(...messages: any): void;
 	relative(path: string): string;
+	onTestRunStart(_specifications: ReadonlyArray<TestSpecification>): void;
 	onTestRunEnd(testModules: ReadonlyArray<TestModule>, unhandledErrors: ReadonlyArray<SerializedError>, _reason: TestRunEndReason): void;
 	onTestCaseResult(testCase: TestCase): void;
 	onTestSuiteResult(testSuite: TestSuite): void;

package/dist/chunks/{rpc.BUV7uWKJ.js → rpc.BytlcPfC.js}

@@ -1,5 +1,5 @@
 import { getSafeTimers } from '@vitest/utils/timers';
-import { c as createBirpc } from './index.DAL392Ss.js';
+import { c as createBirpc } from './index.0kCJoeWi.js';
 import { g as getWorkerState } from './utils.DvEY5TfP.js';
 
 const { get } = Reflect;

package/dist/chunks/{setup-common.LGjNSzXp.js → setup-common.BOzbXE3x.js}

@@ -26,7 +26,7 @@ async function setupCommonEnv(config) {
 	if (globalSetup) return;
 	globalSetup = true;
 	setSafeTimers();
-	if (config.globals) (await import('./globals.DOh96BiR.js')).registerApiGlobally();
+	if (config.globals) (await import('./globals.NLOzC_A5.js')).registerApiGlobally();
 }
 function setupDefines(config) {
 	for (const key in config.defines) globalThis[key] = config.defines[key];
@@ -34,7 +34,7 @@ function setupDefines(config) {
 function setupEnv(env) {
 	const state = getWorkerState();
 	// same boolean-to-string assignment as VitestPlugin.configResolved
-	const { PROD, DEV,...restEnvs } = env;
+	const { PROD, DEV, ...restEnvs } = env;
 	state.metaEnv.PROD = PROD;
 	state.metaEnv.DEV = DEV;
 	for (const key in restEnvs) state.metaEnv[key] = env[key];

package/dist/chunks/{startModuleRunner.BOmUtLIO.js → startModuleRunner.DLjmA_wU.js}

@@ -351,8 +351,8 @@ class VitestMocker {
 	async callFunctionMock(id, url, mock) {
 		const node = this.ensureModule(id, url);
 		if (node.exports) return node.exports;
-		const exports = await mock.resolve();
-		const moduleExports = new Proxy(exports, { get: (target, prop) => {
+		const exports$1 = await mock.resolve();
+		const moduleExports = new Proxy(exports$1, { get: (target, prop) => {
 			const val = target[prop];
 			// 'then' can exist on non-Promise objects, need nested instanceof check for logic to work
 			if (prop === "then") {
@@ -444,8 +444,8 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			const Object = this.primitives.Object;
 			// we have to define a separate object that will copy all properties into itself
 			// and can't just use the same `exports` define automatically by Vite before the evaluator
-			const exports = Object.create(null);
-			Object.defineProperty(exports, Symbol.toStringTag, {
+			const exports$1 = Object.create(null);
+			Object.defineProperty(exports$1, Symbol.toStringTag, {
 				value: "Module",
 				configurable: true,
 				writable: true
@@ -453,10 +453,10 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
 			node.meta = evaluatedNode.meta;
 			node.file = evaluatedNode.file;
-			node.mockedExports = exports;
+			node.mockedExports = exports$1;
 			const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
-			this.mockObject(mod, exports, mock.type);
-			return exports;
+			this.mockObject(mod, exports$1, mock.type);
+			return exports$1;
 		}
 		if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
 			callstack.push(mockId);
@@ -595,8 +595,8 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	* We should keep the Vite behavour when there is a `strict` flag.
 	* @internal
 	*/
-	processImport(exports) {
-		return exports;
+	processImport(exports$1) {
+		return exports$1;
 	}
 	async import(rawId) {
 		const resolved = await this.vitestOptions.transport.resolveId(rawId);

package/dist/chunks/{test.ClrAtjMv.js → test.BPErLMrw.js}

@@ -7,8 +7,8 @@ import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
 import { getTests, getNames, getTestName } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
 import { normalize } from 'pathe';
-import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.Bgcdy3bQ.js';
-import { r as rpc } from './rpc.BUV7uWKJ.js';
+import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.BiaV1qII.js';
+import { r as rpc } from './rpc.BytlcPfC.js';
 
 function createBenchmarkResult(name) {
 	return {

package/dist/chunks/{vi.Bgcdy3bQ.js → vi.BiaV1qII.js}

@@ -9,7 +9,7 @@ import { assertTypes, createSimpleStackTrace } from '@vitest/utils/helpers';
 import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';
 import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
+import { c as commonjsGlobal } from './_commonjsHelpers.D26ty3Ew.js';
 import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
 
 // these matchers are not supported because they don't make sense with poll
@@ -584,7 +584,7 @@ var hasRequiredDeprecated;
 function requireDeprecated () {
 	if (hasRequiredDeprecated) return deprecated;
 	hasRequiredDeprecated = 1;
-	(function (exports) {
+	(function (exports$1) {
 
 		/**
 		 * Returns a function that will invoke the supplied function and print a
@@ -593,9 +593,9 @@ function requireDeprecated () {
 		 * @param  {string} msg
 		 * @returns {Function}
 		 */
-		exports.wrap = function (func, msg) {
+		exports$1.wrap = function (func, msg) {
 		    var wrapped = function () {
-		        exports.printWarning(msg);
+		        exports$1.printWarning(msg);
 		        return func.apply(this, arguments);
 		    };
 		    if (func.prototype) {
@@ -611,7 +611,7 @@ function requireDeprecated () {
 		 * @param  {string} funcName
 		 * @returns {string}
 		 */
-		exports.defaultMsg = function (packageName, funcName) {
+		exports$1.defaultMsg = function (packageName, funcName) {
 		    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
 		};
 
@@ -620,7 +620,7 @@ function requireDeprecated () {
 		 * @param  {string} msg
 		 * @returns {undefined}
 		 */
-		exports.printWarning = function (msg) {
+		exports$1.printWarning = function (msg) {
 		    /* istanbul ignore next */
 		    if (typeof process === "object" && process.emitWarning) {
 		        // Emit Warnings in Node
@@ -839,7 +839,7 @@ var hasRequiredTypeDetect;
 function requireTypeDetect () {
 	if (hasRequiredTypeDetect) return typeDetect$1.exports;
 	hasRequiredTypeDetect = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		(function (global, factory) {
 			module.exports = factory() ;
 		}(typeDetect, (function () {
@@ -3902,7 +3902,7 @@ function _mocker() {
 function getImporter(name) {
 	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n");
 	return parseSingleStack(stackArray[stackArray.findLastIndex((stack) => {
-		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
+		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);
 	}) + 1])?.file || "";
 }