vitest 0.17.1 → 0.19.0

package/dist/{chunk-vite-node-externalize.0fc8ed68.mjs → chunk-vite-node-externalize.a2813ad7.mjs}

@@ -1,32 +1,30 @@
-import { p as pLimit, c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage, e as envPackageNames } from './chunk-env-node.aa51c4cc.mjs';
-import { j as join, o as basename, d as dirname, q as resolve, A as AggregateErrorPonyfill, p as picocolors, s as slash$2, t as isAbsolute, u as relative, v as isNode, x as getTests, e as getFullName, y as hasFailed, z as hasFailedSnapshot, B as getSuites, C as safeSetInterval, D as safeClearInterval, f as safeSetTimeout, E as shuffle, F as toArray$1, G as normalize, n as noop$1, h as safeClearTimeout, H as deepMerge, I as toNamespacedPath, g as getCallLastIndex, l as notNullish, J as ensurePackageInstalled, K as stdout } from './chunk-utils-global.4828c2e2.mjs';
+import { j as join, D as basename, d as dirname, C as resolve, E as AggregateErrorPonyfill, p as picocolors, F as isAbsolute, G as relative, c as slash$2, t as isNode, v as relativePath, H as getTests, h as getFullName, B as hasFailed, I as hasFailedSnapshot, J as safeSetInterval, K as safeClearInterval, L as getSuites, s as safeSetTimeout, z as shuffle, u as toArray$1, M as normalize, n as noop$1, k as safeClearTimeout, N as deepMerge, O as toNamespacedPath, b as getCallLastIndex, l as notNullish, P as ensurePackageInstalled, Q as stdout } from './chunk-utils-global.2aa95025.mjs';
+import { p as pLimit, c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage, d as envPackageNames } from './chunk-defaults.408a0cfe.mjs';
 import { loadConfigFromFile, createServer, mergeConfig } from 'vite';
 import path$a from 'path';
-import url, { fileURLToPath, pathToFileURL } from 'url';
+import _url, { fileURLToPath } from 'url';
 import process$1 from 'process';
 import fs$8, { promises, existsSync, readFileSync } from 'fs';
-import { d as distDir, c as configFiles, a as defaultPort } from './chunk-constants.27550afb.mjs';
-import readline from 'readline';
-import require$$0, { cpus, hostname, constants as constants$5 } from 'os';
-import require$$0$1 from 'util';
-import require$$0$2 from 'stream';
+import { d as distDir, c as configFiles, a as defaultPort } from './chunk-constants.38b43a44.mjs';
+import require$$0, { cpus, hostname } from 'os';
+import util$2 from 'util';
+import require$$0$1 from 'stream';
 import require$$2 from 'events';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.0f776286.mjs';
+import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.ad73f2ab.mjs';
 import createDebug from 'debug';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
 import { performance } from 'perf_hooks';
