@vitest/browser 2.1.0-beta.6 → 2.1.0-beta.7

package/dist/client/__vitest_browser__/{tester-C7y_vb57.js → tester-Bm6k0JOu.js}

@@ -1,16 +1,496 @@
 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);
-import { a as getConfig, e as executor, i as importId, b as extname, g as getBrowserState, _ as __vitePreload, j as join, c as getWorkerState } from "./preload-helper-YsBSwBkS.js";
+import { M as MockerRegistry, R as RedirectedModule, A as AutomockedModule, _ as __vitePreload, b as getConfig, e as executor, g as getBrowserState, c as getWorkerState } from "./preload-helper-D-WYp1PK.js";
 import { loadDiffConfig, loadSnapshotSerializers, takeCoverageInsideWorker, setupCommonEnv, startCoverageInsideWorker, startTests, collectTests, stopCoverageInsideWorker, SpyModule } from "vitest/browser";
 import { page } from "@vitest/browser/context";
-import { globalChannel, channel, waitForChannel, client, onCancel } from "@vitest/browser/client";
+import { globalChannel, channel, client, onCancel, waitForChannel } from "@vitest/browser/client";
 import { getSafeTimers, stringify, format, TraceMap, originalPositionFor } from "vitest/utils";
 import { VitestTestRunner, NodeBenchmarkRunner } from "vitest/runners";
 import { expect } from "vitest";
+function mockObject(options, object, mockExports = {}) {
+  const finalizers = new Array();
+  const refs = new RefTracker();
+  const define = (container, key, value) => {
+    try {
+      container[key] = value;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const mockPropertiesOf = (container, newContainer) => {
+    const containerType = getType(container);
+    const isModule = containerType === "Module" || !!container.__esModule;
+    for (const { key: property, descriptor } of getAllMockableProperties(
+      container,
+      isModule,
+      options.globalConstructors
+    )) {
+      if (!isModule && descriptor.get) {
+        try {
+          Object.defineProperty(newContainer, property, descriptor);
+        } catch {
+        }
+        continue;
+      }
+      if (isSpecialProp(property, containerType)) {
+        continue;
+      }
+      const value = container[property];
+      const refId = refs.getId(value);
+      if (refId !== void 0) {
+        finalizers.push(
+          () => define(newContainer, property, refs.getMockedValue(refId))
+        );
+        continue;
+      }
+      const type = getType(value);
+      if (Array.isArray(value)) {
+        define(newContainer, property, []);
+        continue;
+      }
+      const isFunction2 = type.includes("Function") && typeof value === "function";
+      if ((!isFunction2 || value.__isMockFunction) && type !== "Object" && type !== "Module") {
+        define(newContainer, property, value);
+        continue;
+      }
+      if (!define(newContainer, property, isFunction2 ? value : {})) {
+        continue;
+      }
+      if (isFunction2) {
+        let mockFunction2 = function() {
+          if (this instanceof newContainer[property]) {
+            for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
+              this,
+              false,
+              options.globalConstructors
+            )) {
+              if (descriptor2.get) {
+                continue;
+              }
+              const value2 = this[key];
+              const type2 = getType(value2);
+              const isFunction22 = type2.includes("Function") && typeof value2 === "function";
+              if (isFunction22) {
+                const original = this[key];
+                const mock2 = spyOn(this, key).mockImplementation(original);
+                mock2.mockRestore = () => {
+                  mock2.mockReset();
+                  mock2.mockImplementation(original);
+                  return mock2;
+                };
+              }
+            }
+          }
+        };
+        if (!options.spyOn) {
+          throw new Error(
+            "[@vitest/mocker] `spyOn` is not defined. This is a Vitest error. Please open a new issue with reproduction."
+          );
+        }
+        const spyOn = options.spyOn;
+        const mock = spyOn(newContainer, property);
+        if (options.type === "automock") {
+          mock.mockImplementation(mockFunction2);
+          mock.mockRestore = () => {
+            mock.mockReset();
+            mock.mockImplementation(mockFunction2);
+            return mock;
+          };
+        }
+        Object.defineProperty(newContainer[property], "length", { value: 0 });
+      }
+      refs.track(value, newContainer[property]);
+      mockPropertiesOf(value, newContainer[property]);
+    }
+  };
+  const mockedObject = mockExports;
+  mockPropertiesOf(object, mockedObject);
+  for (const finalizer of finalizers) {
+    finalizer();
+  }
+  return mockedObject;
+}
+class RefTracker {
+  constructor() {
+    __publicField(this, "idMap", /* @__PURE__ */ new Map());
+    __publicField(this, "mockedValueMap", /* @__PURE__ */ new Map());
+  }
+  getId(value) {
+    return this.idMap.get(value);
+  }
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
+  }
+  track(originalValue, mockedValue) {
+    const newId = this.idMap.size;
+    this.idMap.set(originalValue, newId);
+    this.mockedValueMap.set(newId, mockedValue);
+    return newId;
+  }
+}
 function getType(value) {
   return Object.prototype.toString.apply(value).slice(8, -1);
 }
