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

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

@@ -10,7 +10,10 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { i as importId, d as rpc$1, g as getConfig, _ as __vitePreload, b as channel, a as getBrowserState, c as client, l as loadSafeRpc, o as onCancel } from "./rpc-By4jD8av.js";
+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";
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
 function showPopupWarning(name, value, defaultValue) {
   return (...params) => {
     const formatedParams = params.map((p) => JSON.stringify(p)).join(", ");
@@ -42,14 +45,17 @@ async function setupConsoleLogSpy() {
     return format(input);
   };
   const processLog = (args) => args.map(formatInput).join(" ");
-  const sendLog = (type, content) => {
-    var _a, _b;
+  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,
@@ -78,18 +84,19 @@ async function setupConsoleLogSpy() {
     return dirxml(...args);
   };
   console$1.trace = (...args) => {
+    var _a;
     const content = processLog(args);
-    const error2 = new Error("Trace");
-    const stack = (error2.stack || "").split("\n").slice(2).join("\n");
-    sendLog("stdout", `${content}
-${stack}`);
+    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 now = performance.now();
+    const now2 = performance.now();
     time(label);
-    timeLabels[label] = now;
+    timeLabels[label] = now2;
   };
   console$1.timeLog = (label = "default") => {
     timeLog(label);
@@ -148,7 +155,7 @@ function rpc() {
   return globalThis.__vitest_worker__.rpc;
 }
 const browserHashMap = /* @__PURE__ */ new Map();
-function createBrowserRunner(runnerClass, coverageModule) {
+function createBrowserRunner(runnerClass, mocker, state, coverageModule) {
   return class BrowserTestRunner extends runnerClass {
     constructor(options) {
       super(options.config);
@@ -168,8 +175,11 @@ function createBrowserRunner(runnerClass, coverageModule) {
       });
       __publicField(this, "onAfterRunFiles", async (files) => {
         var _a, _b;
-        await ((_a = super.onAfterRunFiles) == null ? void 0 : _a.call(this, files));
-        const coverage = await ((_b = coverageModule == null ? void 0 : coverageModule.takeCoverage) == null ? void 0 : _b.call(coverageModule));
+        const [coverage] = await Promise.all([
+          (_a = coverageModule == null ? void 0 : coverageModule.takeCoverage) == null ? void 0 : _a.call(coverageModule),
+          mocker.invalidate(),
+          (_b = super.onAfterRunFiles) == null ? void 0 : _b.call(this, files)
+        ]);
         if (coverage) {
           await rpc$1().onAfterSuiteRun({
             coverage,
@@ -179,6 +189,12 @@ function createBrowserRunner(runnerClass, coverageModule) {
         }
       });
       __publicField(this, "onCollected", async (files) => {
+        files.forEach((file) => {
+          file.prepareDuration = state.durations.prepare;
+          file.environmentLoad = state.durations.environment;
+          state.durations.prepare = 0;
+          state.durations.environment = 0;
+        });
         if (this.config.includeTaskLocation) {
           try {
             await updateFilesLocations(files);
@@ -196,8 +212,7 @@ function createBrowserRunner(runnerClass, coverageModule) {
           hash = Date.now().toString();
           this.hashMap.set(filepath, [false, hash]);
         }
-        const base = this.config.base || "/";
-        const prefix = `${base}${/^\w:/.test(filepath) ? "@fs/" : ""}`;
+        const prefix = `/${/^\w:/.test(filepath) ? "@fs/" : ""}`;
         const query = `${test ? "browserv" : "v"}=${hash}`;
         const importpath = `${prefix}${filepath}?${query}`.replace(/\/+/g, "/");
         await __vitePreload(() => import(importpath), true ? __vite__mapDeps([]) : void 0);
@@ -207,10 +222,9 @@ function createBrowserRunner(runnerClass, coverageModule) {
   };
 }
 let cachedRunner = null;
-async function initiateRunner() {
+async function initiateRunner(state, mocker, config) {
   if (cachedRunner)
     return cachedRunner;
-  const config = getConfig();
   const [
     { VitestTestRunner, NodeBenchmarkRunner },
     { takeCoverageInsideWorker, loadDiffConfig, loadSnapshotSerializers }
@@ -219,7 +233,7 @@ async function initiateRunner() {
     importId("vitest/browser")
   ]);
   const runnerClass = config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-  const BrowserRunner = createBrowserRunner(runnerClass, {
+  const BrowserRunner = createBrowserRunner(runnerClass, mocker, state, {
     takeCoverage: () => takeCoverageInsideWorker(config.coverage, { executeId: importId })
   });
   if (!config.snapshotOptions.snapshotEnvironment)
@@ -258,25 +272,293 @@ async function updateFilesLocations(files) {
   });
   await Promise.all(promises);
 }
-function throwNotImplemented(name) {
-  throw new Error(`[vitest] ${name} is not implemented in browser environment yet.`);
-}
+const now = Date.now;
 class VitestBrowserClientMocker {
-  importActual() {
-    throwNotImplemented("importActual");
+  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");
+  }
+  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)
+          });
+        }
+      }
+    });
+  }
+  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(`/@id/${resolved.id}`, location.href);
+    const query = `_vitest_original&ext.${ext}`;
+    const actualUrl = `${url2.pathname}${url2.search ? `${url2.search}&${query}` : `?${query}`}${url2.hash}`;
+    return getBrowserState().wrapModule(() => __vitePreload(() => import(actualUrl), true ? __vite__mapDeps([]) : void 0));
+  }
+  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 __vitePreload(() => import(url22.toString()), true ? __vite__mapDeps([]) : void 0);
+    }
+    const url2 = new URL(`/@id/${resolvedId}`, location.href);
+    const query = url2.search ? `${url2.search}&t=${now()}` : `?t=${now()}`;
+    const moduleObject = await __vitePreload(() => import(`${url2.pathname}${query}${url2.hash}`), true ? __vite__mapDeps([]) : void 0);
+    return this.mockObject(moduleObject);
+  }
+  getMockContext() {
+    return { callstack: null };
+  }
+  get(id) {
+    return this.mockObjects[id];
+  }
+  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 }) => {
+      this.ids.add(resolvedId);
+      const urlPaths = resolveMockPaths(resolvedId);
+      const resolvedMock = typeof mockPath === "string" ? new URL(resolvedMockedPath(mockPath), location.href).toString() : mockPath;
+      urlPaths.forEach((url2) => {
+        this.mocks[url2] = resolvedMock;
+        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(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);
   }
-  importMock() {
-    throwNotImplemented("importMock");
+  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 (error) {
+          }
+          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 isFunction = type.includes("Function") && typeof value === "function";
+        if ((!isFunction || value.__isMockFunction) && type !== "Object" && type !== "Module") {
+          define(newContainer, property, value);
+          continue;
+        }
+        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)
+                  continue;
+                const value2 = this[key];
+                const type2 = /* @__PURE__ */ getType(value2);
+                const isFunction2 = type2.includes("Function") && typeof value2 === "function";
+                if (isFunction2) {
+                  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());
   }
-  queueMock() {
-    throwNotImplemented("queueMock");
+  getId(value) {
+    return this.idMap.get(value);
   }
-  queueUnmock() {
-    throwNotImplemented("queueUnmock");
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
   }
-  prepare() {
+  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;
+}
 function on(event, listener) {
   window.addEventListener(event, listener);
   return () => window.removeEventListener(event, listener);
@@ -291,7 +573,13 @@ function serializeError(unhandledError) {
 }
 async function defaultErrorReport(type, unhandledError) {
   const error = serializeError(unhandledError);
-  channel.postMessage({ type: "error", files: getBrowserState().runningFiles, error, errorType: type });
+  channel.postMessage({
+    type: "error",
+    files: getBrowserState().runningFiles,
+    error,
+    errorType: type,
+    id: getBrowserState().iframeId
+  });
 }
 function catchWindowErrors(cb) {
   let userErrorListenerCount = 0;
@@ -347,9 +635,16 @@ async function tryCall(fn) {
   try {
     return await fn();
   } catch (err) {
-    const now = Date.now();
-    const canTry = !reloadStart || now - Number(reloadStart) < 3e4;
-    debug("failed to resolve runner", err == null ? void 0 : err.message, "trying again:", canTry, "time is", now, "reloadStart is", reloadStart);
+    const now2 = Date.now();
+    const canTry = !reloadStart || now2 - Number(reloadStart) < 3e4;
+    const errorStack = (() => {
+      var _a;
+      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);
     if (!canTry) {
       const error = serializeError(new Error("Vitest failed to load its runner after 30 seconds."));
       error.cause = serializeError(err);
@@ -358,7 +653,7 @@ async function tryCall(fn) {
     }
     if (!reloadStart) {
       const newUrl = new URL(location.href);
-      newUrl.searchParams.set("__reloadStart", now.toString());
+      newUrl.searchParams.set("__reloadStart", now2.toString());
       debug("set the new url because reload start is not set to", newUrl);
       location.href = newUrl.toString();
     } else {
@@ -367,14 +662,13 @@ async function tryCall(fn) {
     }
   }
 }
+const startTime = performance.now();
 async function prepareTestEnvironment(files) {
   debug("trying to resolve runner", `${reloadStart}`);
   const config = getConfig();
-  const viteClientPath = `${config.base || "/"}@vite/client`;
+  const viteClientPath = `/@vite/client`;
   await __vitePreload(() => import(viteClientPath), true ? __vite__mapDeps([]) : void 0);
   const rpc2 = await loadSafeRpc(client);
-  stopErrorHandler();
-  registerUnexpectedErrors(rpc2);
   const providedContext = await client.rpc.getProvidedContext();
   const state = {
     ctx: {
@@ -382,7 +676,7 @@ async function prepareTestEnvironment(files) {
       worker: "./browser.js",
       workerId: 1,
       config,
-      projectName: config.name,
+      projectName: config.name || "",
       files,
       environment: {
         name: "browser",
@@ -405,27 +699,34 @@ async function prepareTestEnvironment(files) {
     rpc: rpc2,
     durations: {
       environment: 0,
-      prepare: 0
+      prepare: startTime
     },
     providedContext
   };
   globalThis.__vitest_browser__ = true;
   globalThis.__vitest_worker__ = state;
-  globalThis.__vitest_mocker__ = new VitestBrowserClientMocker();
+  const mocker = new VitestBrowserClientMocker();
+  globalThis.__vitest_mocker__ = mocker;
   await setupConsoleLogSpy();
   setupDialogsSpy();
-  const { startTests, setupCommonEnv } = await importId("vitest/browser");
-  const version = url.searchParams.get("browserv") || "0";
+  const version = url.searchParams.get("browserv") || "";
   files.forEach((filename) => {
     const currentVersion = browserHashMap.get(filename);
     if (!currentVersion || currentVersion[1] !== version)
       browserHashMap.set(filename, [true, version]);
   });
-  const runner = await initiateRunner();
+  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,
     config,
@@ -435,7 +736,11 @@ async function prepareTestEnvironment(files) {
   };
 }
 function done(files) {
-  channel.postMessage({ type: "done", filenames: files });
+  channel.postMessage({
+    type: "done",
+    filenames: files,
+    id: getBrowserState().iframeId
+  });
 }
 async function runTests(files) {
   await client.waitForConnection();
@@ -460,6 +765,8 @@ async function runTests(files) {
   }
   debug("runner resolved successfully");
   const { config, runner, state, setupCommonEnv, startTests } = 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)

package/dist/client/esm-client-injector.js

@@ -1,42 +1,28 @@
 const moduleCache = new Map()
 
 function wrapModule(module) {
-  if (module instanceof Promise) {
-    moduleCache.set(module, { promise: module, evaluated: false })
-    return module
-      .then(m => '__vi_inject__' in m ? m.__vi_inject__ : m)
-      .finally(() => moduleCache.delete(module))
-  }
-  return '__vi_inject__' in module ? module.__vi_inject__ : module
-}
-
-function exportAll(exports, sourceModule) {
-  if (exports === sourceModule)
-    return
-
-  if (Object(sourceModule) !== sourceModule || Array.isArray(sourceModule))
-    return
-
-  for (const key in sourceModule) {
-    if (key !== 'default') {
-      try {
-        Object.defineProperty(exports, key, {
-          enumerable: true,
-          configurable: true,
-          get: () => sourceModule[key],
-        })
-      }
-      catch (_err) { }
-    }
+  if (typeof module === 'function') {
+    const promise = new Promise((resolve, reject) => {
+      if (typeof __vitest_mocker__ === 'undefined')
+        return module().then(resolve, reject)
+      __vitest_mocker__.prepare().finally(() => {
+        module().then(resolve, reject)
+      })
+    })
+    moduleCache.set(promise, { promise, evaluated: false })
+    return promise.finally(() => moduleCache.delete(promise))
   }
+  return module
 }
 
 window.__vitest_browser_runner__ = {
-  exportAll,
   wrapModule,
   moduleCache,
   config: { __VITEST_CONFIG__ },
+  viteConfig: { __VITEST_VITE_CONFIG__ },
   files: { __VITEST_FILES__ },
+  type: { __VITEST_TYPE__ },
+  contextId: { __VITEST_CONTEXT_ID__ },
 }
 
 const config = __vitest_browser_runner__.config

package/dist/client/{index.html → orchestrator.html}

@@ -15,19 +15,20 @@
         padding: 0;
         margin: 0;
       }
-      #vitest-ui {
-        width: 100vw;
-        height: 100vh;
-        border: none;
+      html,
+      body,
+      iframe[data-vitest],
+      #vitest-tester {
+        width: 100%;
+        height: 100%;
       }
     </style>
     <script>{__VITEST_INJECTOR__}</script>
     {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/main-DmAU-Uff.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-By4jD8av.js">
+    <script type="module" crossorigin src="/__vitest_browser__/orchestrator-BCpOi5ot.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-CImfI7bO.js">
   </head>
   <body>
-    <iframe id="vitest-ui" src=""></iframe>
     <div id="vitest-tester"></div>
   </body>
 </html>

package/dist/client/tester.html

@@ -13,14 +13,15 @@
       body {
         padding: 0;
         margin: 0;
+        min-height: 100vh;
       }
     </style>
     <script>{__VITEST_INJECTOR__}</script>
     {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/tester-CrKhlp5g.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-By4jD8av.js">
+    <script type="module" crossorigin src="/__vitest_browser__/tester-e70VCOgC.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-CImfI7bO.js">
   </head>
-  <body>
+  <body style="width: 100%; height: 100%; transform: scale(1); transform-origin: left top;">
     {__VITEST_APPEND__}
   </body>
 </html>