-import { c as stripAnsi, d as stringWidth, e as ansiStyles, h as sliceAnsi, i as cliTruncate, b as parseStacktrace, j as interpretSourcePos, s as stringify$5, u as unifiedDiff, a as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.a9047343.mjs';
-import { o as onetime$1, s as signalExit, m as mergeStream, g as getStream, c as crossSpawn } from './vendor-index.a2a385d8.mjs';
+import { c as stripAnsi, d as cliTruncate, p as parseStacktrace, e as stringWidth, h as ansiStyles, i as sliceAnsi, j as interpretSourcePos, s as stringify$5, u as unifiedDiff, b as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.8b066ce2.mjs';
 import { resolveModule } from 'local-pkg';
 import { createHash } from 'crypto';
-import { Buffer } from 'buffer';
-import childProcess from 'child_process';
+import { o as onetime, s as signalExit } from './vendor-index.61438b77.mjs';
 import MagicString from './chunk-magic-string.efe26975.mjs';
-import { p as prompts } from './vendor-index.98e769c1.mjs';
+import require$$0$2 from 'readline';
+import { p as prompts } from './vendor-index.de788b6a.mjs';
 
-var version = "0.17.1";
+var version$1 = "0.19.0";
 
 class EndError extends Error {
 	constructor(value) {
@@ -935,7 +933,7 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$1 = require$$0$1;
+const util$1 = util$2;
 const toRegexRange = toRegexRange_1;
 
 const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -3972,7 +3970,7 @@ var picomatch_1 = picomatch$1;
 	module.exports = picomatch_1;
 } (picomatch$2));
 
-const util = require$$0$1;
+const util = util$2;
 const braces = braces_1;
 const picomatch = picomatch$2.exports;
 const utils$b = utils$f;
@@ -4616,7 +4614,7 @@ var stream$4 = {};
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0$2;
+const Stream = require$$0$1;
 const PassThrough = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -5900,7 +5898,7 @@ function callSuccessCallback(callback, entries) {
 var stream$1 = {};
 
 Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$5 = require$$0$2;
+const stream_1$5 = require$$0$1;
 const async_1$2 = async$2;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -6108,7 +6106,7 @@ class Reader {
 reader.default = Reader;
 
 Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$3 = require$$0$2;
+const stream_1$3 = require$$0$1;
 const fsStat$1 = out$3;
 const fsWalk$1 = out$2;
 const reader_1$1 = reader;
@@ -6506,7 +6504,7 @@ async$6.default = ProviderAsync;
 var stream = {};
 
 Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$2;
+const stream_1$1 = require$$0$1;
 const stream_2 = stream$2;
 const provider_1$1 = provider;
 class ProviderStream extends provider_1$1.default {
@@ -6736,10 +6734,10 @@ function assertPatternsInput(input) {
 var out = FastGlob;
 
 const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
-const ESM_FOLDER_RE = /\/esm\/(.*\.js)$/;
+const ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/;
 const defaultInline = [
   /virtual:/,
-  /\.ts$/
+  /\.[mc]?ts$/
 ];
 const depsExternal = [
   /\.cjs\.js$/,
@@ -6761,6 +6759,7 @@ function guessCJSversion(id) {
     for (const i of [
       id.replace(ESM_FOLDER_RE, "/umd/$1"),
       id.replace(ESM_FOLDER_RE, "/cjs/$1"),
+      id.replace(ESM_FOLDER_RE, "/lib/$1"),
       id.replace(ESM_FOLDER_RE, "/$1")
     ]) {
       if (existsSync(i))
@@ -6979,7 +6978,7 @@ function addSnapshotResult(summary, result) {
   summary.total += result.added + result.matched + result.unmatched + result.updated;
 }
 
-const workerPath = pathToFileURL(resolve(distDir, "./worker.mjs")).href;
+const workerPath = _url.pathToFileURL(resolve(distDir, "./worker.mjs")).href;
 function createPool(ctx) {
   var _a;
   const threadsCount = ctx.config.watch ? Math.max(Math.floor(cpus().length / 2), 1) : Math.max(cpus().length - 1, 1);
@@ -7014,6 +7013,7 @@ function createPool(ctx) {
   const runWithFiles = (name) => {
     let id = 0;
     async function runFiles(config, files, invalidates = []) {
+      ctx.state.clearFiles(files);
       const { workerPort, port } = createChannel(ctx);
       const workerId = ++id;
       const data = {
@@ -7082,6 +7082,10 @@ function createChannel(ctx) {
     resolveId(id, importer) {
       return ctx.vitenode.resolveId(id, importer);
     },
+    onPathsCollected(paths) {
+      ctx.state.collectPaths(paths);
+      ctx.report("onPathsCollected", paths);
+    },
     onCollected(files) {
       ctx.state.collectFiles(files);
       ctx.report("onCollected", files);
@@ -7267,51 +7271,39 @@ ${picocolors.exports.bold(picocolors.exports.inverse(picocolors.exports.green("
 const WAIT_FOR_CHANGE_FAIL = `
 ${picocolors.exports.bold(picocolors.exports.inverse(picocolors.exports.red(" FAIL ")))}${picocolors.exports.red(" Tests failed. Watching for file changes...")}`;
 const DURATION_LONG$1 = 300;
+const LAST_RUN_LOG_TIMEOUT = 1500;
 class BaseReporter {
   constructor() {
     this.start = 0;
     this.end = 0;
     this.isTTY = isNode && ((_a = process.stdout) == null ? void 0 : _a.isTTY) && !process.env.CI;
     this.ctx = void 0;
+    this._filesInWatchMode = /* @__PURE__ */ new Map();
+    this._lastRunTimeout = 0;
+    this._lastRunCount = 0;
     this.registerUnhandledRejection();
   }
   onInit(ctx) {
-    var _a2, _b;
     this.ctx = ctx;
-    this.ctx.log();
-    const versionTest = this.ctx.config.watch ? picocolors.exports.blue(`v${version}`) : picocolors.exports.cyan(`v${version}`);
-    const mode = this.ctx.config.watch ? picocolors.exports.blue(" DEV ") : picocolors.exports.cyan(" RUN ");
-    this.ctx.log(`${picocolors.exports.inverse(picocolors.exports.bold(mode))} ${versionTest} ${picocolors.exports.gray(this.ctx.config.root)}`);
-    if (this.ctx.config.ui)
-      this.ctx.log(picocolors.exports.dim(picocolors.exports.green(`      UI started at http://${((_a2 = this.ctx.config.api) == null ? void 0 : _a2.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.server.config.server.port}`)}${this.ctx.config.uiBase}`)));
-    else if (this.ctx.config.api)
-      this.ctx.log(picocolors.exports.dim(picocolors.exports.green(`      API started at http://${((_b = this.ctx.config.api) == null ? void 0 : _b.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.config.api.port}`)}`)));
-    this.ctx.log();
+    ctx.logger.printBanner();
     this.start = performance.now();
   }
   relative(path) {
-    return relative(this.ctx.config.root, path);
+    return relativePath(this.ctx.config.root, path);
   }
   async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
     this.end = performance.now();
     await this.reportSummary(files);
     if (errors.length) {
       process.exitCode = 1;
-      const errorMessage = picocolors.exports.red(picocolors.exports.bold(`
-Vitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run. This might cause false positive tests.
-Please, resolve all the errors to make sure your tests are not affected.`));
-      this.ctx.log(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(" Unhandled Errors ")))));
-      this.ctx.log(errorMessage);
-      await Promise.all(errors.map(async (err) => {
-        await this.ctx.printError(err, true, err.type || "Unhandled Error");
-      }));
-      this.ctx.log(picocolors.exports.red(divider()));
+      this.ctx.logger.printUnhandledErrors(errors);
     }
   }
   onTaskUpdate(packs) {
     var _a2, _b, _c;
     if (this.isTTY)
       return;
+    const logger = this.ctx.logger;
     for (const pack of packs) {
       const task = this.ctx.state.idMap.get(pack[0]);
       if (task && "filepath" in task && ((_a2 = task.result) == null ? void 0 : _a2.state) && ((_b = task.result) == null ? void 0 : _b.state) !== "run") {
@@ -7333,43 +7325,81 @@ Please, resolve all the errors to make sure your tests are not affected.`));
         }
         if (this.ctx.config.logHeapUsage && task.result.heap != null)
           suffix += picocolors.exports.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
-        this.ctx.log(` ${getStateSymbol(task)} ${task.name} ${suffix}`);
+        logger.log(` ${getStateSymbol(task)} ${task.name} ${suffix}`);
         for (const test of failed) {
-          this.ctx.log(picocolors.exports.red(`   ${pointer} ${getFullName(test)}`));
-          this.ctx.log(picocolors.exports.red(`     ${F_RIGHT} ${(_c = test.result.error) == null ? void 0 : _c.message}`));
+          logger.log(picocolors.exports.red(`   ${pointer} ${getFullName(test)}`));
+          logger.log(picocolors.exports.red(`     ${F_RIGHT} ${(_c = test.result.error) == null ? void 0 : _c.message}`));
         }
       }
     }
   }
   async onWatcherStart() {
+    this.resetLastRunLog();
     const files = this.ctx.state.getFiles();
     const errors = this.ctx.state.getUnhandledErrors();
     const failed = errors.length > 0 || hasFailed(files);
     const failedSnap = hasFailedSnapshot(files);
     if (failed)
-      this.ctx.log(WAIT_FOR_CHANGE_FAIL);
+      this.ctx.logger.log(WAIT_FOR_CHANGE_FAIL);
     else
-      this.ctx.log(WAIT_FOR_CHANGE_PASS);
+      this.ctx.logger.log(WAIT_FOR_CHANGE_PASS);
     const hints = [HELP_HINT];
     if (failedSnap)
       hints.unshift(HELP_UPDATE_SNAP);
     else
       hints.push(HELP_QUITE);
-    this.ctx.log(BADGE_PADDING + hints.join(picocolors.exports.dim(", ")));
+    this.ctx.logger.log(BADGE_PADDING + hints.join(picocolors.exports.dim(", ")));
+    if (this._lastRunCount) {
+      const LAST_RUN_TEXT = `rerun x${this._lastRunCount}`;
+      const LAST_RUN_TEXTS = [
+        picocolors.exports.blue(LAST_RUN_TEXT),
+        picocolors.exports.gray(LAST_RUN_TEXT),
+        picocolors.exports.dim(picocolors.exports.gray(LAST_RUN_TEXT))
+      ];
+      this.ctx.logger.logUpdate(BADGE_PADDING + LAST_RUN_TEXTS[0]);
+      this._lastRunTimeout = 0;
+      this._lastRunTimer = safeSetInterval(() => {
+        this._lastRunTimeout += 1;
+        if (this._lastRunTimeout >= LAST_RUN_TEXTS.length)
+          this.resetLastRunLog();
+        else
+          this.ctx.logger.logUpdate(BADGE_PADDING + LAST_RUN_TEXTS[this._lastRunTimeout]);
+      }, LAST_RUN_LOG_TIMEOUT / LAST_RUN_TEXTS.length);
+    }
+  }
+  resetLastRunLog() {
+    safeClearInterval(this._lastRunTimer);
+    this._lastRunTimer = void 0;
+    this.ctx.logger.logUpdate.clear();
   }
   async onWatcherRerun(files, trigger) {
+    this.resetLastRunLog();
     this.watchFilters = files;
-    this.ctx.clearScreen();
-    this.ctx.log(`
-${picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" RERUN ")))}${trigger ? picocolors.exports.dim(` ${this.relative(trigger)}
-`) : ""}`);
+    files.forEach((filepath) => {
+      let reruns = this._filesInWatchMode.get(filepath) ?? 0;
+      this._filesInWatchMode.set(filepath, ++reruns);
+    });
+    const BADGE = picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" RERUN ")));
+    const TRIGGER = trigger ? picocolors.exports.dim(` ${this.relative(trigger)}`) : "";
+    if (files.length > 1) {
+      this.ctx.logger.clearScreen(`
+${BADGE}${TRIGGER}
+`, true);
+      this._lastRunCount = 0;
+    } else if (files.length === 1) {
+      const rerun = this._filesInWatchMode.get(files[0]) ?? 1;
+      this._lastRunCount = rerun;
+      this.ctx.logger.clearScreen(`
+${BADGE}${TRIGGER} ${picocolors.exports.blue(`x${rerun}`)}
+`);
+    }
     this.start = performance.now();
   }
   onUserConsoleLog(log) {
     if (!this.shouldLog(log))
       return;
     const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0;
-    this.ctx.log(picocolors.exports.gray(log.type + picocolors.exports.dim(` | ${task ? getFullName(task) : "unknown test"}`)));
+    this.ctx.logger.log(picocolors.exports.gray(log.type + picocolors.exports.dim(` | ${task ? getFullName(task) : "unknown test"}`)));
     process[log.type].write(`${log.content}
 `);
   }
@@ -7383,9 +7413,10 @@ ${picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" R
     return true;
   }
   onServerRestart() {
-    this.ctx.log(picocolors.exports.cyan("Restarted due to config changes..."));
+    this.ctx.logger.log(picocolors.exports.cyan("Restarted due to config changes..."));
   }
   async reportSummary(files) {
+    const logger = this.ctx.logger;
     const suites = getSuites(files);
     const tests = getTests(files);
     const failedSuites = suites.filter((i) => {
@@ -7398,16 +7429,16 @@ ${picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" R
     });
     const failedTotal = failedSuites.length + failedTests.length;
     let current = 1;
-    const errorDivider = () => this.ctx.error(`${picocolors.exports.red(picocolors.exports.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
+    const errorDivider = () => logger.error(`${picocolors.exports.red(picocolors.exports.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
 `);
     if (failedSuites.length) {
-      this.ctx.error(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(` Failed Suites ${failedSuites.length} `)))));
-      this.ctx.error();
+      logger.error(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(` Failed Suites ${failedSuites.length} `)))));
+      logger.error();
       await this.printTaskErrors(failedSuites, errorDivider);
     }
     if (failedTests.length) {
-      this.ctx.error(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(` Failed Tests ${failedTests.length} `)))));
-      this.ctx.error();
+      logger.error(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(` Failed Tests ${failedTests.length} `)))));
+      logger.error();
       await this.printTaskErrors(failedTests, errorDivider);
     }
     const executionTime = this.end - this.start;
@@ -7423,17 +7454,17 @@ ${picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" R
     };
     const snapshotOutput = renderSnapshotSummary(this.ctx.config.root, this.ctx.snapshot.summary);
     if (snapshotOutput.length) {
-      this.ctx.log(snapshotOutput.map((t, i) => i === 0 ? `${padTitle("Snapshots")} ${t}` : `${padTitle("")} ${t}`).join("\n"));
+      logger.log(snapshotOutput.map((t, i) => i === 0 ? `${padTitle("Snapshots")} ${t}` : `${padTitle("")} ${t}`).join("\n"));
       if (snapshotOutput.length > 1)
-        this.ctx.log();
+        logger.log();
     }
-    this.ctx.log(padTitle("Test Files"), getStateString(files));
-    this.ctx.log(padTitle("Tests"), getStateString(tests));
+    logger.log(padTitle("Test Files"), getStateString(files));
+    logger.log(padTitle("Tests"), getStateString(tests));
     if (this.watchFilters)
-      this.ctx.log(padTitle("Time"), time(threadTime));
+      logger.log(padTitle("Time"), time(threadTime));
     else
-      this.ctx.log(padTitle("Time"), time(executionTime) + picocolors.exports.gray(` (in thread ${time(threadTime)}, ${(executionTime / threadTime * 100).toFixed(2)}%)`));
-    this.ctx.log();
+      logger.log(padTitle("Time"), time(executionTime) + picocolors.exports.gray(` (in thread ${time(threadTime)}, ${(executionTime / threadTime * 100).toFixed(2)}%)`));
+    logger.log();
   }
   async printTaskErrors(tasks, errorDivider) {
     var _a2;
@@ -7455,9 +7486,9 @@ ${picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" R
         let name = getFullName(task);
         if (filepath)
           name = `${name} ${picocolors.exports.dim(`[ ${this.relative(filepath)} ]`)}`;
-        this.ctx.error(`${picocolors.exports.red(picocolors.exports.bold(picocolors.exports.inverse(" FAIL ")))} ${name}`);
+        this.ctx.logger.error(`${picocolors.exports.red(picocolors.exports.bold(picocolors.exports.inverse(" FAIL ")))} ${name}`);
       }
-      await this.ctx.printError(error);
+      await this.ctx.logger.printError(error);
       errorDivider();
       await Promise.resolve();
     }
@@ -7465,746 +7496,257 @@ ${picocolors.exports.inverse(picocolors.exports.bold(picocolors.exports.blue(" R
   registerUnhandledRejection() {
     process.on("unhandledRejection", async (err) => {
       process.exitCode = 1;
-      await this.ctx.printError(err, true, "Unhandled Rejection");
-      this.ctx.error("\n\n");
+      await this.ctx.logger.printError(err, true, "Unhandled Rejection");
+      this.ctx.logger.error("\n\n");
       process.exit(1);
     });
   }
 }
 
-const ESC = '\u001B[';
-const OSC = '\u001B]';
-const BEL = '\u0007';
-const SEP = ';';
-const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
+const DURATION_LONG = 300;
+const outputMap = /* @__PURE__ */ new WeakMap();
+function formatFilepath(path) {
+  const lastSlash = Math.max(path.lastIndexOf("/") + 1, 0);
+  const basename = path.slice(lastSlash);
+  let firstDot = basename.indexOf(".");
+  if (firstDot < 0)
+    firstDot = basename.length;
+  firstDot += lastSlash;
+  return picocolors.exports.dim(path.slice(0, lastSlash)) + path.slice(lastSlash, firstDot) + picocolors.exports.dim(path.slice(firstDot));
+}
+function renderHookState(task, hookName, level = 0) {
+  var _a, _b;
+  const state = (_b = (_a = task.result) == null ? void 0 : _a.hooks) == null ? void 0 : _b[hookName];
+  if (state && state === "run")
+    return `${"  ".repeat(level)} ${getHookStateSymbol(task, hookName)} ${picocolors.exports.dim(`[ ${hookName} ]`)}`;
+  return "";
+}
+function renderTree(tasks, options, level = 0) {
+  var _a, _b, _c, _d, _e;
+  let output = [];
+  for (const task of tasks) {
+    let suffix = "";
+    const prefix = ` ${getStateSymbol(task)} `;
+    if (task.type === "suite")
+      suffix += picocolors.exports.dim(` (${getTests(task).length})`);
+    if (task.mode === "skip" || task.mode === "todo")
+      suffix += ` ${picocolors.exports.dim(picocolors.exports.gray("[skipped]"))}`;
+    if (((_a = task.result) == null ? void 0 : _a.duration) != null) {
+      if (task.result.duration > DURATION_LONG)
+        suffix += picocolors.exports.yellow(` ${Math.round(task.result.duration)}${picocolors.exports.dim("ms")}`);
+    }
+    if (options.showHeap && ((_b = task.result) == null ? void 0 : _b.heap) != null)
+      suffix += picocolors.exports.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
+    let name = task.name;
+    if (level === 0)
+      name = formatFilepath(name);
+    output.push("  ".repeat(level) + prefix + name + suffix);
+    if (((_c = task.result) == null ? void 0 : _c.state) !== "pass" && outputMap.get(task) != null) {
+      let data = outputMap.get(task);
+      if (typeof data === "string") {
+        data = stripAnsi(data.trim().split("\n").filter(Boolean).pop());
+        if (data === "")
+          data = void 0;
+      }
+      if (data != null) {
+        const out = `${"  ".repeat(level)}${F_RIGHT} ${data}`;
+        output.push(`   ${picocolors.exports.gray(cliTruncate(out, getCols(-3)))}`);
+      }
+    }
+    output = output.concat(renderHookState(task, "beforeAll", level + 1));
+    output = output.concat(renderHookState(task, "beforeEach", level + 1));
+    if (task.type === "suite" && task.tasks.length > 0) {
+      if (((_d = task.result) == null ? void 0 : _d.state) === "fail" || ((_e = task.result) == null ? void 0 : _e.state) === "run" || options.renderSucceed)
+        output = output.concat(renderTree(task.tasks, options, level + 1));
+    }
+    output = output.concat(renderHookState(task, "afterAll", level + 1));
+    output = output.concat(renderHookState(task, "afterEach", level + 1));
+  }
+  return output.filter(Boolean).join("\n");
+}
+const createListRenderer = (_tasks, options) => {
+  let tasks = _tasks;
+  let timer;
+  const log = options.logger.logUpdate;
+  function update() {
+    log(renderTree(tasks, options));
+  }
+  return {
+    start() {
+      if (timer)
+        return this;
+      timer = safeSetInterval(update, 200);
+      return this;
+    },
+    update(_tasks2) {
+      tasks = _tasks2;
+      update();
+      return this;
+    },
+    async stop() {
+      if (timer) {
+        safeClearInterval(timer);
+        timer = void 0;
+      }
+      log.clear();
+      options.logger.log(renderTree(tasks, options));
+      return this;
+    },
+    clear() {
+      log.clear();
+    }
+  };
+};
 
-const ansiEscapes = {};
+class DefaultReporter extends BaseReporter {
+  constructor() {
+    super(...arguments);
+    this.rendererOptions = {};
+  }
+  async onTestRemoved(trigger) {
+    await this.stopListRender();
+    this.ctx.logger.clearScreen(picocolors.exports.yellow("Test removed...") + (trigger ? picocolors.exports.dim(` [ ${this.relative(trigger)} ]
+`) : ""), true);
+    const files = this.ctx.state.getFiles(this.watchFilters);
+    createListRenderer(files, this.rendererOptions).stop();
+    this.ctx.logger.log();
+    await super.reportSummary(files);
+    super.onWatcherStart();
+  }
+  onCollected() {
+    if (this.isTTY) {
+      this.rendererOptions.logger = this.ctx.logger;
+      this.rendererOptions.showHeap = this.ctx.config.logHeapUsage;
+      const files = this.ctx.state.getFiles(this.watchFilters);
+      if (!this.renderer)
+        this.renderer = createListRenderer(files, this.rendererOptions).start();
+      else
+        this.renderer.update(files);
+    }
+  }
+  async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
+    await this.stopListRender();
+    this.ctx.logger.log();
+    await super.onFinished(files, errors);
+  }
+  async onWatcherStart() {
+    await this.stopListRender();
+    await super.onWatcherStart();
+  }
+  async stopListRender() {
+    var _a;
+    await ((_a = this.renderer) == null ? void 0 : _a.stop());
+    this.renderer = void 0;
+  }
+  async onWatcherRerun(files, trigger) {
+    await this.stopListRender();
+    await super.onWatcherRerun(files, trigger);
+  }
+  onUserConsoleLog(log) {
+    var _a;
+    if (!this.shouldLog(log))
+      return;
+    (_a = this.renderer) == null ? void 0 : _a.clear();
+    super.onUserConsoleLog(log);
+  }
+}
 
-ansiEscapes.cursorTo = (x, y) => {
-	if (typeof x !== 'number') {
-		throw new TypeError('The `x` argument is required');
-	}
+const check = picocolors.exports.green("\xB7");
+const cross = picocolors.exports.red("x");
+const pending = picocolors.exports.yellow("*");
+const skip = picocolors.exports.dim(picocolors.exports.gray("-"));
+function render(tasks) {
+  const all = getTests(tasks);
+  return all.map((i) => {
+    var _a;
+    if (i.mode === "skip" || i.mode === "todo")
+      return skip;
+    switch ((_a = i.result) == null ? void 0 : _a.state) {
+      case "pass":
+        return check;
+      case "fail":
+        return cross;
+      default:
+        return pending;
+    }
+  }).join("");
+}
+const createDotRenderer = (_tasks, options) => {
+  let tasks = _tasks;
+  let timer;
+  const log = options.logger.logUpdate;
+  function update() {
+    log(render(tasks));
+  }
+  return {
+    start() {
+      if (timer)
+        return this;
+      timer = safeSetInterval(update, 200);
+      return this;
+    },
+    update(_tasks2) {
+      tasks = _tasks2;
+      update();
+      return this;
+    },
+    async stop() {
+      if (timer) {
+        safeClearInterval(timer);
+        timer = void 0;
+      }
+      log.clear();
+      options.logger.log(render(tasks));
+      return this;
+    },
+    clear() {
+      log.clear();
+    }
+  };
+};
 
-	if (typeof y !== 'number') {
-		return ESC + (x + 1) + 'G';
-	}
+class DotReporter extends BaseReporter {
+  onCollected() {
+    if (this.isTTY) {
+      const files = this.ctx.state.getFiles(this.watchFilters);
+      if (!this.renderer)
+        this.renderer = createDotRenderer(files, { logger: this.ctx.logger }).start();
+      else
+        this.renderer.update(files);
+    }
+  }
+  async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
+    await this.stopListRender();
+    this.ctx.logger.log();
+    await super.onFinished(files, errors);
+  }
+  async onWatcherStart() {
+    await this.stopListRender();
+    super.onWatcherStart();
+  }
+  async stopListRender() {
+    var _a;
+    (_a = this.renderer) == null ? void 0 : _a.stop();
+    this.renderer = void 0;
+    await new Promise((resolve) => safeSetTimeout(resolve, 10));
+  }
+  async onWatcherRerun(files, trigger) {
+    await this.stopListRender();
+    await super.onWatcherRerun(files, trigger);
+  }
+  onUserConsoleLog(log) {
+    var _a;
+    (_a = this.renderer) == null ? void 0 : _a.clear();
+    super.onUserConsoleLog(log);
+  }
+}
 
-	return ESC + (y + 1) + ';' + (x + 1) + 'H';
-};
-
-ansiEscapes.cursorMove = (x, y) => {
-	if (typeof x !== 'number') {
-		throw new TypeError('The `x` argument is required');
-	}
-
-	let returnValue = '';
-
-	if (x < 0) {
-		returnValue += ESC + (-x) + 'D';
-	} else if (x > 0) {
-		returnValue += ESC + x + 'C';
-	}
-
-	if (y < 0) {
-		returnValue += ESC + (-y) + 'A';
-	} else if (y > 0) {
-		returnValue += ESC + y + 'B';
-	}
-
-	return returnValue;
-};
-
-ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
-ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
-ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
-ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
-
-ansiEscapes.cursorLeft = ESC + 'G';
-ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
-ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
-ansiEscapes.cursorGetPosition = ESC + '6n';
-ansiEscapes.cursorNextLine = ESC + 'E';
-ansiEscapes.cursorPrevLine = ESC + 'F';
-ansiEscapes.cursorHide = ESC + '?25l';
-ansiEscapes.cursorShow = ESC + '?25h';
-
-ansiEscapes.eraseLines = count => {
-	let clear = '';
-
-	for (let i = 0; i < count; i++) {
-		clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
-	}
-
-	if (count) {
-		clear += ansiEscapes.cursorLeft;
-	}
-
-	return clear;
-};
-
-ansiEscapes.eraseEndLine = ESC + 'K';
-ansiEscapes.eraseStartLine = ESC + '1K';
-ansiEscapes.eraseLine = ESC + '2K';
-ansiEscapes.eraseDown = ESC + 'J';
-ansiEscapes.eraseUp = ESC + '1J';
-ansiEscapes.eraseScreen = ESC + '2J';
-ansiEscapes.scrollUp = ESC + 'S';
-ansiEscapes.scrollDown = ESC + 'T';
-
-ansiEscapes.clearScreen = '\u001Bc';
-
-ansiEscapes.clearTerminal = process.platform === 'win32' ?
-	`${ansiEscapes.eraseScreen}${ESC}0f` :
-	// 1. Erases the screen (Only done in case `2` is not supported)
-	// 2. Erases the whole screen including scrollback buffer
-	// 3. Moves cursor to the top-left position
-	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
-	`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
-
-ansiEscapes.beep = BEL;
-
-ansiEscapes.link = (text, url) => {
-	return [
-		OSC,
-		'8',
-		SEP,
-		SEP,
-		url,
-		BEL,
-		text,
-		OSC,
-		'8',
-		SEP,
-		SEP,
-		BEL
-	].join('');
-};
-
-ansiEscapes.image = (buffer, options = {}) => {
-	let returnValue = `${OSC}1337;File=inline=1`;
-
-	if (options.width) {
-		returnValue += `;width=${options.width}`;
-	}
-
-	if (options.height) {
-		returnValue += `;height=${options.height}`;
-	}
-
-	if (options.preserveAspectRatio === false) {
-		returnValue += ';preserveAspectRatio=0';
-	}
-
-	return returnValue + ':' + buffer.toString('base64') + BEL;
-};
-
-ansiEscapes.iTerm = {
-	setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
-
-	annotation: (message, options = {}) => {
-		let returnValue = `${OSC}1337;`;
-
-		const hasX = typeof options.x !== 'undefined';
-		const hasY = typeof options.y !== 'undefined';
-		if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== 'undefined')) {
-			throw new Error('`x`, `y` and `length` must be defined when `x` or `y` is defined');
-		}
-
-		message = message.replace(/\|/g, '');
-
-		returnValue += options.isHidden ? 'AddHiddenAnnotation=' : 'AddAnnotation=';
-
-		if (options.length > 0) {
-			returnValue +=
-					(hasX ?
-						[message, options.length, options.x, options.y] :
-						[options.length, message]).join('|');
-		} else {
-			returnValue += message;
-		}
-
-		return returnValue + BEL;
-	}
-};
-
-const restoreCursor = onetime$1.exports(() => {
-	signalExit.exports(() => {
-		process$1.stderr.write('\u001B[?25h');
-	}, {alwaysLast: true});
-});
-
-let isHidden = false;
-
-const cliCursor = {};
-
-cliCursor.show = (writableStream = process$1.stderr) => {
-	if (!writableStream.isTTY) {
-		return;
-	}
-
-	isHidden = false;
-	writableStream.write('\u001B[?25h');
-};
-
-cliCursor.hide = (writableStream = process$1.stderr) => {
-	if (!writableStream.isTTY) {
-		return;
-	}
-
-	restoreCursor();
-	isHidden = true;
-	writableStream.write('\u001B[?25l');
-};
-
-cliCursor.toggle = (force, writableStream) => {
-	if (force !== undefined) {
-		isHidden = force;
-	}
-
-	if (isHidden) {
-		cliCursor.show(writableStream);
-	} else {
-		cliCursor.hide(writableStream);
-	}
-};
-
-const ESCAPES = new Set([
-	'\u001B',
-	'\u009B',
-]);
-
-const END_CODE = 39;
-const ANSI_ESCAPE_BELL = '\u0007';
-const ANSI_CSI = '[';
-const ANSI_OSC = ']';
-const ANSI_SGR_TERMINATOR = 'm';
-const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
-
-const wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
-
-// Calculate the length of words split on ' ', ignoring
-// the extra characters added by ansi escape codes
-const wordLengths = string => string.split(' ').map(character => stringWidth(character));
-
-// Wrap a long word across multiple rows
-// Ansi escape codes do not count towards length
-const wrapWord = (rows, word, columns) => {
-	const characters = [...word];
-
-	let isInsideEscape = false;
-	let isInsideLinkEscape = false;
-	let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
-
-	for (const [index, character] of characters.entries()) {
-		const characterLength = stringWidth(character);
-
-		if (visible + characterLength <= columns) {
-			rows[rows.length - 1] += character;
-		} else {
-			rows.push(character);
-			visible = 0;
-		}
-
-		if (ESCAPES.has(character)) {
-			isInsideEscape = true;
-			isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
-		}
-
-		if (isInsideEscape) {
-			if (isInsideLinkEscape) {
-				if (character === ANSI_ESCAPE_BELL) {
-					isInsideEscape = false;
-					isInsideLinkEscape = false;
-				}
-			} else if (character === ANSI_SGR_TERMINATOR) {
-				isInsideEscape = false;
-			}
-
-			continue;
-		}
-
-		visible += characterLength;
-
-		if (visible === columns && index < characters.length - 1) {
-			rows.push('');
-			visible = 0;
-		}
-	}
-
-	// It's possible that the last row we copy over is only
-	// ansi escape characters, handle this edge-case
-	if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
-		rows[rows.length - 2] += rows.pop();
-	}
-};
-
-// Trims spaces from a string ignoring invisible sequences
-const stringVisibleTrimSpacesRight = string => {
-	const words = string.split(' ');
-	let last = words.length;
-
-	while (last > 0) {
-		if (stringWidth(words[last - 1]) > 0) {
-			break;
-		}
-
-		last--;
-	}
-
-	if (last === words.length) {
-		return string;
-	}
-
-	return words.slice(0, last).join(' ') + words.slice(last).join('');
-};
-
-// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
-//
-// 'hard' will never allow a string to take up more than columns characters
-//
-// 'soft' allows long words to expand past the column length
-const exec = (string, columns, options = {}) => {
-	if (options.trim !== false && string.trim() === '') {
-		return '';
-	}
-
-	let returnValue = '';
-	let escapeCode;
-	let escapeUrl;
-
-	const lengths = wordLengths(string);
-	let rows = [''];
-
-	for (const [index, word] of string.split(' ').entries()) {
-		if (options.trim !== false) {
-			rows[rows.length - 1] = rows[rows.length - 1].trimStart();
-		}
-
-		let rowLength = stringWidth(rows[rows.length - 1]);
-
-		if (index !== 0) {
-			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
-				// If we start with a new word but the current row length equals the length of the columns, add a new row
-				rows.push('');
-				rowLength = 0;
-			}
-
-			if (rowLength > 0 || options.trim === false) {
-				rows[rows.length - 1] += ' ';
-				rowLength++;
-			}
-		}
-
-		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
-		if (options.hard && lengths[index] > columns) {
-			const remainingColumns = (columns - rowLength);
-			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
-			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
-			if (breaksStartingNextLine < breaksStartingThisLine) {
-				rows.push('');
-			}
-
-			wrapWord(rows, word, columns);
-			continue;
-		}
-
-		if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
-			if (options.wordWrap === false && rowLength < columns) {
-				wrapWord(rows, word, columns);
-				continue;
-			}
-
-			rows.push('');
-		}
-
-		if (rowLength + lengths[index] > columns && options.wordWrap === false) {
-			wrapWord(rows, word, columns);
-			continue;
-		}
-
-		rows[rows.length - 1] += word;
-	}
-
-	if (options.trim !== false) {
-		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
-	}
-
-	const pre = [...rows.join('\n')];
-
-	for (const [index, character] of pre.entries()) {
-		returnValue += character;
-
-		if (ESCAPES.has(character)) {
-			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
-			if (groups.code !== undefined) {
-				const code = Number.parseFloat(groups.code);
-				escapeCode = code === END_CODE ? undefined : code;
-			} else if (groups.uri !== undefined) {
-				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
-			}
-		}
-
-		const code = ansiStyles.codes.get(Number(escapeCode));
-
-		if (pre[index + 1] === '\n') {
-			if (escapeUrl) {
-				returnValue += wrapAnsiHyperlink('');
-			}
-
-			if (escapeCode && code) {
-				returnValue += wrapAnsiCode(code);
-			}
-		} else if (character === '\n') {
-			if (escapeCode && code) {
-				returnValue += wrapAnsiCode(escapeCode);
-			}
-
-			if (escapeUrl) {
-				returnValue += wrapAnsiHyperlink(escapeUrl);
-			}
-		}
-	}
-
-	return returnValue;
-};
-
-// For each newline, invoke the method separately
-function wrapAnsi(string, columns, options) {
-	return String(string)
-		.normalize()
-		.replace(/\r\n/g, '\n')
-		.split('\n')
-		.map(line => exec(line, columns, options))
-		.join('\n');
-}
-
-const defaultTerminalHeight = 24;
-
-const getWidth = stream => {
-	const {columns} = stream;
-
-	if (!columns) {
-		return 80;
-	}
-
-	return columns;
-};
-
-const fitToTerminalHeight = (stream, text) => {
-	const terminalHeight = stream.rows || defaultTerminalHeight;
-	const lines = text.split('\n');
-
-	const toRemove = lines.length - terminalHeight;
-	if (toRemove <= 0) {
-		return text;
-	}
-
-	return sliceAnsi(
-		text,
-		stripAnsi(lines.slice(0, toRemove).join('\n')).length + 1,
-	);
-};
-
-function createLogUpdate(stream, {showCursor = false} = {}) {
-	let previousLineCount = 0;
-	let previousWidth = getWidth(stream);
-	let previousOutput = '';
-
-	const render = (...arguments_) => {
-		if (!showCursor) {
-			cliCursor.hide();
-		}
-
-		let output = arguments_.join(' ') + '\n';
-		output = fitToTerminalHeight(stream, output);
-		const width = getWidth(stream);
-		if (output === previousOutput && previousWidth === width) {
-			return;
-		}
-
-		previousOutput = output;
-		previousWidth = width;
-		output = wrapAnsi(output, width, {
-			trim: false,
-			hard: true,
-			wordWrap: false,
-		});
-		stream.write(ansiEscapes.eraseLines(previousLineCount) + output);
-		previousLineCount = output.split('\n').length;
-	};
-
-	render.clear = () => {
-		stream.write(ansiEscapes.eraseLines(previousLineCount));
-		previousOutput = '';
-		previousWidth = getWidth(stream);
-		previousLineCount = 0;
-	};
-
-	render.done = () => {
-		previousOutput = '';
-		previousWidth = getWidth(stream);
-		previousLineCount = 0;
-
-		if (!showCursor) {
-			cliCursor.show();
-		}
-	};
-
-	return render;
-}
-
-createLogUpdate(process$1.stdout);
-
-createLogUpdate(process$1.stderr);
-
-const DURATION_LONG = 300;
-const outputMap = /* @__PURE__ */ new WeakMap();
-function formatFilepath(path) {
-  const lastSlash = Math.max(path.lastIndexOf("/") + 1, 0);
-  const basename = path.slice(lastSlash);
-  let firstDot = basename.indexOf(".");
-  if (firstDot < 0)
-    firstDot = basename.length;
-  firstDot += lastSlash;
-  return picocolors.exports.dim(path.slice(0, lastSlash)) + path.slice(lastSlash, firstDot) + picocolors.exports.dim(path.slice(firstDot));
-}
-function renderHookState(task, hookName, level = 0) {
-  var _a, _b;
-  const state = (_b = (_a = task.result) == null ? void 0 : _a.hooks) == null ? void 0 : _b[hookName];
-  if (state && state === "run")
-    return `${"  ".repeat(level)} ${getHookStateSymbol(task, hookName)} ${picocolors.exports.dim(`[ ${hookName} ]`)}`;
-  return "";
-}
-function renderTree(tasks, options, level = 0) {
-  var _a, _b, _c, _d, _e;
-  let output = [];
-  for (const task of tasks) {
-    let suffix = "";
-    const prefix = ` ${getStateSymbol(task)} `;
-    if (task.type === "suite")
-      suffix += picocolors.exports.dim(` (${getTests(task).length})`);
-    if (task.mode === "skip" || task.mode === "todo")
-      suffix += ` ${picocolors.exports.dim(picocolors.exports.gray("[skipped]"))}`;
-    if (((_a = task.result) == null ? void 0 : _a.duration) != null) {
-      if (task.result.duration > DURATION_LONG)
-        suffix += picocolors.exports.yellow(` ${Math.round(task.result.duration)}${picocolors.exports.dim("ms")}`);
-    }
-    if (options.showHeap && ((_b = task.result) == null ? void 0 : _b.heap) != null)
-      suffix += picocolors.exports.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
-    let name = task.name;
-    if (level === 0)
-      name = formatFilepath(name);
-    output.push("  ".repeat(level) + prefix + name + suffix);
-    if (((_c = task.result) == null ? void 0 : _c.state) !== "pass" && outputMap.get(task) != null) {
-      let data = outputMap.get(task);
-      if (typeof data === "string") {
-        data = stripAnsi(data.trim().split("\n").filter(Boolean).pop());
-        if (data === "")
-          data = void 0;
-      }
-      if (data != null) {
-        const out = `${"  ".repeat(level)}${F_RIGHT} ${data}`;
-        output.push(`   ${picocolors.exports.gray(cliTruncate(out, getCols(-3)))}`);
-      }
-    }
-    output = output.concat(renderHookState(task, "beforeAll", level + 1));
-    output = output.concat(renderHookState(task, "beforeEach", level + 1));
-    if (task.type === "suite" && task.tasks.length > 0) {
-      if (((_d = task.result) == null ? void 0 : _d.state) === "fail" || ((_e = task.result) == null ? void 0 : _e.state) === "run" || options.renderSucceed)
-        output = output.concat(renderTree(task.tasks, options, level + 1));
-    }
-    output = output.concat(renderHookState(task, "afterAll", level + 1));
-    output = output.concat(renderHookState(task, "afterEach", level + 1));
-  }
-  return output.filter(Boolean).join("\n");
-}
-const createListRenderer = (_tasks, options) => {
-  let tasks = _tasks;
-  let timer;
-  const log = createLogUpdate(options.outputStream);
-  function update() {
-    log(renderTree(tasks, options));
-  }
-  return {
-    start() {
-      if (timer)
-        return this;
-      timer = safeSetInterval(update, 200);
-      return this;
-    },
-    update(_tasks2) {
-      tasks = _tasks2;
-      update();
-      return this;
-    },
-    async stop() {
-      if (timer) {
-        safeClearInterval(timer);
-        timer = void 0;
-      }
-      log.clear();
-      options.outputStream.write(`${renderTree(tasks, options)}
-`);
-      return this;
-    },
-    clear() {
-      log.clear();
-    }
-  };
-};
-
-class DefaultReporter extends BaseReporter {
-  constructor() {
-    super(...arguments);
-    this.rendererOptions = {};
-  }
-  async onTestRemoved(trigger) {
-    await this.stopListRender();
-    this.ctx.clearScreen();
-    this.ctx.log(picocolors.exports.yellow("Test removed...") + (trigger ? picocolors.exports.dim(` [ ${this.relative(trigger)} ]
-`) : ""));
-    const files = this.ctx.state.getFiles(this.watchFilters);
-    createListRenderer(files, this.rendererOptions).stop();
-    this.ctx.log();
-    await super.reportSummary(files);
-    super.onWatcherStart();
-  }
-  onCollected() {
-    if (this.isTTY) {
-      this.rendererOptions.outputStream = this.ctx.outputStream;
-      this.rendererOptions.showHeap = this.ctx.config.logHeapUsage;
-      const files = this.ctx.state.getFiles(this.watchFilters);
-      if (!this.renderer)
-        this.renderer = createListRenderer(files, this.rendererOptions).start();
-      else
-        this.renderer.update(files);
-    }
-  }
-  async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    await this.stopListRender();
-    this.ctx.log();
-    await super.onFinished(files, errors);
-  }
-  async onWatcherStart() {
-    await this.stopListRender();
-    super.onWatcherStart();
-  }
-  async stopListRender() {
-    var _a;
-    await ((_a = this.renderer) == null ? void 0 : _a.stop());
-    this.renderer = void 0;
-  }
-  async onWatcherRerun(files, trigger) {
-    await this.stopListRender();
-    await super.onWatcherRerun(files, trigger);
-  }
-  onUserConsoleLog(log) {
-    var _a;
-    if (!this.shouldLog(log))
-      return;
-    (_a = this.renderer) == null ? void 0 : _a.clear();
-    super.onUserConsoleLog(log);
-  }
-}
-
-const check = picocolors.exports.green("\xB7");
-const cross = picocolors.exports.red("x");
-const pending = picocolors.exports.yellow("*");
-const skip = picocolors.exports.dim(picocolors.exports.gray("-"));
-function render(tasks) {
-  const all = getTests(tasks);
-  return all.map((i) => {
-    var _a;
-    if (i.mode === "skip" || i.mode === "todo")
-      return skip;
-    switch ((_a = i.result) == null ? void 0 : _a.state) {
-      case "pass":
-        return check;
-      case "fail":
-        return cross;
-      default:
-        return pending;
-    }
-  }).join("");
-}
-const createDotRenderer = (_tasks, options) => {
-  let tasks = _tasks;
-  let timer;
-  const log = createLogUpdate(options.outputStream);
-  function update() {
-    log(render(tasks));
-  }
-  return {
-    start() {
-      if (timer)
-        return this;
-      timer = safeSetInterval(update, 200);
-      return this;
-    },
-    update(_tasks2) {
-      tasks = _tasks2;
-      update();
-      return this;
-    },
-    async stop() {
-      if (timer) {
-        safeClearInterval(timer);
-        timer = void 0;
-      }
-      log.clear();
-      options.outputStream.write(`${render(tasks)}
-`);
-      return this;
-    },
-    clear() {
-      log.clear();
-    }
-  };
-};
-
-class DotReporter extends BaseReporter {
-  onCollected() {
-    if (this.isTTY) {
-      const files = this.ctx.state.getFiles(this.watchFilters);
-      if (!this.renderer)
-        this.renderer = createDotRenderer(files, { outputStream: this.ctx.outputStream }).start();
-      else
-        this.renderer.update(files);
-    }
-  }
-  async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    await this.stopListRender();
-    this.ctx.log();
-    await super.onFinished(files, errors);
-  }
-  async onWatcherStart() {
-    await this.stopListRender();
-    super.onWatcherStart();
-  }
-  async stopListRender() {
-    var _a;
-    (_a = this.renderer) == null ? void 0 : _a.stop();
-    this.renderer = void 0;
-    await new Promise((resolve) => safeSetTimeout(resolve, 10));
-  }
-  async onWatcherRerun(files, trigger) {
-    await this.stopListRender();
-    await super.onWatcherRerun(files, trigger);
-  }
-  onUserConsoleLog(log) {
-    var _a;
-    (_a = this.renderer) == null ? void 0 : _a.clear();
-    super.onUserConsoleLog(log);
-  }
-}
-
-const getOutputFile = ({ config }, reporter) => {
-  if (!config.outputFile)
-    return;
-  if (typeof config.outputFile === "string")
-    return config.outputFile;
-  return config.outputFile[reporter];
+const getOutputFile = ({ config }, reporter) => {
+  if (!config.outputFile)
+    return;
+  if (typeof config.outputFile === "string")
+    return config.outputFile;
+  return config.outputFile[reporter];
 };
 
 const StatusMap = {
@@ -8277,14 +7819,15 @@ class JsonReporter {
           status: StatusMap[((_a2 = t.result) == null ? void 0 : _a2.state) || t.mode] || "skipped",
           title: t.name,
           duration: (_b2 = t.result) == null ? void 0 : _b2.duration,
-          failureMessages: ((_d = (_c = t.result) == null ? void 0 : _c.error) == null ? void 0 : _d.message) == null ? [] : [t.result.error.message]
+          failureMessages: ((_d = (_c = t.result) == null ? void 0 : _c.error) == null ? void 0 : _d.message) == null ? [] : [t.result.error.message],
+          location: this.getFailureLocation(t)
         };
       });
       if (tests2.some((t) => {
         var _a2;
         return ((_a2 = t.result) == null ? void 0 : _a2.state) === "run";
       })) {
-        this.ctx.console.warn("WARNING: Some tests are still running when generating the JSON report.This is likely an internal bug in Vitest.Please report it to https://github.com/vitest-dev/vitest/issues");
+        this.ctx.logger.warn("WARNING: Some tests are still running when generating the JSON report.This is likely an internal bug in Vitest.Please report it to https://github.com/vitest-dev/vitest/issues");
       }
       testResults.push({
         assertionResults,
@@ -8325,11 +7868,23 @@ class JsonReporter {
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
       await promises.writeFile(reportFile, report, "utf-8");
-      this.ctx.log(`JSON report written to ${reportFile}`);
+      this.ctx.logger.log(`JSON report written to ${reportFile}`);
     } else {
-      this.ctx.log(report);
+      this.ctx.logger.log(report);
     }
   }
+  getFailureLocation(test) {
+    var _a;
+    const error = (_a = test.result) == null ? void 0 : _a.error;
+    if (!error)
+      return;
+    const stack = parseStacktrace(error);
+    const frame = stack[stack.length - 1];
+    if (!frame)
+      return;
+    const pos = frame.sourcePos || frame;
+    return { line: pos.line, column: pos.column };
+  }
 }
 
 class VerboseReporter extends DefaultReporter {
@@ -8347,9 +7902,9 @@ class VerboseReporter extends DefaultReporter {
         let title = ` ${getStateSymbol(task)} ${getFullName(task)}`;
         if (this.ctx.config.logHeapUsage && task.result.heap != null)
           title += picocolors.exports.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
-        this.ctx.log(title);
+        this.ctx.logger.log(title);
         if (task.result.state === "fail")
-          this.ctx.log(picocolors.exports.red(`   ${F_RIGHT} ${(_c = task.result.error) == null ? void 0 : _c.message}`));
+          this.ctx.logger.log(picocolors.exports.red(`   ${F_RIGHT} ${(_c = task.result.error) == null ? void 0 : _c.message}`));
       }
     }
   }
@@ -8380,7 +7935,7 @@ function tapString(str) {
 class TapReporter {
   onInit(ctx) {
     this.ctx = ctx;
-    this.logger = new IndentedLogger(this.ctx.log.bind(this.ctx));
+    this.logger = new IndentedLogger(this.ctx.logger.log.bind(this.ctx));
   }
   static getComment(task) {
     var _a;
@@ -8483,7 +8038,7 @@ class JUnitReporter {
       this.baseLog = async (text) => await promises.writeFile(fileFd, `${text}
 `);
     } else {
-      this.baseLog = async (text) => this.ctx.log(text);
+      this.baseLog = async (text) => this.ctx.logger.log(text);
     }
     this.logger = new IndentedLogger(this.baseLog);
   }
@@ -8590,7 +8145,7 @@ class JUnitReporter {
       }
     });
     if (this.reportFile)
-      this.ctx.log(`JUNIT report written to ${this.reportFile}`);
+      this.ctx.logger.log(`JUNIT report written to ${this.reportFile}`);
   }
 }
 
@@ -8610,7 +8165,7 @@ class TapFlatReporter extends TapReporter {
     super.onInit(ctx);
   }
   async onFinished(files = this.ctx.state.getFiles()) {
-    this.ctx.log("TAP version 13");
+    this.ctx.logger.log("TAP version 13");
     const flatTasks = files.flatMap((task) => flattenTasks(task));
     this.logTasks(flatTasks);
   }
@@ -8653,95 +8208,13 @@ function createReporters(reporterReferences, runner) {
   return Promise.all(promisedReporters);
 }
 
-class FilesStatsCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  getStats(fsPath) {
-    return this.cache.get(fsPath);
-  }
-  async updateStats(fsPath) {
-    if (!fs$8.existsSync(fsPath))
-      return;
-    const stats = await fs$8.promises.stat(fsPath);
-    this.cache.set(fsPath, { size: stats.size });
-  }
-  removeStats(fsPath) {
-    this.cache.delete(fsPath);
-  }
-}
-
-class ResultsCache {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.cachePath = null;
-    this.version = version;
-    this.root = "/";
-  }
-  setConfig(root, config) {
-    this.root = root;
-    if (config)
-      this.cachePath = resolve(config.dir, "results.json");
-  }
-  getResults(fsPath) {
-    return this.cache.get(fsPath == null ? void 0 : fsPath.slice(this.root.length));
-  }
-  async readFromCache() {
-    if (!this.cachePath)
-      return;
-    if (fs$8.existsSync(this.cachePath)) {
-      const resultsCache = await fs$8.promises.readFile(this.cachePath, "utf8");
-      const { results, version: version2 } = JSON.parse(resultsCache);
-      this.cache = new Map(results);
-      this.version = version2;
-    }
-  }
-  updateResults(files) {
-    files.forEach((file) => {
-      var _a;
-      const result = file.result;
-      if (!result)
-        return;
-      const duration = result.duration || 0;
-      const relativePath = (_a = file.filepath) == null ? void 0 : _a.slice(this.root.length);
-      this.cache.set(relativePath, {
-        duration: duration >= 0 ? duration : 0,
-        failed: result.state === "fail"
-      });
-    });
-  }
-  removeFromCache(filepath) {
-    this.cache.delete(filepath);
-  }
-  async writeToCache() {
-    if (!this.cachePath)
-      return;
-    const results = Array.from(this.cache.entries());
-    const cacheDirname = dirname(this.cachePath);
-    if (!fs$8.existsSync(cacheDirname))
-      await fs$8.promises.mkdir(cacheDirname, { recursive: true });
-    const cache = JSON.stringify({
-      version: this.version,
-      results
-    });
-    await fs$8.promises.writeFile(this.cachePath, cache);
-  }
-}
-
 class StateManager {
   constructor() {
     this.filesMap = /* @__PURE__ */ new Map();
+    this.pathsSet = /* @__PURE__ */ new Set();
     this.idMap = /* @__PURE__ */ new Map();
     this.taskFileMap = /* @__PURE__ */ new WeakMap();
     this.errorsSet = /* @__PURE__ */ new Set();
-    this.results = new ResultsCache();
-    this.stats = new FilesStatsCache();
-  }
-  getFileTestResults(id) {
-    return this.results.getResults(id);
-  }
-  getFileStats(id) {
-    return this.stats.getStats(id);
   }
   catchError(err, type) {
     err.type = type;
@@ -8753,6 +8226,9 @@ class StateManager {
   getUnhandledErrors() {
     return Array.from(this.errorsSet.values());
   }
+  getPaths() {
+    return Array.from(this.pathsSet);
+  }
   getFiles(keys) {
     if (keys)
       return keys.map((key) => this.filesMap.get(key)).filter(Boolean);
@@ -8767,12 +8243,22 @@ class StateManager {
       return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
     }).map((i) => i.filepath);
   }
+  collectPaths(paths = []) {
+    paths.forEach((path) => {
+      this.pathsSet.add(path);
+    });
+  }
   collectFiles(files = []) {
     files.forEach((file) => {
       this.filesMap.set(file.filepath, file);
       this.updateId(file);
     });
   }
+  clearFiles(paths = []) {
+    paths.forEach((path) => {
+      this.filesMap.delete(path);
+    });
+  }
   updateId(task) {
     if (this.idMap.get(task.id) === task)
       return;
@@ -8783,23 +8269,111 @@ class StateManager {
       });
     }
   }
-  updateTasks(packs) {
-    for (const [id, result] of packs) {
-      if (this.idMap.has(id))
-        this.idMap.get(id).result = result;
-    }
+  updateTasks(packs) {
+    for (const [id, result] of packs) {
+      if (this.idMap.has(id))
+        this.idMap.get(id).result = result;
+    }
+  }
+  updateUserLog(log) {
+    const task = log.taskId && this.idMap.get(log.taskId);
+    if (task) {
+      if (!task.logs)
+        task.logs = [];
+      task.logs.push(log);
+    }
+  }
+}
+
+class FilesStatsCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  getStats(fsPath) {
+    return this.cache.get(fsPath);
+  }
+  async updateStats(fsPath) {
+    if (!fs$8.existsSync(fsPath))
+      return;
+    const stats = await fs$8.promises.stat(fsPath);
+    this.cache.set(fsPath, { size: stats.size });
+  }
+  removeStats(fsPath) {
+    this.cache.delete(fsPath);
+  }
+}
+
+class ResultsCache {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cachePath = null;
+    this.version = version$1;
+    this.root = "/";
+  }
+  getCachePath() {
+    return this.cachePath;
+  }
+  setConfig(root, config) {
+    this.root = root;
+    if (config)
+      this.cachePath = resolve(config.dir, "results.json");
+  }
+  getResults(fsPath) {
+    return this.cache.get(fsPath == null ? void 0 : fsPath.slice(this.root.length));
+  }
+  async readFromCache() {
+    if (!this.cachePath)
+      return;
+    if (fs$8.existsSync(this.cachePath)) {
+      const resultsCache = await fs$8.promises.readFile(this.cachePath, "utf8");
+      const { results, version: version2 } = JSON.parse(resultsCache);
+      this.cache = new Map(results);
+      this.version = version2;
+    }
+  }
+  updateResults(files) {
+    files.forEach((file) => {
+      var _a;
+      const result = file.result;
+      if (!result)
+        return;
+      const duration = result.duration || 0;
+      const relativePath = (_a = file.filepath) == null ? void 0 : _a.slice(this.root.length);
+      this.cache.set(relativePath, {
+        duration: duration >= 0 ? duration : 0,
+        failed: result.state === "fail"
+      });
+    });
   }
-  updateUserLog(log) {
-    const task = log.taskId && this.idMap.get(log.taskId);
-    if (task) {
-      if (!task.logs)
-        task.logs = [];
-      task.logs.push(log);
-    }
+  removeFromCache(filepath) {
+    this.cache.delete(filepath);
+  }
+  async writeToCache() {
+    if (!this.cachePath)
+      return;
+    const results = Array.from(this.cache.entries());
+    const cacheDirname = dirname(this.cachePath);
+    if (!fs$8.existsSync(cacheDirname))
+      await fs$8.promises.mkdir(cacheDirname, { recursive: true });
+    const cache = JSON.stringify({
+      version: this.version,
+      results
+    });
+    await fs$8.promises.writeFile(this.cachePath, cache);
   }
 }
 
 class VitestCache {
+  constructor() {
+    this.results = new ResultsCache();
+    this.stats = new FilesStatsCache();
+  }
+  getFileTestResults(id) {
+    return this.results.getResults(id);
+  }
+  getFileStats(id) {
+    return this.stats.getStats(id);
+  }
   static resolveCacheDir(root, dir) {
     return resolve(root, slash$2(dir || "node_modules/.vitest"));
   }
@@ -8841,13 +8415,13 @@ class BaseSequencer {
     }).sort((a, b) => a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0).slice(shardStart, shardEnd).map(({ file }) => file);
   }
   async sort(files) {
-    const { state } = this.ctx;
+    const cache = this.ctx.cache;
     return [...files].sort((a, b) => {
-      const aState = state.getFileTestResults(a);
-      const bState = state.getFileTestResults(b);
+      const aState = cache.getFileTestResults(a);
+      const bState = cache.getFileTestResults(b);
       if (!aState || !bState) {
-        const statsA = state.getFileStats(a);
-        const statsB = state.getFileStats(b);
+        const statsA = cache.getFileStats(a);
+        const statsB = cache.getFileStats(b);
         if (!statsA || !statsB)
           return !statsA && statsB ? -1 : !statsB && statsA ? 1 : 0;
         return statsB.size - statsA.size;
@@ -8880,7 +8454,7 @@ const extraInlineDeps = [
 ];
 function resolveApiConfig(options) {
   let api;
-  if (options.ui && !options.api)
+  if ((options.ui || options.browser) && !options.api)
     api = { port: defaultPort };
   else if (options.api === true)
     api = { port: defaultPort };
@@ -8930,1357 +8504,810 @@ function resolveConfig(options, viteConfig) {
       throw new Error("--shard <count> must be a positive number");
     if (isNaN(index) || index <= 0 || index > count)
       throw new Error("--shard <index> must be a positive number less then <count>");
-    resolved.shard = { index, count };
-  }
-  resolved.deps = resolved.deps || {};
-  if (resolved.deps.inline !== true) {
-    const ssrOptions = viteConfig.ssr;
-    if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.deps.inline == null) {
-      resolved.deps.inline = true;
-    } else {
-      (_b = resolved.deps).inline ?? (_b.inline = []);
-      resolved.deps.inline.push(...extraInlineDeps);
-    }
-  }
-  resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
-  const CI = !!process.env.CI;
-  const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
-  resolved.snapshotOptions = {
-    snapshotFormat: resolved.snapshotFormat || {},
-    updateSnapshot: CI && !UPDATE_SNAPSHOT ? "none" : UPDATE_SNAPSHOT ? "all" : "new",
-    resolveSnapshotPath: options.resolveSnapshotPath
-  };
-  if (options.resolveSnapshotPath)
-    delete resolved.resolveSnapshotPath;
-  if (process.env.VITEST_MAX_THREADS)
-    resolved.maxThreads = parseInt(process.env.VITEST_MAX_THREADS);
-  if (process.env.VITEST_MIN_THREADS)
-    resolved.minThreads = parseInt(process.env.VITEST_MIN_THREADS);
-  resolved.setupFiles = toArray$1(resolved.setupFiles || []).map((file) => normalize(resolveModule(file, { paths: [resolved.root] }) ?? resolve(resolved.root, file)));
-  resolved.api = resolveApiConfig(options);
-  if (options.related)
-    resolved.related = toArray$1(options.related).map((file) => resolve(resolved.root, file));
-  resolved.reporters = Array.from(/* @__PURE__ */ new Set([
-    ...toArray$1(resolved.reporters),
-    ...toArray$1(resolved.reporter)
-  ])).filter(Boolean);
-  if (!resolved.reporters.length)
-    resolved.reporters.push("default");
-  if (resolved.changed)
-    resolved.passWithNoTests ?? (resolved.passWithNoTests = true);
-  resolved.css ?? (resolved.css = {});
-  if (typeof resolved.css === "object")
-    (_c = resolved.css).include ?? (_c.include = [/\.module\./]);
-  resolved.cache ?? (resolved.cache = { dir: "" });
-  if (resolved.cache)
-    resolved.cache.dir = VitestCache.resolveCacheDir(resolved.root, resolved.cache.dir);
-  if (!((_d = resolved.sequence) == null ? void 0 : _d.sequencer)) {
-    resolved.sequence ?? (resolved.sequence = {});
-    resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
-  }
-  return resolved;
-}
-
-function fileFromParsedStack(stack) {
-  var _a, _b;
-  if ((_b = (_a = stack == null ? void 0 : stack.sourcePos) == null ? void 0 : _a.source) == null ? void 0 : _b.startsWith(".."))
-    return join(stack.file, "../", stack.sourcePos.source);
-  return stack.file;
-}
-async function printError(error, ctx, options = {}) {
-  const { showCodeFrame = true, fullStack = false, type } = options;
-  let e = error;
-  if (typeof error === "string") {
-    e = {
-      message: error.split(/\n/g)[0],
-      stack: error
-    };
-  }
-  const stacks = parseStacktrace(e, fullStack);
-  await interpretSourcePos(stacks, ctx);
-  const nearest = stacks.find((stack) => ctx.server.moduleGraph.getModuleById(stack.file) && existsSync(stack.file));
-  const errorProperties = getErrorProperties(e);
-  if (type)
-    printErrorType(type, ctx);
-  printErrorMessage(e, ctx.console);
-  printStack(ctx, stacks, nearest, errorProperties, (s, pos) => {
-    if (showCodeFrame && s === nearest && nearest) {
-      const file = fileFromParsedStack(nearest);
-      if (existsSync(file)) {
-        const sourceCode = readFileSync(file, "utf-8");
-        ctx.log(picocolors.exports.yellow(generateCodeFrame(sourceCode, 4, pos)));
-      }
-    }
-  });
-  if (e.cause) {
-    e.cause.name = `Caused by: ${e.cause.name}`;
-    await printError(e.cause, ctx, { fullStack, showCodeFrame: false });
-  }
-  handleImportOutsideModuleError(e.stack || e.stackStr || "", ctx);
-  if (e.showDiff) {
-    displayDiff(stringify$5(e.actual), stringify$5(e.expected), ctx.console, {
-      outputTruncateLength: ctx.config.outputTruncateLength,
-      outputDiffLines: ctx.config.outputDiffLines
-    });
-  }
-}
-function printErrorType(type, ctx) {
-  ctx.error(`
-${picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(` ${type} `))))}`);
-}
-const skipErrorProperties = [
-  "message",
-  "name",
-  "nameStr",
-  "stack",
-  "cause",
-  "stacks",
-  "stackStr",
-  "type",
-  "showDiff",
-  "actual",
-  "expected",
-  "constructor",
-  "toString"
-];
-function getErrorProperties(e) {
-  const errorObject = /* @__PURE__ */ Object.create(null);
-  if (e.name === "AssertionError")
-    return errorObject;
-  for (const key of Object.getOwnPropertyNames(e)) {
-    if (!skipErrorProperties.includes(key))
-      errorObject[key] = e[key];
-  }
-  return errorObject;
-}
-const esmErrors = [
-  "Cannot use import statement outside a module",
-  "Unexpected token 'export'"
-];
-function handleImportOutsideModuleError(stack, ctx) {
-  if (!esmErrors.some((e) => stack.includes(e)))
-    return;
-  const path = normalize(stack.split("\n")[0].trim());
-  let name = path.split("/node_modules/").pop() || "";
-  if (name == null ? void 0 : name.startsWith("@"))
-    name = name.split("/").slice(0, 2).join("/");
-  else
-    name = name.split("/")[0];
-  ctx.error(picocolors.exports.yellow(`Module ${path} seems to be an ES Module but shipped in a CommonJS package. You might want to create an issue to the package ${picocolors.exports.bold(`"${name}"`)} asking them to ship the file in .mjs extension or add "type": "module" in their package.json.
-
-As a temporary workaround you can try to inline the package by updating your config:
-
-` + picocolors.exports.gray(picocolors.exports.dim("// vitest.config.js")) + "\n" + picocolors.exports.green(`export default {
-  test: {
-    deps: {
-      inline: [
-        ${picocolors.exports.yellow(picocolors.exports.bold(`"${name}"`))}
-      ]
-    }
-  }
-}
-`)));
-}
-function displayDiff(actual, expected, console, options) {
-  console.error(picocolors.exports.gray(unifiedDiff(actual, expected, options)) + "\n");
-}
-function printErrorMessage(error, console) {
-  const errorName = error.name || error.nameStr || "Unknown Error";
-  console.error(picocolors.exports.red(`${picocolors.exports.bold(errorName)}: ${error.message}`));
-}
-function printStack(ctx, stack, highlight, errorProperties, onStack) {
-  if (!stack.length)
-    return;
-  for (const frame of stack) {
-    const pos = frame.sourcePos || frame;
-    const color = frame === highlight ? picocolors.exports.yellow : picocolors.exports.gray;
-    const file = fileFromParsedStack(frame);
-    const path = relative(ctx.config.root, file);
-    ctx.log(color(` ${picocolors.exports.dim(F_POINTER)} ${[frame.method, picocolors.exports.dim(`${path}:${pos.line}:${pos.column}`)].filter(Boolean).join(" ")}`));
-    onStack == null ? void 0 : onStack(frame, pos);
-    if (frame.file in ctx.state.filesMap)
-      break;
-  }
-  ctx.log();
-  const hasProperties = Object.keys(errorProperties).length > 0;
-  if (hasProperties) {
-    ctx.log(picocolors.exports.red(picocolors.exports.dim(divider())));
-    const propertiesString = stringify$5(errorProperties, 10, { printBasicPrototype: false });
-    ctx.log(picocolors.exports.red(picocolors.exports.bold("Serialized Error:")), picocolors.exports.gray(propertiesString));
-  }
-}
-function generateCodeFrame(source, indent = 0, start = 0, end, range = 2) {
-  var _a;
-  start = posToNumber(source, start);
-  end = end || start;
-  const lines = source.split(lineSplitRE);
-  let count = 0;
-  let res = [];
-  const columns = ((_a = process.stdout) == null ? void 0 : _a.columns) || 80;
-  function lineNo(no = "") {
-    return picocolors.exports.gray(`${String(no).padStart(3, " ")}| `);
-  }
-  for (let i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (let j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length)
-          continue;
-        const lineLength = lines[j].length;
-        if (lineLength > 200)
-          return "";
-        res.push(lineNo(j + 1) + cliTruncate(lines[j], columns - 5 - indent));
-        if (j === i) {
-          const pad = start - (count - lineLength);
-          const length = Math.max(1, end > count ? lineLength - pad : end - start);
-          res.push(lineNo() + " ".repeat(pad) + picocolors.exports.red("^".repeat(length)));
-        } else if (j > i) {
-          if (end > count) {
-            const length = Math.max(1, Math.min(end - count, lineLength));
-            res.push(lineNo() + picocolors.exports.red("^".repeat(length)));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break;
+    resolved.shard = { index, count };
+  }
+  resolved.deps = resolved.deps || {};
+  if (resolved.deps.inline !== true) {
+    const ssrOptions = viteConfig.ssr;
+    if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.deps.inline == null) {
+      resolved.deps.inline = true;
+    } else {
+      (_b = resolved.deps).inline ?? (_b.inline = []);
+      resolved.deps.inline.push(...extraInlineDeps);
     }
   }
-  if (indent)
-    res = res.map((line) => " ".repeat(indent) + line);
-  return res.join("\n");
+  resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
+  const CI = !!process.env.CI;
+  const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
+  resolved.snapshotOptions = {
+    snapshotFormat: resolved.snapshotFormat || {},
+    updateSnapshot: CI && !UPDATE_SNAPSHOT ? "none" : UPDATE_SNAPSHOT ? "all" : "new",
+    resolveSnapshotPath: options.resolveSnapshotPath
+  };
+  if (options.resolveSnapshotPath)
+    delete resolved.resolveSnapshotPath;
+  if (process.env.VITEST_MAX_THREADS)
+    resolved.maxThreads = parseInt(process.env.VITEST_MAX_THREADS);
+  if (process.env.VITEST_MIN_THREADS)
+    resolved.minThreads = parseInt(process.env.VITEST_MIN_THREADS);
+  resolved.setupFiles = toArray$1(resolved.setupFiles || []).map((file) => normalize(resolveModule(file, { paths: [resolved.root] }) ?? resolve(resolved.root, file)));
+  resolved.api = resolveApiConfig(options);
+  if (options.related)
+    resolved.related = toArray$1(options.related).map((file) => resolve(resolved.root, file));
+  resolved.reporters = Array.from(/* @__PURE__ */ new Set([
+    ...toArray$1(resolved.reporters),
+    ...toArray$1(resolved.reporter)
+  ])).filter(Boolean);
+  if (!resolved.reporters.length)
+    resolved.reporters.push("default");
+  if (resolved.changed)
+    resolved.passWithNoTests ?? (resolved.passWithNoTests = true);
+  resolved.css ?? (resolved.css = {});
+  if (typeof resolved.css === "object")
+    (_c = resolved.css).include ?? (_c.include = [/\.module\./]);
+  resolved.cache ?? (resolved.cache = { dir: "" });
+  if (resolved.cache)
+    resolved.cache.dir = VitestCache.resolveCacheDir(resolved.root, resolved.cache.dir);
+  if (!((_d = resolved.sequence) == null ? void 0 : _d.sequencer)) {
+    resolved.sequence ?? (resolved.sequence = {});
+    resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
+  }
+  return resolved;
 }
 
-function stripFinalNewline(input) {
-	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
-	const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
-
-	if (input[input.length - 1] === LF) {
-		input = input.slice(0, -1);
-	}
-
-	if (input[input.length - 1] === CR) {
-		input = input.slice(0, -1);
-	}
-
-	return input;
-}
+const ESC = '\u001B[';
+const OSC = '\u001B]';
+const BEL = '\u0007';
+const SEP = ';';
+const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
 
-function pathKey(options = {}) {
-	const {
-		env = process.env,
-		platform = process.platform
-	} = options;
+const ansiEscapes = {};
 
-	if (platform !== 'win32') {
-		return 'PATH';
+ansiEscapes.cursorTo = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
 	}
 
-	return Object.keys(env).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
-}
-
-function npmRunPath(options = {}) {
-	const {
-		cwd = process$1.cwd(),
-		path: path_ = process$1.env[pathKey()],
-		execPath = process$1.execPath,
-	} = options;
-
-	let previous;
-	const cwdString = cwd instanceof URL ? url.fileURLToPath(cwd) : cwd;
-	let cwdPath = path$a.resolve(cwdString);
-	const result = [];
-
-	while (previous !== cwdPath) {
-		result.push(path$a.join(cwdPath, 'node_modules/.bin'));
-		previous = cwdPath;
-		cwdPath = path$a.resolve(cwdPath, '..');
+	if (typeof y !== 'number') {
+		return ESC + (x + 1) + 'G';
 	}
 
-	// Ensure the running `node` binary is used.
-	result.push(path$a.resolve(cwdString, execPath, '..'));
-
-	return [...result, path_].join(path$a.delimiter);
-}
-
-function npmRunPathEnv({env = process$1.env, ...options} = {}) {
-	env = {...env};
-
-	const path = pathKey({env});
-	options.path = env[path];
-	env[path] = npmRunPath(options);
-
-	return env;
-}
-
-const copyProperty = (to, from, property, ignoreNonConfigurable) => {
-	// `Function#length` should reflect the parameters of `to` not `from` since we keep its body.
-	// `Function#prototype` is non-writable and non-configurable so can never be modified.
-	if (property === 'length' || property === 'prototype') {
-		return;
-	}
+	return ESC + (y + 1) + ';' + (x + 1) + 'H';
+};
 
-	// `Function#arguments` and `Function#caller` should not be copied. They were reported to be present in `Reflect.ownKeys` for some devices in React Native (#41), so we explicitly ignore them here.
-	if (property === 'arguments' || property === 'caller') {
-		return;
+ansiEscapes.cursorMove = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
 	}
 
-	const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
-	const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+	let returnValue = '';
 
-	if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
-		return;
+	if (x < 0) {
+		returnValue += ESC + (-x) + 'D';
+	} else if (x > 0) {
+		returnValue += ESC + x + 'C';
 	}
 
-	Object.defineProperty(to, property, fromDescriptor);
-};
-
-// `Object.defineProperty()` throws if the property exists, is not configurable and either:
-// - one its descriptors is changed
-// - it is non-writable and its value is changed
-const canCopyProperty = function (toDescriptor, fromDescriptor) {
-	return toDescriptor === undefined || toDescriptor.configurable || (
-		toDescriptor.writable === fromDescriptor.writable &&
-		toDescriptor.enumerable === fromDescriptor.enumerable &&
-		toDescriptor.configurable === fromDescriptor.configurable &&
-		(toDescriptor.writable || toDescriptor.value === fromDescriptor.value)
-	);
-};
-
-const changePrototype = (to, from) => {
-	const fromPrototype = Object.getPrototypeOf(from);
-	if (fromPrototype === Object.getPrototypeOf(to)) {
-		return;
+	if (y < 0) {
+		returnValue += ESC + (-y) + 'A';
+	} else if (y > 0) {
+		returnValue += ESC + y + 'B';
 	}
 
-	Object.setPrototypeOf(to, fromPrototype);
-};
-
-const wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/\n${fromBody}`;
-
-const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, 'toString');
-const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, 'name');
-
-// We call `from.toString()` early (not lazily) to ensure `from` can be garbage collected.
-// We use `bind()` instead of a closure for the same reason.
-// Calling `from.toString()` early also allows caching it in case `to.toString()` is called several times.
-const changeToString = (to, from, name) => {
-	const withName = name === '' ? '' : `with ${name.trim()}() `;
-	const newToString = wrappedToString.bind(null, withName, from.toString());
-	// Ensure `to.toString.toString` is non-enumerable and has the same `same`
-	Object.defineProperty(newToString, 'name', toStringName);
-	Object.defineProperty(to, 'toString', {...toStringDescriptor, value: newToString});
+	return returnValue;
 };
 
-function mimicFunction(to, from, {ignoreNonConfigurable = false} = {}) {
-	const {name} = to;
-
-	for (const property of Reflect.ownKeys(from)) {
-		copyProperty(to, from, property, ignoreNonConfigurable);
-	}
-
-	changePrototype(to, from);
-	changeToString(to, from, name);
+ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
+ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
+ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
+ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
 
-	return to;
-}
+ansiEscapes.cursorLeft = ESC + 'G';
+ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
+ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
+ansiEscapes.cursorGetPosition = ESC + '6n';
+ansiEscapes.cursorNextLine = ESC + 'E';
+ansiEscapes.cursorPrevLine = ESC + 'F';
+ansiEscapes.cursorHide = ESC + '?25l';
+ansiEscapes.cursorShow = ESC + '?25h';
 
-const calledFunctions = new WeakMap();
+ansiEscapes.eraseLines = count => {
+	let clear = '';
 
-const onetime = (function_, options = {}) => {
-	if (typeof function_ !== 'function') {
-		throw new TypeError('Expected a function');
+	for (let i = 0; i < count; i++) {
+		clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
 	}
 
-	let returnValue;
-	let callCount = 0;
-	const functionName = function_.displayName || function_.name || '<anonymous>';
-
-	const onetime = function (...arguments_) {
-		calledFunctions.set(onetime, ++callCount);
-
-		if (callCount === 1) {
-			returnValue = function_.apply(this, arguments_);
-			function_ = null;
-		} else if (options.throw === true) {
-			throw new Error(`Function \`${functionName}\` can only be called once`);
-		}
-
-		return returnValue;
-	};
-
-	mimicFunction(onetime, function_);
-	calledFunctions.set(onetime, callCount);
-
-	return onetime;
-};
-
-onetime.callCount = function_ => {
-	if (!calledFunctions.has(function_)) {
-		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+	if (count) {
+		clear += ansiEscapes.cursorLeft;
 	}
 
-	return calledFunctions.get(function_);
-};
-
-const getRealtimeSignals=function(){
-const length=SIGRTMAX-SIGRTMIN+1;
-return Array.from({length},getRealtimeSignal);
-};
-
-const getRealtimeSignal=function(value,index){
-return {
-name:`SIGRT${index+1}`,
-number:SIGRTMIN+index,
-action:"terminate",
-description:"Application-specific signal (realtime)",
-standard:"posix"};
-
-};
-
-const SIGRTMIN=34;
-const SIGRTMAX=64;
-
-const SIGNALS=[
-{
-name:"SIGHUP",
-number:1,
-action:"terminate",
-description:"Terminal closed",
-standard:"posix"},
-
-{
-name:"SIGINT",
-number:2,
-action:"terminate",
-description:"User interruption with CTRL-C",
-standard:"ansi"},
-
-{
-name:"SIGQUIT",
-number:3,
-action:"core",
-description:"User interruption with CTRL-\\",
-standard:"posix"},
-
-{
-name:"SIGILL",
-number:4,
-action:"core",
-description:"Invalid machine instruction",
-standard:"ansi"},
-
-{
-name:"SIGTRAP",
-number:5,
-action:"core",
-description:"Debugger breakpoint",
-standard:"posix"},
-
-{
-name:"SIGABRT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"ansi"},
-
-{
-name:"SIGIOT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"bsd"},
-
-{
-name:"SIGBUS",
-number:7,
-action:"core",
-description:
-"Bus error due to misaligned, non-existing address or paging error",
-standard:"bsd"},
-
-{
-name:"SIGEMT",
-number:7,
-action:"terminate",
-description:"Command should be emulated but is not implemented",
-standard:"other"},
-
-{
-name:"SIGFPE",
-number:8,
-action:"core",
-description:"Floating point arithmetic error",
-standard:"ansi"},
-
-{
-name:"SIGKILL",
-number:9,
-action:"terminate",
-description:"Forced termination",
-standard:"posix",
-forced:true},
-
-{
-name:"SIGUSR1",
-number:10,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"},
-
-{
-name:"SIGSEGV",
-number:11,
-action:"core",
-description:"Segmentation fault",
-standard:"ansi"},
-
-{
-name:"SIGUSR2",
-number:12,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"},
-
-{
-name:"SIGPIPE",
-number:13,
-action:"terminate",
-description:"Broken pipe or socket",
-standard:"posix"},
-
-{
-name:"SIGALRM",
-number:14,
-action:"terminate",
-description:"Timeout or timer",
-standard:"posix"},
-
-{
-name:"SIGTERM",
-number:15,
-action:"terminate",
-description:"Termination",
-standard:"ansi"},
-
-{
-name:"SIGSTKFLT",
-number:16,
-action:"terminate",
-description:"Stack is empty or overflowed",
-standard:"other"},
-
-{
-name:"SIGCHLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"posix"},
-
-{
-name:"SIGCLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"other"},
-
-{
-name:"SIGCONT",
-number:18,
-action:"unpause",
-description:"Unpaused",
-standard:"posix",
-forced:true},
-
-{
-name:"SIGSTOP",
-number:19,
-action:"pause",
-description:"Paused",
-standard:"posix",
-forced:true},
-
-{
-name:"SIGTSTP",
-number:20,
-action:"pause",
-description:"Paused using CTRL-Z or \"suspend\"",
-standard:"posix"},
-
-{
-name:"SIGTTIN",
-number:21,
-action:"pause",
-description:"Background process cannot read terminal input",
-standard:"posix"},
-
-{
-name:"SIGBREAK",
-number:21,
-action:"terminate",
-description:"User interruption with CTRL-BREAK",
-standard:"other"},
-
-{
-name:"SIGTTOU",
-number:22,
-action:"pause",
-description:"Background process cannot write to terminal output",
-standard:"posix"},
-
-{
-name:"SIGURG",
-number:23,
-action:"ignore",
-description:"Socket received out-of-band data",
-standard:"bsd"},
-
-{
-name:"SIGXCPU",
-number:24,
-action:"core",
-description:"Process timed out",
-standard:"bsd"},
-
-{
-name:"SIGXFSZ",
-number:25,
-action:"core",
-description:"File too big",
-standard:"bsd"},
-
-{
-name:"SIGVTALRM",
-number:26,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"},
-
-{
-name:"SIGPROF",
-number:27,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"},
-
-{
-name:"SIGWINCH",
-number:28,
-action:"ignore",
-description:"Terminal window size changed",
-standard:"bsd"},
-
-{
-name:"SIGIO",
-number:29,
-action:"terminate",
-description:"I/O is available",
-standard:"other"},
-
-{
-name:"SIGPOLL",
-number:29,
-action:"terminate",
-description:"Watched event",
-standard:"other"},
-
-{
-name:"SIGINFO",
-number:29,
-action:"ignore",
-description:"Request for process information",
-standard:"other"},
-
-{
-name:"SIGPWR",
-number:30,
-action:"terminate",
-description:"Device running out of power",
-standard:"systemv"},
-
-{
-name:"SIGSYS",
-number:31,
-action:"core",
-description:"Invalid system call",
-standard:"other"},
-
-{
-name:"SIGUNUSED",
-number:31,
-action:"terminate",
-description:"Invalid system call",
-standard:"other"}];
-
-const getSignals=function(){
-const realtimeSignals=getRealtimeSignals();
-const signals=[...SIGNALS,...realtimeSignals].map(normalizeSignal);
-return signals;
-};
-
-
-
-
-
-
-
-const normalizeSignal=function({
-name,
-number:defaultNumber,
-description,
-action,
-forced=false,
-standard})
-{
-const{
-signals:{[name]:constantSignal}}=
-constants$5;
-const supported=constantSignal!==undefined;
-const number=supported?constantSignal:defaultNumber;
-return {name,number,description,supported,action,forced,standard};
-};
-
-const getSignalsByName=function(){
-const signals=getSignals();
-return signals.reduce(getSignalByName,{});
-};
-
-const getSignalByName=function(
-signalByNameMemo,
-{name,number,description,supported,action,forced,standard})
-{
-return {
-...signalByNameMemo,
-[name]:{name,number,description,supported,action,forced,standard}};
-
-};
-
-const signalsByName=getSignalsByName();
-
-
-
-
-const getSignalsByNumber=function(){
-const signals=getSignals();
-const length=SIGRTMAX+1;
-const signalsA=Array.from({length},(value,number)=>
-getSignalByNumber(number,signals));
-
-return Object.assign({},...signalsA);
-};
-
-const getSignalByNumber=function(number,signals){
-const signal=findSignalByNumber(number,signals);
-
-if(signal===undefined){
-return {};
-}
-
-const{name,description,supported,action,forced,standard}=signal;
-return {
-[number]:{
-name,
-number,
-description,
-supported,
-action,
-forced,
-standard}};
-
-
+	return clear;
 };
 
+ansiEscapes.eraseEndLine = ESC + 'K';
+ansiEscapes.eraseStartLine = ESC + '1K';
+ansiEscapes.eraseLine = ESC + '2K';
+ansiEscapes.eraseDown = ESC + 'J';
+ansiEscapes.eraseUp = ESC + '1J';
+ansiEscapes.eraseScreen = ESC + '2J';
+ansiEscapes.scrollUp = ESC + 'S';
+ansiEscapes.scrollDown = ESC + 'T';
 
+ansiEscapes.clearScreen = '\u001Bc';
 
-const findSignalByNumber=function(number,signals){
-const signal=signals.find(({name})=>constants$5.signals[name]===number);
+ansiEscapes.clearTerminal = process.platform === 'win32' ?
+	`${ansiEscapes.eraseScreen}${ESC}0f` :
+	// 1. Erases the screen (Only done in case `2` is not supported)
+	// 2. Erases the whole screen including scrollback buffer
+	// 3. Moves cursor to the top-left position
+	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
+	`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
 
-if(signal!==undefined){
-return signal;
-}
+ansiEscapes.beep = BEL;
 
-return signals.find((signalA)=>signalA.number===number);
+ansiEscapes.link = (text, url) => {
+	return [
+		OSC,
+		'8',
+		SEP,
+		SEP,
+		url,
+		BEL,
+		text,
+		OSC,
+		'8',
+		SEP,
+		SEP,
+		BEL
+	].join('');
 };
 
-getSignalsByNumber();
-
-const getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
-	if (timedOut) {
-		return `timed out after ${timeout} milliseconds`;
-	}
-
-	if (isCanceled) {
-		return 'was canceled';
-	}
-
-	if (errorCode !== undefined) {
-		return `failed with ${errorCode}`;
-	}
-
-	if (signal !== undefined) {
-		return `was killed with ${signal} (${signalDescription})`;
-	}
-
-	if (exitCode !== undefined) {
-		return `failed with exit code ${exitCode}`;
-	}
-
-	return 'failed';
-};
+ansiEscapes.image = (buffer, options = {}) => {
+	let returnValue = `${OSC}1337;File=inline=1`;
 
-const makeError = ({
-	stdout,
-	stderr,
-	all,
-	error,
-	signal,
-	exitCode,
-	command,
-	escapedCommand,
-	timedOut,
-	isCanceled,
-	killed,
-	parsed: {options: {timeout}},
-}) => {
-	// `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
-	// We normalize them to `undefined`
-	exitCode = exitCode === null ? undefined : exitCode;
-	signal = signal === null ? undefined : signal;
-	const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
-
-	const errorCode = error && error.code;
-
-	const prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});
-	const execaMessage = `Command ${prefix}: ${command}`;
-	const isError = Object.prototype.toString.call(error) === '[object Error]';
-	const shortMessage = isError ? `${execaMessage}\n${error.message}` : execaMessage;
-	const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
-
-	if (isError) {
-		error.originalMessage = error.message;
-		error.message = message;
-	} else {
-		error = new Error(message);
+	if (options.width) {
+		returnValue += `;width=${options.width}`;
 	}
 
-	error.shortMessage = shortMessage;
-	error.command = command;
-	error.escapedCommand = escapedCommand;
-	error.exitCode = exitCode;
-	error.signal = signal;
-	error.signalDescription = signalDescription;
-	error.stdout = stdout;
-	error.stderr = stderr;
-
-	if (all !== undefined) {
-		error.all = all;
+	if (options.height) {
+		returnValue += `;height=${options.height}`;
 	}
 
-	if ('bufferedData' in error) {
-		delete error.bufferedData;
+	if (options.preserveAspectRatio === false) {
+		returnValue += ';preserveAspectRatio=0';
 	}
 
-	error.failed = true;
-	error.timedOut = Boolean(timedOut);
-	error.isCanceled = isCanceled;
-	error.killed = killed && !timedOut;
-
-	return error;
+	return returnValue + ':' + buffer.toString('base64') + BEL;
 };
 
-const aliases = ['stdin', 'stdout', 'stderr'];
-
-const hasAlias = options => aliases.some(alias => options[alias] !== undefined);
+ansiEscapes.iTerm = {
+	setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
 
-const normalizeStdio = options => {
-	if (!options) {
-		return;
-	}
+	annotation: (message, options = {}) => {
+		let returnValue = `${OSC}1337;`;
 
-	const {stdio} = options;
+		const hasX = typeof options.x !== 'undefined';
+		const hasY = typeof options.y !== 'undefined';
+		if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== 'undefined')) {
+			throw new Error('`x`, `y` and `length` must be defined when `x` or `y` is defined');
+		}
 
-	if (stdio === undefined) {
-		return aliases.map(alias => options[alias]);
-	}
+		message = message.replace(/\|/g, '');
 
-	if (hasAlias(options)) {
-		throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
-	}
+		returnValue += options.isHidden ? 'AddHiddenAnnotation=' : 'AddAnnotation=';
 
-	if (typeof stdio === 'string') {
-		return stdio;
-	}
+		if (options.length > 0) {
+			returnValue +=
+					(hasX ?
+						[message, options.length, options.x, options.y] :
+						[options.length, message]).join('|');
+		} else {
+			returnValue += message;
+		}
 
-	if (!Array.isArray(stdio)) {
-		throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+		return returnValue + BEL;
 	}
-
-	const length = Math.max(stdio.length, aliases.length);
-	return Array.from({length}, (value, index) => stdio[index]);
 };
 
-const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
+const restoreCursor = onetime.exports(() => {
+	signalExit.exports(() => {
+		process$1.stderr.write('\u001B[?25h');
+	}, {alwaysLast: true});
+});
+
+let isHidden = false;
 
-// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
-const spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {
-	const killResult = kill(signal);
-	setKillTimeout(kill, signal, options, killResult);
-	return killResult;
-};
+const cliCursor = {};
 
-const setKillTimeout = (kill, signal, options, killResult) => {
-	if (!shouldForceKill(signal, options, killResult)) {
+cliCursor.show = (writableStream = process$1.stderr) => {
+	if (!writableStream.isTTY) {
 		return;
 	}
 
-	const timeout = getForceKillAfterTimeout(options);
-	const t = setTimeout(() => {
-		kill('SIGKILL');
-	}, timeout);
-
-	// Guarded because there's no `.unref()` when `execa` is used in the renderer
-	// process in Electron. This cannot be tested since we don't run tests in
-	// Electron.
-	// istanbul ignore else
-	if (t.unref) {
-		t.unref();
-	}
+	isHidden = false;
+	writableStream.write('\u001B[?25h');
 };
 
-const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+cliCursor.hide = (writableStream = process$1.stderr) => {
+	if (!writableStream.isTTY) {
+		return;
+	}
 
-const isSigterm = signal => signal === require$$0.constants.signals.SIGTERM
-		|| (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
+	restoreCursor();
+	isHidden = true;
+	writableStream.write('\u001B[?25l');
+};
 
-const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
-	if (forceKillAfterTimeout === true) {
-		return DEFAULT_FORCE_KILL_TIMEOUT;
+cliCursor.toggle = (force, writableStream) => {
+	if (force !== undefined) {
+		isHidden = force;
 	}
 
-	if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
-		throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+	if (isHidden) {
+		cliCursor.show(writableStream);
+	} else {
+		cliCursor.hide(writableStream);
 	}
-
-	return forceKillAfterTimeout;
 };
 
-// `childProcess.cancel()`
-const spawnedCancel = (spawned, context) => {
-	const killResult = spawned.kill();
+const ESCAPES = new Set([
+	'\u001B',
+	'\u009B',
+]);
 
-	if (killResult) {
-		context.isCanceled = true;
-	}
-};
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
 
-const timeoutKill = (spawned, signal, reject) => {
-	spawned.kill(signal);
-	reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
-};
+const wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
 
-// `timeout` option handling
-const setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
-	if (timeout === 0 || timeout === undefined) {
-		return spawnedPromise;
-	}
+// Calculate the length of words split on ' ', ignoring
+// the extra characters added by ansi escape codes
+const wordLengths = string => string.split(' ').map(character => stringWidth(character));
 
-	let timeoutId;
-	const timeoutPromise = new Promise((resolve, reject) => {
-		timeoutId = setTimeout(() => {
-			timeoutKill(spawned, killSignal, reject);
-		}, timeout);
-	});
+// Wrap a long word across multiple rows
+// Ansi escape codes do not count towards length
+const wrapWord = (rows, word, columns) => {
+	const characters = [...word];
 
-	const safeSpawnedPromise = spawnedPromise.finally(() => {
-		clearTimeout(timeoutId);
-	});
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
 
-	return Promise.race([timeoutPromise, safeSpawnedPromise]);
-};
+	for (const [index, character] of characters.entries()) {
+		const characterLength = stringWidth(character);
 
-const validateTimeout = ({timeout}) => {
-	if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
-		throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-	}
-};
+		if (visible + characterLength <= columns) {
+			rows[rows.length - 1] += character;
+		} else {
+			rows.push(character);
+			visible = 0;
+		}
 
-// `cleanup` option handling
-const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
-	if (!cleanup || detached) {
-		return timedPromise;
-	}
+		if (ESCAPES.has(character)) {
+			isInsideEscape = true;
+			isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
+		}
 
-	const removeExitHandler = signalExit.exports(() => {
-		spawned.kill();
-	});
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) {
+				isInsideEscape = false;
+			}
 
-	return timedPromise.finally(() => {
-		removeExitHandler();
-	});
-};
+			continue;
+		}
 
-function isStream(stream) {
-	return stream !== null
-		&& typeof stream === 'object'
-		&& typeof stream.pipe === 'function';
-}
+		visible += characterLength;
 
-// `input` option
-const handleInput = (spawned, input) => {
-	// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
-	// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
-	if (input === undefined || spawned.stdin === undefined) {
-		return;
+		if (visible === columns && index < characters.length - 1) {
+			rows.push('');
+			visible = 0;
+		}
 	}
 
-	if (isStream(input)) {
-		input.pipe(spawned.stdin);
-	} else {
-		spawned.stdin.end(input);
+	// It's possible that the last row we copy over is only
+	// ansi escape characters, handle this edge-case
+	if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
+		rows[rows.length - 2] += rows.pop();
 	}
 };
 
-// `all` interleaves `stdout` and `stderr`
-const makeAllStream = (spawned, {all}) => {
-	if (!all || (!spawned.stdout && !spawned.stderr)) {
-		return;
-	}
+// Trims spaces from a string ignoring invisible sequences
+const stringVisibleTrimSpacesRight = string => {
+	const words = string.split(' ');
+	let last = words.length;
 
-	const mixed = mergeStream();
+	while (last > 0) {
+		if (stringWidth(words[last - 1]) > 0) {
+			break;
+		}
 
-	if (spawned.stdout) {
-		mixed.add(spawned.stdout);
+		last--;
 	}
 
-	if (spawned.stderr) {
-		mixed.add(spawned.stderr);
+	if (last === words.length) {
+		return string;
 	}
 
-	return mixed;
+	return words.slice(0, last).join(' ') + words.slice(last).join('');
 };
 
-// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
-const getBufferedData = async (stream, streamPromise) => {
-	if (!stream) {
-		return;
-	}
-
-	stream.destroy();
-
-	try {
-		return await streamPromise;
-	} catch (error) {
-		return error.bufferedData;
+// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
+//
+// 'hard' will never allow a string to take up more than columns characters
+//
+// 'soft' allows long words to expand past the column length
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === '') {
+		return '';
 	}
-};
 
-const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
-	if (!stream || !buffer) {
-		return;
-	}
+	let returnValue = '';
+	let escapeCode;
+	let escapeUrl;
 
-	if (encoding) {
-		return getStream.exports(stream, {encoding, maxBuffer});
-	}
+	const lengths = wordLengths(string);
+	let rows = [''];
 
-	return getStream.exports.buffer(stream, {maxBuffer});
-};
+	for (const [index, word] of string.split(' ').entries()) {
+		if (options.trim !== false) {
+			rows[rows.length - 1] = rows[rows.length - 1].trimStart();
+		}
 
-// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
-const getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
-	const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
-	const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
-	const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
+		let rowLength = stringWidth(rows[rows.length - 1]);
 
-	try {
-		return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
-	} catch (error) {
-		return Promise.all([
-			{error, signal: error.signal, timedOut: error.timedOut},
-			getBufferedData(stdout, stdoutPromise),
-			getBufferedData(stderr, stderrPromise),
-			getBufferedData(all, allPromise),
-		]);
-	}
-};
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				// If we start with a new word but the current row length equals the length of the columns, add a new row
+				rows.push('');
+				rowLength = 0;
+			}
 
-const nativePromisePrototype = (async () => {})().constructor.prototype;
-const descriptors = ['then', 'catch', 'finally'].map(property => [
-	property,
-	Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),
-]);
+			if (rowLength > 0 || options.trim === false) {
+				rows[rows.length - 1] += ' ';
+				rowLength++;
+			}
+		}
 
-// The return value is a mixin of `childProcess` and `Promise`
-const mergePromise = (spawned, promise) => {
-	for (const [property, descriptor] of descriptors) {
-		// Starting the main `promise` is deferred to avoid consuming streams
-		const value = typeof promise === 'function'
-			? (...args) => Reflect.apply(descriptor.value, promise(), args)
-			: descriptor.value.bind(promise);
+		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
+		if (options.hard && lengths[index] > columns) {
+			const remainingColumns = (columns - rowLength);
+			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+			if (breaksStartingNextLine < breaksStartingThisLine) {
+				rows.push('');
+			}
 
-		Reflect.defineProperty(spawned, property, {...descriptor, value});
-	}
+			wrapWord(rows, word, columns);
+			continue;
+		}
 
-	return spawned;
-};
+		if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				continue;
+			}
 
-// Use promises instead of `child_process` events
-const getSpawnedPromise = spawned => new Promise((resolve, reject) => {
-	spawned.on('exit', (exitCode, signal) => {
-		resolve({exitCode, signal});
-	});
+			rows.push('');
+		}
 
-	spawned.on('error', error => {
-		reject(error);
-	});
+		if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			continue;
+		}
 
-	if (spawned.stdin) {
-		spawned.stdin.on('error', error => {
-			reject(error);
-		});
+		rows[rows.length - 1] += word;
 	}
-});
 
-const normalizeArgs = (file, args = []) => {
-	if (!Array.isArray(args)) {
-		return [file];
+	if (options.trim !== false) {
+		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
 	}
 
-	return [file, ...args];
-};
-
-const NO_ESCAPE_REGEXP = /^[\w.-]+$/;
-const DOUBLE_QUOTES_REGEXP = /"/g;
-
-const escapeArg = arg => {
-	if (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {
-		return arg;
-	}
+	const pre = [...rows.join('\n')];
 
-	return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
-};
+	for (const [index, character] of pre.entries()) {
+		returnValue += character;
 
-const joinCommand = (file, args) => normalizeArgs(file, args).join(' ');
+		if (ESCAPES.has(character)) {
+			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
+			if (groups.code !== undefined) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? undefined : code;
+			} else if (groups.uri !== undefined) {
+				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+			}
+		}
 
-const getEscapedCommand = (file, args) => normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');
+		const code = ansiStyles.codes.get(Number(escapeCode));
 
-const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
+		if (pre[index + 1] === '\n') {
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink('');
+			}
 
-const getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {
-	const env = extendEnv ? {...process$1.env, ...envOption} : envOption;
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(code);
+			}
+		} else if (character === '\n') {
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(escapeCode);
+			}
 
-	if (preferLocal) {
-		return npmRunPathEnv({env, cwd: localDir, execPath});
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink(escapeUrl);
+			}
+		}
 	}
 
-	return env;
+	return returnValue;
 };
 
-const handleArguments = (file, args, options = {}) => {
-	const parsed = crossSpawn.exports._parse(file, args, options);
-	file = parsed.command;
-	args = parsed.args;
-	options = parsed.options;
-
-	options = {
-		maxBuffer: DEFAULT_MAX_BUFFER,
-		buffer: true,
-		stripFinalNewline: true,
-		extendEnv: true,
-		preferLocal: false,
-		localDir: options.cwd || process$1.cwd(),
-		execPath: process$1.execPath,
-		encoding: 'utf8',
-		reject: true,
-		cleanup: true,
-		all: false,
-		windowsHide: true,
-		...options,
-	};
+// For each newline, invoke the method separately
+function wrapAnsi(string, columns, options) {
+	return String(string)
+		.normalize()
+		.replace(/\r\n/g, '\n')
+		.split('\n')
+		.map(line => exec(line, columns, options))
+		.join('\n');
+}
 
-	options.env = getEnv(options);
+const defaultTerminalHeight = 24;
 
-	options.stdio = normalizeStdio(options);
+const getWidth = stream => {
+	const {columns} = stream;
 
-	if (process$1.platform === 'win32' && path$a.basename(file, '.exe') === 'cmd') {
-		// #116
-		args.unshift('/q');
+	if (!columns) {
+		return 80;
 	}
 
-	return {file, args, options, parsed};
+	return columns;
 };
 
-const handleOutput = (options, value, error) => {
-	if (typeof value !== 'string' && !Buffer.isBuffer(value)) {
-		// When `execaSync()` errors, we normalize it to '' to mimic `execa()`
-		return error === undefined ? undefined : '';
-	}
+const fitToTerminalHeight = (stream, text) => {
+	const terminalHeight = stream.rows || defaultTerminalHeight;
+	const lines = text.split('\n');
 
-	if (options.stripFinalNewline) {
-		return stripFinalNewline(value);
+	const toRemove = lines.length - terminalHeight;
+	if (toRemove <= 0) {
+		return text;
 	}
 
-	return value;
+	return sliceAnsi(
+		text,
+		stripAnsi(lines.slice(0, toRemove).join('\n')).length + 1,
+	);
 };
 
-function execa(file, args, options) {
-	const parsed = handleArguments(file, args, options);
-	const command = joinCommand(file, args);
-	const escapedCommand = getEscapedCommand(file, args);
+function createLogUpdate(stream, {showCursor = false} = {}) {
+	let previousLineCount = 0;
+	let previousWidth = getWidth(stream);
+	let previousOutput = '';
+
+	const render = (...arguments_) => {
+		if (!showCursor) {
+			cliCursor.hide();
+		}
+
+		let output = arguments_.join(' ') + '\n';
+		output = fitToTerminalHeight(stream, output);
+		const width = getWidth(stream);
+		if (output === previousOutput && previousWidth === width) {
+			return;
+		}
 
-	validateTimeout(parsed.options);
+		previousOutput = output;
+		previousWidth = width;
+		output = wrapAnsi(output, width, {
+			trim: false,
+			hard: true,
+			wordWrap: false,
+		});
+		stream.write(ansiEscapes.eraseLines(previousLineCount) + output);
+		previousLineCount = output.split('\n').length;
+	};
 
-	let spawned;
-	try {
-		spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
-	} catch (error) {
-		// Ensure the returned error is always both a promise and a child process
-		const dummySpawned = new childProcess.ChildProcess();
-		const errorPromise = Promise.reject(makeError({
-			error,
-			stdout: '',
-			stderr: '',
-			all: '',
-			command,
-			escapedCommand,
-			parsed,
-			timedOut: false,
-			isCanceled: false,
-			killed: false,
-		}));
-		return mergePromise(dummySpawned, errorPromise);
-	}
+	render.clear = () => {
+		stream.write(ansiEscapes.eraseLines(previousLineCount));
+		previousOutput = '';
+		previousWidth = getWidth(stream);
+		previousLineCount = 0;
+	};
 
-	const spawnedPromise = getSpawnedPromise(spawned);
-	const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
-	const processDone = setExitHandler(spawned, parsed.options, timedPromise);
-
-	const context = {isCanceled: false};
-
-	spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
-	spawned.cancel = spawnedCancel.bind(null, spawned, context);
-
-	const handlePromise = async () => {
-		const [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
-		const stdout = handleOutput(parsed.options, stdoutResult);
-		const stderr = handleOutput(parsed.options, stderrResult);
-		const all = handleOutput(parsed.options, allResult);
-
-		if (error || exitCode !== 0 || signal !== null) {
-			const returnedError = makeError({
-				error,
-				exitCode,
-				signal,
-				stdout,
-				stderr,
-				all,
-				command,
-				escapedCommand,
-				parsed,
-				timedOut,
-				isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
-				killed: spawned.killed,
-			});
-
-			if (!parsed.options.reject) {
-				return returnedError;
-			}
+	render.done = () => {
+		previousOutput = '';
+		previousWidth = getWidth(stream);
+		previousLineCount = 0;
 
-			throw returnedError;
+		if (!showCursor) {
+			cliCursor.show();
 		}
-
-		return {
-			command,
-			escapedCommand,
-			exitCode: 0,
-			stdout,
-			stderr,
-			all,
-			failed: false,
-			timedOut: false,
-			isCanceled: false,
-			killed: false,
-		};
 	};
 
-	const handlePromiseOnce = onetime(handlePromise);
+	return render;
+}
+
+createLogUpdate(process$1.stdout);
 
-	handleInput(spawned, parsed.options.input);
+createLogUpdate(process$1.stderr);
 
-	spawned.all = makeAllStream(spawned, parsed.options);
+var version = "0.19.0";
 
-	return mergePromise(spawned, handlePromiseOnce);
+function fileFromParsedStack(stack) {
+  var _a, _b;
+  if ((_b = (_a = stack == null ? void 0 : stack.sourcePos) == null ? void 0 : _a.source) == null ? void 0 : _b.startsWith(".."))
+    return join(stack.file, "../", stack.sourcePos.source);
+  return stack.file;
+}
+async function printError(error, ctx, options = {}) {
+  const { showCodeFrame = true, fullStack = false, type } = options;
+  let e = error;
+  if (typeof error === "string") {
+    e = {
+      message: error.split(/\n/g)[0],
+      stack: error
+    };
+  }
+  const stacks = parseStacktrace(e, fullStack);
+  await interpretSourcePos(stacks, ctx);
+  const nearest = stacks.find((stack) => ctx.server.moduleGraph.getModuleById(stack.file) && existsSync(stack.file));
+  const errorProperties = getErrorProperties(e);
+  if (type)
+    printErrorType(type, ctx);
+  printErrorMessage(e, ctx.logger);
+  printStack(ctx, stacks, nearest, errorProperties, (s, pos) => {
+    if (showCodeFrame && s === nearest && nearest) {
+      const file = fileFromParsedStack(nearest);
+      if (existsSync(file)) {
+        const sourceCode = readFileSync(file, "utf-8");
+        ctx.logger.log(picocolors.exports.yellow(generateCodeFrame(sourceCode, 4, pos)));
+      }
+    }
+  });
+  if (e.cause) {
+    e.cause.name = `Caused by: ${e.cause.name}`;
+    await printError(e.cause, ctx, { fullStack, showCodeFrame: false });
+  }
+  handleImportOutsideModuleError(e.stack || e.stackStr || "", ctx);
+  if (e.showDiff) {
+    displayDiff(stringify$5(e.actual), stringify$5(e.expected), ctx.logger.console, {
+      outputTruncateLength: ctx.config.outputTruncateLength,
+      outputDiffLines: ctx.config.outputDiffLines
+    });
+  }
+}
+function printErrorType(type, ctx) {
+  ctx.logger.error(`
+${picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(` ${type} `))))}`);
+}
+const skipErrorProperties = [
+  "message",
+  "name",
+  "nameStr",
+  "stack",
+  "cause",
+  "stacks",
+  "stackStr",
+  "type",
+  "showDiff",
+  "actual",
+  "expected",
+  "constructor",
+  "toString"
+];
+function getErrorProperties(e) {
+  const errorObject = /* @__PURE__ */ Object.create(null);
+  if (e.name === "AssertionError")
+    return errorObject;
+  for (const key of Object.getOwnPropertyNames(e)) {
+    if (!skipErrorProperties.includes(key))
+      errorObject[key] = e[key];
+  }
+  return errorObject;
 }
+const esmErrors = [
+  "Cannot use import statement outside a module",
+  "Unexpected token 'export'"
+];
+function handleImportOutsideModuleError(stack, ctx) {
+  if (!esmErrors.some((e) => stack.includes(e)))
+    return;
+  const path = normalize(stack.split("\n")[0].trim());
+  let name = path.split("/node_modules/").pop() || "";
+  if (name == null ? void 0 : name.startsWith("@"))
+    name = name.split("/").slice(0, 2).join("/");
+  else
+    name = name.split("/")[0];
+  ctx.logger.error(picocolors.exports.yellow(`Module ${path} seems to be an ES Module but shipped in a CommonJS package. You might want to create an issue to the package ${picocolors.exports.bold(`"${name}"`)} asking them to ship the file in .mjs extension or add "type": "module" in their package.json.
+
+As a temporary workaround you can try to inline the package by updating your config:
 
-class VitestGit {
-  constructor(cwd) {
-    this.cwd = cwd;
+` + picocolors.exports.gray(picocolors.exports.dim("// vitest.config.js")) + "\n" + picocolors.exports.green(`export default {
+  test: {
+    deps: {
+      inline: [
+        ${picocolors.exports.yellow(picocolors.exports.bold(`"${name}"`))}
+      ]
+    }
   }
-  async resolveFilesWithGitCommand(args) {
-    let result;
-    try {
-      result = await execa("git", args, { cwd: this.root });
-    } catch (e) {
-      e.message = e.stderr;
-      throw e;
+}
+`)));
+}
+function displayDiff(actual, expected, console, options) {
+  console.error(picocolors.exports.gray(unifiedDiff(actual, expected, options)) + "\n");
+}
+function printErrorMessage(error, logger) {
+  const errorName = error.name || error.nameStr || "Unknown Error";
+  logger.error(picocolors.exports.red(`${picocolors.exports.bold(errorName)}: ${error.message}`));
+}
+function printStack(ctx, stack, highlight, errorProperties, onStack) {
+  if (!stack.length)
+    return;
+  const logger = ctx.logger;
+  for (const frame of stack) {
+    const pos = frame.sourcePos || frame;
+    const color = frame === highlight ? picocolors.exports.yellow : picocolors.exports.gray;
+    const file = fileFromParsedStack(frame);
+    const path = relative(ctx.config.root, file);
+    logger.log(color(` ${picocolors.exports.dim(F_POINTER)} ${[frame.method, picocolors.exports.dim(`${path}:${pos.line}:${pos.column}`)].filter(Boolean).join(" ")}`));
+    onStack == null ? void 0 : onStack(frame, pos);
+    if (frame.file in ctx.state.filesMap)
+      break;
+  }
+  logger.log();
+  const hasProperties = Object.keys(errorProperties).length > 0;
+  if (hasProperties) {
+    logger.log(picocolors.exports.red(picocolors.exports.dim(divider())));
+    const propertiesString = stringify$5(errorProperties, 10, { printBasicPrototype: false });
+    logger.log(picocolors.exports.red(picocolors.exports.bold("Serialized Error:")), picocolors.exports.gray(propertiesString));
+  }
+}
+function generateCodeFrame(source, indent = 0, start = 0, end, range = 2) {
+  var _a;
+  start = posToNumber(source, start);
+  end = end || start;
+  const lines = source.split(lineSplitRE);
+  let count = 0;
+  let res = [];
+  const columns = ((_a = process.stdout) == null ? void 0 : _a.columns) || 80;
+  function lineNo(no = "") {
+    return picocolors.exports.gray(`${String(no).padStart(3, " ")}| `);
+  }
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length + 1;
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length)
+          continue;
+        const lineLength = lines[j].length;
+        if (lineLength > 200)
+          return "";
+        res.push(lineNo(j + 1) + cliTruncate(lines[j].replace(/\t/g, " "), columns - 5 - indent));
+        if (j === i) {
+          const pad = start - (count - lineLength);
+          const length = Math.max(1, end > count ? lineLength - pad : end - start);
+          res.push(lineNo() + " ".repeat(pad) + picocolors.exports.red("^".repeat(length)));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(1, Math.min(end - count, lineLength));
+            res.push(lineNo() + picocolors.exports.red("^".repeat(length)));
+          }
+          count += lineLength + 1;
+        }
+      }
+      break;
     }
-    return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
   }
-  async findChangedFiles(options) {
-    const root = await this.getRoot(this.cwd);
-    if (!root)
-      return null;
-    this.root = root;
-    const changedSince = options.changedSince;
-    if (typeof changedSince === "string") {
-      const [committed, staged2, unstaged2] = await Promise.all([
-        this.getFilesSince(changedSince),
-        this.getStagedFiles(),
-        this.getUnstagedFiles()
-      ]);
-      return [...committed, ...staged2, ...unstaged2];
-    }
-    const [staged, unstaged] = await Promise.all([
-      this.getStagedFiles(),
-      this.getUnstagedFiles()
-    ]);
-    return [...staged, ...unstaged];
-  }
-  getFilesSince(hash) {
-    return this.resolveFilesWithGitCommand(["diff", "--name-only", `${hash}...HEAD`]);
-  }
-  getStagedFiles() {
-    return this.resolveFilesWithGitCommand(["diff", "--cached", "--name-only"]);
-  }
-  getUnstagedFiles() {
-    return this.resolveFilesWithGitCommand([
-      "ls-files",
-      "--other",
-      "--modified",
-      "--exclude-standard"
-    ]);
-  }
-  async getRoot(cwd) {
-    const options = ["rev-parse", "--show-cdup"];
-    try {
-      const result = await execa("git", options, { cwd });
-      return resolve(cwd, result.stdout);
-    } catch {
-      return null;
+  if (indent)
+    res = res.map((line) => " ".repeat(indent) + line);
+  return res.join("\n");
+}
+
+class Logger {
+  constructor(ctx, console = globalThis.console) {
+    this.ctx = ctx;
+    this.console = console;
+    this.outputStream = process.stdout;
+    this.errorStream = process.stderr;
+    this.logUpdate = createLogUpdate(process.stdout);
+  }
+  log(...args) {
+    this._clearScreen();
+    this.console.log(...args);
+  }
+  error(...args) {
+    this._clearScreen();
+    this.console.error(...args);
+  }
+  warn(...args) {
+    this._clearScreen();
+    this.console.warn(...args);
+  }
+  clearScreen(message, force = false) {
+    if (this.ctx.server.config.clearScreen === false) {
+      this.console.log(message);
+      return;
     }
+    this._clearScreenPending = message;
+    if (force)
+      this._clearScreen();
+  }
+  _clearScreen() {
+    if (!this._clearScreenPending)
+      return;
+    const log = this._clearScreenPending;
+    this._clearScreenPending = void 0;
+    this.console.log(`\x1B[1;1H\x1B[J${log}`);
+  }
+  printError(err, fullStack = false, type) {
+    return printError(err, this.ctx, {
+      fullStack,
+      type,
+      showCodeFrame: true
+    });
+  }
+  printNoTestFound(filters) {
+    const config = this.ctx.config;
+    const comma = picocolors.exports.dim(", ");
+    if (filters == null ? void 0 : filters.length)
+      this.console.error(picocolors.exports.dim("filter:  ") + picocolors.exports.yellow(filters.join(comma)));
+    if (config.include)
+      this.console.error(picocolors.exports.dim("include: ") + picocolors.exports.yellow(config.include.join(comma)));
+    if (config.exclude)
+      this.console.error(picocolors.exports.dim("exclude:  ") + picocolors.exports.yellow(config.exclude.join(comma)));
+    if (config.watchExclude)
+      this.console.error(picocolors.exports.dim("watch exclude:  ") + picocolors.exports.yellow(config.watchExclude.join(comma)));
+    if (config.passWithNoTests)
+      this.log("No test files found, exiting with code 0\n");
+    else
+      this.error(picocolors.exports.red("\nNo test files found, exiting with code 1"));
+  }
+  printBanner() {
+    var _a, _b, _c;
+    this.log();
+    const versionTest = this.ctx.config.watch ? picocolors.exports.blue(`v${version}`) : picocolors.exports.cyan(`v${version}`);
+    const mode = this.ctx.config.watch ? picocolors.exports.blue(" DEV ") : picocolors.exports.cyan(" RUN ");
+    this.log(`${picocolors.exports.inverse(picocolors.exports.bold(mode))} ${versionTest} ${picocolors.exports.gray(this.ctx.config.root)}`);
+    if (this.ctx.config.browser)
+      this.log(picocolors.exports.dim(picocolors.exports.green(`      Browser runner started at http://${((_a = this.ctx.config.api) == null ? void 0 : _a.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.server.config.server.port}`)}`)));
+    else if (this.ctx.config.ui)
+      this.log(picocolors.exports.dim(picocolors.exports.green(`      UI started at http://${((_b = this.ctx.config.api) == null ? void 0 : _b.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.server.config.server.port}`)}${this.ctx.config.uiBase}`)));
+    else if (this.ctx.config.api)
+      this.log(picocolors.exports.dim(picocolors.exports.green(`      API started at http://${((_c = this.ctx.config.api) == null ? void 0 : _c.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.config.api.port}`)}`)));
+    this.log();
+  }
+  async printUnhandledErrors(errors) {
+    const errorMessage = picocolors.exports.red(picocolors.exports.bold(`
+Vitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run. This might cause false positive tests.
+Please, resolve all the errors to make sure your tests are not affected.`));
+    this.log(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(" Unhandled Errors ")))));
+    this.log(errorMessage);
+    await Promise.all(errors.map(async (err) => {
+      await this.printError(err, true, err.type || "Unhandled Error");
+    }));
+    this.log(picocolors.exports.red(divider()));
   }
 }
 
 const WATCHER_DEBOUNCE = 100;
-const CLOSE_TIMEOUT = 1e3;
 class Vitest {
   constructor() {
     this.config = void 0;
     this.server = void 0;
     this.state = void 0;
     this.snapshot = void 0;
+    this.cache = void 0;
     this.reporters = void 0;
-    this.outputStream = process.stdout;
-    this.errorStream = process.stderr;
     this.vitenode = void 0;
     this.invalidates = /* @__PURE__ */ new Set();
     this.changedTests = /* @__PURE__ */ new Set();
@@ -10289,7 +9316,7 @@ class Vitest {
     this.runner = void 0;
     this._onRestartListeners = [];
     this.unregisterWatcher = noop$1;
-    this.console = globalThis.console;
+    this.logger = new Logger(this);
   }
   async setServer(options, server) {
     var _a, _b;
@@ -10302,6 +9329,7 @@ class Vitest {
     this.server = server;
     this.config = resolved;
     this.state = new StateManager();
+    this.cache = new VitestCache();
     this.snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
     if (this.config.watch)
       this.registerWatcher();
@@ -10322,8 +9350,12 @@ class Vitest {
     this._onRestartListeners.forEach((fn) => fn());
     if (resolved.coverage.enabled)
       await cleanCoverage(resolved.coverage, resolved.coverage.clean);
-    this.state.results.setConfig(resolved.root, resolved.cache);
-    await this.state.results.readFromCache();
+    this.cache.results.setConfig(resolved.root, resolved.cache);
+    try {
+      await this.cache.results.readFromCache();
+    } catch (err) {
+      this.logger.error(`[vitest] Error, while trying to parse cache in ${this.cache.results.getCachePath()}:`, err);
+    }
   }
   getSerializableConfig() {
     return deepMerge({
@@ -10345,24 +9377,14 @@ class Vitest {
     const files = await this.filterTestsBySource(await this.globTestFiles(filters));
     if (!files.length) {
       const exitCode = this.config.passWithNoTests ? 0 : 1;
-      const comma = picocolors.exports.dim(", ");
-      if (filters == null ? void 0 : filters.length)
-        this.console.error(picocolors.exports.dim("filter:  ") + picocolors.exports.yellow(filters.join(comma)));
-      if (this.config.include)
-        this.console.error(picocolors.exports.dim("include: ") + picocolors.exports.yellow(this.config.include.join(comma)));
-      if (this.config.watchExclude)
-        this.console.error(picocolors.exports.dim("watch exclude:  ") + picocolors.exports.yellow(this.config.watchExclude.join(comma)));
-      if (this.config.passWithNoTests)
-        this.log("No test files found, exiting with code 0\n");
-      else
-        this.error(picocolors.exports.red("\nNo test files found, exiting with code 1"));
+      this.logger.printNoTestFound(filters);
       process.exit(exitCode);
     }
-    await Promise.all(files.map((file) => this.state.stats.updateStats(file)));
+    await Promise.all(files.map((file) => this.cache.stats.updateStats(file)));
     await this.runFiles(files);
     if (this.config.coverage.enabled)
       await reportCoverage(this);
-    if (this.config.watch)
+    if (this.config.watch && !this.config.browser)
       await this.report("onWatcherStart");
   }
   async getTestDependencies(filepath) {
@@ -10386,12 +9408,13 @@ class Vitest {
   }
   async filterTestsBySource(tests) {
     if (this.config.changed && !this.config.related) {
+      const { VitestGit } = await import('./chunk-node-git.9058b82a.mjs');
       const vitestGit = new VitestGit(this.config.root);
       const related2 = await vitestGit.findChangedFiles({
         changedSince: this.config.changed
       });
       if (!related2) {
-        this.error(picocolors.exports.red("Could not find Git root. Have you initialized git with `git init`?\n"));
+        this.logger.error(picocolors.exports.red("Could not find Git root. Have you initialized git with `git init`?\n"));
         process.exit(1);
       }
       this.config.related = Array.from(new Set(related2));
@@ -10432,9 +9455,10 @@ class Vitest {
       const files = this.state.getFiles();
       if (hasFailed(files))
         process.exitCode = 1;
-      await this.report("onFinished", files, this.state.getUnhandledErrors());
-      this.state.results.updateResults(files);
-      await this.state.results.writeToCache();
+      if (!this.config.browser)
+        await this.report("onFinished", files, this.state.getUnhandledErrors());
+      this.cache.results.updateResults(files);
+      await this.cache.results.writeToCache();
     })().finally(() => {
       this.runningPromise = void 0;
     });
@@ -10443,7 +9467,8 @@ class Vitest {
   async rerunFiles(files = this.state.getFilepaths(), trigger) {
     await this.report("onWatcherRerun", files, trigger);
     await this.runFiles(files);
-    await this.report("onWatcherStart");
+    if (!this.config.browser)
+      await this.report("onWatcherStart");
   }
   async changeNamePattern(pattern, files = this.state.getFilepaths(), trigger) {
     this.config.testNamePattern = pattern ? new RegExp(pattern) : void 0;
@@ -10468,22 +9493,6 @@ class Vitest {
       this.configOverride = void 0;
     }
   }
-  log(...args) {
-    this.console.log(...args);
-  }
-  error(...args) {
-    this.console.error(...args);
-  }
-  clearScreen() {
-    var _a;
-    if (this.server.config.clearScreen === false)
-      return;
-    const repeatCount = (((_a = process.stdout) == null ? void 0 : _a.rows) ?? 0) - 2;
-    const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
-    this.console.log(blank);
-    readline.cursorTo(process.stdout, 0, 0);
-    readline.clearScreenDown(process.stdout);
-  }
   async scheduleRerun(triggerId) {
     const currentCount = this.restartsCount;
     safeClearTimeout(this._rerunTimer);
@@ -10508,7 +9517,8 @@ class Vitest {
       await this.runFiles(files);
       if (this.config.coverage.enabled)
         await reportCoverage(this);
-      await this.report("onWatcherStart");
+      if (!this.config.browser)
+        await this.report("onWatcherStart");
     }, WATCHER_DEBOUNCE);
   }
   registerWatcher() {
@@ -10523,8 +9533,8 @@ class Vitest {
       this.invalidates.add(id);
       if (this.state.filesMap.has(id)) {
         this.state.filesMap.delete(id);
-        this.state.results.removeFromCache(id);
-        this.state.stats.removeStats(id);
+        this.cache.results.removeFromCache(id);
+        this.cache.stats.removeStats(id);
         this.changedTests.delete(id);
         this.report("onTestRemoved", id);
       }
@@ -10533,7 +9543,7 @@ class Vitest {
       id = slash$2(id);
       if (await this.isTargetFile(id)) {
         this.changedTests.add(id);
-        await this.state.stats.updateStats(id);
+        await this.cache.stats.updateStats(id);
         this.scheduleRerun(id);
       }
     };
@@ -10584,7 +9594,7 @@ class Vitest {
         this.server.close()
       ].filter(Boolean)).then((results) => {
         results.filter((r) => r.status === "rejected").forEach((err) => {
-          this.error("error during close", err.reason);
+          this.logger.error("error during close", err.reason);
         });
       });
     }
@@ -10592,9 +9602,9 @@ class Vitest {
   }
   async exit(force = false) {
     safeSetTimeout(() => {
-      console.warn(`close timed out after ${CLOSE_TIMEOUT}ms`);
+      console.warn(`close timed out after ${this.config.teardownTimeout}ms`);
       process.exit();
-    }, CLOSE_TIMEOUT).unref();
+    }, this.config.teardownTimeout).unref();
     await this.close();
     if (force)
       process.exit();
@@ -10648,13 +9658,6 @@ class Vitest {
   isInSourceTestFile(code) {
     return code.includes("import.meta.vitest");
   }
-  printError(err, fullStack = false, type) {
-    return printError(err, this, {
-      fullStack,
-      type,
-      showCodeFrame: true
-    });
-  }
   onServerRestarted(fn) {
     this._onRestartListeners.push(fn);
   }
@@ -10731,9 +9734,9 @@ const GlobalSetupPlugin = (ctx) => {
           globalSetupFile.teardown = teardown;
         }
       } catch (e) {
-        ctx.error(`
+        ctx.logger.error(`
 ${picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(" Error during global setup "))))}`);
-        await ctx.printError(e);
+        await ctx.logger.printError(e);
         process.exit(1);
       }
     },
@@ -10744,7 +9747,7 @@ ${picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inve
           try {
             await ((_a = globalSetupFile.teardown) == null ? void 0 : _a.call(globalSetupFile));
           } catch (error) {
-            console.error(`error during global teardown of ${globalSetupFile.file}`, error);
+            ctx.logger.error(`error during global teardown of ${globalSetupFile.file}`, error);
           }
         }
       }
@@ -10892,9 +9895,15 @@ function CSSEnablerPlugin(ctx) {
 async function VitestPlugin(options = {}, ctx = new Vitest()) {
   let haveStarted = false;
   async function UIPlugin() {
-    await ensurePackageInstalled("@vitest/ui");
+    var _a;
+    await ensurePackageInstalled("@vitest/ui", ((_a = ctx.config) == null ? void 0 : _a.root) || options.root || process.cwd());
     return (await import('@vitest/ui')).default(options.uiBase);
   }
+  async function BrowserPlugin() {
+    var _a;
+    await ensurePackageInstalled("@vitest/browser", ((_a = ctx.config) == null ? void 0 : _a.root) || options.root || process.cwd());
+    return (await import('@vitest/browser')).default("/");
+  }
   return [
     {
       name: "vitest",
@@ -10929,10 +9938,15 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
           }
         }
         options.defines = defines;
-        const open = preOptions.ui && preOptions.open ? preOptions.uiBase ?? "/__vitest__/" : void 0;
+        let open;
+        if (preOptions.ui && preOptions.open)
+          open = preOptions.uiBase ?? "/__vitest__/";
+        else if (preOptions.browser)
+          open = "/";
         const config = {
           resolve: {
-            mainFields: []
+            mainFields: [],
+            alias: preOptions.alias
           },
           server: {
             ...preOptions.api,
@@ -10942,13 +9956,17 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
             open,
             hmr: false,
             preTransformRequests: false
-          },
-          cacheDir: void 0,
-          optimizeDeps: {
-            disabled: true,
-            entries: []
           }
         };
+        if (!options.browser) {
+          Object.assign(config, {
+            cacheDir: void 0,
+            optimizeDeps: {
+              disabled: true,
+              entries: []
+            }
+          });
+        }
         return config;
       },
       async configResolved(viteConfig) {
@@ -10956,6 +9974,8 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
         const viteConfigTest = viteConfig.test || {};
         if (viteConfigTest.watch === false)
           viteConfigTest.run = true;
+        if ("alias" in viteConfigTest)
+          delete viteConfigTest.alias;
         options = deepMerge({}, configDefaults, viteConfigTest, options);
         options.api = resolveApiConfig(options);
         const { PROD, DEV, ...envs } = viteConfig.env;
@@ -10972,9 +9992,9 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
           await ctx.setServer(options, server);
           haveStarted = true;
           if (options.api && options.watch)
-            (await import('./chunk-api-setup.c728e251.mjs')).setup(ctx);
+            (await import('./chunk-api-setup.0cf2c96a.mjs')).setup(ctx);
         } catch (err) {
-          ctx.printError(err, true);
+          ctx.logger.printError(err, true);
           process.exit(1);
         }
         if (!options.watch)
@@ -10984,6 +10004,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
     EnvReplacerPlugin(),
     MocksPlugin(),
     GlobalSetupPlugin(ctx),
+    ...options.browser ? await BrowserPlugin() : [],
     CSSEnablerPlugin(ctx),
     options.ui ? await UIPlugin() : null
   ].filter(notNullish);
@@ -11033,7 +10054,7 @@ function registerConsoleShortcuts(ctx) {
     if (name === "u")
       return ctx.updateSnapshot();
     if (name === "a" || name === "return")
-      return ctx.rerunFiles(void 0, "rerun all");
+      return ctx.rerunFiles(void 0);
     if (name === "f")
       return ctx.rerunFailed();
     if (name === "t")
@@ -11058,8 +10079,8 @@ function registerConsoleShortcuts(ctx) {
   let rl;
   function on() {
     off();
-    rl = readline.createInterface({ input: process.stdin, escapeCodeTimeout: 50 });
-    readline.emitKeypressEvents(process.stdin, rl);
+    rl = require$$0$2.createInterface({ input: process.stdin, escapeCodeTimeout: 50 });
+    require$$0$2.emitKeypressEvents(process.stdin, rl);
     if (process.stdin.isTTY)
       process.stdin.setRawMode(true);
     process.stdin.on("keypress", keypressHandler);
@@ -11081,7 +10102,10 @@ async function startVitest(cliFilters, options, viteOverrides) {
   (_a = process.env).NODE_ENV ?? (_a.NODE_ENV = options.mode || "test");
   if (options.run)
     options.watch = false;
-  if (!await ensurePackageInstalled("vite")) {
+  if (options.browser)
+    options.threads = false;
+  const root = resolve(options.root || process.cwd());
+  if (!await ensurePackageInstalled("vite", root)) {
     process.exitCode = 1;
     return false;
   }
@@ -11089,14 +10113,14 @@ async function startVitest(cliFilters, options, viteOverrides) {
     options.coverage = { enabled: options.coverage };
   const ctx = await createVitest(options, viteOverrides);
   if (ctx.config.coverage.enabled) {
-    if (!await ensurePackageInstalled("c8")) {
+    if (!await ensurePackageInstalled("c8", root)) {
       process.exitCode = 1;
       return false;
     }
   }
   if (ctx.config.environment && ctx.config.environment !== "node") {
     const packageName = envPackageNames[ctx.config.environment];
-    if (!await ensurePackageInstalled(packageName)) {
+    if (!await ensurePackageInstalled(packageName, root)) {
       process.exitCode = 1;
       return false;
     }
@@ -11110,8 +10134,8 @@ async function startVitest(cliFilters, options, viteOverrides) {
     await ctx.start(cliFilters);
   } catch (e) {
     process.exitCode = 1;
-    await ctx.printError(e, true, "Unhandled Error");
-    ctx.error("\n\n");
+    await ctx.logger.printError(e, true, "Unhandled Error");
+    ctx.logger.error("\n\n");
     return false;
   }
   if (!ctx.config.watch) {
@@ -11121,4 +10145,4 @@ async function startVitest(cliFilters, options, viteOverrides) {
   return true;
 }
 
-export { BaseSequencer as B, VitestPlugin as V, createVitest as c, divider as d, startVitest as s, version as v };
+export { BaseSequencer as B, VitestPlugin as V, createVitest as c, divider as d, startVitest as s, version$1 as v };