vitest 1.6.0 → 2.0.0-beta.10

package/dist/vendor/{index.dI9lHwVn.js → index.D3hs2WiI.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.YFlodzP_.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.hATFzZbX.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.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/{index.GVFv9dZ0.js → index.kpsSqFiz.js}

@@ -486,8 +486,9 @@ var jsdom = {
     ];
     for (const name of globalNames) {
       const value = globalThis[name];
-      if (typeof value !== "undefined" && typeof dom.window[name] === "undefined")
+      if (typeof value !== "undefined" && typeof dom.window[name] === "undefined") {
         dom.window[name] = value;
+      }
     }
     return {
       getVmContext() {

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.8nJLd4ay.js → setup-common.DAu7t7mY.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.kw4co3rx.js')).registerApiGlobally();
+    (await import('../chunks/integrations-globals.C6Ah-pUW.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)

package/dist/vendor/spy.Cf_4R5Oe.js

@@ -0,0 +1,22 @@
+import * as spy$1 from '@vitest/spy';
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
+var spy = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null
+}, [spy$1]);
+
+export { spy as s };

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.dEtNIEgr.js → utils.YuQ3LT2a.js}

@@ -1,6 +1,6 @@
 import { isAbsolute, relative, dirname, basename } from 'pathe';
 import c from 'picocolors';
-import { a as slash } from './base.5NT-gWu5.js';
+import { a as slash } from './base._gnK9Slw.js';
 
 const F_RIGHT = "\u2192";
 const F_DOWN = "\u2193";
@@ -214,4 +214,4 @@ var utils = /*#__PURE__*/Object.freeze({
 	spinnerMap: spinnerMap
 });
 
-export { F_RIGHT as F, getStateString as a, formatTimeString as b, countTestErrors as c, divider as d, getCols as e, formatProjectName as f, getStateSymbol as g, getHookStateSymbol as h, F_POINTER as i, pointer as p, renderSnapshotSummary as r, stripAnsi as s, utils as u };
+export { F_RIGHT as F, F_POINTER as a, getStateString as b, formatTimeString as c, countTestErrors as d, divider as e, formatProjectName as f, getStateSymbol as g, getCols as h, getHookStateSymbol as i, pointer as p, renderSnapshotSummary as r, stripAnsi as s, utils as u };

package/dist/vendor/{vi.YFlodzP_.js → vi.hATFzZbX.js}

@@ -1,16 +1,18 @@
 import * as chai$1 from 'chai';
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.jjO7Zipk.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 { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
+import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, 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 'pathe';
+import './env.bmJgw1qP.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { i as isChildProcess } from './base.5NT-gWu5.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) {
@@ -142,32 +144,6 @@ var chaiSubset = {exports: {}};
 var chaiSubsetExports = chaiSubset.exports;
 var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
 
-const MATCHERS_OBJECT = Symbol.for("matchers-object");
-const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
-const GLOBAL_EXPECT = Symbol.for("expect-global");
-const ASYMMETRIC_MATCHERS_OBJECT = Symbol.for("asymmetric-matchers-object");
-
-if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
-  const globalState = /* @__PURE__ */ new WeakMap();
-  const matchers = /* @__PURE__ */ Object.create(null);
-  const customEqualityTesters = [];
-  const assymetricMatchers = /* @__PURE__ */ Object.create(null);
-  Object.defineProperty(globalThis, MATCHERS_OBJECT, {
-    get: () => globalState
-  });
-  Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
-    configurable: true,
-    get: () => ({
-      state: globalState.get(globalThis[GLOBAL_EXPECT]),
-      matchers,
-      customEqualityTesters
-    })
-  });
-  Object.defineProperty(globalThis, ASYMMETRIC_MATCHERS_OBJECT, {
-    get: () => assymetricMatchers
-  });
-}
-
 function recordAsyncExpect(test, promise) {
   if (test && promise instanceof Promise) {
     promise = promise.finally(() => {
@@ -208,11 +184,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(" > ")
     };
   };
@@ -360,11 +335,85 @@ chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
+const unsupported = [
+  // .poll is meant to retry matchers until they succeed, and
+  // snapshots will always succeed as long as the poll method doesn't thow an error
+  // in this case using the `vi.waitFor` method is more appropriate
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  // toThrow will never succeed because we call the poll callback until it doesn't throw
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+  // these are not supported because you can call them without `.poll`,
+  // we throw an error inside the rejects/resolves methods to prevent this
+  // rejects,
+  // resolves
+];
+function createExpectPoll(expect) {
+  return function poll(fn, options = {}) {
+    var _a;
+    const state = getWorkerState();
+    const defaults = ((_a = state.config.expect) == null ? void 0 : _a.poll) ?? {};
+    const {
+      interval = defaults.interval ?? 50,
+      timeout = defaults.timeout ?? 1e3,
+      message
+    } = options;
+    const assertion = expect(null, message).withContext({ poll: true });
+    const proxy = new Proxy(assertion, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        if (typeof result !== "function")
+          return result instanceof chai$1.Assertion ? proxy : result;
+        if (key === "assert")
+          return result;
+        if (typeof key === "string" && unsupported.includes(key))
+          throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
+        return function(...args) {
+          const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+          return new Promise((resolve, reject) => {
+            let intervalId;
+            let lastError;
+            const { setTimeout, clearTimeout } = getSafeTimers();
+            const timeoutId = setTimeout(() => {
+              clearTimeout(intervalId);
+              reject(copyStackTrace$1(new Error(`Matcher did not succeed in ${timeout}ms`, { cause: lastError }), STACK_TRACE_ERROR));
+            }, timeout);
+            const check = async () => {
+              try {
+                chai$1.util.flag(this, "object", await fn());
+                resolve(await result.call(this, ...args));
+                clearTimeout(intervalId);
+                clearTimeout(timeoutId);
+              } catch (err) {
+                lastError = err;
+                intervalId = setTimeout(check, interval);
+              }
+            };
+            check();
+          });
+        };
+      }
+    });
+    return proxy;
+  };
+}
+function copyStackTrace$1(target, source) {
+  if (source.stack !== void 0)
+    target.stack = source.stack.replace(source.message, target.message);
+  return target;
+}
+
 function createExpect(test) {
-  var _a;
   const expect = (value, message) => {
     const { assertionCalls } = getState(expect);
-    setState({ assertionCalls: assertionCalls + 1, soft: false }, expect);
+    setState({ assertionCalls: assertionCalls + 1 }, expect);
     const assert2 = chai$1.expect(value, message);
     const _test = test || getCurrentTest();
     if (_test)
@@ -373,10 +422,11 @@ function createExpect(test) {
       return assert2;
   };
   Object.assign(expect, chai$1.expect);
-  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT$1]);
+  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
   expect.getState = () => getState(expect);
   expect.setState = (state) => setState(state, expect);