+function isSpecialProp(prop, parentType) {
+  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
+}
+function getAllMockableProperties(obj, isModule, constructors) {
+  const { Map: Map2, Object: Object2, Function: Function2, RegExp: RegExp2, Array: Array2 } = constructors;
+  const allProps = new Map2();
+  let curr = obj;
+  do {
+    if (curr === Object2.prototype || curr === Function2.prototype || curr === RegExp2.prototype) {
+      break;
+    }
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object2.getOwnPropertyDescriptor(curr, key);
+      if (descriptor) {
+        allProps.set(key, { key, descriptor });
+      }
+    });
+  } while (curr = Object2.getPrototypeOf(curr));
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object2.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor) {
+      allProps.set("default", { key: "default", descriptor });
+    }
+  }
+  return Array2.from(allProps.values());
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize$1 = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === void 0) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize$1(joined.replace(/\/\/+/g, "/"));
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const _EXTNAME_RE = /.(\.[^./]+)$/;
+const extname = function(p) {
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+};
+const { now } = Date;
+class ModuleMocker {
+  constructor(interceptor, rpc2, spyOn, config) {
+    __publicField(this, "registry", new MockerRegistry());
+    __publicField(this, "queue", /* @__PURE__ */ new Set());
+    __publicField(this, "mockedIds", /* @__PURE__ */ new Set());
+    this.interceptor = interceptor;
+    this.rpc = rpc2;
+    this.spyOn = spyOn;
+    this.config = config;
+  }
+  async prepare() {
+    if (!this.queue.size) {
+      return;
+    }
+    await Promise.all([...this.queue.values()]);
+  }
+  async resolveFactoryModule(id) {
+    const mock = this.registry.get(id);
+    if (!mock || mock.type !== "manual") {
+      throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    const result = await mock.resolve();
+    return result;
+  }
+  getFactoryModule(id) {
+    const mock = this.registry.get(id);
+    if (!mock || mock.type !== "manual") {
+      throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    if (!mock.cache) {
+      throw new Error(`Mock ${id} wasn't resolved. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    return mock.cache;
+  }
+  async invalidate() {
+    const ids = Array.from(this.mockedIds);
+    if (!ids.length) {
+      return;
+    }
+    await this.rpc.invalidate(ids);
+    this.interceptor.invalidate();
+    this.registry.clear();
+  }
+  async importActual(id, importer) {
+    const resolved = await this.rpc.resolveId(id, importer);
+    if (resolved == null) {
+      throw new Error(
+        `[vitest] Cannot resolve ${id} imported from ${importer}`
+      );
+    }
+    const ext = extname(resolved.id);
+    const url2 = new URL(resolved.url, location.href);
+    const query = `_vitest_original&ext${ext}`;
+    const actualUrl = `${url2.pathname}${url2.search ? `${url2.search}&${query}` : `?${query}`}${url2.hash}`;
+    return this.wrapDynamicImport(() => import(
+      /* @vite-ignore */
+      actualUrl
+    )).then((mod) => {
+      if (!resolved.optimized || typeof mod.default === "undefined") {
+        return mod;
+      }
+      const m = mod.default;
+      return (m == null ? void 0 : m.__esModule) ? m : { ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {}, default: m };
+    });
+  }
+  async importMock(rawId, importer) {
+    await this.prepare();
+    const { resolvedId, redirectUrl } = await this.rpc.resolveMock(
+      rawId,
+      importer,
+      { mock: "auto" }
+    );
+    const mockUrl = this.resolveMockPath(cleanVersion(resolvedId));
+    let mock = this.registry.get(mockUrl);
+    if (!mock) {
+      if (redirectUrl) {
+        const resolvedRedirect = new URL(this.resolveMockPath(cleanVersion(redirectUrl)), location.href).toString();
+        mock = new RedirectedModule(rawId, mockUrl, resolvedRedirect);
+      } else {
+        mock = new AutomockedModule(rawId, mockUrl);
+      }
+    }
+    if (mock.type === "manual") {
+      return await mock.resolve();
+    }
+    if (mock.type === "automock" || mock.type === "autospy") {
+      const url2 = new URL(`/@id/${resolvedId}`, location.href);
+      const query = url2.search ? `${url2.search}&t=${now()}` : `?t=${now()}`;
+      const moduleObject = await __vitePreload(() => import(
+        /* @vite-ignore */
+        `${url2.pathname}${query}&mock=${mock.type}${url2.hash}`
+      ), true ? [] : void 0);
+      return this.mockObject(moduleObject, mock.type);
+    }
+    return import(
+      /* @vite-ignore */
+      mock.redirect
+    );
+  }
+  mockObject(object, moduleType = "automock") {
+    return mockObject({
+      globalConstructors: {
+        Object,
+        Function,
+        Array,
+        Map,
+        RegExp
+      },
+      spyOn: this.spyOn,
+      type: moduleType
+    }, object);
+  }
+  queueMock(rawId, importer, factoryOrOptions) {
+    const promise = this.rpc.resolveMock(rawId, importer, {
+      mock: typeof factoryOrOptions === "function" ? "factory" : (factoryOrOptions == null ? void 0 : factoryOrOptions.spy) ? "spy" : "auto"
+    }).then(async ({ redirectUrl, resolvedId, needsInterop, mockType }) => {
+      const mockUrl = this.resolveMockPath(cleanVersion(resolvedId));
+      this.mockedIds.add(resolvedId);
+      const factory = typeof factoryOrOptions === "function" ? async () => {
+        const data = await factoryOrOptions();
+        return needsInterop ? { default: data } : data;
+      } : void 0;
+      const mockRedirect = typeof redirectUrl === "string" ? new URL(this.resolveMockPath(cleanVersion(redirectUrl)), location.href).toString() : null;
+      let module;
+      if (mockType === "manual") {
+        module = this.registry.register("manual", rawId, mockUrl, factory);
+      } else if (mockType === "autospy") {
+        module = this.registry.register("autospy", rawId, mockUrl);
+      } else if (mockType === "redirect") {
+        module = this.registry.register("redirect", rawId, mockUrl, mockRedirect);
+      } else {
+        module = this.registry.register("automock", rawId, mockUrl);
+      }
+      await this.interceptor.register(module);
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  queueUnmock(id, importer) {
+    const promise = this.rpc.resolveId(id, importer).then(async (resolved) => {
+      if (!resolved) {
+        return;
+      }
+      const mockUrl = this.resolveMockPath(cleanVersion(resolved.id));
+      this.mockedIds.add(resolved.id);
+      this.registry.delete(mockUrl);
+      await this.interceptor.delete(mockUrl);
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  // We need to await mock registration before importing the actual module
+  // In case there is a mocked module in the import chain
+  wrapDynamicImport(moduleFactory) {
+    if (typeof moduleFactory === "function") {
+      const promise = new Promise((resolve, reject) => {
+        this.prepare().finally(() => {
+          moduleFactory().then(resolve, reject);
+        });
+      });
+      return promise;
+    }
+    return moduleFactory;
+  }
+  resolveMockPath(path) {
+    const config = this.config;
+    const fsRoot = join("/@fs/", config.root);
+    if (path.startsWith(config.root)) {
+      return path.slice(config.root.length);
+    }
+    if (path.startsWith(fsRoot)) {
+      return path.slice(fsRoot.length);
+    }
+    return path;
+  }
+}
+const versionRegexp = /(\?|&)v=\w{8}/;
+function cleanVersion(url2) {
+  return url2.replace(versionRegexp, "");
+}
+const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = new Uint8Array(64);
+const charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+var UrlType;
+(function(UrlType2) {
+  UrlType2[UrlType2["Empty"] = 1] = "Empty";
+  UrlType2[UrlType2["Hash"] = 2] = "Hash";
+  UrlType2[UrlType2["Query"] = 3] = "Query";
+  UrlType2[UrlType2["RelativePath"] = 4] = "RelativePath";
+  UrlType2[UrlType2["AbsolutePath"] = 5] = "AbsolutePath";
+  UrlType2[UrlType2["SchemeRelative"] = 6] = "SchemeRelative";
+  UrlType2[UrlType2["Absolute"] = 7] = "Absolute";
+})(UrlType || (UrlType = {}));
 function showPopupWarning(name, value, defaultValue) {
   return (...params) => {
     const formatedParams = params.map((p) => JSON.stringify(p)).join(", ");
@@ -95,42 +575,6 @@ function setupConsoleLogSpy() {
     count,
     countReset
   } = console$1;
-  const formatInput = (input) => {
-    if (typeof input === "object") {
-      return stringify(input, void 0, {
-        printBasicPrototype: false,
-        escapeString: false
-      });
-    }
-    return format(input);
-  };
-  const processLog = (args) => args.map(formatInput).join(" ");
-  const sendLog = (type, content, disableStack) => {
-    var _a, _b, _c;
-    if (content.startsWith("[vite]")) {
-      return;
-    }
-    const unknownTestId = "__vitest__unknown_test__";
-    const taskId = ((_b = (_a = globalThis.__vitest_worker__) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
-    const origin = getConfig().printConsoleTrace && !disableStack ? (_c = new Error("STACK_TRACE").stack) == null ? void 0 : _c.split("\n").slice(1).join("\n") : void 0;
-    rpc$1().sendLog({
-      origin,
-      content,
-      browser: true,
-      time: Date$1.now(),
-      taskId,
-      type,
-      size: content.length
-    });
-  };
-  const stdout = (base) => (...args) => {
-    base(...args);
-    sendLog("stdout", processLog(args));
-  };
-  const stderr = (base) => (...args) => {
-    base(...args);
-    sendLog("stderr", processLog(args));
-  };
   console$1.log = stdout(log);
   console$1.debug = stdout(debug2);
   console$1.info = stdout(info);
@@ -190,6 +634,48 @@ ${stack}`, true);
     countLabels[label] = 0;
   };
 }
+function stdout(base) {
+  return (...args) => {
+    base(...args);
+    sendLog("stdout", processLog(args));
+  };
+}
+function stderr(base) {
+  return (...args) => {
+    base(...args);
+    sendLog("stderr", processLog(args));
+  };
+}
+function formatInput(input) {
+  if (typeof input === "object") {
+    return stringify(input, void 0, {
+      printBasicPrototype: false,
+      escapeString: false
+    });
+  }
+  return format(input);
+}
+function processLog(args) {
+  return args.map(formatInput).join(" ");
+}
+function sendLog(type, content, disableStack) {
+  var _a, _b, _c;
+  if (content.startsWith("[vite]")) {
+    return;
+  }
+  const unknownTestId = "__vitest__unknown_test__";
+  const taskId = ((_b = (_a = globalThis.__vitest_worker__) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
+  const origin = getConfig().printConsoleTrace && !disableStack ? (_c = new Error("STACK_TRACE").stack) == null ? void 0 : _c.split("\n").slice(1).join("\n") : void 0;
+  rpc$1().sendLog({
+    origin,
+    content,
+    browser: true,
+    time: Date$1.now(),
+    taskId,
+    type,
+    size: content.length
+  });
+}
 class VitestBrowserSnapshotEnvironment {
   constructor() {
     __publicField(this, "sourceMaps", /* @__PURE__ */ new Map());
@@ -383,354 +869,40 @@ async function updateFilesLocations(files, sourceMaps) {
   });
   await Promise.all(promises2);
 }
-const now = Date.now;
-class VitestBrowserClientMocker {
-  constructor() {
-    __publicField(this, "queue", /* @__PURE__ */ new Set());
-    __publicField(this, "mocks", {});
-    __publicField(this, "mockObjects", {});
-    __publicField(this, "factories", {});
-    __publicField(this, "ids", /* @__PURE__ */ new Set());
-    __publicField(this, "spyModule");
-  }
+class VitestBrowserClientMocker extends ModuleMocker {
   setupWorker() {
     channel.addEventListener(
       "message",
       async (e) => {
         if (e.data.type === "mock-factory:request") {
           try {
-            const module = await this.resolve(e.data.id);
+            const module = await this.resolveFactoryModule(e.data.id);
             const exports = Object.keys(module);
             channel.postMessage({
               type: "mock-factory:response",
               exports
             });
           } catch (err) {
-            const { processError } = await importId(
-              "vitest/browser"
-            );
             channel.postMessage({
               type: "mock-factory:error",
-              error: processError(err)
+              error: {
+                name: err.name,
+                message: err.message,
+                stack: err.stack
+              }
             });
           }
         }
       }
     );
   }
-  setSpyModule(mod) {
-    this.spyModule = mod;
-  }
-  async importActual(id, importer) {
-    const resolved = await rpc$1().resolveId(id, importer);
-    if (resolved == null) {
-      throw new Error(
-        `[vitest] Cannot resolve ${id} imported from ${importer}`
-      );
-    }
-    const ext = extname(resolved.id);
-    const url2 = new URL(resolved.url, location.href);
-    const query = `_vitest_original&ext${ext}`;
-    const actualUrl = `${url2.pathname}${url2.search ? `${url2.search}&${query}` : `?${query}`}${url2.hash}`;
-    return getBrowserState().wrapModule(() => import(
-      /* @vite-ignore */
-      actualUrl
-    )).then((mod) => {
-      if (!resolved.optimized || typeof mod.default === "undefined") {
-        return mod;
-      }
-      const m = mod.default;
-      return (m == null ? void 0 : m.__esModule) ? m : { ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {}, default: m };
-    });
-  }
-  async importMock(rawId, importer) {
-    await this.prepare();
-    const { resolvedId, type, mockPath } = await rpc$1().resolveMock(
-      rawId,
-      importer,
-      false
-    );
-    const factoryReturn = this.get(resolvedId);
-    if (factoryReturn) {
-      return factoryReturn;
-    }
-    if (this.factories[resolvedId]) {
-      return await this.resolve(resolvedId);
-    }
-    if (type === "redirect") {
-      const url22 = new URL(`/@id/${mockPath}`, location.href);
-      return import(
-        /* @vite-ignore */
-        url22.toString()
-      );
-    }
-    const url2 = new URL(`/@id/${resolvedId}`, location.href);
-    const query = url2.search ? `${url2.search}&t=${now()}` : `?t=${now()}`;
-    const moduleObject = await __vitePreload(() => import(
-      /* @vite-ignore */
-      `${url2.pathname}${query}${url2.hash}`
-    ), true ? [] : void 0);
-    return this.mockObject(moduleObject);
-  }
+  // default "vi" utility tries to access mock context to avoid circular dependencies
   getMockContext() {
     return { callstack: null };
   }
-  get(id) {
-    return this.mockObjects[id];
+  wrapDynamicImport(moduleFactory) {
+    return getBrowserState().wrapModule(moduleFactory);
   }
-  async invalidate() {
-    const ids = Array.from(this.ids);
-    if (!ids.length) {
-      return;
-    }
-    await rpc$1().invalidate(ids);
-    channel.postMessage({ type: "mock:invalidate" });
-    this.ids.clear();
-    this.mocks = {};
-    this.mockObjects = {};
-    this.factories = {};
-  }
-  async resolve(id) {
-    const factory = this.factories[id];
-    if (!factory) {
-      throw new Error(`Cannot resolve ${id} mock: no factory provided`);
-    }
-    try {
-      this.mockObjects[id] = await factory();
-      return this.mockObjects[id];
-    } catch (err) {
-      const vitestError = new Error(
-        '[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock'
-      );
-      vitestError.cause = err;
-      throw vitestError;
-    }
-  }
-  queueMock(id, importer, factory) {
-    const promise = rpc$1().resolveMock(id, importer, !!factory).then(async ({ mockPath, resolvedId, needsInterop }) => {
-      this.ids.add(resolvedId);
-      const urlPaths = resolveMockPaths(cleanVersion(resolvedId));
-      const resolvedMock = typeof mockPath === "string" ? new URL(resolvedMockedPath(cleanVersion(mockPath)), location.href).toString() : mockPath;
-      const _factory = factory && needsInterop ? async () => {
-        const data = await factory();
-        return { default: data };
-      } : factory;
-      urlPaths.forEach((url2) => {
-        this.mocks[url2] = resolvedMock;
-        if (_factory) {
-          this.factories[url2] = _factory;
-        }
-      });
-      channel.postMessage({
-        type: "mock",
-        paths: urlPaths,
-        mock: resolvedMock
-      });
-      await waitForChannel("mock:done");
-    }).finally(() => {
-      this.queue.delete(promise);
-    });
-    this.queue.add(promise);
-  }
-  queueUnmock(id, importer) {
-    const promise = rpc$1().resolveId(id, importer).then(async (resolved) => {
-      if (!resolved) {
-        return;
-      }
-      this.ids.delete(resolved.id);
-      const urlPaths = resolveMockPaths(cleanVersion(resolved.id));
-      urlPaths.forEach((url2) => {
-        delete this.mocks[url2];
-        delete this.factories[url2];
-        delete this.mockObjects[url2];
-      });
-      channel.postMessage({
-        type: "unmock",
-        paths: urlPaths
-      });
-      await waitForChannel("unmock:done");
-    }).finally(() => {
-      this.queue.delete(promise);
-    });
-    this.queue.add(promise);
-  }
-  async prepare() {
-    if (!this.queue.size) {
-      return;
-    }
-    await Promise.all([...this.queue.values()]);
-  }
-  // TODO: move this logic into a util(?)
-  mockObject(object, mockExports = {}) {
-    const finalizers = new Array();
-    const refs = new RefTracker();
-    const define = (container, key, value) => {
-      try {
-        container[key] = value;
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    const mockPropertiesOf = (container, newContainer) => {
-      const containerType = /* @__PURE__ */ getType(container);
-      const isModule = containerType === "Module" || !!container.__esModule;
-      for (const { key: property, descriptor } of getAllMockableProperties(
-        container,
-        isModule
-      )) {
-        if (!isModule && descriptor.get) {
-          try {
-            Object.defineProperty(newContainer, property, descriptor);
-          } catch {
-          }
-          continue;
-        }
-        if (isSpecialProp(property, containerType)) {
-          continue;
-        }
-        const value = container[property];
-        const refId = refs.getId(value);
-        if (refId !== void 0) {
-          finalizers.push(
-            () => define(newContainer, property, refs.getMockedValue(refId))
-          );
-          continue;
-        }
-        const type = /* @__PURE__ */ getType(value);
-        if (Array.isArray(value)) {
-          define(newContainer, property, []);
-          continue;
-        }
-        const isFunction2 = type.includes("Function") && typeof value === "function";
-        if ((!isFunction2 || value.__isMockFunction) && type !== "Object" && type !== "Module") {
-          define(newContainer, property, value);
-          continue;
-        }
-        if (!define(newContainer, property, isFunction2 ? value : {})) {
-          continue;
-        }
-        if (isFunction2) {
-          let mockFunction = function() {
-            if (this instanceof newContainer[property]) {
-              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
-                this,
-                false
-              )) {
-                if (descriptor2.get) {
-                  continue;
-                }
-                const value2 = this[key];
-                const type2 = /* @__PURE__ */ getType(value2);
-                const isFunction22 = type2.includes("Function") && typeof value2 === "function";
-                if (isFunction22) {
-                  const original = this[key];
-                  const mock2 = spyModule.spyOn(this, key).mockImplementation(original);
-                  mock2.mockRestore = () => {
-                    mock2.mockReset();
-                    mock2.mockImplementation(original);
-                    return mock2;
-                  };
-                }
-              }
-            }
-          };
-          const spyModule = this.spyModule;
-          if (!spyModule) {
-            throw new Error(
-              "[vitest] `spyModule` is not defined. This is Vitest error. Please open a new issue with reproduction."
-            );
-          }
-          const mock = spyModule.spyOn(newContainer, property).mockImplementation(mockFunction);
-          mock.mockRestore = () => {
-            mock.mockReset();
-            mock.mockImplementation(mockFunction);
-            return mock;
-          };
-          Object.defineProperty(newContainer[property], "length", { value: 0 });
-        }
-        refs.track(value, newContainer[property]);
-        mockPropertiesOf(value, newContainer[property]);
-      }
-    };
-    const mockedObject = mockExports;
-    mockPropertiesOf(object, mockedObject);
-    for (const finalizer of finalizers) {
-      finalizer();
-    }
-    return mockedObject;
-  }
-}
-function isSpecialProp(prop, parentType) {
-  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
-}
-class RefTracker {
-  constructor() {
-    __publicField(this, "idMap", /* @__PURE__ */ new Map());
-    __publicField(this, "mockedValueMap", /* @__PURE__ */ new Map());
-  }
-  getId(value) {
-    return this.idMap.get(value);
-  }
-  getMockedValue(id) {
-    return this.mockedValueMap.get(id);
-  }
-  track(originalValue, mockedValue) {
-    const newId = this.idMap.size;
-    this.idMap.set(originalValue, newId);
-    this.mockedValueMap.set(newId, mockedValue);
-    return newId;
-  }
-}
-function getAllMockableProperties(obj, isModule) {
-  const allProps = /* @__PURE__ */ new Map();
-  let curr = obj;
-  do {
-    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype) {
-      break;
-    }
-    collectOwnProperties(curr, (key) => {
-      const descriptor = Object.getOwnPropertyDescriptor(curr, key);
-      if (descriptor) {
-        allProps.set(key, { key, descriptor });
-      }
-    });
-  } while (curr = Object.getPrototypeOf(curr));
-  if (isModule && !allProps.has("default") && "default" in obj) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, "default");
-    if (descriptor) {
-      allProps.set("default", { key: "default", descriptor });
-    }
-  }
-  return Array.from(allProps.values());
-}
-function collectOwnProperties(obj, collector) {
-  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
-  Object.getOwnPropertyNames(obj).forEach(collect);
-  Object.getOwnPropertySymbols(obj).forEach(collect);
-}
-function resolvedMockedPath(path) {
-  const config = getBrowserState().viteConfig;
-  if (path.startsWith(config.root)) {
-    return path.slice(config.root.length);
-  }
-  return path;
-}
-function resolveMockPaths(path) {
-  const config = getBrowserState().viteConfig;
-  const fsRoot = join("/@fs/", config.root);
-  const paths = [path, join("/@fs/", path)];
-  if (path.startsWith(config.root)) {
-    paths.push(path.slice(config.root.length));
-  }
-  if (path.startsWith(fsRoot)) {
-    paths.push(path.slice(fsRoot.length));
-  }
-  return paths;
-}
-const versionRegexp = /(\?|&)v=\w{8}/;
-function cleanVersion(url2) {
-  return url2.replace(versionRegexp, "");
 }
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
@@ -10064,8 +10236,8 @@ function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
 }
 var _equalArrays = equalArrays$2;
 var root$4 = _root;
-var Uint8Array$1 = root$4.Uint8Array;
-var _Uint8Array = Uint8Array$1;
+var Uint8Array$2 = root$4.Uint8Array;
+var _Uint8Array = Uint8Array$2;
 function mapToArray$1(map) {
   var index = -1, result = Array(map.size);
   map.forEach(function(value, key) {
@@ -10082,7 +10254,7 @@ function setToArray$1(set) {
   return result;
 }
 var _setToArray = setToArray$1;
-var Symbol$1 = _Symbol, Uint8Array2 = _Uint8Array, eq = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
+var Symbol$1 = _Symbol, Uint8Array$1 = _Uint8Array, eq = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
 var COMPARE_PARTIAL_FLAG$2 = 1, COMPARE_UNORDERED_FLAG = 2;
 var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag = "[object Symbol]";
 var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]";
@@ -10096,7 +10268,7 @@ function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack)
       object = object.buffer;
       other = other.buffer;
     case arrayBufferTag$1:
-      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array$1(object), new Uint8Array$1(other))) {
         return false;
       }
       return true;
@@ -11902,7 +12074,34 @@ async function prepareTestEnvironment(files) {
   state.ctx.files = files;
   state.onCancel = onCancel;
   state.rpc = rpc2;
-  const mocker = new VitestBrowserClientMocker();
+  const mocker = new VitestBrowserClientMocker(
+    {
+      async delete(url2) {
+        channel.postMessage({
+          type: "unmock",
+          url: url2
+        });
+        await waitForChannel("unmock:done");
+      },
+      async register(module) {
+        channel.postMessage({
+          type: "mock",
+          module: module.toJSON()
+        });
+        await waitForChannel("mock:done");
+      },
+      invalidate() {
+        channel.postMessage({
+          type: "mock:invalidate"
+        });
+      }
+    },
+    rpc2,
+    SpyModule.spyOn,
+    {
+      root: getBrowserState().viteConfig.root
+    }
+  );
   globalThis.__vitest_mocker__ = mocker;
   setupConsoleLogSpy();
   setupDialogsSpy();
@@ -11915,7 +12114,6 @@ async function prepareTestEnvironment(files) {
       browserHashMap.set(filename, [true, version]);
     }
   });
-  mocker.setSpyModule(SpyModule);
   mocker.setupWorker();
   onCancel.then((reason) => {
     var _a;
@@ -11959,8 +12157,17 @@ async function executeTests(method, files) {
   state.durations.prepare = performance.now() - state.durations.prepare;
   debug("prepare time", state.durations.prepare, "ms");
   try {
-    await setupCommonEnv(config);
-    await startCoverageInsideWorker(config.coverage, executor);
+    await Promise.all([
+      setupCommonEnv(config),
+      startCoverageInsideWorker(config.coverage, executor),
+      (async () => {
+        const VitestIndex = await __vitePreload(() => import("vitest"), true ? [] : void 0);
+        Object.defineProperty(window, "__vitest_index__", {
+          value: VitestIndex,
+          enumerable: false
+        });
+      })()
+    ]);
     for (const file of files) {
       state.filepath = file;
       if (method === "run") {
@@ -11982,7 +12189,14 @@ async function executeTests(method, files) {
       }, "Cleanup Error");
     }
     state.environmentTeardownRun = true;
-    await stopCoverageInsideWorker(config.coverage, executor);
+    await stopCoverageInsideWorker(config.coverage, executor).catch((error) => {
+      client.rpc.onUnhandledError({
+        name: error.name,
+        message: error.message,
+        stack: String(error.stack)
+      }, "Coverage Error").catch(() => {
+      });
+    });
     debug("finished running tests");
     done(files);
   }