vitest 2.1.5 → 2.2.0-beta.2

package/dist/chunks/{index.DsZFoqi9.js → index.bzFpKeaq.js}

@@ -3,85 +3,22 @@ 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, e as getStateString, h as countTestErrors, i as getCols, j as getHookStateSymbol } from './utils.DNoFbBUZ.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.DJONn5B5.js';
 import { stripVTControlCharacters } from 'node:util';
 import { highlight, isPrimitive, inspect, positionToOffset, lineSplitRE, toArray, notNullish } from '@vitest/utils';
-import { performance } from 'node:perf_hooks';
+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.CMRlh2v4.js';
+import { a as TypeCheckError, R as RandomSequencer, g as getOutputFile, b as isNode, c as isDeno } from './RandomSequencer.BPedXEug.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, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
-import require$$0 from 'assert';
-import require$$0$1 from 'events';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { createRequire } from 'node:module';
 import { hostname } from 'node:os';
 
-class TestProject {
-  /**
-   * The global vitest instance.
-   * @experimental The public Vitest API is experimental and does not follow semver.
-   */
-  vitest;
-  /**
-   * The workspace project this test project is associated with.
-   * @experimental The public Vitest API is experimental and does not follow semver.
-   */
-  workspaceProject;
-  /**
-   * Vite's dev server instance. Every workspace project has its own server.
-   */
-  vite;
-  /**
-   * Resolved project configuration.
-   */
-  config;
-  /**
-   * Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
-   */
-  globalConfig;
-  /**
-   * The name of the project or an empty string if not set.
-   */
-  name;
-  constructor(workspaceProject) {
-    this.workspaceProject = workspaceProject;
-    this.vitest = workspaceProject.ctx;
-    this.vite = workspaceProject.server;
-    this.globalConfig = workspaceProject.ctx.config;
-    this.config = workspaceProject.config;
-    this.name = workspaceProject.getName();
-  }
-  /**
-   * Serialized project configuration. This is the config that tests receive.
-   */
-  get serializedConfig() {
-    return this.workspaceProject.getSerializableConfig();
-  }
-  /**
-   * Custom context provided to the project.
-   */
-  context() {
-    return this.workspaceProject.getProvidedContext();
-  }
-  /**
-   * Provide a custom serializable context to the project. This context will be available for tests once they run.
-   */
-  provide(key, value) {
-    this.workspaceProject.provide(key, value);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      serializedConfig: this.serializedConfig,
-      context: this.context()
-    };
-  }
-}
-
 class ReportedTaskImplementation {
   /**
    * Task instance.
@@ -104,7 +41,7 @@ class ReportedTaskImplementation {
   location;
   constructor(task, project) {
     this.task = task;
-    this.project = project.testProject || (project.testProject = new TestProject(project));
+    this.project = project;
     this.id = task.id;
     this.location = task.location;
   }
@@ -170,9 +107,22 @@ class TestCase extends ReportedTaskImplementation {
       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
+      errors: result.errors || []
     };
   }
   /**
@@ -402,10 +352,10 @@ function getTestState(test) {
   return result ? result.state : "running";
 }
 function storeTask(project, runnerTask, reportedTask) {
-  project.ctx.state.reportedTasksMap.set(runnerTask, reportedTask);
+  project.vitest.state.reportedTasksMap.set(runnerTask, reportedTask);
 }
 function getReportedTask(project, runnerTask) {
-  const reportedTask = project.ctx.state.getReportedEntity(runnerTask);
+  const reportedTask = project.vitest.state.getReportedEntity(runnerTask);
   if (!reportedTask) {
     throw new Error(
       `Task instance was not found for ${runnerTask.type} "${runnerTask.name}"`
@@ -521,7 +471,7 @@ const stringify = (value, replacer, space) => {
   }
 };
 
-const ESC$1 = '\u001B[';
+const ESC$2 = '\u001B[';
 const OSC = '\u001B]';
 const BEL = '\u0007';
 const SEP = ';';
@@ -535,10 +485,10 @@ ansiEscapes.cursorTo = (x, y) => {
 	}
 
 	if (typeof y !== 'number') {
-		return ESC$1 + (x + 1) + 'G';
+		return ESC$2 + (x + 1) + 'G';
 	}
 
-	return ESC$1 + (y + 1) + ';' + (x + 1) + 'H';
+	return ESC$2 + (y + 1) + ';' + (x + 1) + 'H';
 };
 
 ansiEscapes.cursorMove = (x, y) => {
@@ -549,33 +499,33 @@ ansiEscapes.cursorMove = (x, y) => {
 	let returnValue = '';
 
 	if (x < 0) {
-		returnValue += ESC$1 + (-x) + 'D';
+		returnValue += ESC$2 + (-x) + 'D';
 	} else if (x > 0) {
-		returnValue += ESC$1 + x + 'C';
+		returnValue += ESC$2 + x + 'C';
 	}
 
 	if (y < 0) {
-		returnValue += ESC$1 + (-y) + 'A';
+		returnValue += ESC$2 + (-y) + 'A';
 	} else if (y > 0) {
-		returnValue += ESC$1 + y + 'B';
+		returnValue += ESC$2 + y + 'B';
 	}
 
 	return returnValue;
 };
 
-ansiEscapes.cursorUp = (count = 1) => ESC$1 + count + 'A';
-ansiEscapes.cursorDown = (count = 1) => ESC$1 + count + 'B';
-ansiEscapes.cursorForward = (count = 1) => ESC$1 + count + 'C';
-ansiEscapes.cursorBackward = (count = 1) => ESC$1 + count + 'D';
+ansiEscapes.cursorUp = (count = 1) => ESC$2 + count + 'A';
+ansiEscapes.cursorDown = (count = 1) => ESC$2 + count + 'B';
+ansiEscapes.cursorForward = (count = 1) => ESC$2 + count + 'C';
+ansiEscapes.cursorBackward = (count = 1) => ESC$2 + count + 'D';
 
-ansiEscapes.cursorLeft = ESC$1 + 'G';
-ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC$1 + 's';
-ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC$1 + 'u';
-ansiEscapes.cursorGetPosition = ESC$1 + '6n';
-ansiEscapes.cursorNextLine = ESC$1 + 'E';
-ansiEscapes.cursorPrevLine = ESC$1 + 'F';
-ansiEscapes.cursorHide = ESC$1 + '?25l';
-ansiEscapes.cursorShow = ESC$1 + '?25h';
+ansiEscapes.cursorLeft = ESC$2 + 'G';
+ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC$2 + 's';
+ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC$2 + 'u';
+ansiEscapes.cursorGetPosition = ESC$2 + '6n';
+ansiEscapes.cursorNextLine = ESC$2 + 'E';
+ansiEscapes.cursorPrevLine = ESC$2 + 'F';
+ansiEscapes.cursorHide = ESC$2 + '?25l';
+ansiEscapes.cursorShow = ESC$2 + '?25h';
 
 ansiEscapes.eraseLines = count => {
 	let clear = '';
@@ -591,24 +541,24 @@ ansiEscapes.eraseLines = count => {
 	return clear;
 };
 
-ansiEscapes.eraseEndLine = ESC$1 + 'K';
-ansiEscapes.eraseStartLine = ESC$1 + '1K';
-ansiEscapes.eraseLine = ESC$1 + '2K';
-ansiEscapes.eraseDown = ESC$1 + 'J';
-ansiEscapes.eraseUp = ESC$1 + '1J';
-ansiEscapes.eraseScreen = ESC$1 + '2J';
-ansiEscapes.scrollUp = ESC$1 + 'S';
-ansiEscapes.scrollDown = ESC$1 + 'T';
+ansiEscapes.eraseEndLine = ESC$2 + 'K';
+ansiEscapes.eraseStartLine = ESC$2 + '1K';
+ansiEscapes.eraseLine = ESC$2 + '2K';
+ansiEscapes.eraseDown = ESC$2 + 'J';
+ansiEscapes.eraseUp = ESC$2 + '1J';
+ansiEscapes.eraseScreen = ESC$2 + '2J';
+ansiEscapes.scrollUp = ESC$2 + 'S';
+ansiEscapes.scrollDown = ESC$2 + 'T';
 
 ansiEscapes.clearScreen = '\u001Bc';
 
 ansiEscapes.clearTerminal = process.platform === 'win32' ?
-	`${ansiEscapes.eraseScreen}${ESC$1}0f` :
+	`${ansiEscapes.eraseScreen}${ESC$2}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$1}3J${ESC$1}H`;
+	`${ansiEscapes.eraseScreen}${ESC$2}3J${ESC$2}H`;
 
 ansiEscapes.beep = BEL;
 
@@ -676,370 +626,6 @@ 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 = {};
@@ -2403,8 +1989,10 @@ function isWide(x) {
 		|| x === 0x25FE
 		|| x === 0x2614
 		|| x === 0x2615
+		|| x >= 0x2630 && x <= 0x2637
 		|| x >= 0x2648 && x <= 0x2653
 		|| x === 0x267F
+		|| x >= 0x268A && x <= 0x268F
 		|| x === 0x2693
 		|| x === 0x26A1
 		|| x === 0x26AA
@@ -2445,11 +2033,10 @@ function isWide(x) {
 		|| x >= 0x3099 && x <= 0x30FF
 		|| x >= 0x3105 && x <= 0x312F
 		|| x >= 0x3131 && x <= 0x318E
-		|| x >= 0x3190 && x <= 0x31E3
+		|| x >= 0x3190 && x <= 0x31E5
 		|| x >= 0x31EF && x <= 0x321E
 		|| x >= 0x3220 && x <= 0x3247
-		|| x >= 0x3250 && x <= 0x4DBF
-		|| x >= 0x4E00 && x <= 0xA48C
+		|| x >= 0x3250 && x <= 0xA48C
 		|| x >= 0xA490 && x <= 0xA4C6
 		|| x >= 0xA960 && x <= 0xA97C
 		|| x >= 0xAC00 && x <= 0xD7A3
@@ -2463,7 +2050,7 @@ function isWide(x) {
 		|| x === 0x16FF1
 		|| x >= 0x17000 && x <= 0x187F7
 		|| x >= 0x18800 && x <= 0x18CD5
-		|| x >= 0x18D00 && x <= 0x18D08
+		|| x >= 0x18CFF && x <= 0x18D08
 		|| x >= 0x1AFF0 && x <= 0x1AFF3
 		|| x >= 0x1AFF5 && x <= 0x1AFFB
 		|| x === 0x1AFFD
@@ -2474,6 +2061,8 @@ function isWide(x) {
 		|| x === 0x1B155
 		|| x >= 0x1B164 && x <= 0x1B167
 		|| x >= 0x1B170 && x <= 0x1B2FB
+		|| x >= 0x1D300 && x <= 0x1D356
+		|| x >= 0x1D360 && x <= 0x1D376
 		|| x === 0x1F004
 		|| x === 0x1F0CF
 		|| x === 0x1F18E
@@ -2517,11 +2106,10 @@ function isWide(x) {
 		|| x >= 0x1F93C && x <= 0x1F945
 		|| x >= 0x1F947 && x <= 0x1F9FF
 		|| x >= 0x1FA70 && x <= 0x1FA7C
-		|| x >= 0x1FA80 && x <= 0x1FA88
-		|| x >= 0x1FA90 && x <= 0x1FABD
-		|| x >= 0x1FABF && x <= 0x1FAC5
-		|| x >= 0x1FACE && x <= 0x1FADB
-		|| x >= 0x1FAE0 && x <= 0x1FAE8
+		|| x >= 0x1FA80 && x <= 0x1FA89
+		|| x >= 0x1FA8F && x <= 0x1FAC6
+		|| x >= 0x1FACE && x <= 0x1FADC
+		|| x >= 0x1FADF && x <= 0x1FAE9
 		|| x >= 0x1FAF0 && x <= 0x1FAF8
 		|| x >= 0x20000 && x <= 0x2FFFD
 		|| x >= 0x30000 && x <= 0x3FFFD;
@@ -3011,10 +2599,10 @@ function lineNo(no = "") {
 }
 
 const PAD = "      ";
-const ESC = "\x1B[";
-const ERASE_DOWN = `${ESC}J`;
-const ERASE_SCROLLBACK = `${ESC}3J`;
-const CURSOR_TO_START = `${ESC}1;1H`;
+const ESC$1 = "\x1B[";
+const ERASE_DOWN = `${ESC$1}J`;
+const ERASE_SCROLLBACK = `${ESC$1}3J`;
+const CURSOR_TO_START = `${ESC$1}1;1H`;
 const CLEAR_SCREEN = "\x1Bc";
 class Logger {
   constructor(ctx, outputStream = process.stdout, errorStream = process.stderr) {
@@ -3073,7 +2661,7 @@ class Logger {
   }
   printError(err, options = {}) {
     const { fullStack = false, type } = options;
-    const project = options.project ?? this.ctx.getCoreWorkspaceProject() ?? this.ctx.projects[0];
+    const project = options.project ?? this.ctx.coreWorkspaceProject ?? this.ctx.projects[0];
     return printError(err, project, {
       type,
       showCodeFrame: options.showCodeFrame ?? true,
@@ -3122,8 +2710,7 @@ class Logger {
     }
     this.ctx.projects.forEach((project) => {
       const config2 = project.config;
-      const name = project.getName();
-      const output = project.isCore() || !name ? "" : `[${name}]`;
+      const output = project.isRootProject() || !project.name ? "" : `[${project.name}]`;
       if (output) {
         this.console.error(c.bgCyan(`${output} Config`));
       }
@@ -3199,8 +2786,7 @@ Vitest is running in standalone mode. Edit a test file to rerun tests.`));
     if (!origin) {
       return;
     }
-    const name = project.getName();
-    const output = project.isCore() ? "" : formatProjectName(name);
+    const output = project.isRootProject() ? "" : formatProjectName(project.name);
     const provider = project.browser.provider.name;
     const providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
     this.log(
@@ -3281,7 +2867,7 @@ class BlobReporter {
       (project) => {
         return [
           project.getName(),
-          [...project.server.moduleGraph.idToModuleMap.entries()].map((mod) => {
+          [...project.vite.moduleGraph.idToModuleMap.entries()].map((mod) => {
             if (!mod[1].file) {
               return null;
             }
@@ -3357,10 +2943,10 @@ ${blobs.map((b) => `- "${b.file}" uses v${b.version}`).join("\n")}`
         return;
       }
       moduleIds.forEach(([moduleId, file, url]) => {
-        const moduleNode = project.server.moduleGraph.createFileOnlyEntry(file);
+        const moduleNode = project.vite.moduleGraph.createFileOnlyEntry(file);
         moduleNode.url = url;
         moduleNode.id = moduleId;
-        project.server.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
+        project.vite.moduleGraph.idToModuleMap.set(moduleId, moduleNode);
       });
     });
   });
@@ -3387,7 +2973,6 @@ function hasFailedSnapshot(suite) {
 }
 
 const BADGE_PADDING = "       ";
-const LAST_RUN_LOG_TIMEOUT = 1500;
 class BaseReporter {
   start = 0;
   end = 0;
@@ -3395,19 +2980,17 @@ class BaseReporter {
   failedUnwatchedFiles = [];
   isTTY;
   ctx = void 0;
+  renderSucceed = false;
   verbose = false;
   _filesInWatchMode = /* @__PURE__ */ new Map();
   _timeStart = formatTimeString(/* @__PURE__ */ new Date());
-  _lastRunTimeout = 0;
-  _lastRunTimer;
-  _lastRunCount = 0;
   constructor(options = {}) {
     this.isTTY = options.isTTY ?? ((isNode || isDeno) && process.stdout?.isTTY && !isCI);
   }
   onInit(ctx) {
     this.ctx = ctx;
     this.ctx.logger.printBanner();
-    this.start = performance.now();
+    this.start = performance$1.now();
   }
   log(...messages) {
     this.ctx.logger.log(...messages);
@@ -3419,13 +3002,10 @@ class BaseReporter {
     return relative(this.ctx.config.root, path);
   }
   onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    this.end = performance.now();
+    this.end = performance$1.now();
     this.reportSummary(files, errors);
   }
   onTaskUpdate(packs) {
-    if (this.isTTY) {
-      return;
-    }
     for (const pack of packs) {
       const task = this.ctx.state.idMap.get(pack[0]);
       if (task) {
@@ -3459,6 +3039,7 @@ class BaseReporter {
       title += ` ${formatProjectName(task.projectName, "")}`;
     }
     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;
       if (test.result?.state === "fail") {
@@ -3471,6 +3052,10 @@ class BaseReporter {
         this.log(
           `   ${c.yellow(c.dim(F_CHECK))} ${getTestName(test, c.dim(" > "))} ${c.yellow(Math.round(duration) + c.dim("ms"))}`
         );
+      } 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(" > "))}`);
       }
     }
   }
@@ -3482,7 +3067,6 @@ class BaseReporter {
     return color(` ${Math.round(task.result.duration)}${c.dim("ms")}`);
   }
   onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    this.resetLastRunLog();
     const failed = errors.length > 0 || hasFailed(files);
     if (failed) {
       this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
@@ -3498,34 +3082,8 @@ class BaseReporter {
       hints.push(c.dim("press ") + c.bold("q") + c.dim(" to quit"));
     }
     this.log(BADGE_PADDING + hints.join(c.dim(", ")));
-    if (this._lastRunCount) {
-      const LAST_RUN_TEXT = `rerun x${this._lastRunCount}`;
-      const LAST_RUN_TEXTS = [
-        c.blue(LAST_RUN_TEXT),
-        c.gray(LAST_RUN_TEXT),
-        c.dim(c.gray(LAST_RUN_TEXT))
-      ];
-      this.ctx.logger.logUpdate(BADGE_PADDING + LAST_RUN_TEXTS[0]);
-      this._lastRunTimeout = 0;
-      this._lastRunTimer = setInterval(() => {
-        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() {
-    clearInterval(this._lastRunTimer);
-    this._lastRunTimer = void 0;
-    this.ctx.logger.logUpdate.clear();
   }
   onWatcherRerun(files, trigger) {
-    this.resetLastRunLog();
     this.watchFilters = files;
     this.failedUnwatchedFiles = this.ctx.state.getFiles().filter(
       (file) => !files.includes(file.filepath) && hasFailed(file)
@@ -3535,9 +3093,7 @@ class BaseReporter {
       this._filesInWatchMode.set(filepath, ++reruns);
     });
     let banner = trigger ? c.dim(`${this.relative(trigger)} `) : "";
-    if (files.length > 1 || !files.length) {
-      this._lastRunCount = 0;
-    } else if (files.length === 1) {
+    if (files.length === 1) {
       const rerun = this._filesInWatchMode.get(files[0]) ?? 1;
       banner += c.blue(`x${rerun} `);
     }
@@ -3553,13 +3109,11 @@ class BaseReporter {
       this.log(BADGE_PADDING + c.dim(" Test name pattern: ") + c.blue(String(this.ctx.configOverride.testNamePattern)));
     }
     this.log("");
-    if (!this.isTTY) {
-      for (const task of this.failedUnwatchedFiles) {
-        this.printTask(task);
-      }
+    for (const task of this.failedUnwatchedFiles) {
+      this.printTask(task);
     }
     this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
-    this.start = performance.now();
+    this.start = performance$1.now();
   }
   onUserConsoleLog(log) {
     if (!this.shouldLog(log)) {
@@ -3580,7 +3134,7 @@ class BaseReporter {
       if (log.browser) {
         write("\n");
       }
-      const project = log.taskId ? this.ctx.getProjectByTaskId(log.taskId) : this.ctx.getCoreWorkspaceProject();
+      const project = log.taskId ? this.ctx.getProjectByTaskId(log.taskId) : this.ctx.getRootTestProject();
       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) {
@@ -3624,6 +3178,7 @@ class BaseReporter {
     }
   }
   reportTestSummary(files, errors) {
+    this.log();
     const affectedFiles = [
       ...this.failedUnwatchedFiles,
       ...files
@@ -3635,32 +3190,32 @@ class BaseReporter {
     );
     for (const [index, snapshot] of snapshotOutput.entries()) {
       const title = index === 0 ? "Snapshots" : "";
-      this.log(`${padTitle(title)} ${snapshot}`);
+      this.log(`${padSummaryTitle(title)} ${snapshot}`);
     }
     if (snapshotOutput.length > 1) {
       this.log();
     }
-    this.log(padTitle("Test Files"), getStateString(affectedFiles));
-    this.log(padTitle("Tests"), getStateString(tests));
+    this.log(padSummaryTitle("Test Files"), getStateString$1(affectedFiles));
+    this.log(padSummaryTitle("Tests"), getStateString$1(tests));
     if (this.ctx.projects.some((c2) => c2.config.typecheck.enabled)) {
       const failed = tests.filter((t) => t.meta?.typecheck && t.result?.errors?.length);
       this.log(
-        padTitle("Type Errors"),
+        padSummaryTitle("Type Errors"),
         failed.length ? c.bold(c.red(`${failed.length} failed`)) : c.dim("no errors")
       );
     }
     if (errors.length) {
       this.log(
-        padTitle("Errors"),
+        padSummaryTitle("Errors"),
         c.bold(c.red(`${errors.length} error${errors.length > 1 ? "s" : ""}`))
       );
     }
-    this.log(padTitle("Start at"), this._timeStart);
+    this.log(padSummaryTitle("Start at"), this._timeStart);
     const collectTime = sum(files, (file) => file.collectDuration);
     const testsTime = sum(files, (file) => file.result?.duration);
     const setupTime = sum(files, (file) => file.setupDuration);
     if (this.watchFilters) {
-      this.log(padTitle("Duration"), time(collectTime + testsTime + setupTime));
+      this.log(padSummaryTitle("Duration"), formatTime(collectTime + testsTime + setupTime));
     } else {
       const executionTime = this.end - this.start;
       const environmentTime = sum(files, (file) => file.environmentLoad);
@@ -3668,15 +3223,15 @@ class BaseReporter {
       const transformTime = sum(this.ctx.projects, (project) => project.vitenode.getTotalDuration());
       const typecheck = sum(this.ctx.projects, (project) => project.typechecker?.getResult().time);
       const timers = [
-        `transform ${time(transformTime)}`,
-        `setup ${time(setupTime)}`,
-        `collect ${time(collectTime)}`,
-        `tests ${time(testsTime)}`,
-        `environment ${time(environmentTime)}`,
-        `prepare ${time(prepareTime)}`,
-        typecheck && `typecheck ${time(typecheck)}`
+        `transform ${formatTime(transformTime)}`,
+        `setup ${formatTime(setupTime)}`,
+        `collect ${formatTime(collectTime)}`,
+        `tests ${formatTime(testsTime)}`,
+        `environment ${formatTime(environmentTime)}`,
+        `prepare ${formatTime(prepareTime)}`,
+        typecheck && `typecheck ${formatTime(typecheck)}`
       ].filter(Boolean).join(", ");
-      this.log(padTitle("Duration"), time(executionTime) + c.dim(` (${timers})`));
+      this.log(padSummaryTitle("Duration"), formatTime(executionTime) + c.dim(` (${timers})`));
     }
     this.log();
   }
@@ -3771,15 +3326,6 @@ class BaseReporter {
 function errorBanner(message) {
   return c.red(divider(c.bold(c.inverse(` ${message} `))));
 }
-function padTitle(str) {
-  return c.dim(`${str.padStart(11)} `);
-}
-function time(time2) {
-  if (time2 > 1e3) {
-    return `${(time2 / 1e3).toFixed(2)}s`;
-  }
-  return `${Math.round(time2)}ms`;
-}
 function sum(items, cb) {
   return items.reduce((total, next) => {
     return total + Math.max(cb(next) || 0, 0);
@@ -3791,288 +3337,521 @@ class BasicReporter extends BaseReporter {
     super();
     this.isTTY = false;
   }
+  onInit(ctx) {
+    super.onInit(ctx);
+    ctx.logger.log(c.inverse(c.bold(c.yellow(" DEPRECATED "))), c.yellow(
+      `'basic' reporter is deprecated and will be removed in Vitest v3.
+Remove 'basic' from 'reporters' option. To match 'basic' reporter 100%, use configuration:
+${JSON.stringify({ test: { reporters: [["default", { summary: false }]] } }, null, 2)}`
+    ));
+  }
   reportSummary(files, errors) {
     this.ctx.logger.log();
     return super.reportSummary(files, errors);
   }
 }
 
-const outputMap$1 = /* @__PURE__ */ new WeakMap();
-function formatFilepath$1(path) {
-  const lastSlash = Math.max(path.lastIndexOf("/") + 1, 0);
-  const basename = path.slice(lastSlash);
-  let firstDot = basename.indexOf(".");
-  if (firstDot < 0) {
-    firstDot = basename.length;
+const DEFAULT_RENDER_INTERVAL = 16;
+const ESC = "\x1B[";
+const CLEAR_LINE = `${ESC}K`;
+const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
+const HIDE_CURSOR = `${ESC}?25l`;
+const SHOW_CURSOR = `${ESC}?25h`;
+const SYNC_START = `${ESC}?2026h`;
+const SYNC_END = `${ESC}?2026l`;
+class WindowRenderer {
+  options;
+  streams;
+  buffer = [];
+  renderInterval = void 0;
+  windowHeight = 0;
+  finished = false;
+  cleanups = [];
+  constructor(options) {
+    this.options = {
+      interval: DEFAULT_RENDER_INTERVAL,
+      ...options
+    };
+    this.streams = {
+      output: options.logger.outputStream.write.bind(options.logger.outputStream),
+      error: options.logger.errorStream.write.bind(options.logger.errorStream)
+    };
+    this.cleanups.push(
+      this.interceptStream(process.stdout, "output"),
+      this.interceptStream(process.stderr, "error")
+    );
+    restoreCursor();
+    this.write(HIDE_CURSOR, "output");
+    this.start();
   }
-  firstDot += lastSlash;
-  return c.dim(path.slice(0, lastSlash)) + path.slice(lastSlash, firstDot) + c.dim(path.slice(firstDot));
-}
-function formatNumber$1(number) {
-  const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
-  return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
-}
-function renderHookState(task, hookName, level = 0) {
-  const state = task.result?.hooks?.[hookName];
-  if (state && state === "run") {
-    return `${"  ".repeat(level)} ${getHookStateSymbol(task, hookName)} ${c.dim(
-      `[ ${hookName} ]`
-    )}`;
-  }
-  return "";
-}
-function renderBenchmarkItems$1(result) {
-  return [
-    result.name,
-    formatNumber$1(result.hz || 0),
-    formatNumber$1(result.p99 || 0),
-    `\xB1${result.rme.toFixed(2)}%`,
-    result.samples.length.toString()
-  ];
-}
-function renderBenchmark$1(task, tasks) {
-  const result = task.result?.benchmark;
-  if (!result) {
-    return task.name;
-  }
-  const benches = tasks.map((i) => i.meta?.benchmark ? i.result?.benchmark : void 0).filter(notNullish);
-  const allItems = benches.map(renderBenchmarkItems$1);
-  const items = renderBenchmarkItems$1(result);
-  const padded = items.map((i, idx) => {
-    const width = Math.max(...allItems.map((i2) => i2[idx].length));
-    return idx ? i.padStart(width, " ") : i.padEnd(width, " ");
-  });
-  return [
-    padded[0],
-    // name
-    c.dim("  "),
-    c.blue(padded[1]),
-    c.dim(" ops/sec "),
-    c.cyan(padded[3]),
-    c.dim(` (${padded[4]} samples)`),
-    result.rank === 1 ? c.bold(c.green(" fastest")) : result.rank === benches.length && benches.length > 2 ? c.bold(c.gray(" slowest")) : ""
-  ].join("");
-}
-function renderTree$1(tasks, options, level = 0, maxRows) {
-  const output = [];
-  let currentRowCount = 0;
-  for (const task of [...tasks].reverse()) {
-    const taskOutput = [];
-    let suffix = "";
-    let prefix = ` ${getStateSymbol(task)} `;
-    if (level === 0 && task.type === "suite" && "projectName" in task) {
-      prefix += formatProjectName(task.projectName);
-    }
-    if (level === 0 && task.type === "suite" && task.meta.typecheck) {
-      prefix += c.bgBlue(c.bold(" TS "));
-      prefix += " ";
+  start() {
+    this.finished = false;
+    this.renderInterval = setInterval(() => this.flushBuffer(), this.options.interval);
+  }
+  stop() {
+    this.write(SHOW_CURSOR, "output");
+    this.cleanups.splice(0).map((fn) => fn());
+    clearInterval(this.renderInterval);
+  }
+  /**
+   * Write all buffered output and stop buffering.
+   * All intercepted writes are forwarded to actual write after this.
+   */
+  finish() {
+    this.finished = true;
+    this.flushBuffer();
+    clearInterval(this.renderInterval);
+  }
+  flushBuffer() {
+    if (this.buffer.length === 0) {
+      return this.render();
+    }
+    let current;
+    for (const next of this.buffer.splice(0)) {
+      if (!current) {
+        current = next;
+        continue;
+      }
+      if (current.type !== next.type) {
+        this.render(current.message, current.type);
+        current = next;
+        continue;
+      }
+      current.message += next.message;
     }
-    if (task.type === "test" && task.result?.retryCount && task.result.retryCount > 0) {
-      suffix += c.yellow(` (retry x${task.result.retryCount})`);
+    if (current) {
+      this.render(current?.message, current?.type);
     }
-    if (task.type === "suite") {
-      const tests = getTests(task);
-      suffix += c.dim(` (${tests.length})`);
+  }
+  render(message, type = "output") {
+    if (this.finished) {
+      this.clearWindow();
+      return this.write(message || "", type);
     }
-    if (task.mode === "skip" || task.mode === "todo") {
-      suffix += ` ${c.dim(c.gray("[skipped]"))}`;
+    const windowContent = this.options.getWindow();
+    const rowCount = getRenderedRowCount(windowContent, this.options.logger.outputStream);
+    let padding = this.windowHeight - rowCount;
+    if (padding > 0 && message) {
+      padding -= getRenderedRowCount([message], this.options.logger.outputStream);
     }
-    if (task.type === "test" && task.result?.repeatCount && task.result.repeatCount > 0) {
-      suffix += c.yellow(` (repeat x${task.result.repeatCount})`);
+    this.write(SYNC_START);
+    this.clearWindow();
+    if (message) {
+      this.write(message, type);
     }
-    if (task.result?.duration != null) {
-      if (task.result.duration > options.slowTestThreshold) {
-        suffix += c.yellow(
-          ` ${Math.round(task.result.duration)}${c.dim("ms")}`
-        );
-      }
+    if (padding > 0) {
+      this.write("\n".repeat(padding));
     }
-    if (options.showHeap && task.result?.heap != null) {
-      suffix += c.magenta(
-        ` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`
-      );
+    this.write(windowContent.join("\n"));
+    this.write(SYNC_END);
+    this.windowHeight = rowCount + Math.max(0, padding);
+  }
+  clearWindow() {
+    if (this.windowHeight === 0) {
+      return;
     }
-    let name = task.name;
-    if (level === 0) {
-      name = formatFilepath$1(name);
+    this.write(CLEAR_LINE);
+    for (let i = 1; i < this.windowHeight; i++) {
+      this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
     }
-    const padding = "  ".repeat(level);
-    const body = task.meta?.benchmark ? renderBenchmark$1(task, tasks) : name;
-    taskOutput.push(padding + prefix + body + suffix);
-    if (task.result?.state !== "pass" && outputMap$1.get(task) != null) {
-      let data = outputMap$1.get(task);
-      if (typeof data === "string") {
-        data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
-        if (data === "") {
-          data = void 0;
+    this.windowHeight = 0;
+  }
+  interceptStream(stream, type) {
+    const original = stream.write;
+    stream.write = (chunk, _, callback) => {
+      if (chunk) {
+        if (this.finished) {
+          this.write(chunk.toString(), type);
+        } else {
+          this.buffer.push({ type, message: chunk.toString() });
         }
       }
-      if (data != null) {
-        const out = `${"  ".repeat(level)}${F_RIGHT} ${data}`;
-        taskOutput.push(`   ${c.gray(cliTruncate(out, getCols(-3)))}`);
-      }
-    }
-    taskOutput.push(renderHookState(task, "beforeAll", level + 1));
-    taskOutput.push(renderHookState(task, "beforeEach", level + 1));
-    if (task.type === "suite" && task.tasks.length > 0) {
-      if (task.result?.state === "fail" || task.result?.state === "run" || options.renderSucceed) {
-        if (options.logger.ctx.config.hideSkippedTests) {
-          const filteredTasks = task.tasks.filter(
-            (t) => t.mode !== "skip" && t.mode !== "todo"
-          );
-          taskOutput.push(
-            renderTree$1(filteredTasks, options, level + 1, maxRows)
-          );
+      callback?.();
+    };
+    return function restore() {
+      stream.write = original;
+    };
+  }
+  write(message, type = "output") {
+    this.streams[type](message);
+  }
+}
+function getRenderedRowCount(rows, stream) {
+  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));
+  }
+  return count;
+}
+
+class TaskParser {
+  ctx;
+  onInit(ctx) {
+    this.ctx = ctx;
+  }
+  onHookStart(_options) {
+  }
+  onHookEnd(_options) {
+  }
+  onTestStart(_test) {
+  }
+  onTestFinished(_test) {
+  }
+  onTestFilePrepare(_file) {
+  }
+  onTestFileFinished(_file) {
+  }
+  onTaskUpdate(packs) {
+    const startingTestFiles = [];
+    const finishedTestFiles = [];
+    const startingTests = [];
+    const finishedTests = [];
+    const startingHooks = [];
+    const endingHooks = [];
+    for (const pack of packs) {
+      const task = this.ctx.state.idMap.get(pack[0]);
+      if (task?.type === "suite" && "filepath" in task && task.result?.state) {
+        if (task?.result?.state === "run") {
+          startingTestFiles.push(task);
         } else {
-          taskOutput.push(renderTree$1(task.tasks, options, level + 1, maxRows));
+          for (const test of getTests(task)) {
+            if (!test.result || test.result?.state === "skip") {
+              finishedTests.push(test);
+            }
+          }
+          finishedTestFiles.push(task.file);
+        }
+      }
+      if (task?.type === "test" || task?.type === "custom") {
+        if (task.result?.state === "run") {
+          startingTests.push(task);
+        } else if (task.result?.hooks?.afterEach !== "run") {
+          finishedTests.push(task);
+        }
+      }
+      if (task?.result?.hooks) {
+        for (const [hook, state] of Object.entries(task.result.hooks)) {
+          if (state === "run") {
+            startingHooks.push({ name: hook, file: task.file, id: task.id, type: task.type });
+          } else {
+            endingHooks.push({ name: hook, file: task.file, id: task.id, type: task.type });
+          }
         }
       }
     }
-    taskOutput.push(renderHookState(task, "afterAll", level + 1));
-    taskOutput.push(renderHookState(task, "afterEach", level + 1));
-    const rows = taskOutput.filter(Boolean);
-    output.push(rows.join("\n"));
-    currentRowCount += rows.length;
-    if (maxRows && currentRowCount >= maxRows) {
-      break;
-    }
+    endingHooks.forEach((hook) => this.onHookEnd(hook));
+    finishedTests.forEach((test) => this.onTestFinished(test));
+    finishedTestFiles.forEach((file) => this.onTestFileFinished(file));
+    startingTestFiles.forEach((file) => this.onTestFilePrepare(file));
+    startingTests.forEach((test) => this.onTestStart(test));
+    startingHooks.forEach(
+      (hook) => this.onHookStart(hook)
+    );
   }
-  return output.reverse().join("\n");
 }
-function createListRenderer(_tasks, options) {
-  let tasks = _tasks;
-  let timer;
-  const log = options.logger.logUpdate;
-  function update() {
-    if (options.logger.ctx.config.hideSkippedTests) {
-      const filteredTasks = tasks.filter(
-        (t) => t.mode !== "skip" && t.mode !== "todo"
-      );
-      log(
-        renderTree$1(
-          filteredTasks,
-          options,
-          0,
-          // log-update already limits the amount of printed rows to fit the current terminal
-          // but we can optimize performance by doing it ourselves
-          process.stdout.rows
-        )
-      );
-    } else {
-      log(
-        renderTree$1(
-          tasks,
-          options,
-          0,
-          // log-update already limits the amount of printed rows to fit the current terminal
-          // but we can optimize performance by doing it ourselves
-          process.stdout.rows
-        )
-      );
+
+const DURATION_UPDATE_INTERVAL_MS = 100;
+const FINISHED_TEST_CLEANUP_TIME_MS = 1e3;
+class SummaryReporter extends TaskParser {
+  options;
+  renderer;
+  suites = emptyCounters();
+  tests = emptyCounters();
+  maxParallelTests = 0;
+  /** Currently running tests, may include finished tests too */
+  runningTests = /* @__PURE__ */ new Map();
+  /** ID of finished `this.runningTests` that are currently being shown */
+  finishedTests = /* @__PURE__ */ new Map();
+  /** IDs of all finished tests */
+  allFinishedTests = /* @__PURE__ */ new Set();
+  startTime = "";
+  currentTime = 0;
+  duration = 0;
+  durationInterval = void 0;
+  onInit(ctx, options = {}) {
+    this.ctx = ctx;
+    this.options = {
+      verbose: false,
+      ...options
+    };
+    this.renderer = new WindowRenderer({
+      logger: ctx.logger,
+      getWindow: () => this.createSummary()
+    });
+    this.startTimers();
+    this.ctx.onClose(() => {
+      clearInterval(this.durationInterval);
+      this.renderer.stop();
+    });
+  }
+  onPathsCollected(paths) {
+    this.suites.total = (paths || []).length;
+  }
+  onWatcherRerun() {
+    this.runningTests.clear();
+    this.finishedTests.clear();
+    this.allFinishedTests.clear();
+    this.suites = emptyCounters();
+    this.tests = emptyCounters();
+    this.startTimers();
+    this.renderer.start();
+  }
+  onFinished() {
+    this.runningTests.clear();
+    this.finishedTests.clear();
+    this.allFinishedTests.clear();
+    this.renderer.finish();
+    clearInterval(this.durationInterval);
+  }
+  onTestFilePrepare(file) {
+    if (this.allFinishedTests.has(file.id) || this.runningTests.has(file.id)) {
+      return;
     }
+    const total = getTests(file).length;
+    this.tests.total += total;
+    if (this.finishedTests.size) {
+      const finished = this.finishedTests.keys().next().value;
+      this.removeTestFile(finished);
+    }
+    this.runningTests.set(file.id, {
+      total,
+      completed: 0,
+      filename: file.name,
+      projectName: file.projectName,
+      tests: /* @__PURE__ */ new Map()
+    });
+    this.maxParallelTests = Math.max(this.maxParallelTests, this.runningTests.size);
   }
-  return {
-    start() {
-      if (timer) {
-        return this;
+  onHookStart(options) {
+    const stats = this.getHookStats(options);
+    if (!stats) {
+      return;
+    }
+    const hook = {
+      name: options.name,
+      visible: false,
+      startTime: performance.now(),
+      onFinish: () => {
       }
-      timer = setInterval(update, 16);
-      return this;
-    },
-    update(_tasks2) {
-      tasks = _tasks2;
-      return this;
-    },
-    stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
+    };
+    stats.hook?.onFinish?.();
+    stats.hook = hook;
+    const timeout = setTimeout(() => {
+      hook.visible = true;
+    }, this.ctx.config.slowTestThreshold).unref();
+    hook.onFinish = () => clearTimeout(timeout);
+  }
+  onHookEnd(options) {
+    const stats = this.getHookStats(options);
+    if (stats?.hook?.name !== options.name) {
+      return;
+    }
+    stats.hook.onFinish();
+    stats.hook.visible = false;
+  }
+  onTestStart(test) {
+    if (!this.options.verbose) {
+      return;
+    }
+    const stats = this.getTestStats(test);
+    if (!stats || stats.tests.has(test.id)) {
+      return;
+    }
+    const slowTest = {
+      name: test.name,
+      visible: false,
+      startTime: performance.now(),
+      onFinish: () => {
       }
-      log.clear();
-      if (options.logger.ctx.config.hideSkippedTests) {
-        const filteredTasks = tasks.filter(
-          (t) => t.mode !== "skip" && t.mode !== "todo"
+    };
+    const timeout = setTimeout(() => {
+      slowTest.visible = true;
+    }, this.ctx.config.slowTestThreshold).unref();
+    slowTest.onFinish = () => {
+      slowTest.hook?.onFinish();
+      clearTimeout(timeout);
+    };
+    stats.tests.set(test.id, slowTest);
+  }
+  onTestFinished(test) {
+    const stats = this.getTestStats(test);
+    if (!stats) {
+      return;
+    }
+    stats.tests.get(test.id)?.onFinish();
+    stats.tests.delete(test.id);
+    stats.completed++;
+    const result = test.result;
+    if (result?.state === "pass") {
+      this.tests.passed++;
+    } else if (result?.state === "fail") {
+      this.tests.failed++;
+    } else if (!result?.state || result?.state === "skip" || result?.state === "todo") {
+      this.tests.skipped++;
+    }
+  }
+  onTestFileFinished(file) {
+    if (this.allFinishedTests.has(file.id)) {
+      return;
+    }
+    this.allFinishedTests.add(file.id);
+    this.suites.completed++;
+    if (file.result?.state === "pass") {
+      this.suites.passed++;
+    } else if (file.result?.state === "fail") {
+      this.suites.failed++;
+    } else if (file.result?.state === "skip") {
+      this.suites.skipped++;
+    } else if (file.result?.state === "todo") {
+      this.suites.todo++;
+    }
+    const left = this.suites.total - this.suites.completed;
+    if (left > this.maxParallelTests) {
+      this.finishedTests.set(file.id, setTimeout(() => {
+        this.removeTestFile(file.id);
+      }, FINISHED_TEST_CLEANUP_TIME_MS).unref());
+    } else {
+      this.removeTestFile(file.id);
+    }
+  }
+  getTestStats(test) {
+    const file = test.file;
+    let stats = this.runningTests.get(file.id);
+    if (!stats) {
+      this.onTestFilePrepare(test.file);
+      stats = this.runningTests.get(file.id);
+      if (!stats) {
+        return;
+      }
+    }
+    return stats;
+  }
+  getHookStats({ file, id, type }) {
+    if (!this.options.verbose) {
+      return;
+    }
+    const stats = this.runningTests.get(file.id);
+    if (!stats) {
+      return;
+    }
+    return type === "suite" ? stats : stats?.tests.get(id);
+  }
+  createSummary() {
+    const summary = [""];
+    for (const testFile of Array.from(this.runningTests.values()).sort(sortRunningTests)) {
+      summary.push(
+        c.bold(c.yellow(` ${F_POINTER} `)) + formatProjectName(testFile.projectName) + testFile.filename + c.dim(` ${testFile.completed}/${testFile.total}`)
+      );
+      const slowTasks = [
+        testFile.hook,
+        ...Array.from(testFile.tests.values())
+      ].filter((t) => t != null && t.visible);
+      for (const [index, task] of slowTasks.entries()) {
+        const elapsed = this.currentTime - task.startTime;
+        const icon = index === slowTasks.length - 1 ? F_TREE_NODE_END : F_TREE_NODE_MIDDLE;
+        summary.push(
+          c.bold(c.yellow(`   ${icon} `)) + task.name + c.bold(c.yellow(` ${formatTime(Math.max(0, elapsed))}`))
         );
-        options.logger.log(renderTree$1(filteredTasks, options));
-      } else {
-        options.logger.log(renderTree$1(tasks, options));
+        if (task.hook?.visible) {
+          summary.push(c.bold(c.yellow(`      ${F_TREE_NODE_END} `)) + task.hook.name);
+        }
       }
-      return this;
-    },
-    clear() {
-      log.clear();
     }
-  };
+    if (this.runningTests.size > 0) {
+      summary.push("");
+    }
+    summary.push(padSummaryTitle("Test Files") + getStateString(this.suites));
+    summary.push(padSummaryTitle("Tests") + getStateString(this.tests));
+    summary.push(padSummaryTitle("Start at") + this.startTime);
+    summary.push(padSummaryTitle("Duration") + formatTime(this.duration));
+    summary.push("");
+    return summary;
+  }
+  startTimers() {
+    const start = performance.now();
+    this.startTime = formatTimeString(/* @__PURE__ */ new Date());
+    this.durationInterval = setInterval(() => {
+      this.currentTime = performance.now();
+      this.duration = this.currentTime - start;
+    }, DURATION_UPDATE_INTERVAL_MS).unref();
+  }
+  removeTestFile(id) {
+    if (!id) {
+      return;
+    }
+    const testFile = this.runningTests.get(id);
+    testFile?.hook?.onFinish();
+    testFile?.tests?.forEach((test) => test.onFinish());
+    this.runningTests.delete(id);
+    clearTimeout(this.finishedTests.get(id));
+    this.finishedTests.delete(id);
+  }
+}
+function emptyCounters() {
+  return { completed: 0, passed: 0, failed: 0, skipped: 0, todo: 0, total: 0 };
+}
+function getStateString(entry) {
+  return [
+    entry.failed ? c.bold(c.red(`${entry.failed} failed`)) : null,
+    c.bold(c.green(`${entry.passed} passed`)),
+    entry.skipped ? c.yellow(`${entry.skipped} skipped`) : null,
+    entry.todo ? c.gray(`${entry.todo} todo`) : null
+  ].filter(Boolean).join(c.dim(" | ")) + c.gray(` (${entry.total})`);
+}
+function sortRunningTests(a, b) {
+  if ((a.projectName || "") > (b.projectName || "")) {
+    return 1;
+  }
+  if ((a.projectName || "") < (b.projectName || "")) {
+    return -1;
+  }
+  return a.filename.localeCompare(b.filename);
 }
 
 class DefaultReporter extends BaseReporter {
-  renderer;
-  rendererOptions = {};
-  renderSucceedDefault;
-  onPathsCollected(paths = []) {
-    if (this.isTTY) {
-      if (this.renderSucceedDefault === void 0) {
-        this.renderSucceedDefault = !!this.rendererOptions.renderSucceed;
-      }
-      if (this.renderSucceedDefault !== true) {
-        this.rendererOptions.renderSucceed = paths.length <= 1;
-      }
+  options;
+  summary;
+  constructor(options = {}) {
+    super(options);
+    this.options = {
+      summary: true,
+      ...options
+    };
+    if (!this.isTTY) {
+      this.options.summary = false;
+    }
+    if (this.options.summary) {
+      this.summary = new SummaryReporter();
     }
   }
-  async onTestRemoved(trigger) {
-    this.stopListRender();
-    this.ctx.logger.clearScreen(
-      c.yellow("Test removed...") + (trigger ? c.dim(` [ ${this.relative(trigger)} ]
-`) : ""),
-      true
-    );
-    const files = this.ctx.state.getFiles(this.watchFilters);
-    createListRenderer(files, this.rendererOptions).stop();
-    this.ctx.logger.log();
-    super.reportSummary(files, this.ctx.state.getUnhandledErrors());
-    super.onWatcherStart();
+  onInit(ctx) {
+    super.onInit(ctx);
+    this.summary?.onInit(ctx, { verbose: this.verbose });
   }
-  onCollected() {
+  onPathsCollected(paths = []) {
     if (this.isTTY) {
-      this.rendererOptions.logger = this.ctx.logger;
-      this.rendererOptions.showHeap = this.ctx.config.logHeapUsage;
-      this.rendererOptions.slowTestThreshold = this.ctx.config.slowTestThreshold;
-      this.rendererOptions.mode = this.ctx.config.mode;
-      const files = this.ctx.state.getFiles(this.watchFilters);
-      if (!this.renderer) {
-        this.renderer = createListRenderer(files, this.rendererOptions).start();
-      } else {
-        this.renderer.update(files);
+      if (this.renderSucceed === void 0) {
+        this.renderSucceed = !!this.renderSucceed;
+      }
+      if (this.renderSucceed !== true) {
+        this.renderSucceed = paths.length <= 1;
       }
     }
+    this.summary?.onPathsCollected(paths);
   }
-  onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    this.renderer?.update([
-      ...this.failedUnwatchedFiles,
-      ...files
-    ]);
-    this.stopListRender();
-    this.ctx.logger.log();
-    super.onFinished(files, errors);
-  }
-  async onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    this.stopListRender();
-    await super.onWatcherStart(files, errors);
-  }
-  stopListRender() {
-    this.renderer?.stop();
-    this.renderer = void 0;
+  onTaskUpdate(packs) {
+    this.summary?.onTaskUpdate(packs);
+    super.onTaskUpdate(packs);
   }
-  async onWatcherRerun(files, trigger) {
-    this.stopListRender();
-    await super.onWatcherRerun(files, trigger);
+  onWatcherRerun(files, trigger) {
+    this.summary?.onWatcherRerun();
+    super.onWatcherRerun(files, trigger);
   }
-  onUserConsoleLog(log) {
-    if (!this.shouldLog(log)) {
-      return;
-    }
-    this.renderer?.clear();
-    super.onUserConsoleLog(log);
+  onFinished(files, errors) {
+    this.summary?.onFinished();
+    super.onFinished(files, errors);
   }
 }
 
@@ -4172,6 +3951,8 @@ function createDotRenderer(_tasks, options) {
 
 class DotReporter extends BaseReporter {
   renderer;
+  onTaskUpdate() {
+  }
   onCollected() {
     if (this.isTTY) {
       const files = this.ctx.state.getFiles(this.watchFilters);
@@ -4217,7 +3998,7 @@ class GithubActionsReporter {
     const projectErrors = new Array();
     for (const error of errors) {
       projectErrors.push({
-        project: this.ctx.getCoreWorkspaceProject(),
+        project: this.ctx.getRootTestProject(),
         title: "Unhandled error",
         error
       });
@@ -4311,7 +4092,7 @@ class JsonReporter {
     this.ctx = ctx;
     this.start = Date.now();
   }
-  async logTasks(files) {
+  async logTasks(files, coverageMap) {
     const suites = getSuites(files);
     const numTotalTestSuites = suites.length;
     const tests = getTests(files);
@@ -4394,12 +4175,13 @@ class JsonReporter {
       snapshot: this.ctx.snapshot.summary,
       startTime: this.start,
       success,
-      testResults
+      testResults,
+      coverageMap
     };
     await this.writeReport(JSON.stringify(result));
   }
-  async onFinished(files = this.ctx.state.getFiles()) {
-    await this.logTasks(files);
+  async onFinished(files = this.ctx.state.getFiles(), _errors = [], coverageMap) {
+    await this.logTasks(files, coverageMap);
   }
   /**
    * Writes the report to an output file if specified in the config,
@@ -4554,10 +4336,22 @@ class JUnitReporter {
   }
   async writeTasks(tasks, filename) {
     for (const task of tasks) {
+      let classname = filename;
+      const templateVars = {
+        filename: task.file.name,
+        filepath: task.file.filepath
+      };
+      if (typeof this.options.classnameTemplate === "function") {
+        classname = this.options.classnameTemplate(templateVars);
+      } else if (typeof this.options.classnameTemplate === "string") {
+        classname = this.options.classnameTemplate.replace(/\{filename\}/g, templateVars.filename).replace(/\{filepath\}/g, templateVars.filepath);
+      } else if (typeof this.options.classname === "string") {
+        classname = this.options.classname;
+      }
       await this.writeElement(
         "testcase",
         {
-          classname: this.options.classname ?? filename,
+          classname,
           file: this.options.addFileAttribute ? filename : void 0,
           name: task.name,
           time: getDuration(task)
@@ -4803,13 +4597,10 @@ class TapFlatReporter extends TapReporter {
 
 class VerboseReporter extends DefaultReporter {
   verbose = true;
-  constructor() {
-    super();
-    this.rendererOptions.renderSucceed = true;
-  }
+  renderSucceed = true;
   onTaskUpdate(packs) {
     if (this.isTTY) {
-      return;
+      return super.onTaskUpdate(packs);
     }
     for (const pack of packs) {
       const task = this.ctx.state.idMap.get(pack[0]);
@@ -4829,6 +4620,9 @@ class VerboseReporter extends DefaultReporter {
             ` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`
           );
         }
+        if (task.result?.note) {
+          title += c.dim(c.gray(` [${task.result.note}]`));
+        }
         this.ctx.logger.log(title);
         if (task.result.state === "fail") {
           task.result.errors?.forEach((error) => {
@@ -5230,4 +5024,4 @@ const ReportersMap = {
   "github-actions": GithubActionsReporter
 };
 
-export { BasicReporter as B, DefaultReporter as D, GithubActionsReporter as G, HangingProcessReporter as H, JsonReporter as J, Logger as L, ReportersMap as R, TapFlatReporter as T, VerboseReporter as V, DotReporter as a, JUnitReporter as b, TapReporter as c, TestFile as d, TestCase as e, TestModule as f, TestSuite as g, BenchmarkReportsMap as h, TestProject as i, generateCodeFrame as j, BlobReporter as k, parse as p, readBlobs as r, stringify as s };
+export { BasicReporter as B, DefaultReporter as D, GithubActionsReporter as G, HangingProcessReporter as H, JsonReporter as J, Logger as L, ReportersMap as R, TapFlatReporter as T, VerboseReporter as V, DotReporter as a, JUnitReporter as b, TapReporter as c, TestFile as d, TestCase as e, TestModule as f, TestSuite as g, BenchmarkReportsMap as h, generateCodeFrame as i, BlobReporter as j, parse as p, readBlobs as r, stringify as s };