vitest 1.5.3 → 2.0.0-beta.1

package/dist/vendor/{index.QVcwRDVW.js → index.CmILuxzC.js}

@@ -1,8 +1,8 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-import { b as bench } from './benchmark.yGkUTKnC.js';
-import { i as isFirstRun, a as runOnce } from './run-once.Olz_Zkd8.js';
-import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.Y_w82WR8.js';
-import { g as getWorkerState } from './global.CkGT_TMy.js';
+import { b as bench } from './benchmark.BNLebNi5.js';
+import { i as isFirstRun, a as runOnce } from './run-once.DLomgGUH.js';
+import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.ClD3hi7L.js';
+import { g as getWorkerState } from './global.7bFbnyXl.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
@@ -61,7 +61,7 @@ var dist = {};
 	        'branded',
 	    ];
 	    const obj = {
-	        /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
+	        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 	        toBeAny: fn,
 	        toBeUnknown: fn,
 	        toBeNever: fn,
@@ -80,9 +80,11 @@ var dist = {};
 	        toEqualTypeOf: fn,
 	        toBeCallableWith: fn,
 	        toBeConstructibleWith: fn,
-	        /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
+	        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
 	        extract: exports.expectTypeOf,
 	        exclude: exports.expectTypeOf,
+	        pick: exports.expectTypeOf,
+	        omit: exports.expectTypeOf,
 	        toHaveProperty: exports.expectTypeOf,
 	        parameter: exports.expectTypeOf,
 	    };

