vitest 2.2.0-beta.2 → 3.0.0-beta.1

package/dist/chunks/{index.bzFpKeaq.js → index.DKe7vK-G.js}

@@ -3,19 +3,20 @@ import { getTests, getTestName, hasFailed, getFullName, getSuites, getTasks } fr
 import * as pathe from 'pathe';
 import { extname, relative, normalize, resolve, dirname } from 'pathe';
 import c from 'tinyrainbow';
-import { d as divider, F as F_POINTER, w as withLabel, f as formatProjectName, a as formatTimeString, g as getStateSymbol, t as taskFail, b as F_RIGHT, c as F_CHECK, r as renderSnapshotSummary, p as padSummaryTitle, e as getStateString$1, h as formatTime, i as countTestErrors, j as F_TREE_NODE_END, k as F_TREE_NODE_MIDDLE, l as getCols } from './utils.DJONn5B5.js';
+import { d as divider, F as F_POINTER, w as withLabel, f as formatProjectName, a as formatTimeString, g as getStateSymbol, t as taskFail, b as F_RIGHT, c as F_CHECK, r as renderSnapshotSummary, p as padSummaryTitle, e as getStateString$1, h as formatTime, i as countTestErrors, j as F_TREE_NODE_END, k as F_TREE_NODE_MIDDLE, l as getCols } from './utils.CMUTX-p8.js';
 import { stripVTControlCharacters } from 'node:util';
 import { highlight, isPrimitive, inspect, positionToOffset, lineSplitRE, toArray, notNullish } from '@vitest/utils';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
-import { a as TypeCheckError, R as RandomSequencer, g as getOutputFile, b as isNode, c as isDeno } from './RandomSequencer.BPedXEug.js';
+import { a as TypeCheckError, R as RandomSequencer, g as getOutputFile, b as isNode, c as isDeno } from './RandomSequencer.gisBJ77r.js';
 import { isCI } from 'std-env';
 import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
-import restoreCursor from 'restore-cursor';
 import { Writable } from 'node:stream';
 import { Console } from 'node:console';
 import process$1 from 'node:process';
-import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
+import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
+import require$$0 from 'assert';
+import require$$0$1 from 'events';
 import { createRequire } from 'node:module';
 import { hostname } from 'node:os';
 
@@ -626,6 +627,370 @@ ansiEscapes.iTerm = {
 	}
 };
 
