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

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

@@ -3,12 +3,12 @@ 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.CMUTX-p8.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.gisBJ77r.js';
 import { isCI } from 'std-env';
 import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
 import { Writable } from 'node:stream';
@@ -20,68 +20,6 @@ import require$$0$1 from 'events';
 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 +42,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;
   }
@@ -415,10 +353,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}"`
@@ -534,7 +472,7 @@ const stringify = (value, replacer, space) => {
   }
 };
 
-const ESC$1 = '\u001B[';
+const ESC$2 = '\u001B[';
 const OSC = '\u001B]';
 const BEL = '\u0007';
 const SEP = ';';
@@ -548,10 +486,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) => {
@@ -562,33 +500,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 = '';
@@ -604,24 +542,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;
 
@@ -3026,10 +2964,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) {
@@ -3088,7 +3026,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,
@@ -3137,8 +3075,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`));
       }
@@ -3214,8 +3151,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(
@@ -3233,15 +3169,15 @@ Vitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} du
 This might cause false positive tests. Resolve unhandled errors to make sure your tests are not affected.`
       )
     );
-    this.log(c.red(divider(c.bold(c.inverse(" Unhandled Errors ")))));
-    this.log(errorMessage);
+    this.error(c.red(divider(c.bold(c.inverse(" Unhandled Errors ")))));
+    this.error(errorMessage);
     errors.forEach((err) => {
       this.printError(err, {
         fullStack: true,
         type: err.type || "Unhandled Error"
       });
     });
-    this.log(c.red(divider()));
+    this.error(c.red(divider()));
   }
   printSourceTypeErrors(errors) {
     const errorMessage = c.red(
@@ -3295,8 +3231,8 @@ class BlobReporter {
     const modules = this.ctx.projects.map(
       (project) => {
         return [
-          project.getName(),
-          [...project.server.moduleGraph.idToModuleMap.entries()].map((mod) => {
+          project.name,
+          [...project.vite.moduleGraph.idToModuleMap.entries()].map((mod) => {
             if (!mod[1].file) {
               return null;
             }
@@ -3363,7 +3299,7 @@ ${blobs.map((b) => `- "${b.file}" uses v${b.version}`).join("\n")}`
     );
   }
   const projects = Object.fromEntries(
-    projectsArray.map((p) => [p.getName(), p])
+    projectsArray.map((p) => [p.name, p])
   );
   blobs.forEach((blob) => {
     blob.moduleKeys.forEach(([projectName, moduleIds]) => {
@@ -3372,10 +3308,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);
       });
     });
   });
@@ -3402,7 +3338,6 @@ function hasFailedSnapshot(suite) {
 }
 
 const BADGE_PADDING = "       ";
-const LAST_RUN_LOG_TIMEOUT = 1500;
 class BaseReporter {
   start = 0;
   end = 0;
@@ -3410,19 +3345,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);
@@ -3434,13 +3367,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) {
@@ -3474,18 +3404,29 @@ 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;
+      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 (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.dim(getStateSymbol(test))} ${getTestName(test, c.dim(" > "))}${suffix2}`);
       }
     }
   }
@@ -3497,7 +3438,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..."));
@@ -3513,34 +3453,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)
@@ -3550,9 +3464,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} `);
     }
@@ -3568,13 +3480,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)) {
@@ -3595,7 +3505,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) {
@@ -3639,6 +3549,7 @@ class BaseReporter {
     }
   }
   reportTestSummary(files, errors) {
+    this.log();
     const affectedFiles = [
       ...this.failedUnwatchedFiles,
       ...files
@@ -3650,32 +3561,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);
@@ -3683,15 +3594,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();
   }
@@ -3705,12 +3616,14 @@ class BaseReporter {
     const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
 `);
     if (failedSuites.length) {
-      this.error(`${errorBanner(`Failed Suites ${failedSuites.length}`)}
+      this.error(`
+${errorBanner(`Failed Suites ${failedSuites.length}`)}
 `);
       this.printTaskErrors(failedSuites, errorDivider);
     }
     if (failedTests.length) {
-      this.error(`${errorBanner(`Failed Tests ${failedTests.length}`)}
+      this.error(`
+${errorBanner(`Failed Tests ${failedTests.length}`)}
 `);
       this.printTaskErrors(failedTests, errorDivider);
     }
@@ -3769,7 +3682,7 @@ class BaseReporter {
           name += c.dim(` [ ${this.relative(filepath)} ]`);
         }
         this.ctx.logger.error(
-          `${c.red(c.bold(c.inverse(" FAIL ")))}${formatProjectName(projectName)} ${name}`
+          `${c.red(c.bold(c.inverse(" FAIL ")))} ${formatProjectName(projectName)}${name}`
         );
       }
       const screenshotPaths = tasks2.map((t) => t.meta?.failScreenshotPath).filter((screenshot) => screenshot != null);
@@ -3786,15 +3699,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);
@@ -3806,423 +3710,669 @@ 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"),
+      this.addProcessExitListeners()
+    );
+    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);
+  }
+  getColumns() {
+    return "columns" in this.options.logger.outputStream ? this.options.logger.outputStream.columns : 80;
+  }
+  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") {
-      const note = task.result?.note || "skipped";
-      suffix += ` ${c.dim(c.gray(`[${note}]`))}`;
+    const windowContent = this.options.getWindow();
+    const rowCount = getRenderedRowCount(windowContent, this.getColumns());
+    let padding = this.windowHeight - rowCount;
+    if (padding > 0 && message) {
+      padding -= getRenderedRowCount([message], this.getColumns());
     }
