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

package/dist/chunks/{index.bzFpKeaq.js → index.9ZEBV_TJ.js}

@@ -3,367 +3,23 @@ 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';
 
-class ReportedTaskImplementation {
-  /**
-   * Task instance.
-   * @experimental Public runner task API is experimental and does not follow semver.
-   */
-  task;
-  /**
-   * The project assosiacted with the test or suite.
-   */
-  project;
-  /**
-   * Unique identifier.
-   * This ID is deterministic and will be the same for the same test across multiple runs.
-   * The ID is based on the project name, module url and test position.
-   */
-  id;
-  /**
-   * Location in the module where the test or suite is defined.
-   */
-  location;
-  constructor(task, project) {
-    this.task = task;
-    this.project = project;
-    this.id = task.id;
-    this.location = task.location;
-  }
-  /**
-   * Creates a new reported task instance and stores it in the project's state for future use.
-   */
-  static register(task, project) {
-    const state = new this(task, project);
-    storeTask(project, task, state);
-    return state;
-  }
-}
-class TestCase extends ReportedTaskImplementation {
-  #fullName;
-  type = "test";
-  /**
-   * Direct reference to the test module where the test or suite is defined.
-   */
-  module;
-  /**
-   * Name of the test.
-   */
-  name;
-  /**
-   * Options that the test was initiated with.
-   */
-  options;
-  /**
-   * Parent suite. If the test was called directly inside the module, the parent will be the module itself.
-   */
-  parent;
-  constructor(task, project) {
-    super(task, project);
-    this.name = task.name;
-    this.module = getReportedTask(project, task.file);
-    const suite = this.task.suite;
-    if (suite) {
-      this.parent = getReportedTask(project, suite);
-    } else {
-      this.parent = this.module;
-    }
-    this.options = buildOptions(task);
-  }
-  /**
-   * Full name of the test including all parent suites separated with `>`.
-   */
-  get fullName() {
-    if (this.#fullName === void 0) {
-      if (this.parent.type !== "module") {
-        this.#fullName = `${this.parent.fullName} > ${this.name}`;
-      } else {
-        this.#fullName = this.name;
-      }
-    }
-    return this.#fullName;
-  }
-  /**
-   * Test results. Will be `undefined` if test is not finished yet or was just collected.
-   */
-  result() {
-    const result = this.task.result;
-    if (!result || result.state === "run") {
-      return void 0;
-    }
-    const state = result.state === "fail" ? "failed" : result.state === "pass" ? "passed" : "skipped";
-    if (state === "skipped") {
-      return {
-        state,
-        note: result.note,
-        errors: void 0
-      };
-    }
-    if (state === "passed") {
-      return {
-        state,
-        errors: result.errors
-      };
-    }
-    return {
-      state,
-      errors: result.errors || []
-    };
-  }
-  /**
-   * Checks if the test did not fail the suite.
-   * If the test is not finished yet or was skipped, it will return `true`.
-   */
-  ok() {
-    const result = this.result();
-    return !result || result.state !== "failed";
-  }
-  /**
-   * Custom metadata that was attached to the test during its execution.
-   */
-  meta() {
-    return this.task.meta;
-  }
-  /**
-   * Useful information about the test like duration, memory usage, etc.
-   * Diagnostic is only available after the test has finished.
-   */
-  diagnostic() {
-    const result = this.task.result;
-    if (!result || result.state === "run" || !result.startTime) {
-      return void 0;
-    }
-    const duration = result.duration || 0;
-    const slow = duration > this.project.globalConfig.slowTestThreshold;
-    return {
-      slow,
-      heap: result.heap,
-      duration,
-      startTime: result.startTime,
-      retryCount: result.retryCount ?? 0,
-      repeatCount: result.repeatCount ?? 0,
-      flaky: !!result.retryCount && result.state === "pass" && result.retryCount > 0
-    };
-  }
-}
-class TestCollection {
-  #task;
-  #project;
-  constructor(task, project) {
-    this.#task = task;
-    this.#project = project;
-  }
-  /**
-   * Returns the test or suite at a specific index in the array.
-   */
-  at(index) {
-    if (index < 0) {
-      index = this.size + index;
-    }
-    return getReportedTask(this.#project, this.#task.tasks[index]);
-  }
-  /**
-   * The number of tests and suites in the collection.
-   */
-  get size() {
-    return this.#task.tasks.length;
-  }
-  /**
-   * Returns the collection in array form for easier manipulation.
-   */
-  array() {
-    return Array.from(this);
-  }
-  /**
-   * Filters all tests that are part of this collection and its children.
-   */
-  *allTests(state) {
-    for (const child of this) {
-      if (child.type === "suite") {
-        yield* child.children.allTests(state);
-      } else if (state) {
-        const testState = getTestState(child);
-        if (state === testState) {
-          yield child;
-        }
-      } else {
-        yield child;
-      }
-    }
-  }
-  /**
-   * Filters only the tests that are part of this collection.
-   */
-  *tests(state) {
-    for (const child of this) {
-      if (child.type !== "test") {
-        continue;
-      }
-      if (state) {
-        const testState = getTestState(child);
-        if (state === testState) {
-          yield child;
-        }
-      } else {
-        yield child;
-      }
-    }
-  }
-  /**
-   * Filters only the suites that are part of this collection.
-   */
-  *suites() {
-    for (const child of this) {
-      if (child.type === "suite") {
-        yield child;
-      }
-    }
-  }
-  /**
-   * Filters all suites that are part of this collection and its children.
-   */
-  *allSuites() {
-    for (const child of this) {
-      if (child.type === "suite") {
-        yield child;
-        yield* child.children.allSuites();
-      }
-    }
-  }
-  *[Symbol.iterator]() {
-    for (const task of this.#task.tasks) {
-      yield getReportedTask(this.#project, task);
-    }
-  }
-}
-class SuiteImplementation extends ReportedTaskImplementation {
-  /**
-   * Collection of suites and tests that are part of this suite.
-   */
-  children;
-  constructor(task, project) {
-    super(task, project);
-    this.children = new TestCollection(task, project);
-  }
-}
-class TestSuite extends SuiteImplementation {
-  #fullName;
-  type = "suite";
-  /**
-   * Name of the test or the suite.
-   */
-  name;
-  /**
-   * Direct reference to the test module where the test or suite is defined.
-   */
-  module;
-  /**
-   * Parent suite. If suite was called directly inside the module, the parent will be the module itself.
-   */
-  parent;
-  /**
-   * Options that suite was initiated with.
-   */
-  options;
-  constructor(task, project) {
-    super(task, project);
-    this.name = task.name;
-    this.module = getReportedTask(project, task.file);
-    const suite = this.task.suite;
-    if (suite) {
-      this.parent = getReportedTask(project, suite);
-    } else {
-      this.parent = this.module;
-    }
-    this.options = buildOptions(task);
-  }
-  /**
-   * Full name of the suite including all parent suites separated with `>`.
-   */
-  get fullName() {
-    if (this.#fullName === void 0) {
-      if (this.parent.type !== "module") {
-        this.#fullName = `${this.parent.fullName} > ${this.name}`;
-      } else {
-        this.#fullName = this.name;
-      }
-    }
-    return this.#fullName;
-  }
-}
-class TestModule extends SuiteImplementation {
-  type = "module";
-  /**
-   * This is usually an absolute UNIX file path.
-   * It can be a virtual id if the file is not on the disk.
-   * This value corresponds to Vite's `ModuleGraph` id.
-   */
-  moduleId;
-  constructor(task, project) {
-    super(task, project);
-    this.moduleId = task.filepath;
-  }
-  /**
-   * Useful information about the module like duration, memory usage, etc.
-   * If the module was not executed yet, all diagnostic values will return `0`.
-   */
-  diagnostic() {
-    const setupDuration = this.task.setupDuration || 0;
-    const collectDuration = this.task.collectDuration || 0;
-    const prepareDuration = this.task.prepareDuration || 0;
-    const environmentSetupDuration = this.task.environmentLoad || 0;
-    const duration = this.task.result?.duration || 0;
-    return {
-      environmentSetupDuration,
-      prepareDuration,
-      collectDuration,
-      setupDuration,
-      duration
-    };
-  }
-}
-function buildOptions(task) {
-  return {
-    each: task.each,
-    concurrent: task.concurrent,
-    shuffle: task.shuffle,
-    retry: task.retry,
-    repeats: task.repeats,
-    mode: task.mode
-  };
-}
-function getTestState(test) {
-  const result = test.result();
-  return result ? result.state : "running";
-}
-function storeTask(project, runnerTask, reportedTask) {
-  project.vitest.state.reportedTasksMap.set(runnerTask, reportedTask);
-}
-function getReportedTask(project, runnerTask) {
-  const reportedTask = project.vitest.state.getReportedEntity(runnerTask);
-  if (!reportedTask) {
-    throw new Error(
-      `Task instance was not found for ${runnerTask.type} "${runnerTask.name}"`
-    );
-  }
-  return reportedTask;
-}
-
 /// <reference types="../types/index.d.ts" />
 
 // (c) 2020-present Andrea Giammarchi
@@ -626,6 +282,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 +2824,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 +2886,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 +2954,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 +3061,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}`);
       }
     }
   }
@@ -3103,7 +3129,7 @@ class BaseReporter {
       this.log(BADGE_PADDING + c.dim(" Project name: ") + c.blue(toArray(this.ctx.configOverride.project).join(", ")));
     }
     if (this.ctx.filenamePattern) {
-      this.log(BADGE_PADDING + c.dim(" Filename pattern: ") + c.blue(this.ctx.filenamePattern));
+      this.log(BADGE_PADDING + c.dim(" Filename pattern: ") + c.blue(this.ctx.filenamePattern.join(", ")));
     }
     if (this.ctx.configOverride.testNamePattern) {
       this.log(BADGE_PADDING + c.dim(" Test name pattern: ") + c.blue(String(this.ctx.configOverride.testNamePattern)));
@@ -3134,7 +3160,7 @@ class BaseReporter {
       if (log.browser) {
         write("\n");
       }
-      const project = log.taskId ? this.ctx.getProjectByTaskId(log.taskId) : this.ctx.getRootTestProject();
+      const project = task ? this.ctx.getProjectByName(task.file.projectName || "") : this.ctx.getRootProject();
       const stack = log.browser ? project.browser?.parseStacktrace(log.origin) || [] : parseStacktrace(log.origin);
       const highlight = task && stack.find((i) => i.file === task.file.filepath);
       for (const frame of stack) {
@@ -3245,12 +3271,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,12 +3337,12 @@ 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);
       this.ctx.logger.printError(error, {
-        project: this.ctx.getProjectByTaskId(tasks2[0].id),
+        project: this.ctx.getProjectByName(tasks2[0].file.projectName || ""),
         verbose: this.verbose,
         screenshotPaths,
         task: tasks2[0]
@@ -3378,9 +3406,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 +3430,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 +3460,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 +3506,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 +3572,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 +3903,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;
@@ -3998,14 +4038,14 @@ class GithubActionsReporter {
     const projectErrors = new Array();
     for (const error of errors) {
       projectErrors.push({
-        project: this.ctx.getRootTestProject(),
+        project: this.ctx.getRootProject(),
         title: "Unhandled error",
         error
       });
     }
     for (const file of files) {
       const tasks = getTasks(file);
-      const project = this.ctx.getProjectByTaskId(file.id);
+      const project = this.ctx.getProjectByName(file.projectName || "");
       for (const task of tasks) {
         if (task.result?.state !== "fail") {
           continue;
@@ -4380,7 +4420,7 @@ class JUnitReporter {
                   const result = capturePrintError(
                     error,
                     this.ctx,
-                    { project: this.ctx.getProjectByTaskId(task.id), task }
+                    { project: this.ctx.getProjectByName(task.file.projectName || ""), task }
                   );
                   await this.baseLog(
                     escapeXML(stripVTControlCharacters(result.output.trim()))
@@ -4390,98 +4430,473 @@ class JUnitReporter {
             }
           }
         }
-      );
+      );
+    }
+  }
+  async onFinished(files = this.ctx.state.getFiles()) {
+    await this.logger.log('<?xml version="1.0" encoding="UTF-8" ?>');
+    const transformed = files.map((file) => {
+      const tasks = file.tasks.flatMap((task) => flattenTasks$1(task));
+      const stats2 = tasks.reduce(
+        (stats3, task) => {
+          return {
+            passed: stats3.passed + Number(task.result?.state === "pass"),
+            failures: stats3.failures + Number(task.result?.state === "fail"),
+            skipped: stats3.skipped + Number(task.mode === "skip" || task.mode === "todo")
+          };
+        },
+        {
+          passed: 0,
+          failures: 0,
+          skipped: 0
+        }
+      );
+      const suites = getSuites(file);
+      for (const suite of suites) {
+        if (suite.result?.errors) {
+          tasks.push(suite);
+          stats2.failures += 1;
+        }
+      }
+      if (tasks.length === 0 && file.result?.state === "fail") {
+        stats2.failures = 1;
+        tasks.push({
+          id: file.id,
+          type: "test",
+          name: file.name,
+          mode: "run",
+          result: file.result,
+          meta: {},
+          // NOTE: not used in JUnitReporter
+          context: null,
+          suite: null,
+          file: null
+        });
+      }
+      return {
+        ...file,
+        tasks,
+        stats: stats2
+      };
+    });
+    const stats = transformed.reduce(
+      (stats2, file) => {
+        stats2.tests += file.tasks.length;
+        stats2.failures += file.stats.failures;
+        stats2.time += file.result?.duration || 0;
+        return stats2;
+      },
+      {
+        name: this.options.suiteName || "vitest tests",
+        tests: 0,
+        failures: 0,
+        errors: 0,
+        // we cannot detect those
+        time: 0
+      }
+    );
+    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(
+          "testsuite",
+          {
+            name: filename,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            hostname: hostname(),
+            tests: file.tasks.length,
+            failures: file.stats.failures,
+            errors: 0,
+            // An errored test is one that had an unanticipated problem. We cannot detect those.
+            skipped: file.stats.skipped,
+            time: getDuration(file)
+          },
+          async () => {
+            await this.writeTasks(file.tasks, filename);
+          }
+        );
+      }
+    });
+    if (this.reportFile) {
+      this.ctx.logger.log(`JUNIT report written to ${this.reportFile}`);
+    }
+    await this.fileFd?.close();
+    this.fileFd = void 0;
+  }
+}
+
+class ReportedTaskImplementation {
+  /**
+   * Task instance.
+   * @internal
+   */
+  task;
+  /**
+   * The project assosiacted with the test or suite.
+   */
+  project;
+  /**
+   * Unique identifier.
+   * This ID is deterministic and will be the same for the same test across multiple runs.
+   * The ID is based on the project name, module url and test order.
+   */
+  id;
+  /**
+   * Location in the module where the test or suite is defined.
+   */
+  location;
+  /** @internal */
+  constructor(task, project) {
+    this.task = task;
+    this.project = project;
+    this.id = task.id;
+    this.location = task.location;
+  }
+  /**
+   * Checks if the test did not fail the suite.
+   * If the test is not finished yet or was skipped, it will return `true`.
+   */
+  ok() {
+    const result = this.task.result;
+    return !result || result.state !== "fail";
+  }
+  /**
+   * Creates a new reported task instance and stores it in the project's state for future use.
+   * @internal
+   */
+  static register(task, project) {
+    const state = new this(task, project);
+    storeTask(project, task, state);
+    return state;
+  }
+}
+class TestCase extends ReportedTaskImplementation {
+  #fullName;
+  type = "test";
+  /**
+   * Direct reference to the test module where the test or suite is defined.
+   */
+  module;
+  /**
+   * Name of the test.
+   */
+  name;
+  /**
+   * Options that the test was initiated with.
+   */
+  options;
+  /**
+   * Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+   */
+  parent;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.name = task.name;
+    this.module = getReportedTask(project, task.file);
+    const suite = this.task.suite;
+    if (suite) {
+      this.parent = getReportedTask(project, suite);
+    } else {
+      this.parent = this.module;
+    }
+    this.options = buildOptions(task);
+  }
+  /**
+   * Full name of the test including all parent suites separated with `>`.
+   */
+  get fullName() {
+    if (this.#fullName === void 0) {
+      if (this.parent.type !== "module") {
+        this.#fullName = `${this.parent.fullName} > ${this.name}`;
+      } else {
+        this.#fullName = this.name;
+      }
+    }
+    return this.#fullName;
+  }
+  /**
+   * Test results. Will be `undefined` if test is skipped, not finished yet or was just collected.
+   */
+  result() {
+    const result = this.task.result;
+    if (!result || result.state === "run") {
+      return void 0;
+    }
+    const state = result.state === "fail" ? "failed" : result.state === "pass" ? "passed" : "skipped";
+    if (state === "skipped") {
+      return {
+        state,
+        note: result.note,
+        errors: void 0
+      };
+    }
+    if (state === "passed") {
+      return {
+        state,
+        errors: result.errors
+      };
+    }
+    return {
+      state,
+      errors: result.errors || []
+    };
+  }
+  /**
+   * Checks if the test was skipped during collection or dynamically with `ctx.skip()`.
+   */
+  skipped() {
+    const mode = this.task.result?.state || this.task.mode;
+    return mode === "skip" || mode === "todo";
+  }
+  /**
+   * Custom metadata that was attached to the test during its execution.
+   */
+  meta() {
+    return this.task.meta;
+  }
+  /**
+   * Useful information about the test like duration, memory usage, etc.
+   * Diagnostic is only available after the test has finished.
+   */
+  diagnostic() {
+    const result = this.task.result;
+    if (!result || result.state === "run" || !result.startTime) {
+      return void 0;
+    }
+    const duration = result.duration || 0;
+    const slow = duration > this.project.globalConfig.slowTestThreshold;
+    return {
+      slow,
+      heap: result.heap,
+      duration,
+      startTime: result.startTime,
+      retryCount: result.retryCount ?? 0,
+      repeatCount: result.repeatCount ?? 0,
+      flaky: !!result.retryCount && result.state === "pass" && result.retryCount > 0
+    };
+  }
+}
+class TestCollection {
+  #task;
+  #project;
+  constructor(task, project) {
+    this.#task = task;
+    this.#project = project;
+  }
+  /**
+   * Returns the test or suite at a specific index.
+   */
+  at(index) {
+    if (index < 0) {
+      index = this.size + index;
+    }
+    return getReportedTask(this.#project, this.#task.tasks[index]);
+  }
+  /**
+   * The number of tests and suites in the collection.
+   */
+  get size() {
+    return this.#task.tasks.length;
+  }
+  /**
+   * Returns the collection in array form for easier manipulation.
+   */
+  array() {
+    return Array.from(this);
+  }
+  /**
+   * Filters all tests that are part of this collection and its children.
+   */
+  *allTests(state) {
+    for (const child of this) {
+      if (child.type === "suite") {
+        yield* child.children.allTests(state);
+      } else if (state) {
+        const testState = getTestState(child);
+        if (state === testState) {
+          yield child;
+        }
+      } else {
+        yield child;
+      }
     }
   }
-  async onFinished(files = this.ctx.state.getFiles()) {
-    await this.logger.log('<?xml version="1.0" encoding="UTF-8" ?>');
-    const transformed = files.map((file) => {
-      const tasks = file.tasks.flatMap((task) => flattenTasks$1(task));
-      const stats2 = tasks.reduce(
-        (stats3, task) => {
-          return {
-            passed: stats3.passed + Number(task.result?.state === "pass"),
-            failures: stats3.failures + Number(task.result?.state === "fail"),
-            skipped: stats3.skipped + Number(task.mode === "skip" || task.mode === "todo")
-          };
-        },
-        {
-          passed: 0,
-          failures: 0,
-          skipped: 0
-        }
-      );
-      const suites = getSuites(file);
-      for (const suite of suites) {
-        if (suite.result?.errors) {
-          tasks.push(suite);
-          stats2.failures += 1;
+  /**
+   * Filters only the tests that are part of this collection.
+   */
+  *tests(state) {
+    for (const child of this) {
+      if (child.type !== "test") {
+        continue;
+      }
+      if (state) {
+        const testState = getTestState(child);
+        if (state === testState) {
+          yield child;
         }
+      } else {
+        yield child;
       }
-      if (tasks.length === 0 && file.result?.state === "fail") {
-        stats2.failures = 1;
-        tasks.push({
-          id: file.id,
-          type: "test",
-          name: file.name,
-          mode: "run",
-          result: file.result,
-          meta: {},
-          // NOTE: not used in JUnitReporter
-          context: null,
-          suite: null,
-          file: null
-        });
+    }
+  }
+  /**
+   * Filters only the suites that are part of this collection.
+   */
+  *suites() {
+    for (const child of this) {
+      if (child.type === "suite") {
+        yield child;
       }
-      return {
-        ...file,
-        tasks,
-        stats: stats2
-      };
-    });
-    const stats = transformed.reduce(
-      (stats2, file) => {
-        stats2.tests += file.tasks.length;
-        stats2.failures += file.stats.failures;
-        return stats2;
-      },
-      {
-        name: this.options.suiteName || "vitest tests",
-        tests: 0,
-        failures: 0,
-        errors: 0,
-        // we cannot detect those
-        time: executionTime((/* @__PURE__ */ new Date()).getTime() - this._timeStart.getTime())
+    }
+  }
+  /**
+   * Filters all suites that are part of this collection and its children.
+   */
+  *allSuites() {
+    for (const child of this) {
+      if (child.type === "suite") {
+        yield child;
+        yield* child.children.allSuites();
       }
-    );
-    await this.writeElement("testsuites", stats, async () => {
-      for (const file of transformed) {
-        const filename = relative(this.ctx.config.root, file.filepath);
-        await this.writeElement(
-          "testsuite",
-          {
-            name: filename,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            hostname: hostname(),
-            tests: file.tasks.length,
-            failures: file.stats.failures,
-            errors: 0,
-            // An errored test is one that had an unanticipated problem. We cannot detect those.
-            skipped: file.stats.skipped,
-            time: getDuration(file)
-          },
-          async () => {
-            await this.writeTasks(file.tasks, filename);
-          }
-        );
+    }
+  }
+  *[Symbol.iterator]() {
+    for (const task of this.#task.tasks) {
+      yield getReportedTask(this.#project, task);
+    }
+  }
+}
+class SuiteImplementation extends ReportedTaskImplementation {
+  /**
+   * Collection of suites and tests that are part of this suite.
+   */
+  children;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.children = new TestCollection(task, project);
+  }
+  /**
+   * Checks if the suite was skipped during collection.
+   */
+  skipped() {
+    const mode = this.task.mode;
+    return mode === "skip" || mode === "todo";
+  }
+  /**
+   * Errors that happened outside of the test run during collection, like syntax errors.
+   */
+  errors() {
+    return this.task.result?.errors || [];
+  }
+}
+class TestSuite extends SuiteImplementation {
+  #fullName;
+  type = "suite";
+  /**
+   * Name of the test or the suite.
+   */
+  name;
+  /**
+   * Direct reference to the test module where the test or suite is defined.
+   */
+  module;
+  /**
+   * Parent suite. If suite was called directly inside the module, the parent will be the module itself.
+   */
+  parent;
+  /**
+   * Options that suite was initiated with.
+   */
+  options;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.name = task.name;
+    this.module = getReportedTask(project, task.file);
+    const suite = this.task.suite;
+    if (suite) {
+      this.parent = getReportedTask(project, suite);
+    } else {
+      this.parent = this.module;
+    }
+    this.options = buildOptions(task);
+  }
+  /**
+   * Full name of the suite including all parent suites separated with `>`.
+   */
+  get fullName() {
+    if (this.#fullName === void 0) {
+      if (this.parent.type !== "module") {
+        this.#fullName = `${this.parent.fullName} > ${this.name}`;
+      } else {
+        this.#fullName = this.name;
       }
-    });
-    if (this.reportFile) {
-      this.ctx.logger.log(`JUNIT report written to ${this.reportFile}`);
     }
-    await this.fileFd?.close();
-    this.fileFd = void 0;
+    return this.#fullName;
+  }
+}
+class TestModule extends SuiteImplementation {
+  type = "module";
+  /**
+   * This is usually an absolute UNIX file path.
+   * It can be a virtual id if the file is not on the disk.
+   * This value corresponds to Vite's `ModuleGraph` id.
+   */
+  moduleId;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.moduleId = task.filepath;
+  }
+  /**
+   * Useful information about the module like duration, memory usage, etc.
+   * If the module was not executed yet, all diagnostic values will return `0`.
+   */
+  diagnostic() {
+    const setupDuration = this.task.setupDuration || 0;
+    const collectDuration = this.task.collectDuration || 0;
+    const prepareDuration = this.task.prepareDuration || 0;
+    const environmentSetupDuration = this.task.environmentLoad || 0;
+    const duration = this.task.result?.duration || 0;
+    return {
+      environmentSetupDuration,
+      prepareDuration,
+      collectDuration,
+      setupDuration,
+      duration
+    };
+  }
+}
+function buildOptions(task) {
+  return {
+    each: task.each,
+    concurrent: task.concurrent,
+    shuffle: task.shuffle,
+    retry: task.retry,
+    repeats: task.repeats,
+    mode: task.mode
+  };
+}
+function getTestState(test) {
+  if (test.skipped()) {
+    return "skipped";
+  }
+  const result = test.result();
+  return result ? result.state : "running";
+}
+function storeTask(project, runnerTask, reportedTask) {
+  project.vitest.state.reportedTasksMap.set(runnerTask, reportedTask);
+}
+function getReportedTask(project, runnerTask) {
+  const reportedTask = project.vitest.state.getReportedEntity(runnerTask);
+  if (!reportedTask) {
+    throw new Error(
+      `Task instance was not found for ${runnerTask.type} "${runnerTask.name}"`
+    );
   }
+  return reportedTask;
 }
 
 function yamlString(str) {
@@ -4532,7 +4947,7 @@ class TapReporter {
         this.logger.log("}");
       } else {
         this.logger.log(`${ok} ${id} - ${tapString(task.name)}${comment}`);
-        const project = this.ctx.getProjectByTaskId(task.id);
+        const project = this.ctx.getProjectByName(task.file.projectName || "");
         if (task.result?.state === "fail" && task.result.errors) {
           this.logger.indent();
           task.result.errors.forEach((error) => {