+var onetime$1 = {exports: {}};
+
+var mimicFn = {exports: {}};
+
+var hasRequiredMimicFn;
+
+function requireMimicFn () {
+	if (hasRequiredMimicFn) return mimicFn.exports;
+	hasRequiredMimicFn = 1;
+
+	const mimicFn$1 = (to, from) => {
+		for (const prop of Reflect.ownKeys(from)) {
+			Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+		}
+
+		return to;
+	};
+
+	mimicFn.exports = mimicFn$1;
+	// TODO: Remove this for the next major release
+	mimicFn.exports.default = mimicFn$1;
+	return mimicFn.exports;
+}
+
+var hasRequiredOnetime;
+
+function requireOnetime () {
+	if (hasRequiredOnetime) return onetime$1.exports;
+	hasRequiredOnetime = 1;
+	const mimicFn = requireMimicFn();
+
+	const calledFunctions = new WeakMap();
+
+	const onetime = (function_, options = {}) => {
+		if (typeof function_ !== 'function') {
+			throw new TypeError('Expected a function');
+		}
+
+		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;
+		};
+
+		mimicFn(onetime, function_);
+		calledFunctions.set(onetime, callCount);
+
+		return onetime;
+	};
+
+	onetime$1.exports = onetime;
+	// TODO: Remove this for the next major release
+	onetime$1.exports.default = onetime;
+
+	onetime$1.exports.callCount = function_ => {
+		if (!calledFunctions.has(function_)) {
+			throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+		}
+
+		return calledFunctions.get(function_);
+	};
+	return onetime$1.exports;
+}
+
+var onetimeExports = requireOnetime();
+var onetime = /*@__PURE__*/getDefaultExportFromCjs(onetimeExports);
+
+var signalExit$1 = {exports: {}};
+
+var signals = {exports: {}};
+
+var hasRequiredSignals;
+
+function requireSignals () {
+	if (hasRequiredSignals) return signals.exports;
+	hasRequiredSignals = 1;
+	(function (module) {
+		// This is not the set of all possible signals.
+		//
+		// It IS, however, the set of all signals that trigger
+		// an exit on either Linux or BSD systems.  Linux is a
+		// superset of the signal names supported on BSD, and
+		// the unknown signals just fail to register, so we can
+		// catch that easily enough.
+		//
+		// Don't bother with SIGKILL.  It's uncatchable, which
+		// means that we can't fire any callbacks anyway.
+		//
+		// If a user does happen to register a handler on a non-
+		// fatal signal like SIGWINCH or something, and then
+		// exit, it'll end up firing `process.emit('exit')`, so
+		// the handler will be fired anyway.
+		//
+		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+		// artificially, inherently leave the process in a
+		// state from which it is not safe to try and enter JS
+		// listeners.
+		module.exports = [
+		  'SIGABRT',
+		  'SIGALRM',
+		  'SIGHUP',
+		  'SIGINT',
+		  'SIGTERM'
+		];
+
+		if (process.platform !== 'win32') {
+		  module.exports.push(
+		    'SIGVTALRM',
+		    'SIGXCPU',
+		    'SIGXFSZ',
+		    'SIGUSR2',
+		    'SIGTRAP',
+		    'SIGSYS',
+		    'SIGQUIT',
+		    'SIGIOT'
+		    // should detect profiler and enable/disable accordingly.
+		    // see #21
+		    // 'SIGPROF'
+		  );
+		}
+
+		if (process.platform === 'linux') {
+		  module.exports.push(
+		    'SIGIO',
+		    'SIGPOLL',
+		    'SIGPWR',
+		    'SIGSTKFLT',
+		    'SIGUNUSED'
+		  );
+		} 
+	} (signals));
+	return signals.exports;
+}
+
+var hasRequiredSignalExit;
+
+function requireSignalExit () {
+	if (hasRequiredSignalExit) return signalExit$1.exports;
+	hasRequiredSignalExit = 1;
+	// Note: since nyc uses this module to output coverage, any lines
+	// that are in the direct sync flow of nyc's outputCoverage are
+	// ignored, since we can never get coverage for them.
+	// grab a reference to node's real process object right away
+	var process = commonjsGlobal.process;
+
+	const processOk = function (process) {
+	  return process &&
+	    typeof process === 'object' &&
+	    typeof process.removeListener === 'function' &&
+	    typeof process.emit === 'function' &&
+	    typeof process.reallyExit === 'function' &&
+	    typeof process.listeners === 'function' &&
+	    typeof process.kill === 'function' &&
+	    typeof process.pid === 'number' &&
+	    typeof process.on === 'function'
+	};
+
+	// some kind of non-node environment, just no-op
+	/* istanbul ignore if */
+	if (!processOk(process)) {
+	  signalExit$1.exports = function () {
+	    return function () {}
+	  };
+	} else {
+	  var assert = require$$0;
+	  var signals = requireSignals();
+	  var isWin = /^win/i.test(process.platform);
+
+	  var EE = require$$0$1;
+	  /* istanbul ignore if */
+	  if (typeof EE !== 'function') {
+	    EE = EE.EventEmitter;
+	  }
+
+	  var emitter;
+	  if (process.__signal_exit_emitter__) {
+	    emitter = process.__signal_exit_emitter__;
+	  } else {
+	    emitter = process.__signal_exit_emitter__ = new EE();
+	    emitter.count = 0;
+	    emitter.emitted = {};
+	  }
+
+	  // Because this emitter is a global, we have to check to see if a
+	  // previous version of this library failed to enable infinite listeners.
+	  // I know what you're about to say.  But literally everything about
+	  // signal-exit is a compromise with evil.  Get used to it.
+	  if (!emitter.infinite) {
+	    emitter.setMaxListeners(Infinity);
+	    emitter.infinite = true;
+	  }
+
+	  signalExit$1.exports = function (cb, opts) {
+	    /* istanbul ignore if */
+	    if (!processOk(commonjsGlobal.process)) {
+	      return function () {}
+	    }
+	    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+
+	    if (loaded === false) {
+	      load();
+	    }
+
+	    var ev = 'exit';
+	    if (opts && opts.alwaysLast) {
+	      ev = 'afterexit';
+	    }
+
+	    var remove = function () {
+	      emitter.removeListener(ev, cb);
+	      if (emitter.listeners('exit').length === 0 &&
+	          emitter.listeners('afterexit').length === 0) {
+	        unload();
+	      }
+	    };
+	    emitter.on(ev, cb);
+
+	    return remove
+	  };
+
+	  var unload = function unload () {
+	    if (!loaded || !processOk(commonjsGlobal.process)) {
+	      return
+	    }
+	    loaded = false;
+
+	    signals.forEach(function (sig) {
+	      try {
+	        process.removeListener(sig, sigListeners[sig]);
+	      } catch (er) {}
+	    });
+	    process.emit = originalProcessEmit;
+	    process.reallyExit = originalProcessReallyExit;
+	    emitter.count -= 1;
+	  };
+	  signalExit$1.exports.unload = unload;
+
+	  var emit = function emit (event, code, signal) {
+	    /* istanbul ignore if */
+	    if (emitter.emitted[event]) {
+	      return
+	    }
+	    emitter.emitted[event] = true;
+	    emitter.emit(event, code, signal);
+	  };
+
+	  // { <signal>: <listener fn>, ... }
+	  var sigListeners = {};
+	  signals.forEach(function (sig) {
+	    sigListeners[sig] = function listener () {
+	      /* istanbul ignore if */
+	      if (!processOk(commonjsGlobal.process)) {
+	        return
+	      }
+	      // If there are no other listeners, an exit is coming!
+	      // Simplest way: remove us and then re-send the signal.
+	      // We know that this will kill the process, so we can
+	      // safely emit now.
+	      var listeners = process.listeners(sig);
+	      if (listeners.length === emitter.count) {
+	        unload();
+	        emit('exit', null, sig);
+	        /* istanbul ignore next */
+	        emit('afterexit', null, sig);
+	        /* istanbul ignore next */
+	        if (isWin && sig === 'SIGHUP') {
+	          // "SIGHUP" throws an `ENOSYS` error on Windows,
+	          // so use a supported signal instead
+	          sig = 'SIGINT';
+	        }
+	        /* istanbul ignore next */
+	        process.kill(process.pid, sig);
+	      }
+	    };
+	  });
+
+	  signalExit$1.exports.signals = function () {
+	    return signals
+	  };
+
+	  var loaded = false;
+
+	  var load = function load () {
+	    if (loaded || !processOk(commonjsGlobal.process)) {
+	      return
+	    }
+	    loaded = true;
+
+	    // This is the number of onSignalExit's that are in play.
+	    // It's important so that we can count the correct number of
+	    // listeners on signals, and don't wait for the other one to
+	    // handle it instead of us.
+	    emitter.count += 1;
+
+	    signals = signals.filter(function (sig) {
+	      try {
+	        process.on(sig, sigListeners[sig]);
+	        return true
+	      } catch (er) {
+	        return false
+	      }
+	    });
+
+	    process.emit = processEmit;
+	    process.reallyExit = processReallyExit;
+	  };
+	  signalExit$1.exports.load = load;
+
+	  var originalProcessReallyExit = process.reallyExit;
+	  var processReallyExit = function processReallyExit (code) {
+	    /* istanbul ignore if */
+	    if (!processOk(commonjsGlobal.process)) {
+	      return
+	    }
+	    process.exitCode = code || /* istanbul ignore next */ 0;
+	    emit('exit', process.exitCode, null);
+	    /* istanbul ignore next */
+	    emit('afterexit', process.exitCode, null);
+	    /* istanbul ignore next */
+	    originalProcessReallyExit.call(process, process.exitCode);
+	  };
+
+	  var originalProcessEmit = process.emit;
+	  var processEmit = function processEmit (ev, arg) {
+	    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
+	      /* istanbul ignore else */
+	      if (arg !== undefined) {
+	        process.exitCode = arg;
+	      }
+	      var ret = originalProcessEmit.apply(this, arguments);
+	      /* istanbul ignore next */
+	      emit('exit', process.exitCode, null);
+	      /* istanbul ignore next */
+	      emit('afterexit', process.exitCode, null);
+	      /* istanbul ignore next */
+	      return ret
+	    } else {
+	      return originalProcessEmit.apply(this, arguments)
+	    }
+	  };
+	}
+	return signalExit$1.exports;
+}
+
+var signalExitExports = requireSignalExit();
+var signalExit = /*@__PURE__*/getDefaultExportFromCjs(signalExitExports);
+
+const restoreCursor = onetime(() => {
+	signalExit(() => {
+		process$1.stderr.write('\u001B[?25h');
+	}, {alwaysLast: true});
+});
+
 let isHidden = false;
 
 const cliCursor = {};
