@vitest/browser 2.0.0-beta.10 → 2.0.0-beta.11

package/dist/client/__vitest_browser__/{tester-e70VCOgC.js → tester-IF8AbWCS.js}

@@ -10,7 +10,10 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { i as importId, b as getConfig, e as rpc$1, _ as __vitePreload, a as channel, f as extname, g as getBrowserState, w as waitForChannel, j as join, c as client, l as loadSafeRpc, o as onCancel } from "./rpc-CImfI7bO.js";
+import { b as getConfig, e as rpc$1, i as importId, _ as __vitePreload, c as channel, f as extname, g as getBrowserState, w as waitForChannel, j as join, a as client, h as createSafeRpc, o as onCancel, k as getWorkerState } from "./rpc-D6HtJ5Rb.js";
+import { processError, loadDiffConfig, loadSnapshotSerializers, takeCoverageInsideWorker, SpyModule, setupCommonEnv, startTests } from "/__virtual_vitest__?id=vitest%2Fbrowser";
+import { stringify, format, TraceMap, originalPositionFor } from "/__virtual_vitest__?id=vitest%2Futils";
+import { VitestTestRunner, NodeBenchmarkRunner } from "/__virtual_vitest__?id=vitest%2Frunners";
 function getType(value) {
   return Object.prototype.toString.apply(value).slice(8, -1);
 }
@@ -35,20 +38,88 @@ function setupDialogsSpy() {
   globalThis.confirm = showPopupWarning("confirm", false, true);
   globalThis.prompt = showPopupWarning("prompt", null, "your value");
 }
+function on(event, listener) {
+  window.addEventListener(event, listener);
+  return () => window.removeEventListener(event, listener);
+}
+function serializeError(unhandledError) {
+  return {
+    ...unhandledError,
+    name: unhandledError.name,
+    message: unhandledError.message,
+    stack: String(unhandledError.stack)
+  };
+}
+function catchWindowErrors(cb) {
+  let userErrorListenerCount = 0;
+  function throwUnhandlerError(e) {
+    if (userErrorListenerCount === 0 && e.error != null) {
+      cb(e);
+    } else {
+      console.error(e.error);
+    }
+  }
+  const addEventListener = window.addEventListener.bind(window);
+  const removeEventListener = window.removeEventListener.bind(window);
+  window.addEventListener("error", throwUnhandlerError);
+  window.addEventListener = function(...args) {
+    if (args[0] === "error") {
+      userErrorListenerCount++;
+    }
+    return addEventListener.apply(this, args);
+  };
+  window.removeEventListener = function(...args) {
+    if (args[0] === "error" && userErrorListenerCount) {
+      userErrorListenerCount--;
+    }
+    return removeEventListener.apply(this, args);
+  };
+  return function clearErrorHandlers() {
+    window.removeEventListener("error", throwUnhandlerError);
+  };
+}
+function registerUnexpectedErrors(rpc2) {
+  catchWindowErrors(
+    (event) => reportUnexpectedError(rpc2, "Error", event.error)
+  );
+  on("unhandledrejection", (event) => reportUnexpectedError(rpc2, "Unhandled Rejection", event.reason));
+}
+async function reportUnexpectedError(rpc2, type, error) {
+  const processedError = processError(error);
+  await rpc2.onUnhandledError(processedError, type);
+}
 const { Date: Date$1, console: console$1 } = globalThis;