-  const globalState = getState(globalThis[GLOBAL_EXPECT$1]) || {};
+  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
+  const testPath = getTestFile(test);
   setState({
     // this should also add "snapshotState" that is added conditionally
     ...globalState,
@@ -386,18 +436,15 @@ 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);
   expect.soft = (...args) => {
-    const assert2 = expect(...args);
-    expect.setState({
-      soft: true
-    });
-    return assert2;
+    return expect(...args).withContext({ soft: true });
   };
+  expect.poll = createExpectPoll(expect);
   expect.unreachable = (message) => {
     chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
   };
@@ -423,8 +470,14 @@ 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, {
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
   value: globalExpect,
   writable: true,
   configurable: true
@@ -3223,6 +3276,8 @@ function waitFor(callback, options = {}) {
       resolve(result);
     };
     const handleTimeout = () => {
+      if (intervalId)
+        clearInterval(intervalId);
       let error = lastError;
       if (!error)
         error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
@@ -3271,6 +3326,8 @@ function waitUntil(callback, options = {}) {
     let timeoutId;
     let intervalId;
     const onReject = (error) => {
+      if (intervalId)
+        clearInterval(intervalId);
       if (!error)
         error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
       reject(error);
@@ -3338,10 +3395,13 @@ function createVitest() {
   const _stubsGlobal = /* @__PURE__ */ new Map();
   const _stubsEnv = /* @__PURE__ */ new Map();
   const _envBooleans = ["PROD", "DEV", "SSR"];
-  const getImporter = () => {
-    const stackTrace = createSimpleStackTrace({ stackTraceLimit: 4 });
-    const importerStack = stackTrace.split("\n")[4];
-    const stack = parseSingleStack(importerStack);
+  const getImporter = (name) => {
+    const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
+    const stackArray = stackTrace.split("\n");
+    const importerStackIndex = stackArray.findIndex((stack2) => {
+      return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
+    });
+    const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
     return (stack == null ? void 0 : stack.file) || "";
   };
   const utils = {
@@ -3434,7 +3494,9 @@ function createVitest() {
       return factory();
     },
     mock(path, factory) {
-      const importer = getImporter();
+      if (typeof path !== "string")
+        throw new Error(`vi.mock() expects a string path, but received a ${typeof path}`);
+      const importer = getImporter("mock");
       _mocker.queueMock(
         path,
         importer,
@@ -3443,10 +3505,14 @@ function createVitest() {
       );
     },
     unmock(path) {
-      _mocker.queueUnmock(path, getImporter());
+      if (typeof path !== "string")
+        throw new Error(`vi.unmock() expects a string path, but received a ${typeof path}`);
+      _mocker.queueUnmock(path, getImporter("unmock"));
     },
     doMock(path, factory) {
-      const importer = getImporter();
+      if (typeof path !== "string")
+        throw new Error(`vi.doMock() expects a string path, but received a ${typeof path}`);
+      const importer = getImporter("doMock");
       _mocker.queueMock(
         path,
         importer,
@@ -3455,17 +3521,19 @@ function createVitest() {
       );
     },
     doUnmock(path) {
-      _mocker.queueUnmock(path, getImporter());
+      if (typeof path !== "string")
+        throw new Error(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
+      _mocker.queueUnmock(path, getImporter("doUnmock"));
     },
     async importActual(path) {
       return _mocker.importActual(
         path,
-        getImporter(),
+        getImporter("importActual"),
         _mocker.getMockContext().callstack
       );
     },
     async importMock(path) {
-      return _mocker.importMock(path, getImporter());
+      return _mocker.importMock(path, getImporter("importMock"));
     },
     // this is typed in the interface so it's not necessary to type it here
     mocked(item, _options = {}) {

package/dist/vendor/{vm.QEE48c0T.js → vm.Ow-X2mkS.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.fL3szUAI.js';
+import { createCustomConsole } from '../chunks/runtime-console.DiVMr5d4.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.BHj6OMh4.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();
@@ -245,24 +245,14 @@ const SyntheticModule$1 = vm.SyntheticModule;
 const SourceTextModule = vm.SourceTextModule;
 
 var __defProp$1 = Object.defineProperty;
-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);
-  return value;
-};
-var __accessCheck$1 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$1 = (obj, member, getter) => {
-  __accessCheck$1(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$1 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+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 {
@@ -286,12 +276,17 @@ class EsmExecutor {
       await m.evaluate();
     return m;
   }
-  async createEsModule(fileUrl, getCode) {
-    const cached = this.moduleCache.get(fileUrl);
+  async createEsModule(fileURL, getCode) {
+    const cached = this.moduleCache.get(fileURL);
     if (cached)
       return cached;
+    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")) {
+    if (fileURL.endsWith(".json")) {
       const m2 = new SyntheticModule$1(
         ["default"],
         () => {
@@ -299,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) => {
@@ -321,7 +316,7 @@ class EsmExecutor {
         }
       }
     );
-    this.moduleCache.set(fileUrl, m);
+    this.moduleCache.set(fileURL, m);
     return m;
   }
   async createWebAssemblyModule(fileUrl, getCode) {
@@ -523,29 +518,15 @@ class ViteExecutor {
 }
 
 var __defProp = Object.defineProperty;
-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);
-  return value;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw 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");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
+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;
@@ -562,7 +543,7 @@ class ExternalModulesExecutor {
     // 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 this.esm.evaluateModule(module);
+      return await this.esm.evaluateModule(module);
     });
     __publicField(this, "resolveModule", async (specifier, referencer) => {
       let identifier = this.resolve(specifier, referencer);
@@ -699,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);
@@ -709,14 +690,13 @@ class ExternalModulesExecutor {
       case "wasm":
         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 this.esm.createNetworkModule(url);
-      }
+      case "network":
+        return await this.esm.createNetworkModule(url);
       default: {
         const _deadend = type;
         return _deadend;
@@ -741,9 +721,17 @@ _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);
@@ -751,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);
@@ -783,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);