@@ -2804,15 +3169,15 @@ Vitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} du
 This might cause false positive tests. Resolve unhandled errors to make sure your tests are not affected.`
       )
     );
-    this.log(c.red(divider(c.bold(c.inverse(" Unhandled Errors ")))));
-    this.log(errorMessage);
+    this.error(c.red(divider(c.bold(c.inverse(" Unhandled Errors ")))));
+    this.error(errorMessage);
     errors.forEach((err) => {
       this.printError(err, {
         fullStack: true,
         type: err.type || "Unhandled Error"
       });
     });
-    this.log(c.red(divider()));
+    this.error(c.red(divider()));
   }
   printSourceTypeErrors(errors) {
     const errorMessage = c.red(
@@ -2866,7 +3231,7 @@ class BlobReporter {
     const modules = this.ctx.projects.map(
       (project) => {
         return [
-          project.getName(),
+          project.name,
           [...project.vite.moduleGraph.idToModuleMap.entries()].map((mod) => {
             if (!mod[1].file) {
               return null;
@@ -2934,7 +3299,7 @@ ${blobs.map((b) => `- "${b.file}" uses v${b.version}`).join("\n")}`
     );
   }
   const projects = Object.fromEntries(
-    projectsArray.map((p) => [p.getName(), p])
+    projectsArray.map((p) => [p.name, p])
   );
   blobs.forEach((blob) => {
     blob.moduleKeys.forEach(([projectName, moduleIds]) => {
@@ -3041,21 +3406,27 @@ class BaseReporter {
     this.log(` ${title} ${task.name} ${suffix}`);
     const anyFailed = tests.some((test) => test.result?.state === "fail");
     for (const test of tests) {
-      const duration = test.result?.duration;
+      const { duration, retryCount, repeatCount } = test.result || {};
+      let suffix2 = "";
+      if (retryCount != null && retryCount > 0) {
+        suffix2 += c.yellow(` (retry x${retryCount})`);
+      }
+      if (repeatCount != null && repeatCount > 0) {
+        suffix2 += c.yellow(` (repeat x${repeatCount})`);
+      }
       if (test.result?.state === "fail") {
-        const suffix2 = this.getDurationPrefix(test);
-        this.log(c.red(`   ${taskFail} ${getTestName(test, c.dim(" > "))}${suffix2}`));
+        this.log(c.red(`   ${taskFail} ${getTestName(test, c.dim(" > "))}${this.getDurationPrefix(test)}`) + suffix2);
         test.result?.errors?.forEach((e) => {
           this.log(c.red(`     ${F_RIGHT} ${e?.message}`));
         });
       } else if (duration && duration > this.ctx.config.slowTestThreshold) {
         this.log(
-          `   ${c.yellow(c.dim(F_CHECK))} ${getTestName(test, c.dim(" > "))} ${c.yellow(Math.round(duration) + c.dim("ms"))}`
+          `   ${c.yellow(c.dim(F_CHECK))} ${getTestName(test, c.dim(" > "))} ${c.yellow(Math.round(duration) + c.dim("ms"))}${suffix2}`
         );
-      } else if (test.result?.state === "skip" && test.result.note) {
+      } else if (this.ctx.config.hideSkippedTests && (test.mode === "skip" || test.result?.state === "skip")) ; else if (test.result?.state === "skip" && test.result.note) {
         this.log(`   ${getStateSymbol(test)} ${getTestName(test)}${c.dim(c.gray(` [${test.result.note}]`))}`);
       } else if (this.renderSucceed || anyFailed) {
-        this.log(`   ${c.green(c.dim(F_CHECK))} ${getTestName(test, c.dim(" > "))}`);
+        this.log(`   ${c.dim(getStateSymbol(test))} ${getTestName(test, c.dim(" > "))}${suffix2}`);
       }
     }
   }
@@ -3245,12 +3616,14 @@ class BaseReporter {
     const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
 `);
     if (failedSuites.length) {
-      this.error(`${errorBanner(`Failed Suites ${failedSuites.length}`)}
+      this.error(`
+${errorBanner(`Failed Suites ${failedSuites.length}`)}
 `);
       this.printTaskErrors(failedSuites, errorDivider);
     }
     if (failedTests.length) {
-      this.error(`${errorBanner(`Failed Tests ${failedTests.length}`)}
+      this.error(`
+${errorBanner(`Failed Tests ${failedTests.length}`)}
 `);
       this.printTaskErrors(failedTests, errorDivider);
     }
@@ -3309,7 +3682,7 @@ class BaseReporter {
           name += c.dim(` [ ${this.relative(filepath)} ]`);
         }
         this.ctx.logger.error(
-          `${c.red(c.bold(c.inverse(" FAIL ")))}${formatProjectName(projectName)} ${name}`
+          `${c.red(c.bold(c.inverse(" FAIL ")))} ${formatProjectName(projectName)}${name}`
         );
       }
       const screenshotPaths = tasks2.map((t) => t.meta?.failScreenshotPath).filter((screenshot) => screenshot != null);
@@ -3378,9 +3751,9 @@ class WindowRenderer {
     };
     this.cleanups.push(
       this.interceptStream(process.stdout, "output"),
-      this.interceptStream(process.stderr, "error")
+      this.interceptStream(process.stderr, "error"),
+      this.addProcessExitListeners()
     );
-    restoreCursor();
     this.write(HIDE_CURSOR, "output");
     this.start();
   }
@@ -3402,6 +3775,9 @@ class WindowRenderer {
     this.flushBuffer();
     clearInterval(this.renderInterval);
   }
+  getColumns() {
+    return "columns" in this.options.logger.outputStream ? this.options.logger.outputStream.columns : 80;
+  }
   flushBuffer() {
     if (this.buffer.length === 0) {
       return this.render();
@@ -3429,10 +3805,10 @@ class WindowRenderer {
       return this.write(message || "", type);
     }
     const windowContent = this.options.getWindow();
-    const rowCount = getRenderedRowCount(windowContent, this.options.logger.outputStream);
+    const rowCount = getRenderedRowCount(windowContent, this.getColumns());
     let padding = this.windowHeight - rowCount;
     if (padding > 0 && message) {
-      padding -= getRenderedRowCount([message], this.options.logger.outputStream);
+      padding -= getRenderedRowCount([message], this.getColumns());
     }
     this.write(SYNC_START);
     this.clearWindow();
@@ -3475,10 +3851,27 @@ class WindowRenderer {
   write(message, type = "output") {
     this.streams[type](message);
   }
+  addProcessExitListeners() {
+    const onExit = (signal, exitCode) => {
+      this.flushBuffer();
+      this.stop();
+      if (process.exitCode === void 0) {
+        process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
+      }
+      process.exit();
+    };
+    process.once("SIGINT", onExit);
+    process.once("SIGTERM", onExit);
+    process.once("exit", onExit);
+    return function cleanup() {
+      process.off("SIGINT", onExit);
+      process.off("SIGTERM", onExit);
+      process.off("exit", onExit);
+    };
+  }
 }
-function getRenderedRowCount(rows, stream) {
+function getRenderedRowCount(rows, columns) {
   let count = 0;
-  const columns = "columns" in stream ? stream.columns : 80;
   for (const row of rows) {
     const text = stripVTControlCharacters(row);
     count += Math.max(1, Math.ceil(text.length / columns));
@@ -3524,7 +3917,7 @@ class TaskParser {
           finishedTestFiles.push(task.file);
         }
       }
-      if (task?.type === "test" || task?.type === "custom") {
+      if (task?.type === "test") {
         if (task.result?.state === "run") {
           startingTests.push(task);
         } else if (task.result?.hooks?.afterEach !== "run") {
@@ -3855,139 +4248,131 @@ class DefaultReporter extends BaseReporter {
   }
 }
 
-const check = { char: "\xB7", color: c.green };
-const cross = { char: "x", color: c.red };
+class DotReporter extends BaseReporter {
+  summary;
+  onInit(ctx) {
+    super.onInit(ctx);
+    if (this.isTTY) {
+      this.summary = new DotSummary();
+      this.summary.onInit(ctx);
+    }
+  }
+  onTaskUpdate(packs) {
+    this.summary?.onTaskUpdate(packs);
+    if (!this.isTTY) {
+      super.onTaskUpdate(packs);
+    }
+  }
+  onWatcherRerun(files, trigger) {
+    this.summary?.onWatcherRerun();
+    super.onWatcherRerun(files, trigger);
+  }
+  onFinished(files, errors) {
+    this.summary?.onFinished();
+    super.onFinished(files, errors);
+  }
+}
+class DotSummary extends TaskParser {
+  renderer;
+  tests = /* @__PURE__ */ new Map();
+  finishedTests = /* @__PURE__ */ new Set();
+  onInit(ctx) {
+    this.ctx = ctx;
+    this.renderer = new WindowRenderer({
+      logger: ctx.logger,
+      getWindow: () => this.createSummary()
+    });
+    this.ctx.onClose(() => this.renderer.stop());
+  }
+  onWatcherRerun() {
+    this.tests.clear();
+    this.renderer.start();
+  }
+  onFinished() {
+    const finalLog = formatTests(Array.from(this.tests.values()));
+    this.ctx.logger.log(finalLog);
+    this.tests.clear();
+    this.renderer.finish();
+  }
+  onTestFilePrepare(file) {
+    for (const test of getTests(file)) {
+      this.onTestStart(test);
+    }
+  }
+  onTestStart(test) {
+    if (this.finishedTests.has(test.id)) {
+      return;
+    }
+    this.tests.set(test.id, test.mode || "run");
+  }
+  onTestFinished(test) {
+    if (this.finishedTests.has(test.id)) {
+      return;
+    }
+    this.finishedTests.add(test.id);
+    this.tests.set(test.id, test.result?.state || "skip");
+  }
+  onTestFileFinished() {
+    const columns = this.renderer.getColumns();
+    if (this.tests.size < columns) {
+      return;
+    }
+    const finishedTests = Array.from(this.tests).filter((entry) => entry[1] !== "run");
+    if (finishedTests.length < columns) {
+      return;
+    }
+    const states = [];
+    let count = 0;
+    for (const [id, state] of finishedTests) {
+      if (count++ >= columns) {
+        break;
+      }
+      this.tests.delete(id);
+      states.push(state);
+    }
+    this.ctx.logger.log(formatTests(states));
+  }
+  createSummary() {
+    return [
+      formatTests(Array.from(this.tests.values())),
+      ""
+    ];
+  }
+}
+const pass = { char: "\xB7", color: c.green };
+const fail = { char: "x", color: c.red };
 const pending = { char: "*", color: c.yellow };
 const skip = { char: "-", color: (char) => c.dim(c.gray(char)) };
-function getIcon(task) {
-  if (task.mode === "skip" || task.mode === "todo") {
-    return skip;
-  }
-  switch (task.result?.state) {
+function getIcon(state) {
+  switch (state) {
     case "pass":
-      return check;
+      return pass;
     case "fail":
-      return cross;
+      return fail;
+    case "skip":
+    case "todo":
+      return skip;
     default:
       return pending;
   }
 }
-function render(tasks, width) {
-  const all = getTests(tasks);
+function formatTests(states) {
   let currentIcon = pending;
-  let currentTasks = 0;
-  let previousLineWidth = 0;
+  let count = 0;
   let output = "";
-  const addOutput = () => {
-    const { char, color } = currentIcon;
-    const availableWidth = width - previousLineWidth;
-    if (availableWidth > currentTasks) {
-      output += color(char.repeat(currentTasks));
-      previousLineWidth += currentTasks;
-    } else {
-      let buf = `${char.repeat(availableWidth)}
-`;
-      const remaining = currentTasks - availableWidth;
-      const fullRows = Math.floor(remaining / width);
-      buf += `${char.repeat(width)}
-`.repeat(fullRows);
-      const partialRow = remaining % width;
-      if (partialRow > 0) {
-        buf += char.repeat(partialRow);
-        previousLineWidth = partialRow;
-      } else {
-        previousLineWidth = 0;
-      }
-      output += color(buf);
-    }
-  };
-  for (const task of all) {
-    const icon = getIcon(task);
-    if (icon === currentIcon) {
-      currentTasks++;
+  for (const state of states) {
+    const icon = getIcon(state);
+    if (currentIcon === icon) {
+      count++;
       continue;
     }
-    addOutput();
-    currentTasks = 1;
+    output += currentIcon.color(currentIcon.char.repeat(count));
+    count = 1;
     currentIcon = icon;
   }
-  addOutput();
+  output += currentIcon.color(currentIcon.char.repeat(count));
   return output;
 }
-function createDotRenderer(_tasks, options) {
-  let tasks = _tasks;
-  let timer;
-  const { logUpdate: log, outputStream } = options.logger;
-  const columns = "columns" in outputStream ? outputStream.columns : 80;
-  function update() {
-    log(render(tasks, columns));
-  }
-  return {
-    start() {
-      if (timer) {
-        return this;
-      }
-      timer = setInterval(update, 16);
-      return this;
-    },
-    update(_tasks2) {
-      tasks = _tasks2;
-      return this;
-    },
-    async stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
-      }
-      log.clear();
-      options.logger.log(render(tasks, columns));
-      return this;
-    },
-    clear() {
-      log.clear();
-    }
-  };
-}
-
-class DotReporter extends BaseReporter {
-  renderer;
-  onTaskUpdate() {
-  }
-  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();
-    super.onFinished(files, errors);
-  }
-  async onWatcherStart() {
-    await this.stopListRender();
-    super.onWatcherStart();
-  }
-  async stopListRender() {
-    this.renderer?.stop();
-    this.renderer = void 0;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  async onWatcherRerun(files, trigger) {
-    await this.stopListRender();
-    super.onWatcherRerun(files, trigger);
-  }
-  onUserConsoleLog(log) {
-    this.renderer?.clear();
-    super.onUserConsoleLog(log);
-  }
-}
 
 class GithubActionsReporter {
   ctx = void 0;
@@ -4443,6 +4828,7 @@ class JUnitReporter {
       (stats2, file) => {
         stats2.tests += file.tasks.length;
         stats2.failures += file.stats.failures;
+        stats2.time += file.result?.duration || 0;
         return stats2;
       },
       {
@@ -4451,10 +4837,10 @@ class JUnitReporter {
         failures: 0,
         errors: 0,
         // we cannot detect those
-        time: executionTime((/* @__PURE__ */ new Date()).getTime() - this._timeStart.getTime())
+        time: 0
       }
     );
-    await this.writeElement("testsuites", stats, async () => {
+    await this.writeElement("testsuites", { ...stats, time: executionTime(stats.time) }, async () => {
       for (const file of transformed) {
         const filename = relative(this.ctx.config.root, file.filepath);
         await this.writeElement(