vitest 0.28.4 → 0.28.5

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
 export { ConfigEnv } from 'vite';
-import { a1 as ResolvedCoverageOptions, U as UserConfig$1, a4 as CoverageC8Options, _ as CoverageProviderModule, a2 as BaseCoverageOptions, a3 as CoverageIstanbulOptions, $ as CoverageReporter, F as FakeTimerInstallOpts } from './types-aac763a5.js';
+import { a1 as ResolvedCoverageOptions, U as UserConfig$1, a4 as CoverageC8Options, _ as CoverageProviderModule, a2 as BaseCoverageOptions, a3 as CoverageIstanbulOptions, $ as CoverageReporter, F as FakeTimerInstallOpts } from './types-0373403c.js';
 import '@vitest/expect';
 import '@vitest/runner/types';
 import '@vitest/runner';

package/dist/entry.js

@@ -1,22 +1,22 @@
 import { promises, existsSync } from 'node:fs';
 import { m as micromatch_1, t as takeCoverageInsideWorker } from './chunk-integrations-coverage.48e6286b.js';
 import { startTests } from '@vitest/runner';
+import { resolve } from 'pathe';
 import { g as getWorkerState, r as resetModules } from './chunk-utils-global.442d1d33.js';
-import { R as RealDate, g as globalExpect, a as vi } from './chunk-utils-import.0402c9db.js';
+import { R as RealDate, g as globalExpect, a as vi } from './chunk-utils-import.847b4a2d.js';
 import { e as environments, a as envs } from './chunk-env-node.ffd1183b.js';
+import { d as distDir } from './chunk-constants.797d3ebf.js';
 import { createRequire } from 'node:module';
 import c from 'picocolors';
 import { installSourcemapsSupport } from 'vite-node/source-map';
 import { setColors, getSafeTimers } from '@vitest/utils';
-import { i as index } from './chunk-integrations-utils.dae69d89.js';
-import { s as setupSnapshotEnvironment } from './chunk-snapshot-env.6457638e.js';
+import { i as index } from './chunk-integrations-utils.9717ad89.js';
+import { s as setupSnapshotEnvironment } from './chunk-snapshot-env.a347d647.js';
 import { r as rpc } from './chunk-runtime-rpc.9c0386cc.js';
-import { s as setupCommonEnv } from './chunk-runtime-setup.7dfc1a6a.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './runners-chunk.js';
+import { s as setupCommonEnv } from './chunk-runtime-setup.30ab0a4b.js';
 import 'local-pkg';
 import 'util';
 import 'path';
-import 'pathe';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
 import '@vitest/runner/utils';
@@ -24,9 +24,10 @@ import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
 import '@vitest/expect';
 import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-utils-tasks.d07dcea9.js';
 import '@vitest/spy';
 import 'node:console';
+import 'node:url';
 import './chunk-integrations-run-once.38756e30.js';
 
 class NodeSnapshotEnvironment {
@@ -175,8 +176,8 @@ async function setupConsoleLogSpy() {
     groupIndentation: 2
   });
 }