-    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)))}`);
+      callback?.();
+    };
+    return function restore() {
+      stream.write = original;
+    };
+  }
+  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);
       }
-    }
-    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)
-          );
+      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, columns) {
+  let count = 0;
+  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") {
+        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;
+  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();
+    }
+  }
+  onInit(ctx) {
+    super.onInit(ctx);
+    this.summary?.onInit(ctx, { verbose: this.verbose });
+  }
   onPathsCollected(paths = []) {
     if (this.isTTY) {
-      if (this.renderSucceedDefault === void 0) {
-        this.renderSucceedDefault = !!this.rendererOptions.renderSucceed;
+      if (this.renderSucceed === void 0) {
+        this.renderSucceed = !!this.renderSucceed;
       }
-      if (this.renderSucceedDefault !== true) {
-        this.rendererOptions.renderSucceed = paths.length <= 1;
+      if (this.renderSucceed !== true) {
+        this.renderSucceed = paths.length <= 1;
       }
     }
+    this.summary?.onPathsCollected(paths);
   }
-  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();
+  onTaskUpdate(packs) {
+    this.summary?.onTaskUpdate(packs);
+    super.onTaskUpdate(packs);
+  }
+  onWatcherRerun(files, trigger) {
+    this.summary?.onWatcherRerun();
+    super.onWatcherRerun(files, trigger);
+  }
+  onFinished(files, errors) {
+    this.summary?.onFinished();
+    super.onFinished(files, errors);
   }
-  onCollected() {
+}
+
+class DotReporter extends BaseReporter {
+  summary;
+  onInit(ctx) {
+    super.onInit(ctx);
     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);
-      }
+      this.summary = new DotSummary();
+      this.summary.onInit(ctx);
     }
   }
-  onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    this.renderer?.update([
-      ...this.failedUnwatchedFiles,
-      ...files
-    ]);
-    this.stopListRender();
-    this.ctx.logger.log();
+  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);
   }
-  async onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-    this.stopListRender();
-    await super.onWatcherStart(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());
   }
-  stopListRender() {
-    this.renderer?.stop();
-    this.renderer = void 0;
+  onWatcherRerun() {
+    this.tests.clear();
+    this.renderer.start();
   }
-  async onWatcherRerun(files, trigger) {
-    this.stopListRender();
-    await super.onWatcherRerun(files, trigger);
+  onFinished() {
+    const finalLog = formatTests(Array.from(this.tests.values()));
+    this.ctx.logger.log(finalLog);
+    this.tests.clear();
+    this.renderer.finish();
   }
-  onUserConsoleLog(log) {
-    if (!this.shouldLog(log)) {
+  onTestFilePrepare(file) {
+    for (const test of getTests(file)) {
+      this.onTestStart(test);
+    }
+  }
+  onTestStart(test) {
+    if (this.finishedTests.has(test.id)) {
       return;
     }
-    this.renderer?.clear();
-    super.onUserConsoleLog(log);
+    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 check = { char: "\xB7", color: c.green };
-const cross = { char: "x", color: c.red };
+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;
-  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;
@@ -4233,7 +4383,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
       });
@@ -4571,10 +4721,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)
@@ -4666,6 +4828,7 @@ class JUnitReporter {
       (stats2, file) => {
         stats2.tests += file.tasks.length;
         stats2.failures += file.stats.failures;
+        stats2.time += file.result?.duration || 0;
         return stats2;
       },
       {
@@ -4674,10 +4837,10 @@ class JUnitReporter {
         failures: 0,
         errors: 0,
         // we cannot detect those
-        time: executionTime((/* @__PURE__ */ new Date()).getTime() - this._timeStart.getTime())
+        time: 0
       }
     );
-    await this.writeElement("testsuites", stats, async () => {
+    await this.writeElement("testsuites", { ...stats, time: executionTime(stats.time) }, async () => {
       for (const file of transformed) {
         const filename = relative(this.ctx.config.root, file.filepath);
         await this.writeElement(
@@ -4820,13 +4983,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]);
@@ -5250,4 +5410,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 };