vitest 0.11.0 → 0.12.2

package/dist/entry.js

@@ -1,4 +1,4 @@
-export { r as run } from './vendor-entry.1b0b46f1.js';
+export { r as run } from './vendor-entry.3adaf0b2.js';
 import 'fs';
 import './chunk-utils-global.a5a8641f.js';
 import 'tty';
@@ -6,7 +6,7 @@ import 'local-pkg';
 import 'path';
 import 'console';
 import 'stream';
-import './chunk-runtime-chain.8a313ffb.js';
+import './chunk-runtime-chain.221b8dcb.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
 import './chunk-runtime-rpc.63398738.js';
@@ -14,7 +14,7 @@ import './chunk-utils-timers.f25e8f44.js';
 import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.23b3ae8a.js';
+import './chunk-defaults.ecb46baf.js';
 import 'module';
 import 'url';
 import 'crypto';

package/dist/index.d.ts

@@ -196,6 +196,72 @@ interface RawMatcherFn<T extends MatcherState = MatcherState> {
 }
 declare type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
 
+// Type definitions for @sinonjs/fake-timers 8.1
+// Project: https://github.com/sinonjs/fake-timers
+// Definitions by: Wim Looman <https://github.com/Nemo157>
+//                 Rogier Schouten <https://github.com/rogierschouten>
+//                 Yishai Zehavi <https://github.com/zyishai>
+//                 Remco Haszing <https://github.com/remcohaszing>
+//                 Jaden Simon <https://github.com/JadenSimon>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/**
+ * Names of clock methods that may be faked by install.
+ */
+type FakeMethod =
+    | 'setTimeout'
+    | 'clearTimeout'
+    | 'setImmediate'
+    | 'clearImmediate'
+    | 'setInterval'
+    | 'clearInterval'
+    | 'Date'
+    | 'nextTick'
+    | 'hrtime'
+    | 'requestAnimationFrame'
+    | 'cancelAnimationFrame'
+    | 'requestIdleCallback'
+    | 'cancelIdleCallback'
+    | 'performance'
+    | 'queueMicrotask';
+
+interface FakeTimerInstallOpts {
+    /**
+     * Installs fake timers with the specified unix epoch (default: 0)
+     */
+    now?: number | Date | undefined;
+
+    /**
+     * An array with names of global methods and APIs to fake. By default, `@sinonjs/fake-timers` does not replace `nextTick()` and `queueMicrotask()`.
+     * For instance, `FakeTimers.install({ toFake: ['setTimeout', 'nextTick'] })` will fake only `setTimeout()` and `nextTick()`
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll() (default: 1000)
+     */
+    loopLimit?: number | undefined;
+
+    /**
+     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
+     * 20ms for every 20ms change in the real system time) (default: false)
+     */
+    shouldAdvanceTime?: boolean | undefined;
+
+    /**
+     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
+     * in the real system time (default: 20)
+     */
+    advanceTimeDelta?: number | undefined;
+
+    /**
+     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by
+     * default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers. (default: false)
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+}
+
 declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
     normalizePath(fsPath: string): string;
     set(fsPath: string, mod: Partial<ModuleCache$1>): this;
@@ -333,7 +399,6 @@ declare class SnapshotManager {
 declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
 interface WorkerPool {
     runTests: RunWithFiles;
-    collectTests: RunWithFiles;
     close: () => Promise<void>;
 }
 
@@ -758,6 +823,7 @@ declare type TaskResultPack = [id: string, result: TaskResult | undefined];
 interface Suite extends TaskBase {
     type: 'suite';
     tasks: Task[];
+    filepath?: string;
 }
 interface File extends Suite {
     filepath: string;
@@ -810,8 +876,8 @@ declare type SuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'onl
 };
 declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return | void>;
 interface SuiteHooks {
-    beforeAll: HookListener<[Suite], () => Awaitable<void>>[];
-    afterAll: HookListener<[Suite]>[];
+    beforeAll: HookListener<[Suite | File], () => Awaitable<void>>[];
+    afterAll: HookListener<[Suite | File]>[];
     beforeEach: HookListener<[TestContext, Suite], () => Awaitable<void>>[];
     afterEach: HookListener<[TestContext, Suite]>[];
 }
@@ -1069,7 +1135,7 @@ interface InlineConfig {
     /**
      * Pattern of file paths to be ignore from triggering watch rerun
      *
-     * @default ['**\/node_modules\/**', '**\/dist/**']
+     * @default [/\/node_modules\//, /\/dist\//]
      */
     watchIgnore?: (string | RegExp)[];
     /**
@@ -1154,10 +1220,26 @@ interface InlineConfig {
      * Resolve custom snapshot path
      */
     resolveSnapshotPath?: (path: string, extension: string) => string;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
+    /**
+     * Allow tests and suites that are marked as only
+     */
+    allowOnly?: boolean;
     /**
      * Show heap usage after each test. Usefull for debugging memory leaks.
      */
     logHeapUsage?: boolean;
+    /**
+     * Custom environment variables assigned to `process.env` before running tests.
+     */
+    env?: Record<string, string>;
+    /**
+     * Options for @sinon/fake-timers
+     */
+    fakeTimers?: FakeTimerInstallOpts;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -1174,14 +1256,6 @@ interface UserConfig extends InlineConfig {
      * Use happy-dom
      */
     dom?: boolean;
-    /**
-     * Pass with no tests
-     */
-    passWithNoTests?: boolean;
-    /**
-     * Allow tests and suites that are marked as only
-     */
-    allowOnly?: boolean;
     /**
      * Run tests that cover a list of source files
      */
@@ -1380,7 +1454,7 @@ declare class VitestUtils {
     private _mockedDate;
     private _mocker;
     constructor();
-    useFakeTimers(): this;
+    useFakeTimers(config?: FakeTimerInstallOpts): this;
     useRealTimers(): this;
     runOnlyPendingTimers(): this;
     runAllTimers(): this;

package/dist/index.js

@@ -1,4 +1,4 @@
-export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.8a313ffb.js';
+export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.221b8dcb.js';
 export { assert, default as chai, should } from 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
 import './chunk-runtime-rpc.63398738.js';

package/dist/node.d.ts

@@ -211,6 +211,72 @@ declare type OldPlugin = {
 declare type Plugin = NewPlugin | OldPlugin;
 declare type Plugins = Array<Plugin>;
 
+// Type definitions for @sinonjs/fake-timers 8.1
+// Project: https://github.com/sinonjs/fake-timers
+// Definitions by: Wim Looman <https://github.com/Nemo157>
+//                 Rogier Schouten <https://github.com/rogierschouten>
+//                 Yishai Zehavi <https://github.com/zyishai>
+//                 Remco Haszing <https://github.com/remcohaszing>
+//                 Jaden Simon <https://github.com/JadenSimon>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/**
+ * Names of clock methods that may be faked by install.
+ */
+type FakeMethod =
+    | 'setTimeout'
+    | 'clearTimeout'
+    | 'setImmediate'
+    | 'clearImmediate'
+    | 'setInterval'
+    | 'clearInterval'
+    | 'Date'
+    | 'nextTick'
+    | 'hrtime'
+    | 'requestAnimationFrame'
+    | 'cancelAnimationFrame'
+    | 'requestIdleCallback'
+    | 'cancelIdleCallback'
+    | 'performance'
+    | 'queueMicrotask';
+
+interface FakeTimerInstallOpts {
+    /**
+     * Installs fake timers with the specified unix epoch (default: 0)
+     */
+    now?: number | Date | undefined;
+
+    /**
+     * An array with names of global methods and APIs to fake. By default, `@sinonjs/fake-timers` does not replace `nextTick()` and `queueMicrotask()`.
+     * For instance, `FakeTimers.install({ toFake: ['setTimeout', 'nextTick'] })` will fake only `setTimeout()` and `nextTick()`
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll() (default: 1000)
+     */
+    loopLimit?: number | undefined;
+
+    /**
+     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
+     * 20ms for every 20ms change in the real system time) (default: false)
+     */
+    shouldAdvanceTime?: boolean | undefined;
+
+    /**
+     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
+     * in the real system time (default: 20)
+     */
+    advanceTimeDelta?: number | undefined;
+
+    /**
+     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by
+     * default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers. (default: false)
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+}
+
 declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
@@ -521,6 +587,7 @@ declare type TaskResultPack = [id: string, result: TaskResult | undefined];
 interface Suite extends TaskBase {
     type: 'suite';
     tasks: Task[];
+    filepath?: string;
 }
 interface File extends Suite {
     filepath: string;
@@ -536,8 +603,8 @@ interface Test<ExtraContext = {}> extends TaskBase {
 declare type Task = Test | Suite | File;
 declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return | void>;
 interface SuiteHooks {
-    beforeAll: HookListener<[Suite], () => Awaitable<void>>[];
-    afterAll: HookListener<[Suite]>[];
+    beforeAll: HookListener<[Suite | File], () => Awaitable<void>>[];
+    afterAll: HookListener<[Suite | File]>[];
     beforeEach: HookListener<[TestContext, Suite], () => Awaitable<void>>[];
     afterEach: HookListener<[TestContext, Suite]>[];
 }
@@ -770,7 +837,7 @@ interface InlineConfig {
     /**
      * Pattern of file paths to be ignore from triggering watch rerun
      *
-     * @default ['**\/node_modules\/**', '**\/dist/**']
+     * @default [/\/node_modules\//, /\/dist\//]
      */
     watchIgnore?: (string | RegExp)[];
     /**
@@ -855,10 +922,26 @@ interface InlineConfig {
      * Resolve custom snapshot path
      */
     resolveSnapshotPath?: (path: string, extension: string) => string;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
+    /**
+     * Allow tests and suites that are marked as only
+     */
+    allowOnly?: boolean;
     /**
      * Show heap usage after each test. Usefull for debugging memory leaks.
      */
     logHeapUsage?: boolean;
+    /**
+     * Custom environment variables assigned to `process.env` before running tests.
+     */
+    env?: Record<string, string>;
+    /**
+     * Options for @sinon/fake-timers
+     */
+    fakeTimers?: FakeTimerInstallOpts;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -875,14 +958,6 @@ interface UserConfig extends InlineConfig {
      * Use happy-dom
      */
     dom?: boolean;
-    /**
-     * Pass with no tests
-     */
-    passWithNoTests?: boolean;
-    /**
-     * Allow tests and suites that are marked as only
-     */
-    allowOnly?: boolean;
     /**
      * Run tests that cover a list of source files
      */
@@ -927,7 +1002,6 @@ declare class SnapshotManager {
 declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
 interface WorkerPool {
     runTests: RunWithFiles;
-    collectTests: RunWithFiles;
     close: () => Promise<void>;
 }
 

package/dist/node.js

@@ -1,5 +1,5 @@
-export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.d6642729.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.ee72d19a.js';
+export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.2c1fbe22.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.acd615bd.js';
 import 'buffer';
 import 'path';
 import 'child_process';
@@ -19,10 +19,10 @@ import 'local-pkg';
 import 'vite';
 import './chunk-constants.0567483c.js';
 import 'readline';
-import './chunk-vite-node-utils.20782527.js';
+import './chunk-vite-node-utils.1536f168.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.23b3ae8a.js';
+import './chunk-defaults.ecb46baf.js';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';

package/dist/{vendor-entry.1b0b46f1.js → vendor-entry.3adaf0b2.js}

@@ -1,13 +1,13 @@
 import { promises } from 'fs';
-import { a as getWorkerState, t as toArray, G as clone, E as getType, l as relative, A as stdout, H as partitionSuiteChildren, I as hasTests, q as hasFailed, o as getFullName, r as resetModules } from './chunk-utils-global.a5a8641f.js';
+import { a as getWorkerState, t as toArray, G as clone, E as getType, l as relative, H as partitionSuiteChildren, I as hasTests, q as hasFailed, o as getFullName, r as resetModules } from './chunk-utils-global.a5a8641f.js';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
-import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as expect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, R as RealDate, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, z as getFn, A as getState } from './chunk-runtime-chain.8a313ffb.js';
+import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as expect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, R as RealDate, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, z as getFn, A as getState } from './chunk-runtime-chain.221b8dcb.js';
 import chai, { assert, should, util } from 'chai';
 import { r as rpc } from './chunk-runtime-rpc.63398738.js';
 import { d as clearTimeout, c as setTimeout, s as stringify } from './chunk-utils-timers.f25e8f44.js';
-import { t as takeCoverage } from './chunk-defaults.23b3ae8a.js';
+import { t as takeCoverage } from './chunk-defaults.ecb46baf.js';
 import { createHash } from 'crypto';
 import { format } from 'util';
 
@@ -270,7 +270,9 @@ const allowRewrite = [
 ];
 const skipKeys = [
   "window",
-  "self"
+  "self",
+  "top",
+  "parent"
 ];
 function getWindowKeys(global, win) {
   const keys = new Set(KEYS.concat(Object.getOwnPropertyNames(win)).filter((k) => {
@@ -282,14 +284,18 @@ function getWindowKeys(global, win) {
   }));
   return keys;
 }
-function populateGlobal(global, win) {
+function populateGlobal(global, win, options = {}) {
+  const { bindFunctions = false } = options;
   const keys = getWindowKeys(global, win);
   const overrideObject = /* @__PURE__ */ new Map();
   for (const key of keys) {
+    const shouldBind = bindFunctions && typeof win[key] === "function";
     Object.defineProperty(global, key, {
       get() {
         if (overrideObject.has(key))
           return overrideObject.get(key);
+        if (shouldBind)
+          return win[key].bind(win);
         return win[key];
       },
       set(v) {
@@ -298,50 +304,50 @@ function populateGlobal(global, win) {
       configurable: true
     });
   }
-  const globalKeys = /* @__PURE__ */ new Set(["window", "self", "GLOBAL", "global"]);
+  const globalKeys = /* @__PURE__ */ new Set(["window", "self", "top", "parent"]);
+  const globalProxy = new Proxy(win.window, {
+    get(target, p, receiver) {
+      if (overrideObject.has(p))
+        return overrideObject.get(p);
+      return Reflect.get(target, p, receiver);
+    },
+    set(target, p, value, receiver) {
+      try {
+        Object.defineProperty(global, p, {
+          get: () => overrideObject.get(p),
+          set: (value2) => overrideObject.set(p, value2),
+          configurable: true
+        });
+        overrideObject.set(p, value);
+        Reflect.set(target, p, value, receiver);
+      } catch {
+      }
+      return true;
+    },
+    deleteProperty(target, p) {
+      Reflect.deleteProperty(global, p);
+      overrideObject.delete(p);
+      return Reflect.deleteProperty(target, p);
+    },
+    defineProperty(target, p, attributes) {
+      if (attributes.writable && "value" in attributes) ; else if (attributes.get) {
+        overrideObject.delete(p);
+        Reflect.defineProperty(global, p, attributes);
+      }
+      return Reflect.defineProperty(target, p, attributes);
+    }
+  });
   globalKeys.forEach((key) => {
     if (!win[key])
       return;
-    const proxy = new Proxy(win[key], {
-      get(target, p, receiver) {
-        if (overrideObject.has(p))
-          return overrideObject.get(p);
-        return Reflect.get(target, p, receiver);
-      },
-      set(target, p, value, receiver) {
-        try {
-          Object.defineProperty(global, p, {
-            get: () => overrideObject.get(p),
-            set: (value2) => overrideObject.set(p, value2),
-            configurable: true
-          });
-          overrideObject.set(p, value);
-          Reflect.set(target, p, value, receiver);
-        } catch {
-        }
-        return true;
-      },
-      deleteProperty(target, p) {
-        Reflect.deleteProperty(global, p);
-        overrideObject.delete(p);
-        return Reflect.deleteProperty(target, p);
-      },
-      defineProperty(target, p, attributes) {
-        if (attributes.writable && "value" in attributes) ; else if (attributes.get) {
-          overrideObject.delete(p);
-          Reflect.defineProperty(global, p, attributes);
-        }
-        return Reflect.defineProperty(target, p, attributes);
-      }
-    });
     Object.defineProperty(global, key, {
       get() {
-        return proxy;
+        return globalProxy;
       },
       configurable: true
     });
   });
-  global.globalThis = new Proxy(global.globalThis, {
+  const globalThisProxy = new Proxy(global.globalThis, {
     set(target, key, value, receiver) {
       overrideObject.set(key, value);
       return Reflect.set(target, key, value, receiver);
@@ -360,6 +366,9 @@ function populateGlobal(global, win) {
       return Reflect.defineProperty(target, p, attributes);
     }
   });
+  global.globalThis = globalThisProxy;
+  if (global.global)
+    global.global = globalThisProxy;
   skipKeys.forEach((k) => keys.add(k));
   return {
     keys,
@@ -455,7 +464,7 @@ var happy = {
   async setup(global) {
     const { Window, GlobalWindow } = await importModule("happy-dom");
     const win = new (GlobalWindow || Window)();
-    const { keys, allowRewrite } = populateGlobal(global, win);
+    const { keys, allowRewrite } = populateGlobal(global, win, { bindFunctions: true });
     const originals = new Map(allowRewrite.map(([key]) => [key, global[key]]));
     return {
       teardown(global2) {
@@ -486,7 +495,7 @@ async function setupGlobalEnv(config) {
   globalSetup = true;
   setupConsoleLogSpy();
   if (config.globals)
-    (await import('./chunk-integrations-globals.1ce15dfd.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.60fc66ef.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -513,33 +522,39 @@ function setupConsoleLogSpy() {
   }
   function sendStdout(taskId) {
     const buffer = stdoutBuffer.get(taskId);
-    if (buffer) {
-      const timer = timers.get(taskId);
-      rpc().onUserConsoleLog({
-        type: "stdout",
-        content: buffer.map((i) => String(i)).join(""),
-        taskId,
-        time: timer.stdoutTime || RealDate.now(),
-        size: buffer.length
-      });
-      stdoutBuffer.set(taskId, []);
-      timer.stdoutTime = 0;
-    }
+    if (!buffer)
+      return;
+    const content = buffer.map((i) => String(i)).join("");
+    if (!content.trim())
+      return;
+    const timer = timers.get(taskId);
+    rpc().onUserConsoleLog({
+      type: "stdout",
+      content,
+      taskId,
+      time: timer.stdoutTime || RealDate.now(),
+      size: buffer.length
+    });
+    stdoutBuffer.set(taskId, []);
+    timer.stdoutTime = 0;
   }
   function sendStderr(taskId) {
     const buffer = stderrBuffer.get(taskId);
-    if (buffer) {
-      const timer = timers.get(taskId);
-      rpc().onUserConsoleLog({
-        type: "stderr",
-        content: buffer.map((i) => String(i)).join(""),
-        taskId,
-        time: timer.stderrTime || RealDate.now(),
-        size: buffer.length
-      });
-      stderrBuffer.set(taskId, []);
-      timer.stderrTime = 0;
-    }
+    if (!buffer)
+      return;
+    const content = buffer.map((i) => String(i)).join("");
+    if (!content.trim())
+      return;
+    const timer = timers.get(taskId);
+    rpc().onUserConsoleLog({
+      type: "stderr",
+      content,
+      taskId,
+      time: timer.stderrTime || RealDate.now(),
+      size: buffer.length
+    });
+    stderrBuffer.set(taskId, []);
+    timer.stderrTime = 0;
   }
   const stdout = new Writable({
     write(data, encoding, callback) {
@@ -643,6 +658,9 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     return clone2;
   }
 }
+function normalizeErrorMessage(message) {
+  return message.replace(/__vite_ssr_import_\d+__\./g, "");
+}
 function processError(err) {
   if (!err)
     return err;
@@ -659,6 +677,10 @@ function processError(err) {
     err.expected = stringify(err.expected);
   if (typeof err.actual !== "string")
     err.actual = stringify(err.actual);
+  if (typeof err.message === "string")
+    err.message = normalizeErrorMessage(err.message);
+  if (typeof err.cause === "object" && err.cause.message === "string")
+    err.cause.message = normalizeErrorMessage(err.cause.message);
   try {
     return serializeError(err);
   } catch (e) {
@@ -739,7 +761,6 @@ async function collectTests(paths, config) {
         state: "fail",
         error: processError(e)
       };
-      stdout().write("\0");
     }
     calculateHash(file);
     const hasOnlyTasks = someTasksAreOnly(file);
@@ -1037,21 +1058,39 @@ function clearModuleMocks() {
 }
 
 async function run(files, config) {
-  var _a;
   await setupGlobalEnv(config);
   const workerState = getWorkerState();
-  for (const file of files) {
-    workerState.mockMap.clear();
-    resetModules();
+  const envs = ["node", "jsdom", "happy-dom"];
+  const filesWithEnv = await Promise.all(files.map(async (file) => {
+    var _a;
     const code = await promises.readFile(file, "utf-8");
     const env = ((_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1]) || config.environment || "node";
-    if (!["node", "jsdom", "happy-dom"].includes(env))
-      throw new Error(`Unsupported environment: ${env}`);
-    workerState.filepath = file;
-    await withEnv(env, config.environmentOptions || {}, async () => {
-      await startTests([file], config);
+    if (!envs.includes(env))
+      throw new Error(`Unsupported environment: "${env}" in ${file}`);
+    return {
+      file,
+      env
+    };
+  }));
+  const filesByEnv = filesWithEnv.reduce((acc, { file, env }) => {
+    acc[env] || (acc[env] = []);
+    acc[env].push(file);
+    return acc;
+  }, {});
+  for (const env of envs) {
+    const environment = env;
+    const files2 = filesByEnv[environment];
+    if (!files2 || !files2.length)
+      continue;
+    await withEnv(environment, config.environmentOptions || {}, async () => {
+      for (const file of files2) {
+        workerState.mockMap.clear();
+        resetModules();
+        workerState.filepath = file;
+        await startTests([file], config);
+        workerState.filepath = void 0;
+      }
     });
-    workerState.filepath = void 0;
   }
 }
 

package/dist/worker.js

@@ -1,7 +1,7 @@
-import { h as resolve, a as getWorkerState, A as stdout } from './chunk-utils-global.a5a8641f.js';
-import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.20782527.js';
+import { h as resolve, a as getWorkerState } from './chunk-utils-global.a5a8641f.js';
+import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.1536f168.js';
 import { d as distDir } from './chunk-constants.0567483c.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.ee72d19a.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.acd615bd.js';
 import { r as rpc } from './chunk-runtime-rpc.63398738.js';
 import 'tty';
 import 'local-pkg';
@@ -54,7 +54,6 @@ async function startViteNode(ctx) {
 function init(ctx) {
   if (typeof __vitest_worker__ !== "undefined" && ctx.config.threads && ctx.config.isolate)
     throw new Error(`worker for ${ctx.files.join(",")} already initialized by ${getWorkerState().ctx.files.join(",")}. This is probably an internal bug of Vitest.`);
-  stdout().write("\0");
   const { config, port, id } = ctx;
   process.env.VITEST_WORKER_ID = String(id);
   globalThis.__vitest_worker__ = {