package/dist/vendor/{index.xL8XjTLv.js → index.DP-km6lF.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './_commonjsHelpers.jjO7Zipk.js';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'util';
 import p from 'path';
 

package/dist/vendor/{index.SMVOaj7F.js → index._7XLd8Kd.js}

@@ -1,8 +1,8 @@
 import { relative } from 'pathe';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import { g as getWorkerState } from './global.CkGT_TMy.js';
-import './env.AtSIuHFg.js';
+import { g as getWorkerState } from './global.7bFbnyXl.js';
+import './env.bmJgw1qP.js';
 
 function getRunMode() {
   return getWorkerState().config.mode;

package/dist/vendor/{rpc.joBhAkyK.js → rpc.DRDE9Pu1.js}

@@ -1,6 +1,6 @@
 import { getSafeTimers } from '@vitest/utils';
-import { c as createBirpc } from './index.8bPxjt7g.js';
-import { g as getWorkerState } from './global.CkGT_TMy.js';
+import { c as createBirpc } from './index.BpSiYbpB.js';
+import { g as getWorkerState } from './global.7bFbnyXl.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {

package/dist/vendor/{run-once.Olz_Zkd8.js → run-once.DLomgGUH.js}

@@ -1,4 +1,4 @@
-import { g as getWorkerState } from './global.CkGT_TMy.js';
+import { g as getWorkerState } from './global.7bFbnyXl.js';
 
 const filesCount = /* @__PURE__ */ new Map();
 const cache = /* @__PURE__ */ new Map();

package/dist/vendor/{setup-common.5nUd4r76.js → setup-common.XeoZAW8t.js}

@@ -1,6 +1,6 @@
 import { setSafeTimers } from '@vitest/utils';
 import { addSerializer } from '@vitest/snapshot';
-import { r as resetRunOnceCounter } from './run-once.Olz_Zkd8.js';
+import { r as resetRunOnceCounter } from './run-once.DLomgGUH.js';
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
@@ -12,7 +12,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals)
-    (await import('../chunks/integrations-globals.Hr6znn-f.js')).registerApiGlobally();
+    (await import('../chunks/integrations-globals.B5Jl0grA.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)

package/dist/vendor/{tasks.IknbGB2n.js → tasks.WC7M-K-v.js}

@@ -10,5 +10,8 @@ function hasFailedSnapshot(suite) {
 function getFullName(task, separator = " > ") {
   return getNames(task).join(separator);
 }
+function getTestName(task, separator = " > ") {
+  return getNames(task).slice(1).join(separator);
+}
 
-export { getFullName as g, hasFailedSnapshot as h };
+export { getFullName as a, getTestName as g, hasFailedSnapshot as h };

package/dist/vendor/{utils.VYmeMh-u.js → utils.D5gGkwyH.js}

@@ -1,6 +1,6 @@
 import { isAbsolute, relative, dirname, basename } from 'pathe';
 import c from 'picocolors';
-import { a as slash } from './base.Xt0Omgh7.js';
+import { a as slash } from './base._gnK9Slw.js';
 
 const F_RIGHT = "\u2192";
 const F_DOWN = "\u2193";

package/dist/vendor/{vi.Y_w82WR8.js → vi.ClD3hi7L.js}

@@ -1,16 +1,16 @@
 import * as chai$1 from 'chai';
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.jjO7Zipk.js';
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT as GLOBAL_EXPECT$1, ASYMMETRIC_MATCHERS_OBJECT as ASYMMETRIC_MATCHERS_OBJECT$1, getState, setState, addCustomEqualityTesters } from '@vitest/expect';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import { getNames } from '@vitest/runner/utils';
 import '@vitest/utils/error';
 import { getCurrentTest } from '@vitest/runner';
-import { g as getFullName } from './tasks.IknbGB2n.js';
-import { g as getWorkerState, a as getCurrentEnvironment } from './global.CkGT_TMy.js';
+import { g as getTestName } from './tasks.WC7M-K-v.js';
+import { g as getWorkerState, a as getCurrentEnvironment } from './global.7bFbnyXl.js';
 import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { i as isChildProcess } from './base.Xt0Omgh7.js';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.Ns1pGd_X.js';
+import { i as isChildProcess } from './base._gnK9Slw.js';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.BKM1wewY.js';
 import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';
 
 function resetModules(modules, resetMocks = false) {
@@ -208,11 +208,10 @@ function getError(expected, promise) {
 }
 const SnapshotPlugin = (chai, utils) => {
   const getTestNames = (test) => {
-    var _a;
     if (!test)
       return {};
     return {
-      filepath: (_a = test.file) == null ? void 0 : _a.filepath,
+      filepath: test.file.filepath,
       name: getNames(test).slice(1).join(" > ")
     };
   };
@@ -361,7 +360,6 @@ chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
 function createExpect(test) {
-  var _a;
   const expect = (value, message) => {
     const { assertionCalls } = getState(expect);
     setState({ assertionCalls: assertionCalls + 1, soft: false }, expect);
@@ -377,6 +375,7 @@ function createExpect(test) {
   expect.getState = () => getState(expect);
   expect.setState = (state) => setState(state, expect);
   const globalState = getState(globalThis[GLOBAL_EXPECT$1]) || {};
+  const testPath = getTestFile(test);
   setState({
     // this should also add "snapshotState" that is added conditionally
     ...globalState,
@@ -386,8 +385,8 @@ function createExpect(test) {
     expectedAssertionsNumber: null,
     expectedAssertionsNumberErrorGen: null,
     environment: getCurrentEnvironment(),
-    testPath: test ? (_a = test.suite.file) == null ? void 0 : _a.filepath : globalState.testPath,
-    currentTestName: test ? getFullName(test) : globalState.currentTestName
+    testPath,
+    currentTestName: test ? getTestName(test) : globalState.currentTestName
   }, expect);
   expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
   expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
@@ -423,6 +422,12 @@ function createExpect(test) {
   chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
   return expect;
 }
+function getTestFile(test) {
+  if (test)
+    return test.file.filepath;
+  const state = getWorkerState();
+  return state.filepath;
+}
 const globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT$1, {
   value: globalExpect,
@@ -3434,6 +3439,8 @@ function createVitest() {
       return factory();
     },
     mock(path, factory) {
+      if (typeof path !== "string")
+        throw new Error(`vi.mock() expects a string path, but received a ${typeof path}`);
       const importer = getImporter();
       _mocker.queueMock(
         path,
@@ -3443,9 +3450,13 @@ function createVitest() {
       );
     },
     unmock(path) {
+      if (typeof path !== "string")
+        throw new Error(`vi.unmock() expects a string path, but received a ${typeof path}`);
       _mocker.queueUnmock(path, getImporter());
     },
     doMock(path, factory) {
+      if (typeof path !== "string")
+        throw new Error(`vi.doMock() expects a string path, but received a ${typeof path}`);
       const importer = getImporter();
       _mocker.queueMock(
         path,
@@ -3455,6 +3466,8 @@ function createVitest() {
       );
     },
     doUnmock(path) {
+      if (typeof path !== "string")
+        throw new Error(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
       _mocker.queueUnmock(path, getImporter());
     },
     async importActual(path) {

package/dist/vendor/{vm.i4FO5N37.js → vm.Bi3bljci.js}

@@ -1,18 +1,18 @@
 import vm, { isContext } from 'node:vm';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
-import { createCustomConsole } from '../chunks/runtime-console.EO5ha7qv.js';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.2_yoIC01.js';
+import { createCustomConsole } from '../chunks/runtime-console.CUES-L8X.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.CLLNVNnK.js';
 import { distDir } from '../path.js';
 import { dirname as dirname$1 } from 'node:path';
-import { statSync, existsSync, readFileSync } from 'node:fs';
+import { statSync, existsSync, promises, readFileSync } from 'node:fs';
 import { isNodeBuiltin, isPrimitive, toArray, getCachedData, setCacheData } from 'vite-node/utils';
 import { createRequire, Module } from 'node:module';
 import { CSS_LANGS_RE, KNOWN_ASSET_RE } from 'vite-node/constants';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import { p as provideWorkerState } from './global.CkGT_TMy.js';
-import './env.AtSIuHFg.js';
+import { p as provideWorkerState } from './global.7bFbnyXl.js';
+import './env.bmJgw1qP.js';
 
 const _require = createRequire(import.meta.url);
 const requiresCache = /* @__PURE__ */ new WeakMap();
@@ -244,15 +244,26 @@ function interopCommonJsModule(interopDefault, mod) {
 const SyntheticModule$1 = vm.SyntheticModule;
 const SourceTextModule = vm.SourceTextModule;
 
+var __defProp$1 = Object.defineProperty;
+var __typeError$1 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
+var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _httpIp;
 const dataURIRegex = /^data:(?<mime>text\/javascript|application\/json|application\/wasm)(?:;(?<encoding>charset=utf-8|base64))?,(?<code>.*)$/;
 class EsmExecutor {
   constructor(executor, options) {
     this.executor = executor;
+    __publicField$1(this, "moduleCache", /* @__PURE__ */ new Map());
+    __publicField$1(this, "esmLinkMap", /* @__PURE__ */ new WeakMap());
+    __publicField$1(this, "context");
+    __privateAdd$1(this, _httpIp, IPnumber("127.0.0.0"));
     this.context = options.context;
   }
-  moduleCache = /* @__PURE__ */ new Map();
-  esmLinkMap = /* @__PURE__ */ new WeakMap();
-  context;
   async evaluateModule(m) {
     if (m.status === "unlinked") {
       this.esmLinkMap.set(
@@ -265,11 +276,17 @@ class EsmExecutor {
       await m.evaluate();
     return m;
   }
-  async createEsModule(fileUrl, code) {
-    const cached = this.moduleCache.get(fileUrl);
+  async createEsModule(fileURL, getCode) {
+    const cached = this.moduleCache.get(fileURL);
     if (cached)
       return cached;
-    if (fileUrl.endsWith(".json")) {
+    const promise = this.loadEsModule(fileURL, getCode);
+    this.moduleCache.set(fileURL, promise);
+    return promise;
+  }
+  async loadEsModule(fileURL, getCode) {
+    const code = await getCode();
+    if (fileURL.endsWith(".json")) {
       const m2 = new SyntheticModule$1(
         ["default"],
         () => {
@@ -277,13 +294,13 @@ class EsmExecutor {
           m2.setExport("default", result);
         }
       );
-      this.moduleCache.set(fileUrl, m2);
+      this.moduleCache.set(fileURL, m2);
       return m2;
     }
     const m = new SourceTextModule(
       code,
       {
-        identifier: fileUrl,
+        identifier: fileURL,
         context: this.context,
         importModuleDynamically: this.executor.importModuleDynamically,
         initializeImportMeta: (meta, mod) => {
@@ -299,17 +316,29 @@ class EsmExecutor {
         }
       }
     );
-    this.moduleCache.set(fileUrl, m);
+    this.moduleCache.set(fileURL, m);
     return m;
   }
-  async createWebAssemblyModule(fileUrl, code) {
+  async createWebAssemblyModule(fileUrl, getCode) {
     const cached = this.moduleCache.get(fileUrl);
     if (cached)
       return cached;
-    const m = this.loadWebAssemblyModule(code, fileUrl);
+    const m = this.loadWebAssemblyModule(getCode(), fileUrl);
     this.moduleCache.set(fileUrl, m);
     return m;
   }
+  async createNetworkModule(fileUrl) {
+    if (fileUrl.startsWith("http:")) {
+      const url = new URL(fileUrl);
+      if (url.hostname !== "localhost" && url.hostname !== "::1" && (IPnumber(url.hostname) & IPmask(8)) !== __privateGet$1(this, _httpIp)) {
+        throw new Error(
+          // we don't know the importer, so it's undefined (the same happens in --pool=threads)
+          `import of '${fileUrl}' by undefined is not supported: http can only be used to load local resources (use https instead).`
+        );
+      }
+    }
+    return this.createEsModule(fileUrl, () => fetch(fileUrl).then((r) => r.text()));
+  }
   async loadWebAssemblyModule(source, identifier) {
     const cached = this.moduleCache.get(identifier);
     if (cached)
@@ -393,9 +422,19 @@ class EsmExecutor {
       this.moduleCache.set(identifier, module);
       return module;
     }
-    return this.createEsModule(identifier, code);
+    return this.createEsModule(identifier, () => code);
   }
 }
+_httpIp = new WeakMap();
+function IPnumber(address) {
+  const ip = address.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (ip)
+    return (+ip[1] << 24) + (+ip[2] << 16) + (+ip[3] << 8) + +ip[4];
+  throw new Error(`Expected IP address, received ${address}`);
+}
+function IPmask(maskSize) {
+  return -1 << 32 - maskSize;
+}
 
 const CLIENT_ID = "/@vite/client";
 const CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
@@ -433,10 +472,12 @@ class ViteExecutor {
     const cached = this.esm.resolveCachedModule(fileUrl);
     if (cached)
       return cached;
-    const result = await this.options.transform(fileUrl, "web");
-    if (!result.code)
-      throw new Error(`[vitest] Failed to transform ${fileUrl}. Does the file exist?`);
-    return this.esm.createEsModule(fileUrl, result.code);
+    return this.esm.createEsModule(fileUrl, async () => {
+      const result = await this.options.transform(fileUrl, "web");
+      if (!result.code)
+        throw new Error(`[vitest] Failed to transform ${fileUrl}. Does the file exist?`);
+      return result.code;
+    });
   }
   createViteClientModule() {
     const identifier = CLIENT_ID;
@@ -476,11 +517,40 @@ class ViteExecutor {
   };
 }
 
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _networkSupported;
 const SyntheticModule = vm.SyntheticModule;
 const nativeResolve = import.meta.resolve;
 class ExternalModulesExecutor {
   constructor(options) {
     this.options = options;
+    __publicField(this, "cjs");
+    __publicField(this, "esm");
+    __publicField(this, "vite");
+    __publicField(this, "context");
+    __publicField(this, "fs");
+    __publicField(this, "resolvers", []);
+    __privateAdd(this, _networkSupported, null);
+    // dynamic import can be used in both ESM and CJS, so we have it in the executor
+    __publicField(this, "importModuleDynamically", async (specifier, referencer) => {
+      const module = await this.resolveModule(specifier, referencer.identifier);
+      return await this.esm.evaluateModule(module);
+    });
+    __publicField(this, "resolveModule", async (specifier, referencer) => {
+      let identifier = this.resolve(specifier, referencer);
+      if (identifier instanceof Promise)
+        identifier = await identifier;
+      return await this.createModule(identifier);
+    });
     this.context = options.context;
     this.fs = options.fileMap;
     this.esm = new EsmExecutor(this, {
@@ -499,23 +569,17 @@ class ExternalModulesExecutor {
     });
     this.resolvers = [this.vite.resolve];
   }
-  cjs;
-  esm;
-  vite;
-  context;
-  fs;
-  resolvers = [];
-  // dynamic import can be used in both ESM and CJS, so we have it in the executor
-  importModuleDynamically = async (specifier, referencer) => {
-    const module = await this.resolveModule(specifier, referencer.identifier);
-    return this.esm.evaluateModule(module);
-  };
-  resolveModule = async (specifier, referencer) => {
-    let identifier = this.resolve(specifier, referencer);
-    if (identifier instanceof Promise)
-      identifier = await identifier;
-    return await this.createModule(identifier);
-  };
+  async import(identifier) {
+    const module = await this.createModule(identifier);
+    await this.esm.evaluateModule(module);
+    return module.namespace;
+  }
+  require(identifier) {
+    return this.cjs.require(identifier);
+  }
+  createRequire(identifier) {
+    return this.cjs.createRequire(identifier);
+  }
   resolve(specifier, parent) {
     for (const resolver of this.resolvers) {
       const id = resolver(specifier, parent);
@@ -587,6 +651,8 @@ class ExternalModulesExecutor {
     const extension = extname(identifier);
     if (extension === ".node" || isNodeBuiltin(identifier))
       return { type: "builtin", url: identifier, path: identifier };
+    if (this.isNetworkSupported && (identifier.startsWith("http:") || identifier.startsWith("https:")))
+      return { type: "network", url: identifier, path: identifier };
     const isFileUrl = identifier.startsWith("file://");
     const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
     const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
@@ -614,7 +680,7 @@ class ExternalModulesExecutor {
     }
     switch (type) {
       case "data":
-        return this.esm.createDataModule(identifier);
+        return await this.esm.createDataModule(identifier);
       case "builtin": {
         const exports = this.require(identifier);
         return this.wrapCoreSynteticModule(identifier, exports);
@@ -622,38 +688,50 @@ class ExternalModulesExecutor {
       case "vite":
         return await this.vite.createViteModule(url);
       case "wasm":
-        return await this.esm.createWebAssemblyModule(url, this.fs.readBuffer(path));
+        return await this.esm.createWebAssemblyModule(url, () => this.fs.readBuffer(path));
       case "module":
-        return await this.esm.createEsModule(url, this.fs.readFile(path));
+        return await this.esm.createEsModule(url, () => this.fs.readFileAsync(path));
       case "commonjs": {
         const exports = this.require(path);
         return this.wrapCommonJsSynteticModule(identifier, exports);
       }
+      case "network":
+        return await this.esm.createNetworkModule(url);
       default: {
         const _deadend = type;
         return _deadend;
       }
     }
   }
-  async import(identifier) {
-    const module = await this.createModule(identifier);
-    await this.esm.evaluateModule(module);
-    return module.namespace;
-  }
-  require(identifier) {
-    return this.cjs.require(identifier);
-  }
-  createRequire(identifier) {
-    return this.cjs.createRequire(identifier);
+  get isNetworkSupported() {
+    var _a;
+    if (__privateGet(this, _networkSupported) == null) {
+      if (process.execArgv.includes("--experimental-network-imports"))
+        __privateSet(this, _networkSupported, true);
+      else if ((_a = process.env.NODE_OPTIONS) == null ? void 0 : _a.includes("--experimental-network-imports"))
+        __privateSet(this, _networkSupported, true);
+      else
+        __privateSet(this, _networkSupported, false);
+    }
+    return __privateGet(this, _networkSupported);
   }
 }
+_networkSupported = new WeakMap();
 
 class FileMap {
   fsCache = /* @__PURE__ */ new Map();
   fsBufferCache = /* @__PURE__ */ new Map();
+  async readFileAsync(path) {
+    const cached = this.fsCache.get(path);
+    if (cached != null)
+      return cached;
+    const source = await promises.readFile(path, "utf-8");
+    this.fsCache.set(path, source);
+    return source;
+  }
   readFile(path) {
     const cached = this.fsCache.get(path);
-    if (cached)
+    if (cached != null)
       return cached;
     const source = readFileSync(path, "utf-8");
     this.fsCache.set(path, source);
@@ -661,7 +739,7 @@ class FileMap {
   }
   readBuffer(path) {
     const cached = this.fsBufferCache.get(path);
-    if (cached)
+    if (cached != null)
       return cached;
     const buffer = readFileSync(path);
     this.fsBufferCache.set(path, buffer);
@@ -693,7 +771,7 @@ async function runVmTests(state) {
   provideWorkerState(context, state);
   context.process = process;
   context.global = context;
-  context.console = state.config.disableConsoleIntercept ? console : createCustomConsole();
+  context.console = state.config.disableConsoleIntercept ? console : createCustomConsole(state);
   context.setImmediate = setImmediate;
   context.clearImmediate = clearImmediate;
   const stubs = getDefaultRequestStubs(context);

package/dist/worker.js

@@ -1,16 +1,17 @@
 import { pathToFileURL } from 'node:url';
 import { workerId } from 'tinypool';
 import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
+import { readFileSync } from 'node:fs';
 import { resolve, normalize } from 'pathe';
-import { e as environments } from './vendor/index.GVFv9dZ0.js';
-import { i as isChildProcess, s as setProcessTitle } from './vendor/base.Xt0Omgh7.js';
-import { s as setupInspect } from './vendor/inspector.IgLX3ur5.js';
-import { c as createRuntimeRpc, a as rpcDone } from './vendor/rpc.joBhAkyK.js';
+import { e as environments } from './vendor/index.DeR1hhfY.js';
+import { i as isChildProcess, s as setProcessTitle } from './vendor/base._gnK9Slw.js';
+import { s as setupInspect } from './vendor/inspector.hPQncR7V.js';
+import { c as createRuntimeRpc, a as rpcDone } from './vendor/rpc.DRDE9Pu1.js';
 import 'node:console';
 import '@vitest/utils';
 import 'node:module';
-import './vendor/index.8bPxjt7g.js';
-import './vendor/global.CkGT_TMy.js';
+import './vendor/index.BpSiYbpB.js';
+import './vendor/global.7bFbnyXl.js';
 
 function isBuiltinEnvironment(env) {
   return env in environments;
@@ -31,7 +32,12 @@ async function loadEnvironment(ctx, rpc) {
     return environments[name];
   const loader = await createEnvironmentLoader({
     root: ctx.config.root,
-    fetchModule: (id) => rpc.fetch(id, "ssr"),
+    fetchModule: async (id) => {
+      const result = await rpc.fetch(id, "ssr");
+      if (result.id)
+        return { code: readFileSync(result.id, "utf-8") };
+      return result;
+    },
     resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
   });
   const root = loader.root;

package/dist/workers/forks.js

@@ -1,18 +1,18 @@
 import v8 from 'node:v8';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../vendor/utils.0uYuCbzo.js';
-import { r as runBaseTests } from '../vendor/base.oIzAvGLe.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../vendor/utils.CUjzkRH7.js';
+import { r as runBaseTests } from '../vendor/base.VFkIJ66g.js';
 import '@vitest/utils';
 import 'vite-node/client';
-import '../vendor/global.CkGT_TMy.js';
-import '../vendor/execute.2_yoIC01.js';
+import '../vendor/global.7bFbnyXl.js';
+import '../vendor/execute.CLLNVNnK.js';
 import 'node:vm';
 import 'node:url';
+import 'node:fs';
 import 'vite-node/utils';
 import 'pathe';
 import '@vitest/utils/error';
 import '../path.js';
-import 'node:fs';
-import '../vendor/base.Xt0Omgh7.js';
+import '../vendor/base._gnK9Slw.js';
 
 class ForksBaseWorker {
   getRpcOptions() {