-async function loadEnvironment(name) {
-  const pkg = await import(`vitest-environment-${name}`);
+async function loadEnvironment(name, executor) {
+  const pkg = await executor.executeId(`vitest-environment-${name}`);
   if (!pkg || !pkg.default || typeof pkg.default !== "object" || typeof pkg.default.setup !== "function") {
     throw new Error(
       `Environment "${name}" is not a valid environment. Package "vitest-environment-${name}" should have default export with "setup" method.`
@@ -184,8 +185,8 @@ async function loadEnvironment(name) {
   }
   return pkg.default;
 }
-async function withEnv(name, options, fn) {
-  const config = environments[name] || await loadEnvironment(name);
+async function withEnv(name, options, executor, fn) {
+  const config = environments[name] || await loadEnvironment(name, executor);
   globalThis.__vitest_environment__ = config.name || name;
   globalExpect.setState({
     environment: config.name || name || "node"
@@ -198,6 +199,7 @@ async function withEnv(name, options, fn) {
   }
 }
 
+const runnersFile = resolve(distDir, "runners.js");
 function groupBy(collection, iteratee) {
   return collection.reduce((acc, item) => {
     const key = iteratee(item);
@@ -206,17 +208,24 @@ function groupBy(collection, iteratee) {
     return acc;
   }, {});
 }
-async function getTestRunnerConstructor(config) {
-  if (!config.runner)
+async function getTestRunnerConstructor(config, executor) {
+  if (!config.runner) {
+    const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
     return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-  const mod = await import(config.runner);
+  }
+  const mod = await executor.executeId(config.runner);
   if (!mod.default && typeof mod.default !== "function")
     throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
   return mod.default;
 }
-async function getTestRunner(config) {
-  const TestRunner = await getTestRunnerConstructor(config);
+async function getTestRunner(config, executor) {
+  const TestRunner = await getTestRunnerConstructor(config, executor);
   const testRunner = new TestRunner(config);
+  Object.defineProperty(testRunner, "__vitest_executor", {
+    value: executor,
+    enumerable: false,
+    configurable: false
+  });
   if (!testRunner.config)
     testRunner.config = config;
   if (!testRunner.importFile)
@@ -240,10 +249,10 @@ async function getTestRunner(config) {
   };
   return testRunner;
 }
-async function run(files, config) {
+async function run(files, config, executor) {
   await setupGlobalEnv(config);
   const workerState = getWorkerState();
-  const runner = await getTestRunner(config);
+  const runner = await getTestRunner(config, executor);
   const filesWithEnv = await Promise.all(files.map(async (file) => {
     var _a, _b;
     const code = await promises.readFile(file, "utf-8");
@@ -279,7 +288,7 @@ async function run(files, config) {
       const files3 = filesByOptions[options];
       if (!files3 || !files3.length)
         continue;
-      await withEnv(environment, files3[0].envOptions || config.environmentOptions || {}, async () => {
+      await withEnv(environment, files3[0].envOptions || config.environmentOptions || {}, executor, async () => {
         for (const { file } of files3) {
           if (config.isolate) {
             workerState.mockMap.clear();
@@ -289,6 +298,7 @@ async function run(files, config) {
           await startTests([file], runner);
           workerState.filepath = void 0;
           vi.resetConfig();
+          vi.restoreAllMocks();
         }
       });
     }

package/dist/environments.d.ts

@@ -1,4 +1,4 @@
-import { P as Environment } from './types-aac763a5.js';
+import { P as Environment } from './types-0373403c.js';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner/types';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Test } from '@vitest/runner';
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, a as ResolvedConfig, b as ModuleGraphData, S as SnapshotResult, c as Reporter } from './types-aac763a5.js';
-export { u as AfterSuiteRunMeta, A as ApiConfig, z as ArgumentsType, y as Arrayable, x as Awaitable, a2 as BaseCoverageOptions, a8 as BenchFunction, a6 as Benchmark, B as BenchmarkAPI, a7 as BenchmarkResult, a5 as BenchmarkUserOptions, h as BuiltinEnvironment, i as CSSModuleScopeStrategy, C as CollectLineNumbers, e as CollectLines, K as Constructable, g as Context, a4 as CoverageC8Options, a3 as CoverageIstanbulOptions, a0 as CoverageOptions, Y as CoverageProvider, _ as CoverageProviderModule, $ as CoverageReporter, G as DeepMerge, P as Environment, E as EnvironmentOptions, O as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, D as MergeInsertions, L as ModuleCache, b as ModuleGraphData, H as MutableArray, N as Nullable, X as OnServerRestartHandler, d as RawErrsMap, Z as ReportContext, c as Reporter, t as ResolveIdFunction, a as ResolvedConfig, a1 as ResolvedCoverageOptions, f as RootAndTarget, R as RuntimeConfig, j as SequenceHooks, n as SnapshotData, q as SnapshotMatchOptions, S as SnapshotResult, p as SnapshotStateOptions, s as SnapshotSummary, o as SnapshotUpdateState, T as TscErrorInfo, l as TypecheckConfig, r as UncheckedSnapshot, U as UserConfig, Q as UserConsoleLog, m as Vitest, V as VitestEnvironment, k as VitestRunMode, W as WorkerContext, w as WorkerGlobalState, v as WorkerRPC } from './types-aac763a5.js';
+import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, a as ResolvedConfig, b as ModuleGraphData, S as SnapshotResult, c as Reporter } from './types-0373403c.js';
+export { u as AfterSuiteRunMeta, A as ApiConfig, z as ArgumentsType, y as Arrayable, x as Awaitable, a2 as BaseCoverageOptions, a8 as BenchFunction, a6 as Benchmark, B as BenchmarkAPI, a7 as BenchmarkResult, a5 as BenchmarkUserOptions, h as BuiltinEnvironment, i as CSSModuleScopeStrategy, C as CollectLineNumbers, e as CollectLines, K as Constructable, g as Context, a4 as CoverageC8Options, a3 as CoverageIstanbulOptions, a0 as CoverageOptions, Y as CoverageProvider, _ as CoverageProviderModule, $ as CoverageReporter, G as DeepMerge, P as Environment, E as EnvironmentOptions, O as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, D as MergeInsertions, L as ModuleCache, b as ModuleGraphData, H as MutableArray, N as Nullable, X as OnServerRestartHandler, d as RawErrsMap, Z as ReportContext, c as Reporter, t as ResolveIdFunction, a as ResolvedConfig, a1 as ResolvedCoverageOptions, f as RootAndTarget, R as RuntimeConfig, j as SequenceHooks, n as SnapshotData, q as SnapshotMatchOptions, S as SnapshotResult, p as SnapshotStateOptions, s as SnapshotSummary, o as SnapshotUpdateState, T as TscErrorInfo, l as TypecheckConfig, r as UncheckedSnapshot, U as UserConfig, Q as UserConsoleLog, m as Vitest, V as VitestEnvironment, k as VitestRunMode, W as WorkerContext, w as WorkerGlobalState, v as WorkerRPC } from './types-0373403c.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, EnhancedSpy } from '@vitest/spy';
 export { EnhancedSpy, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
 export { S as SnapshotEnvironment } from './env-afee91f0.js';
@@ -306,7 +306,7 @@ declare class VitestUtils {
      */
     unstubAllGlobals(): this;
     /**
-     * Reset enviromental variables to the ones that were available before first `vi.stubEnv` was called.
+     * Reset environmental variables to the ones that were available before first `vi.stubEnv` was called.
      */
     unstubAllEnvs(): this;
     resetModules(): this;

package/dist/index.js

@@ -1,8 +1,8 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench, c as createExpect, g as expect, a as vi, v as vitest } from './chunk-utils-import.0402c9db.js';
+export { b as bench, c as createExpect, g as expect, a as vi, v as vitest } from './chunk-utils-import.847b4a2d.js';
 export { i as isFirstRun, r as runOnce } from './chunk-integrations-run-once.38756e30.js';
-import { d as dist } from './chunk-integrations-utils.dae69d89.js';
-export { b as assertType, g as getRunningMode, a as isWatchMode } from './chunk-integrations-utils.dae69d89.js';
+import { d as dist } from './chunk-integrations-utils.9717ad89.js';
+export { b as assertType, g as getRunningMode, a as isWatchMode } from './chunk-integrations-utils.9717ad89.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
@@ -15,9 +15,9 @@ import 'std-env';
 import './vendor-_commonjsHelpers.addc3445.js';
 import '@vitest/expect';
 import './chunk-runtime-rpc.9c0386cc.js';
-import './chunk-snapshot-env.6457638e.js';
+import './chunk-snapshot-env.a347d647.js';
 import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-utils-tasks.d07dcea9.js';
 import 'util';
 import '@vitest/spy';
 

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { k as VitestRunMode, U as UserConfig, m as Vitest, a9 as MockFactory, aa as MockMap, ab as TestSequencer } from './types-aac763a5.js';
-export { ab as TestSequencer, ad as TestSequencerConstructor, m as Vitest, ac as startVitest } from './types-aac763a5.js';
+import { k as VitestRunMode, U as UserConfig, m as Vitest, a9 as MockFactory, aa as MockMap, ab as TestSequencer } from './types-0373403c.js';
+export { ab as TestSequencer, ad as TestSequencerConstructor, m as Vitest, ac as startVitest } from './types-0373403c.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeRunnerOptions } from 'vite-node';
@@ -19,12 +19,10 @@ declare function VitestPlugin(options?: UserConfig, ctx?: Vitest): Promise<Plugi
 
 type Key = string | symbol;
 declare class VitestMocker {
-    runner: VitestRunner;
+    executor: VitestExecutor;
     private static pendingIds;
-    private static spyModulePath;
-    private static spyModule?;
     private resolveCache;
-    constructor(runner: VitestRunner);
+    constructor(executor: VitestExecutor);
     private get root();
     private get base();
     private get mockMap();
@@ -45,7 +43,6 @@ declare class VitestMocker {
     mockPath(originalId: string, path: string, external: string | null, factory?: MockFactory): void;
     importActual<T>(rawId: string, importee: string): Promise<T>;
     importMock(rawId: string, importee: string): Promise<any>;
-    initializeSpyModule(): Promise<void>;
     requestWithMock(url: string, callstack: string[]): Promise<any>;
     queueMock(id: string, importer: string, factory?: MockFactory): void;
     queueUnmock(id: string, importer: string): void;
@@ -54,7 +51,7 @@ declare class VitestMocker {
 interface ExecuteOptions extends ViteNodeRunnerOptions {
     mockMap: MockMap;
 }
-declare class VitestRunner extends ViteNodeRunner {
+declare class VitestExecutor extends ViteNodeRunner {
     options: ExecuteOptions;
     mocker: VitestMocker;
     constructor(options: ExecuteOptions);
@@ -71,4 +68,4 @@ declare class BaseSequencer implements TestSequencer {
     sort(files: string[]): Promise<string[]>;
 }
 
-export { BaseSequencer, ExecuteOptions, VitestPlugin, VitestRunner, createVitest };
+export { BaseSequencer, ExecuteOptions, VitestExecutor, VitestPlugin, createVitest };

package/dist/node.js

@@ -1,5 +1,5 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-node-pkg.94145502.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.eb0c265c.js';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-node-pkg.9a107dfb.js';
+export { V as VitestExecutor } from './chunk-runtime-mocker.dafe0f77.js';
 import 'pathe';
 import './chunk-constants.797d3ebf.js';
 import 'node:url';
@@ -43,7 +43,7 @@ import 'tinypool';
 import './vendor-index.783e7f3e.js';
 import 'perf_hooks';
 import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-utils-tasks.d07dcea9.js';
 import 'crypto';
 import 'vite-node/utils';
 import '@vitest/utils/diff';
@@ -56,3 +56,4 @@ import 'node:module';
 import 'node:assert';
 import 'node:v8';
 import 'node:util';
+import '@vitest/spy';

package/dist/runners.d.ts

@@ -1,5 +1,5 @@
 import { VitestRunner, VitestRunnerImportSource, Suite, Test, TestContext } from '@vitest/runner';
-import { a as ResolvedConfig } from './types-aac763a5.js';
+import { a as ResolvedConfig } from './types-0373403c.js';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner/types';
@@ -16,6 +16,7 @@ declare class VitestTestRunner implements VitestRunner {
     config: ResolvedConfig;
     private snapshotClient;
     private workerState;
+    private __vitest_executor;
     constructor(config: ResolvedConfig);
     importFile(filepath: string, source: VitestRunnerImportSource): unknown;
     onBeforeRun(): void;
@@ -30,6 +31,7 @@ declare class VitestTestRunner implements VitestRunner {
 
 declare class NodeBenchmarkRunner implements VitestRunner {
     config: ResolvedConfig;
+    private __vitest_executor;
     constructor(config: ResolvedConfig);
     importFile(filepath: string, source: VitestRunnerImportSource): unknown;
     runSuite(suite: Suite): Promise<void>;

package/dist/runners.js

@@ -1,18 +1,226 @@
-export { N as NodeBenchmarkRunner, V as VitestTestRunner } from './runners-chunk.js';
-import '@vitest/expect';
-import './chunk-utils-import.0402c9db.js';
-import '@vitest/runner';
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { d as getSnapshotClient, c as createExpect, a as vi, e as getBenchOptions, f as getBenchFn } from './chunk-utils-import.847b4a2d.js';
+import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
+import { g as getFullName } from './chunk-utils-tasks.d07dcea9.js';
+import { updateTask } from '@vitest/runner';
+import { createDefer, getSafeTimers } from '@vitest/utils';
 import '@vitest/runner/utils';
-import '@vitest/utils';
-import './chunk-utils-global.442d1d33.js';
-import 'pathe';
-import './chunk-utils-env.860d90c2.js';
-import 'std-env';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
 import './chunk-runtime-rpc.9c0386cc.js';
-import './chunk-snapshot-env.6457638e.js';
+import 'pathe';
+import './chunk-snapshot-env.a347d647.js';
 import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
 import 'util';
 import '@vitest/spy';
+import './chunk-utils-env.860d90c2.js';
+import 'std-env';
+
+class VitestTestRunner {
+  constructor(config) {
+    this.config = config;
+    this.snapshotClient = getSnapshotClient();
+    this.workerState = getWorkerState();
+  }
+  importFile(filepath, source) {
+    if (source === "setup")
+      this.workerState.moduleCache.delete(filepath);
+    return this.__vitest_executor.executeId(filepath);
+  }
+  onBeforeRun() {
+    this.snapshotClient.clear();
+  }
+  async onAfterRun() {
+    await this.snapshotClient.saveCurrent();
+  }
+  onAfterRunSuite(suite) {
+    if (this.config.logHeapUsage && typeof process !== "undefined")
+      suite.result.heap = process.memoryUsage().heapUsed;
+  }
+  onAfterRunTest(test) {
+    this.snapshotClient.clearTest();
+    if (this.config.logHeapUsage && typeof process !== "undefined")
+      test.result.heap = process.memoryUsage().heapUsed;
+    this.workerState.current = void 0;
+  }
+  async onBeforeRunTest(test) {
+    if (test.mode !== "run") {
+      this.snapshotClient.skipTestSnapshots(test);
+      return;
+    }
+    clearModuleMocks(this.config);
+    await this.snapshotClient.setTest(test);
+    this.workerState.current = test;
+  }
+  onBeforeTryTest(test) {
+    var _a;
+    setState({
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberErrorGen: null,
+      testPath: (_a = test.suite.file) == null ? void 0 : _a.filepath,
+      currentTestName: getFullName(test),
+      snapshotState: this.snapshotClient.snapshotState
+    }, globalThis[GLOBAL_EXPECT]);
+  }
+  onAfterTryTest(test) {
+    const {
+      assertionCalls,
+      expectedAssertionsNumber,
+      expectedAssertionsNumberErrorGen,
+      isExpectingAssertions,
+      isExpectingAssertionsError
+    } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
+      throw expectedAssertionsNumberErrorGen();
+    if (isExpectingAssertions === true && assertionCalls === 0)
+      throw isExpectingAssertionsError;
+  }
+  extendTestContext(context) {
+    let _expect;
+    Object.defineProperty(context, "expect", {
+      get() {
+        if (!_expect)
+          _expect = createExpect(context.meta);
+        return _expect;
+      }
+    });
+    Object.defineProperty(context, "_local", {
+      get() {
+        return _expect != null;
+      }
+    });
+    return context;
+  }
+}
+function clearModuleMocks(config) {
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+  if (restoreMocks)
+    vi.restoreAllMocks();
+  else if (mockReset)
+    vi.resetAllMocks();
+  else if (clearMocks)
+    vi.clearAllMocks();
+  if (unstubEnvs)
+    vi.unstubAllEnvs();
+  if (unstubGlobals)
+    vi.unstubAllGlobals();
+}
+
+async function importTinybench() {
+  if (!globalThis.EventTarget)
+    await import('./vendor-index.534e612c.js').then(function (n) { return n.i; });
+  return await import('tinybench');
+}
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+async function runBenchmarkSuite(suite, runner) {
+  var _a;
+  const { Task, Bench } = await importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run")
+      continue;
+    if ((_a = task.meta) == null ? void 0 : _a.benchmark)
+      benchmarkGroup.push(task);
+    else if (task.type === "suite")
+      benchmarkSuiteGroup.push(task);
+  }
+  if (benchmarkSuiteGroup.length)
+    await Promise.all(benchmarkSuiteGroup.map((subSuite) => runBenchmarkSuite(subSuite, runner)));
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    const benchmarkMap = {};
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1(suite);
+    benchmarkGroup.forEach((benchmark, idx) => {
+      const options = getBenchOptions(benchmark);
+      const benchmarkInstance = new Bench(options);
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const id = idx.toString();
+      benchmarkMap[id] = benchmark;
+      const task = new Task(benchmarkInstance, id, benchmarkFn);
+      benchmark.meta.task = task;
+      updateTask$1(benchmark);
+    });
+    benchmarkGroup.forEach((benchmark) => {
+      benchmark.meta.task.addEventListener("complete", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        if (_benchmark) {
+          const taskRes = task.result;
+          const result = _benchmark.result.benchmark;
+          Object.assign(result, taskRes);
+          updateTask$1(_benchmark);
+        }
+      });
+      benchmark.meta.task.addEventListener("error", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        defer.reject(_benchmark ? task.result.error : e);
+      });
+    });
+    Promise.all(benchmarkGroup.map(async (benchmark) => {
+      await benchmark.meta.task.warmup();
+      const { setTimeout } = getSafeTimers();
+      return await new Promise((resolve) => setTimeout(async () => {
+        resolve(await benchmark.meta.task.run());
+      }));
+    })).then((tasks) => {
+      suite.result.duration = performance.now() - start;
+      suite.result.state = "pass";
+      tasks.sort((a, b) => a.result.mean - b.result.mean).forEach((cycle, idx) => {
+        const benchmark = benchmarkMap[cycle.name || ""];
+        benchmark.result.state = "pass";
+        if (benchmark) {
+          const result = benchmark.result.benchmark;
+          result.rank = Number(idx) + 1;
+          updateTask$1(benchmark);
+        }
+      });
+      updateTask$1(suite);
+      defer.resolve(null);
+    });
+    await defer;
+  }
+  function updateTask$1(task) {
+    updateTask(task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  importFile(filepath, source) {
+    if (source === "setup")
+      getWorkerState().moduleCache.delete(filepath);
+    return this.__vitest_executor.executeId(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTest() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };

package/dist/{types-aac763a5.d.ts → types-0373403c.d.ts}

@@ -1026,7 +1026,7 @@ type ResolvedCoverageOptions<T extends Provider = Provider> = CoverageOptions<T>
 };
 interface BaseCoverageOptions {
     /**
-     * Enables coverage collection. Can be overriden using `--coverage` CLI option.
+     * Enables coverage collection. Can be overridden using `--coverage` CLI option.
      *
      * @default false
      */
@@ -1979,7 +1979,7 @@ declare global {
             toBeInstanceOf<E>(expected: E): void;
             toBeCalledTimes(times: number): void;
             toHaveLength(length: number): void;
-            toHaveProperty<E>(property: string | string[], value?: E): void;
+            toHaveProperty<E>(property: string | (string | number)[], value?: E): void;
             toBeCloseTo(number: number, numDigits?: number): void;
             toHaveBeenCalledTimes(times: number): void;
             toHaveBeenCalledOnce(): void;

package/dist/worker.js

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url';
 import { resolve, relative } from 'pathe';
 import { c as createBirpc } from './vendor-index.783e7f3e.js';
 import { workerId } from 'tinypool';
@@ -6,9 +7,8 @@ import { ModuleCacheMap } from 'vite-node/client';
 import { isPrimitive } from 'vite-node/utils';
 import { d as distDir } from './chunk-constants.797d3ebf.js';
 import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.eb0c265c.js';
+import { c as createVitestExecutor } from './chunk-runtime-mocker.dafe0f77.js';
 import { r as rpc } from './chunk-runtime-rpc.9c0386cc.js';
-import 'node:url';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
 import '@vitest/utils';
@@ -22,6 +22,7 @@ import 'node:path';
 import 'node:v8';
 import 'node:util';
 import './chunk-utils-base.904102a8.js';
+import '@vitest/spy';
 
 let _viteNode;
 const moduleCache = new ModuleCacheMap();
@@ -48,10 +49,7 @@ async function startViteNode(ctx) {
   }
   process.on("uncaughtException", (e) => catchError(e, "Uncaught Exception"));
   process.on("unhandledRejection", (e) => catchError(e, "Unhandled Rejection"));
-  const { run: run2 } = (await executeInViteNode({
-    files: [
-      resolve(distDir, "entry.js")
-    ],
+  const executor = await createVitestExecutor({
     fetchModule(id) {
       return rpc().fetch(id);
     },
@@ -63,8 +61,9 @@ async function startViteNode(ctx) {
     interopDefault: config.deps.interopDefault,
     root: config.root,
     base: config.base
-  }))[0];
-  _viteNode = { run: run2 };
+  });
+  const { run: run2 } = await import(pathToFileURL(resolve(distDir, "entry.js")).href);
+  _viteNode = { run: run2, executor };
   return _viteNode;
 }
 function init(ctx) {
@@ -102,8 +101,8 @@ function init(ctx) {
 }
 async function run(ctx) {
   init(ctx);
-  const { run: run2 } = await startViteNode(ctx);
-  return run2(ctx.files, ctx.config);
+  const { run: run2, executor } = await startViteNode(ctx);
+  return run2(ctx.files, ctx.config, executor);
 }
 
 export { run };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.28.4",
+  "version": "0.28.5",
   "description": "A blazing fast unit test framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -128,11 +128,11 @@
     "tinyspy": "^1.0.2",
     "vite": "^3.0.0 || ^4.0.0",
     "why-is-node-running": "^2.2.2",
-    "vite-node": "0.28.4",
-    "@vitest/utils": "0.28.4",
-    "@vitest/expect": "0.28.4",
-    "@vitest/runner": "0.28.4",
-    "@vitest/spy": "0.28.4"
+    "vite-node": "0.28.5",
+    "@vitest/expect": "0.28.5",
+    "@vitest/runner": "0.28.5",
+    "@vitest/utils": "0.28.5",
+    "@vitest/spy": "0.28.5"
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.1",