-async function setupConsoleLogSpy() {
-  const { stringify, format, inspect } = await importId("vitest/utils");
-  const { log, info, error, dir, dirxml, trace, time, timeEnd, timeLog, warn, debug: debug2, count, countReset } = console$1;
+function setupConsoleLogSpy() {
+  const {
+    log,
+    info,
+    error,
+    dir,
+    dirxml,
+    trace,
+    time,
+    timeEnd,
+    timeLog,
+    warn,
+    debug: debug2,
+    count,
+    countReset
+  } = console$1;
   const formatInput = (input) => {
-    if (input instanceof Node)
-      return stringify(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]"))
+    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;
@@ -63,12 +134,12 @@ async function setupConsoleLogSpy() {
     });
   };
   const stdout = (base) => (...args) => {
+    base(...args);
     sendLog("stdout", processLog(args));
-    return base(...args);
   };
   const stderr = (base) => (...args) => {
+    base(...args);
     sendLog("stderr", processLog(args));
-    return base(...args);
   };
   console$1.log = stdout(log);
   console$1.debug = stdout(debug2);
@@ -76,38 +147,39 @@ async function setupConsoleLogSpy() {
   console$1.error = stderr(error);
   console$1.warn = stderr(warn);
   console$1.dir = (item, options) => {
-    sendLog("stdout", inspect(item, options));
-    return dir(item, options);
+    dir(item, options);
+    sendLog("stdout", formatInput(item));
   };
   console$1.dirxml = (...args) => {
+    dirxml(...args);
     sendLog("stdout", processLog(args));
-    return dirxml(...args);
   };
   console$1.trace = (...args) => {
     var _a;
+    trace(...args);
     const content = processLog(args);
     const error2 = new Error("$$Trace");
     const stack = (error2.stack || "").split("\n").slice(((_a = error2.stack) == null ? void 0 : _a.includes("$$Trace")) ? 2 : 1).join("\n");
     sendLog("stderr", `${content}
 ${stack}`, true);
-    return trace(...args);
   };
   const timeLabels = {};
   console$1.time = (label = "default") => {
-    const now2 = performance.now();
     time(label);
+    const now2 = performance.now();
     timeLabels[label] = now2;
   };
   console$1.timeLog = (label = "default") => {
     timeLog(label);
-    if (!(label in timeLabels))
+    if (!(label in timeLabels)) {
       sendLog("stderr", `Timer "${label}" does not exist`);
-    else
+    } else {
       sendLog("stdout", `${label}: ${timeLabels[label]} ms`);
+    }
   };
   console$1.timeEnd = (label = "default") => {
-    const end = performance.now();
     timeEnd(label);
+    const end = performance.now();
     const start = timeLabels[label];
     if (!(label in timeLabels)) {
       sendLog("stderr", `Timer "${label}" does not exist`);
@@ -118,17 +190,24 @@ ${stack}`, true);
   };
   const countLabels = {};
   console$1.count = (label = "default") => {
+    count(label);
     const counter = (countLabels[label] ?? 0) + 1;
     countLabels[label] = counter;
     sendLog("stdout", `${label}: ${counter}`);
-    return count(label);
   };
   console$1.countReset = (label = "default") => {
+    countReset(label);
     countLabels[label] = 0;
-    return countReset(label);
   };
 }
 class VitestBrowserSnapshotEnvironment {
+  constructor() {
+    __publicField(this, "sourceMaps", /* @__PURE__ */ new Map());
+    __publicField(this, "traceMaps", /* @__PURE__ */ new Map());
+  }
+  addSourceMap(filepath, map) {
+    this.sourceMaps.set(filepath, map);
+  }
   getVersion() {
     return "1";
   }
@@ -150,6 +229,22 @@ class VitestBrowserSnapshotEnvironment {
   removeSnapshotFile(filepath) {
     return rpc().removeSnapshotFile(filepath);
   }
+  processStackTrace(stack) {
+    const map = this.sourceMaps.get(stack.file);
+    if (!map) {
+      return stack;
+    }
+    let traceMap = this.traceMaps.get(stack.file);
+    if (!traceMap) {
+      traceMap = new TraceMap(map);
+      this.traceMaps.set(stack.file, traceMap);
+    }
+    const { line, column } = originalPositionFor(traceMap, stack);
+    if (line != null && column != null) {
+      return { ...stack, line, column };
+    }
+    return stack;
+  }
 }
 function rpc() {
   return globalThis.__vitest_worker__.rpc;
@@ -161,6 +256,7 @@ function createBrowserRunner(runnerClass, mocker, state, coverageModule) {
       super(options.config);
       __publicField(this, "config");
       __publicField(this, "hashMap", browserHashMap);
+      __publicField(this, "sourceMapCache", /* @__PURE__ */ new Map());
       __publicField(this, "onAfterRunTask", async (task) => {
         var _a, _b, _c;
         await ((_a = super.onAfterRunTask) == null ? void 0 : _a.call(this, task));
@@ -173,6 +269,22 @@ function createBrowserRunner(runnerClass, mocker, state, coverageModule) {
           }
         }
       });
+      __publicField(this, "onBeforeRunSuite", async (suite) => {
+        var _a;
+        await Promise.all([
+          (_a = super.onBeforeRunSuite) == null ? void 0 : _a.call(this, suite),
+          (async () => {
+            if ("filepath" in suite) {
+              const map = await rpc$1().getBrowserFileSourceMap(suite.filepath);
+              this.sourceMapCache.set(suite.filepath, map);
+              const snapshotEnvironment = this.config.snapshotOptions.snapshotEnvironment;
+              if (snapshotEnvironment instanceof VitestBrowserSnapshotEnvironment) {
+                snapshotEnvironment.addSourceMap(suite.filepath, map);
+              }
+            }
+          })()
+        ]);
+      });
       __publicField(this, "onAfterRunFiles", async (files) => {
         var _a, _b;
         const [coverage] = await Promise.all([
@@ -197,7 +309,7 @@ function createBrowserRunner(runnerClass, mocker, state, coverageModule) {
         });
         if (this.config.includeTaskLocation) {
           try {
-            await updateFilesLocations(files);
+            await updateFilesLocations(files, this.sourceMapCache);
           } catch (_) {
           }
         }
@@ -223,21 +335,16 @@ function createBrowserRunner(runnerClass, mocker, state, coverageModule) {
 }
 let cachedRunner = null;
 async function initiateRunner(state, mocker, config) {
-  if (cachedRunner)
+  if (cachedRunner) {
     return cachedRunner;
-  const [
-    { VitestTestRunner, NodeBenchmarkRunner },
-    { takeCoverageInsideWorker, loadDiffConfig, loadSnapshotSerializers }
-  ] = await Promise.all([
-    importId("vitest/runners"),
-    importId("vitest/browser")
-  ]);
+  }
   const runnerClass = config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
   const BrowserRunner = createBrowserRunner(runnerClass, mocker, state, {
     takeCoverage: () => takeCoverageInsideWorker(config.coverage, { executeId: importId })
   });
-  if (!config.snapshotOptions.snapshotEnvironment)
+  if (!config.snapshotOptions.snapshotEnvironment) {
     config.snapshotOptions.snapshotEnvironment = new VitestBrowserSnapshotEnvironment();
+  }
   const runner = new BrowserRunner({
     config
   });
@@ -250,22 +357,23 @@ async function initiateRunner(state, mocker, config) {
   cachedRunner = runner;
   return runner;
 }
-async function updateFilesLocations(files) {
-  const { loadSourceMapUtils } = await importId("vitest/utils");
-  const { TraceMap, originalPositionFor } = await loadSourceMapUtils();
+async function updateFilesLocations(files, sourceMaps) {
   const promises = files.map(async (file) => {
-    const result = await rpc$1().getBrowserFileSourceMap(file.filepath);
-    if (!result)
+    const result = sourceMaps.get(file.filepath) || await rpc$1().getBrowserFileSourceMap(file.filepath);
+    if (!result) {
       return null;
+    }
     const traceMap = new TraceMap(result);
     function updateLocation(task) {
       if (task.location) {
         const { line, column } = originalPositionFor(traceMap, task.location);
-        if (line != null && column != null)
+        if (line != null && column != null) {
           task.location = { line, column: task.each ? column : column + 1 };
+        }
       }
-      if ("tasks" in task)
+      if ("tasks" in task) {
         task.tasks.forEach(updateLocation);
+      }
     }
     file.tasks.forEach(updateLocation);
     return null;
@@ -283,32 +391,40 @@ class VitestBrowserClientMocker {
     __publicField(this, "spyModule");
   }
   setupWorker() {
-    channel.addEventListener("message", async (e) => {
-      if (e.data.type === "mock-factory:request") {
-        try {
-          const module = await this.resolve(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)
-          });
+    channel.addEventListener(
+      "message",
+      async (e) => {
+        if (e.data.type === "mock-factory:request") {
+          try {
+            const module = await this.resolve(e.data.id);
+            const exports = Object.keys(module);
+            channel.postMessage({
+              type: "mock-factory:response",
+              exports
+            });
+          } catch (err) {
+            const { processError: processError2 } = await importId(
+              "vitest/browser"
+            );
+            channel.postMessage({
+              type: "mock-factory:error",
+              error: processError2(err)
+            });
+          }
         }
       }
-    });
+    );
   }
   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}`);
+    if (resolved == null) {
+      throw new Error(
+        `[vitest] Cannot resolve ${id} imported from ${importer}`
+      );
+    }
     const ext = extname(resolved.id);
     const url2 = new URL(`/@id/${resolved.id}`, location.href);
     const query = `_vitest_original&ext.${ext}`;
@@ -317,12 +433,18 @@ class VitestBrowserClientMocker {
   }
   async importMock(rawId, importer) {
     await this.prepare();
-    const { resolvedId, type, mockPath } = await rpc$1().resolveMock(rawId, importer, false);
+    const { resolvedId, type, mockPath } = await rpc$1().resolveMock(
+      rawId,
+      importer,
+      false
+    );
     const factoryReturn = this.get(resolvedId);
-    if (factoryReturn)
+    if (factoryReturn) {
       return factoryReturn;
-    if (this.factories[resolvedId])
+    }
+    if (this.factories[resolvedId]) {
       return await this.resolve(resolvedId);
+    }
     if (type === "redirect") {
       const url22 = new URL(`/@id/${mockPath}`, location.href);
       return __vitePreload(() => import(url22.toString()), true ? __vite__mapDeps([]) : void 0);
@@ -340,8 +462,9 @@ class VitestBrowserClientMocker {
   }
   async invalidate() {
     const ids = Array.from(this.ids);
-    if (!ids.length)
+    if (!ids.length) {
       return;
+    }
     await rpc$1().invalidate(ids);
     channel.postMessage({ type: "mock:invalidate" });
     this.ids.clear();
@@ -351,8 +474,9 @@ class VitestBrowserClientMocker {
   }
   async resolve(id) {
     const factory = this.factories[id];
-    if (!factory)
+    if (!factory) {
       throw new Error(`Cannot resolve ${id} mock: no factory provided`);
+    }
     try {
       this.mockObjects[id] = await factory();
       return this.mockObjects[id];
@@ -386,8 +510,9 @@ class VitestBrowserClientMocker {
   }
   queueUnmock(id, importer) {
     const promise = rpc$1().resolveId(id, importer).then(async (resolved) => {
-      if (!resolved)
+      if (!resolved) {
         return;
+      }
       this.ids.delete(resolved.id);
       const urlPaths = resolveMockPaths(resolved.id);
       urlPaths.forEach((url2) => {
@@ -406,11 +531,10 @@ class VitestBrowserClientMocker {
     this.queue.add(promise);
   }
   async prepare() {
-    if (!this.queue.size)
+    if (!this.queue.size) {
       return;
-    await Promise.all([
-      ...this.queue.values()
-    ]);
+    }
+    await Promise.all([...this.queue.values()]);
   }
   // TODO: move this logic into a util(?)
   mockObject(object, mockExports = {}) {
@@ -427,7 +551,10 @@ class VitestBrowserClientMocker {
     const mockPropertiesOf = (container, newContainer) => {
       const containerType = /* @__PURE__ */ getType(container);
       const isModule = containerType === "Module" || !!container.__esModule;
-      for (const { key: property, descriptor } of getAllMockableProperties(container, isModule)) {
+      for (const { key: property, descriptor } of getAllMockableProperties(
+        container,
+        isModule
+      )) {
         if (!isModule && descriptor.get) {
           try {
             Object.defineProperty(newContainer, property, descriptor);
@@ -435,12 +562,15 @@ class VitestBrowserClientMocker {
           }
           continue;
         }
-        if (isSpecialProp(property, containerType))
+        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)));
+          finalizers.push(
+            () => define(newContainer, property, refs.getMockedValue(refId))
+          );
           continue;
         }
         const type = /* @__PURE__ */ getType(value);
@@ -453,14 +583,19 @@ class VitestBrowserClientMocker {
           define(newContainer, property, value);
           continue;
         }
-        if (!define(newContainer, property, isFunction ? value : {}))
+        if (!define(newContainer, property, isFunction ? value : {})) {
           continue;
+        }
         if (isFunction) {
           let mockFunction = function() {
             if (this instanceof newContainer[property]) {
-              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(this, false)) {
-                if (descriptor2.get)
+              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
+                this,
+                false
+              )) {
+                if (descriptor2.get) {
                   continue;
+                }
                 const value2 = this[key];
                 const type2 = /* @__PURE__ */ getType(value2);
                 const isFunction2 = type2.includes("Function") && typeof value2 === "function";
@@ -477,8 +612,11 @@ class VitestBrowserClientMocker {
             }
           };
           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.");
+          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();
@@ -493,8 +631,9 @@ class VitestBrowserClientMocker {
     };
     const mockedObject = mockExports;
     mockPropertiesOf(object, mockedObject);
-    for (const finalizer of finalizers)
+    for (const finalizer of finalizers) {
       finalizer();
+    }
     return mockedObject;
   }
 }
@@ -523,18 +662,21 @@ function getAllMockableProperties(obj, isModule) {
   const allProps = /* @__PURE__ */ new Map();
   let curr = obj;
   do {
-    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype)
+    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype) {
       break;
+    }
     collectOwnProperties(curr, (key) => {
       const descriptor = Object.getOwnPropertyDescriptor(curr, key);
-      if (descriptor)
+      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)
+    if (descriptor) {
       allProps.set("default", { key: "default", descriptor });
+    }
   }
   return Array.from(allProps.values());
 }
@@ -545,91 +687,30 @@ function collectOwnProperties(obj, collector) {
 }
 function resolvedMockedPath(path) {
   const config = getBrowserState().viteConfig;
-  if (path.startsWith(config.root))
+  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))
+  if (path.startsWith(config.root)) {
     paths.push(path.slice(config.root.length));
-  if (path.startsWith(fsRoot))
+  }
+  if (path.startsWith(fsRoot)) {
     paths.push(path.slice(fsRoot.length));
-  return paths;
-}
-function on(event, listener) {
-  window.addEventListener(event, listener);
-  return () => window.removeEventListener(event, listener);
-}
-function serializeError(unhandledError) {
-  return {
-    ...unhandledError,
-    name: unhandledError.name,
-    message: unhandledError.message,
-    stack: String(unhandledError.stack)
-  };
-}
-async function defaultErrorReport(type, unhandledError) {
-  const error = serializeError(unhandledError);
-  channel.postMessage({
-    type: "error",
-    files: getBrowserState().runningFiles,
-    error,
-    errorType: type,
-    id: getBrowserState().iframeId
-  });
-}
-function catchWindowErrors(cb) {
-  let userErrorListenerCount = 0;
-  function throwUnhandlerError(e) {
-    if (userErrorListenerCount === 0 && e.error != null)
-      cb(e);
-    else
-      console.error(e.error);
   }
-  const addEventListener = window.addEventListener.bind(window);
-  const removeEventListener = window.removeEventListener.bind(window);
-  window.addEventListener("error", throwUnhandlerError);
-  window.addEventListener = function(...args) {
-    if (args[0] === "error")
-      userErrorListenerCount++;
-    return addEventListener.apply(this, args);
-  };
-  window.removeEventListener = function(...args) {
-    if (args[0] === "error" && userErrorListenerCount)
-      userErrorListenerCount--;
-    return removeEventListener.apply(this, args);
-  };
-  return function clearErrorHandlers() {
-    window.removeEventListener("error", throwUnhandlerError);
-  };
-}
-function registerUnhandledErrors() {
-  const stopErrorHandler2 = catchWindowErrors((e) => defaultErrorReport("Error", e.error));
-  const stopRejectionHandler = on("unhandledrejection", (e) => defaultErrorReport("Unhandled Rejection", e.reason));
-  return () => {
-    stopErrorHandler2();
-    stopRejectionHandler();
-  };
-}
-function registerUnexpectedErrors(rpc2) {
-  catchWindowErrors((event) => reportUnexpectedError(rpc2, "Error", event.error));
-  on("unhandledrejection", (event) => reportUnexpectedError(rpc2, "Unhandled Rejection", event.reason));
-}
-async function reportUnexpectedError(rpc2, type, error) {
-  const { processError } = await importId("vitest/browser");
-  const processedError = processError(error);
-  await rpc2.onUnhandledError(processedError, type);
+  return paths;
 }
-const stopErrorHandler = registerUnhandledErrors();
 const url = new URL(location.href);
 const reloadStart = url.searchParams.get("__reloadStart");
 function debug(...args) {
   const debug2 = getConfig().env.VITEST_BROWSER_DEBUG;
-  if (debug2 && debug2 !== "false")
+  if (debug2 && debug2 !== "false") {
     client.rpc.debug(...args.map(String));
+  }
 }
 async function tryCall(fn) {
   try {
@@ -639,14 +720,27 @@ async function tryCall(fn) {
     const canTry = !reloadStart || now2 - Number(reloadStart) < 3e4;
     const errorStack = (() => {
       var _a;
-      if (!err)
+      if (!err) {
         return null;
+      }
       return ((_a = err.stack) == null ? void 0 : _a.includes(err.message)) ? err.stack : `${err.message}
 ${err.stack}`;
     })();
-    debug("failed to resolve runner", "trying again:", canTry, "time is", now2, "reloadStart is", reloadStart, ":\n", errorStack);
+    debug(
+      "failed to resolve runner",
+      "trying again:",
+      canTry,
+      "time is",
+      now2,
+      "reloadStart is",
+      reloadStart,
+      ":\n",
+      errorStack
+    );
     if (!canTry) {
-      const error = serializeError(new Error("Vitest failed to load its runner after 30 seconds."));
+      const error = serializeError(
+        new Error("Vitest failed to load its runner after 30 seconds.")
+      );
       error.cause = serializeError(err);
       await client.rpc.onUnhandledError(error, "Preload Error");
       return false;
@@ -662,70 +756,32 @@ ${err.stack}`;
     }
   }
 }
-const startTime = performance.now();
 async function prepareTestEnvironment(files) {
   debug("trying to resolve runner", `${reloadStart}`);
   const config = getConfig();
-  const viteClientPath = `/@vite/client`;
-  await __vitePreload(() => import(viteClientPath), true ? __vite__mapDeps([]) : void 0);
-  const rpc2 = await loadSafeRpc(client);
-  const providedContext = await client.rpc.getProvidedContext();
-  const state = {
-    ctx: {
-      pool: "browser",
-      worker: "./browser.js",
-      workerId: 1,
-      config,
-      projectName: config.name || "",
-      files,
-      environment: {
-        name: "browser",
-        options: null
-      },
-      providedContext,
-      invalidates: []
-    },
-    onCancel,
-    mockMap: /* @__PURE__ */ new Map(),
-    config,
-    environment: {
-      name: "browser",
-      transformMode: "web",
-      setup() {
-        throw new Error("Not called in the browser");
-      }
-    },
-    moduleCache: getBrowserState().moduleCache,
-    rpc: rpc2,
-    durations: {
-      environment: 0,
-      prepare: startTime
-    },
-    providedContext
-  };
-  globalThis.__vitest_browser__ = true;
-  globalThis.__vitest_worker__ = state;
+  const rpc2 = createSafeRpc(client);
+  const state = getWorkerState();
+  state.ctx.files = files;
+  state.onCancel = onCancel;
+  state.rpc = rpc2;
   const mocker = new VitestBrowserClientMocker();
   globalThis.__vitest_mocker__ = mocker;
-  await setupConsoleLogSpy();
+  setupConsoleLogSpy();
   setupDialogsSpy();
+  const runner = await initiateRunner(state, mocker, config);
   const version = url.searchParams.get("browserv") || "";
   files.forEach((filename) => {
     const currentVersion = browserHashMap.get(filename);
-    if (!currentVersion || currentVersion[1] !== version)
+    if (!currentVersion || currentVersion[1] !== version) {
       browserHashMap.set(filename, [true, version]);
+    }
   });
-  const [runner, { startTests, setupCommonEnv, SpyModule }] = await Promise.all([
-    initiateRunner(state, mocker, config),
-    importId("vitest/browser")
-  ]);
   mocker.setSpyModule(SpyModule);
   mocker.setupWorker();
   onCancel.then((reason) => {
     var _a;
     (_a = runner.onCancel) == null ? void 0 : _a.call(runner, reason);
   });
-  stopErrorHandler();
   registerUnexpectedErrors(rpc2);
   return {
     runner,
@@ -764,13 +820,14 @@ async function runTests(files) {
     return;
   }
   debug("runner resolved successfully");
-  const { config, runner, state, setupCommonEnv, startTests } = preparedData;
+  const { config, runner, state, setupCommonEnv: setupCommonEnv2, startTests: startTests2 } = preparedData;
   state.durations.prepare = performance.now() - state.durations.prepare;
   debug("prepare time", state.durations.prepare, "ms");
   try {
-    await setupCommonEnv(config);
-    for (const file of files)
-      await startTests([file], runner);
+    await setupCommonEnv2(config);
+    for (const file of files) {
+      await startTests2([file], runner);
+    }
   } finally {
     state.environmentTeardownRun = true;
     debug("finished running tests");