vitest 2.1.4 → 2.1.5

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

@@ -3,7 +3,7 @@ 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, g as getStateSymbol, f as formatProjectName, t as taskFail, a as F_RIGHT, b as F_CHECK, r as renderSnapshotSummary, c as getStateString, e as formatTimeString, h as countTestErrors, i as getCols, j as getHookStateSymbol } from './utils.BB4zjzR8.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, e as getStateString, h as countTestErrors, i as getCols, j as getHookStateSymbol } from './utils.DNoFbBUZ.js';
 import { stripVTControlCharacters } from 'node:util';
 import { highlight, isPrimitive, inspect, positionToOffset, lineSplitRE, toArray, notNullish } from '@vitest/utils';
 import { performance } from 'node:perf_hooks';
@@ -31,6 +31,10 @@ class TestProject {
    * @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.
    */
@@ -46,6 +50,7 @@ class TestProject {
   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();
@@ -3005,6 +3010,7 @@ function lineNo(no = "") {
   return c.gray(`${String(no).padStart(3, " ")}| `);
 }
 
+const PAD = "      ";
 const ESC = "\x1B[";
 const ERASE_DOWN = `${ESC}J`;
 const ERASE_SCROLLBACK = `${ESC}3J`;
@@ -3018,6 +3024,7 @@ class Logger {
     this.console = new Console({ stdout: outputStream, stderr: errorStream });
     this.logUpdate = createLogUpdate(this.outputStream);
     this._highlights.clear();
+    this.registerUnhandledRejection();
   }
   logUpdate;
   _clearScreenPending;
@@ -3035,12 +3042,16 @@ class Logger {
     this._clearScreen();
     this.console.warn(...args);
   }
-  clearFullScreen(message) {
+  clearFullScreen(message = "") {
     if (!this.ctx.config.clearScreen) {
       this.console.log(message);
       return;
     }
-    this.console.log(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}${message}`);
+    if (message) {
+      this.console.log(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}${message}`);
+    } else {
+      this.outputStream.write(`${CLEAR_SCREEN}${ERASE_SCROLLBACK}`);
+    }
   }
   clearScreen(message, force = false) {
     if (!this.ctx.config.clearScreen) {
@@ -3152,68 +3163,53 @@ No ${config.mode} files found, exiting with code 1`)
   }
   printBanner() {
     this.log();
-    const versionTest = this.ctx.config.watch ? c.blue(`v${this.ctx.version}`) : c.cyan(`v${this.ctx.version}`);
-    const mode = this.ctx.config.watch ? c.blue(" DEV ") : c.cyan(" RUN ");
-    this.log(
-      `${c.inverse(c.bold(mode))} ${versionTest} ${c.gray(
-        this.ctx.config.root
-      )}`
-    );
+    const color = this.ctx.config.watch ? "blue" : "cyan";
+    const mode = this.ctx.config.watch ? "DEV" : "RUN";
+    this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root));
     if (this.ctx.config.sequence.sequencer === RandomSequencer) {
-      this.log(
-        c.gray(
-          `      Running tests with seed "${this.ctx.config.sequence.seed}"`
-        )
-      );
+      this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
     }
-    this.ctx.projects.forEach((project) => {
-      if (!project.browser) {
-        return;
-      }
-      const name = project.getName();
-      const output = project.isCore() ? "" : ` [${name}]`;
-      const resolvedUrls = project.browser.vite.resolvedUrls;
-      const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
-      const provider = project.browser.provider.name;
-      const providerString = provider === "preview" ? "" : ` by ${provider}`;
-      this.log(
-        c.dim(
-          c.green(
-            `     ${output} Browser runner started${providerString} at ${new URL("/", origin)}`
-          )
-        )
-      );
-    });
     if (this.ctx.config.ui) {
-      this.log(
-        c.dim(
-          c.green(
-            `      UI started at http://${this.ctx.config.api?.host || "localhost"}:${c.bold(`${this.ctx.server.config.server.port}`)}${this.ctx.config.uiBase}`
-          )
-        )
-      );
+      const host = this.ctx.config.api?.host || "localhost";
+      const port = this.ctx.server.config.server.port;
+      const base = this.ctx.config.uiBase;
+      this.log(PAD + c.dim(c.green(`UI started at http://${host}:${c.bold(port)}${base}`)));
     } else if (this.ctx.config.api?.port) {
       const resolvedUrls = this.ctx.server.resolvedUrls;
       const fallbackUrl = `http://${this.ctx.config.api.host || "localhost"}:${this.ctx.config.api.port}`;
       const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0] ?? fallbackUrl;
-      this.log(c.dim(c.green(`      API started at ${new URL("/", origin)}`)));
+      this.log(PAD + c.dim(c.green(`API started at ${new URL("/", origin)}`)));
     }
     if (this.ctx.coverageProvider) {
-      this.log(
-        c.dim("      Coverage enabled with ") + c.yellow(this.ctx.coverageProvider.name)
-      );
+      this.log(PAD + c.dim("Coverage enabled with ") + c.yellow(this.ctx.coverageProvider.name));
     }
     if (this.ctx.config.standalone) {
-      this.log(
-        c.yellow(
-          `
-Vitest is running in standalone mode. Edit a test file to rerun tests.`
-        )
-      );
+      this.log(c.yellow(`
+Vitest is running in standalone mode. Edit a test file to rerun tests.`));
     } else {
       this.log();
     }
   }
+  printBrowserBanner(project) {
+    if (!project.browser) {
+      return;
+    }
+    const resolvedUrls = project.browser.vite.resolvedUrls;
+    const origin = resolvedUrls?.local[0] ?? resolvedUrls?.network[0];
+    if (!origin) {
+      return;
+    }
+    const name = project.getName();
+    const output = project.isCore() ? "" : formatProjectName(name);
+    const provider = project.browser.provider.name;
+    const providerString = provider === "preview" ? "" : ` by ${c.reset(c.bold(provider))}`;
+    this.log(
+      c.dim(
+        `${output}Browser runner started${providerString} ${c.dim("at")} ${c.blue(new URL("/", origin))}
+`
+      )
+    );
+  }
   printUnhandledErrors(errors) {
     const errorMessage = c.red(
       c.bold(
@@ -3246,6 +3242,21 @@ Vitest found ${errors.length} error${errors.length > 1 ? "s" : ""} not related t
     });
     this.log(c.red(divider()));
   }
+  registerUnhandledRejection() {
+    const onUnhandledRejection = (err) => {
+      process.exitCode = 1;
+      this.printError(err, {
+        fullStack: true,
+        type: "Unhandled Rejection"
+      });
+      this.error("\n\n");
+      process.exit();
+    };
+    process.on("unhandledRejection", onUnhandledRejection);
+    this.ctx.onClose(() => {
+      process.off("unhandledRejection", onUnhandledRejection);
+    });
+  }
 }
 
 class BlobReporter {
@@ -3376,21 +3387,6 @@ function hasFailedSnapshot(suite) {
 }
 
 const BADGE_PADDING = "       ";
-const HELP_HINT = `${c.dim("press ")}${c.bold("h")}${c.dim(" to show help")}`;
-const HELP_UPDATE_SNAP = c.dim("press ") + c.bold(c.yellow("u")) + c.dim(" to update snapshot");
-const HELP_QUITE = `${c.dim("press ")}${c.bold("q")}${c.dim(" to quit")}`;
-const WAIT_FOR_CHANGE_PASS = `
-${c.bold(
-  c.inverse(c.green(" PASS "))
-)}${c.green(" Waiting for file changes...")}`;
-const WAIT_FOR_CHANGE_FAIL = `
-${c.bold(c.inverse(c.red(" FAIL ")))}${c.red(
-  " Tests failed. Watching for file changes..."
-)}`;
-const WAIT_FOR_CHANGE_CANCELLED = `
-${c.bold(
-  c.inverse(c.red(" CANCELLED "))
-)}${c.red(" Test run cancelled. Watching for file changes...")}`;
 const LAST_RUN_LOG_TIMEOUT = 1500;
 class BaseReporter {
   start = 0;
@@ -3401,37 +3397,30 @@ class BaseReporter {
   ctx = void 0;
   verbose = false;
   _filesInWatchMode = /* @__PURE__ */ new Map();
+  _timeStart = formatTimeString(/* @__PURE__ */ new Date());
   _lastRunTimeout = 0;
   _lastRunTimer;
   _lastRunCount = 0;
-  _timeStart = /* @__PURE__ */ new Date();
-  _offUnhandledRejection;
   constructor(options = {}) {
     this.isTTY = options.isTTY ?? ((isNode || isDeno) && process.stdout?.isTTY && !isCI);
-    this.registerUnhandledRejection();
-  }
-  get mode() {
-    return this.ctx.config.mode;
   }
   onInit(ctx) {
     this.ctx = ctx;
-    ctx.onClose(() => {
-      this._offUnhandledRejection?.();
-    });
-    ctx.logger.printBanner();
+    this.ctx.logger.printBanner();
     this.start = performance.now();
   }
+  log(...messages) {
+    this.ctx.logger.log(...messages);
+  }
+  error(...messages) {
+    this.ctx.logger.error(...messages);
+  }
   relative(path) {
     return relative(this.ctx.config.root, path);
   }
   onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
     this.end = performance.now();
     this.reportSummary(files, errors);
-    if (errors.length) {
-      if (!this.ctx.config.dangerouslyIgnoreUnhandledErrors) {
-        process.exitCode = 1;
-      }
-    }
   }
   onTaskUpdate(packs) {
     if (this.isTTY) {
@@ -3448,48 +3437,39 @@ class BaseReporter {
     if (!("filepath" in task) || !task.result?.state || task.result?.state === "run") {
       return;
     }
-    const logger = this.ctx.logger;
     const tests = getTests(task);
     const failed = tests.filter((t) => t.result?.state === "fail");
-    const skipped = tests.filter(
-      (t) => t.mode === "skip" || t.mode === "todo"
-    );
+    const skipped = tests.filter((t) => t.mode === "skip" || t.mode === "todo");
     let state = c.dim(`${tests.length} test${tests.length > 1 ? "s" : ""}`);
     if (failed.length) {
-      state += ` ${c.dim("|")} ${c.red(`${failed.length} failed`)}`;
+      state += c.dim(" | ") + c.red(`${failed.length} failed`);
     }
     if (skipped.length) {
-      state += ` ${c.dim("|")} ${c.yellow(`${skipped.length} skipped`)}`;
+      state += c.dim(" | ") + c.yellow(`${skipped.length} skipped`);
     }
-    let suffix = c.dim(" (") + state + c.dim(")");
-    suffix += this.getDurationPrefix(task);
+    let suffix = c.dim("(") + state + c.dim(")") + this.getDurationPrefix(task);
     if (this.ctx.config.logHeapUsage && task.result.heap != null) {
-      suffix += c.magenta(
-        ` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`
-      );
+      suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
     }
-    let title = ` ${getStateSymbol(task)} `;
+    let title = getStateSymbol(task);
     if (task.meta.typecheck) {
-      title += `${c.bgBlue(c.bold(" TS "))} `;
+      title += ` ${c.bgBlue(c.bold(" TS "))}`;
     }
     if (task.projectName) {
-      title += formatProjectName(task.projectName);
+      title += ` ${formatProjectName(task.projectName, "")}`;
     }
-    title += `${task.name} ${suffix}`;
-    logger.log(title);
+    this.log(` ${title} ${task.name} ${suffix}`);
     for (const test of tests) {
       const duration = test.result?.duration;
       if (test.result?.state === "fail") {
         const suffix2 = this.getDurationPrefix(test);
-        logger.log(c.red(`   ${taskFail} ${getTestName(test, c.dim(" > "))}${suffix2}`));
+        this.log(c.red(`   ${taskFail} ${getTestName(test, c.dim(" > "))}${suffix2}`));
         test.result?.errors?.forEach((e) => {
-          logger.log(c.red(`     ${F_RIGHT} ${e?.message}`));
+          this.log(c.red(`     ${F_RIGHT} ${e?.message}`));
         });
       } else if (duration && duration > this.ctx.config.slowTestThreshold) {
-        logger.log(
-          `   ${c.yellow(c.dim(F_CHECK))} ${getTestName(test, c.dim(" > "))}${c.yellow(
-            ` ${Math.round(duration)}${c.dim("ms")}`
-          )}`
+        this.log(
+          `   ${c.yellow(c.dim(F_CHECK))} ${getTestName(test, c.dim(" > "))} ${c.yellow(Math.round(duration) + c.dim("ms"))}`
         );
       }
     }
@@ -3504,23 +3484,20 @@ class BaseReporter {
   onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
     this.resetLastRunLog();
     const failed = errors.length > 0 || hasFailed(files);
-    const failedSnap = hasFailedSnapshot(files);
-    const cancelled = this.ctx.isCancelling;
     if (failed) {
-      this.ctx.logger.log(WAIT_FOR_CHANGE_FAIL);
-    } else if (cancelled) {
-      this.ctx.logger.log(WAIT_FOR_CHANGE_CANCELLED);
+      this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
+    } else if (this.ctx.isCancelling) {
+      this.log(withLabel("red", "CANCELLED", "Test run cancelled. Watching for file changes..."));
     } else {
-      this.ctx.logger.log(WAIT_FOR_CHANGE_PASS);
+      this.log(withLabel("green", "PASS", "Waiting for file changes..."));
     }
-    const hints = [];
-    hints.push(HELP_HINT);
-    if (failedSnap) {
-      hints.unshift(HELP_UPDATE_SNAP);
+    const hints = [c.dim("press ") + c.bold("h") + c.dim(" to show help")];
+    if (hasFailedSnapshot(files)) {
+      hints.unshift(c.dim("press ") + c.bold(c.yellow("u")) + c.dim(" to update snapshot"));
     } else {
-      hints.push(HELP_QUITE);
+      hints.push(c.dim("press ") + c.bold("q") + c.dim(" to quit"));
     }
-    this.ctx.logger.log(BADGE_PADDING + hints.join(c.dim(", ")));
+    this.log(BADGE_PADDING + hints.join(c.dim(", ")));
     if (this._lastRunCount) {
       const LAST_RUN_TEXT = `rerun x${this._lastRunCount}`;
       const LAST_RUN_TEXTS = [
@@ -3550,90 +3527,79 @@ class BaseReporter {
   onWatcherRerun(files, trigger) {
     this.resetLastRunLog();
     this.watchFilters = files;
-    this.failedUnwatchedFiles = this.ctx.state.getFiles().filter((file) => {
-      return !files.includes(file.filepath) && hasFailed(file);
-    });
+    this.failedUnwatchedFiles = this.ctx.state.getFiles().filter(
+      (file) => !files.includes(file.filepath) && hasFailed(file)
+    );
     files.forEach((filepath) => {
       let reruns = this._filesInWatchMode.get(filepath) ?? 0;
       this._filesInWatchMode.set(filepath, ++reruns);
     });
-    const BADGE = c.inverse(c.bold(c.blue(" RERUN ")));
-    const TRIGGER = trigger ? c.dim(` ${this.relative(trigger)}`) : "";
-    const FILENAME_PATTERN = this.ctx.filenamePattern ? `${BADGE_PADDING} ${c.dim("Filename pattern: ")}${c.blue(
-      this.ctx.filenamePattern
-    )}
-` : "";
-    const TESTNAME_PATTERN = this.ctx.configOverride.testNamePattern ? `${BADGE_PADDING} ${c.dim("Test name pattern: ")}${c.blue(
-      String(this.ctx.configOverride.testNamePattern)
-    )}
-` : "";
-    const PROJECT_FILTER = this.ctx.configOverride.project ? `${BADGE_PADDING} ${c.dim("Project name: ")}${c.blue(
-      toArray(this.ctx.configOverride.project).join(", ")
-    )}
-` : "";
+    let banner = trigger ? c.dim(`${this.relative(trigger)} `) : "";
     if (files.length > 1 || !files.length) {
-      this.ctx.logger.clearFullScreen(
-        `
-${BADGE}${TRIGGER}
-${PROJECT_FILTER}${FILENAME_PATTERN}${TESTNAME_PATTERN}`
-      );
       this._lastRunCount = 0;
     } else if (files.length === 1) {
       const rerun = this._filesInWatchMode.get(files[0]) ?? 1;
-      this._lastRunCount = rerun;
-      this.ctx.logger.clearFullScreen(
-        `
-${BADGE}${TRIGGER} ${c.blue(
-          `x${rerun}`
-        )}
-${PROJECT_FILTER}${FILENAME_PATTERN}${TESTNAME_PATTERN}`
-      );
+      banner += c.blue(`x${rerun} `);
+    }
+    this.ctx.logger.clearFullScreen();
+    this.log(withLabel("blue", "RERUN", banner));
+    if (this.ctx.configOverride.project) {
+      this.log(BADGE_PADDING + c.dim(" Project name: ") + c.blue(toArray(this.ctx.configOverride.project).join(", ")));
+    }
+    if (this.ctx.filenamePattern) {
+      this.log(BADGE_PADDING + c.dim(" Filename pattern: ") + c.blue(this.ctx.filenamePattern));
     }
+    if (this.ctx.configOverride.testNamePattern) {
+      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);
       }
     }
-    this._timeStart = /* @__PURE__ */ new Date();
+    this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
     this.start = performance.now();
   }
   onUserConsoleLog(log) {
     if (!this.shouldLog(log)) {
       return;
     }
-    const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0;
-    const header = c.gray(
-      log.type + c.dim(
-        ` | ${task ? getFullName(task, c.dim(" > ")) : log.taskId !== "__vitest__unknown_test__" ? log.taskId : "unknown test"}`
-      )
-    );
     const output = log.type === "stdout" ? this.ctx.logger.outputStream : this.ctx.logger.errorStream;
     const write = (msg) => output.write(msg);
-    write(`${header}
-${log.content}`);
+    let headerText = "unknown test";
+    const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0;
+    if (task) {
+      headerText = getFullName(task, c.dim(" > "));
+    } else if (log.taskId && log.taskId !== "__vitest__unknown_test__") {
+      headerText = log.taskId;
+    }
+    write(c.gray(log.type + c.dim(` | ${headerText}
+`)) + log.content);
     if (log.origin) {
       if (log.browser) {
         write("\n");
       }
       const project = log.taskId ? this.ctx.getProjectByTaskId(log.taskId) : this.ctx.getCoreWorkspaceProject();
       const stack = log.browser ? project.browser?.parseStacktrace(log.origin) || [] : parseStacktrace(log.origin);
-      const highlight = task ? stack.find((i) => i.file === task.file.filepath) : null;
+      const highlight = task && stack.find((i) => i.file === task.file.filepath);
       for (const frame of stack) {
         const color = frame === highlight ? c.cyan : c.gray;
         const path = relative(project.config.root, frame.file);
-        write(
-          color(
-            ` ${c.dim(F_POINTER)} ${[
-              frame.method,
-              `${path}:${c.dim(`${frame.line}:${frame.column}`)}`
-            ].filter(Boolean).join(" ")}
-`
-          )
-        );
+        const positions = [
+          frame.method,
+          `${path}:${c.dim(`${frame.line}:${frame.column}`)}`
+        ].filter(Boolean).join(" ");
+        write(color(` ${c.dim(F_POINTER)} ${positions}
+`));
       }
     }
     write("\n");
   }
+  onTestRemoved(trigger) {
+    this.log(c.yellow("Test removed...") + (trigger ? c.dim(` [ ${this.relative(trigger)} ]
+`) : ""));
+  }
   shouldLog(log) {
     if (this.ctx.config.silent) {
       return false;
@@ -3645,17 +3611,13 @@ ${log.content}`);
     return true;
   }
   onServerRestart(reason) {
-    this.ctx.logger.log(
-      c.bold(
-        c.magenta(
-          reason === "config" ? "\nRestarting due to config changes..." : "\nRestarting Vitest..."
-        )
-      )
-    );
+    this.log(c.bold(c.magenta(
+      reason === "config" ? "\nRestarting due to config changes..." : "\nRestarting Vitest..."
+    )));
   }
   reportSummary(files, errors) {
     this.printErrorsSummary(files, errors);
-    if (this.mode === "benchmark") {
+    if (this.ctx.config.mode === "benchmark") {
       this.reportBenchmarkSummary(files);
     } else {
       this.reportTestSummary(files, errors);
@@ -3667,167 +3629,117 @@ ${log.content}`);
       ...files
     ];
     const tests = getTests(affectedFiles);
-    const logger = this.ctx.logger;
-    const executionTime = this.end - this.start;
-    const collectTime = files.reduce(
-      (acc, test) => acc + Math.max(0, test.collectDuration || 0),
-      0
-    );
-    const setupTime = files.reduce(
-      (acc, test) => acc + Math.max(0, test.setupDuration || 0),
-      0
-    );
-    const testsTime = files.reduce(
-      (acc, test) => acc + Math.max(0, test.result?.duration || 0),
-      0
-    );
-    const transformTime = this.ctx.projects.flatMap((w) => w.vitenode.getTotalDuration()).reduce((a, b) => a + b, 0);
-    const environmentTime = files.reduce(
-      (acc, file) => acc + Math.max(0, file.environmentLoad || 0),
-      0
-    );
-    const prepareTime = files.reduce(
-      (acc, file) => acc + Math.max(0, file.prepareDuration || 0),
-      0
-    );
-    const threadTime = collectTime + testsTime + setupTime;
     const snapshotOutput = renderSnapshotSummary(
       this.ctx.config.root,
       this.ctx.snapshot.summary
     );
-    if (snapshotOutput.length) {
-      logger.log(
-        snapshotOutput.map(
-          (t, i) => i === 0 ? `${padTitle("Snapshots")} ${t}` : `${padTitle("")} ${t}`
-        ).join("\n")
-      );
-      if (snapshotOutput.length > 1) {
-        logger.log();
-      }
+    for (const [index, snapshot] of snapshotOutput.entries()) {
+      const title = index === 0 ? "Snapshots" : "";
+      this.log(`${padTitle(title)} ${snapshot}`);
+    }
+    if (snapshotOutput.length > 1) {
+      this.log();
     }
-    logger.log(padTitle("Test Files"), getStateString(affectedFiles));
-    logger.log(padTitle("Tests"), getStateString(tests));
+    this.log(padTitle("Test Files"), getStateString(affectedFiles));
+    this.log(padTitle("Tests"), getStateString(tests));
     if (this.ctx.projects.some((c2) => c2.config.typecheck.enabled)) {
-      const failed = tests.filter(
-        (t) => t.meta?.typecheck && t.result?.errors?.length
-      );
-      logger.log(
+      const failed = tests.filter((t) => t.meta?.typecheck && t.result?.errors?.length);
+      this.log(
         padTitle("Type Errors"),
         failed.length ? c.bold(c.red(`${failed.length} failed`)) : c.dim("no errors")
       );
     }
     if (errors.length) {
-      logger.log(
+      this.log(
         padTitle("Errors"),
         c.bold(c.red(`${errors.length} error${errors.length > 1 ? "s" : ""}`))
       );
     }
-    logger.log(padTitle("Start at"), formatTimeString(this._timeStart));
+    this.log(padTitle("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) {
-      logger.log(padTitle("Duration"), time(threadTime));
+      this.log(padTitle("Duration"), time(collectTime + testsTime + setupTime));
     } else {
-      let timers = `transform ${time(transformTime)}, setup ${time(
-        setupTime
-      )}, collect ${time(collectTime)}, tests ${time(
-        testsTime
-      )}, environment ${time(environmentTime)}, prepare ${time(prepareTime)}`;
-      const typecheck = this.ctx.projects.reduce(
-        (acc, c2) => acc + (c2.typechecker?.getResult().time || 0),
-        0
-      );
-      if (typecheck) {
-        timers += `, typecheck ${time(typecheck)}`;
-      }
-      logger.log(
-        padTitle("Duration"),
-        time(executionTime) + c.dim(` (${timers})`)
-      );
+      const executionTime = this.end - this.start;
+      const environmentTime = sum(files, (file) => file.environmentLoad);
+      const prepareTime = sum(files, (file) => file.prepareDuration);
+      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)}`
+      ].filter(Boolean).join(", ");
+      this.log(padTitle("Duration"), time(executionTime) + c.dim(` (${timers})`));
     }
-    logger.log();
+    this.log();
   }
   printErrorsSummary(files, errors) {
-    const logger = this.ctx.logger;
     const suites = getSuites(files);
     const tests = getTests(files);
     const failedSuites = suites.filter((i) => i.result?.errors);
     const failedTests = tests.filter((i) => i.result?.state === "fail");
     const failedTotal = countTestErrors(failedSuites) + countTestErrors(failedTests);
     let current = 1;
-    const errorDivider = () => logger.error(
-      `${c.red(
-        c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1))
-      )}
-`
-    );
+    const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
+`);
     if (failedSuites.length) {
-      logger.error(
-        c.red(
-          divider(c.bold(c.inverse(` Failed Suites ${failedSuites.length} `)))
-        )
-      );
-      logger.error();
+      this.error(`${errorBanner(`Failed Suites ${failedSuites.length}`)}
+`);
       this.printTaskErrors(failedSuites, errorDivider);
     }
     if (failedTests.length) {
-      logger.error(
-        c.red(
-          divider(c.bold(c.inverse(` Failed Tests ${failedTests.length} `)))
-        )
-      );
-      logger.error();
+      this.error(`${errorBanner(`Failed Tests ${failedTests.length}`)}
+`);
       this.printTaskErrors(failedTests, errorDivider);
     }
     if (errors.length) {
-      logger.printUnhandledErrors(errors);
-      logger.error();
+      this.ctx.logger.printUnhandledErrors(errors);
+      this.error();
     }
-    return tests;
   }
   reportBenchmarkSummary(files) {
-    const logger = this.ctx.logger;
     const benches = getTests(files);
     const topBenches = benches.filter((i) => i.result?.benchmark?.rank === 1);
-    logger.log(
-      `
-${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
-`
-    );
+    this.log(withLabel("cyan", "BENCH", "Summary\n"));
     for (const bench of topBenches) {
       const group = bench.suite || bench.file;
       if (!group) {
         continue;
       }
       const groupName = getFullName(group, c.dim(" > "));
-      logger.log(`  ${bench.name}${c.dim(` - ${groupName}`)}`);
+      this.log(`  ${bench.name}${c.dim(` - ${groupName}`)}`);
       const siblings = group.tasks.filter((i) => i.meta.benchmark && i.result?.benchmark && i !== bench).sort((a, b) => a.result.benchmark.rank - b.result.benchmark.rank);
-      if (siblings.length === 0) {
-        logger.log("");
-        continue;
-      }
       for (const sibling of siblings) {
-        const number = `${(sibling.result.benchmark.mean / bench.result.benchmark.mean).toFixed(2)}x`;
-        logger.log(
-          `    ${c.green(number)} ${c.gray("faster than")} ${sibling.name}`
-        );
+        const number = (sibling.result.benchmark.mean / bench.result.benchmark.mean).toFixed(2);
+        this.log(c.green(`    ${number}x `) + c.gray("faster than ") + sibling.name);
       }
-      logger.log("");
+      this.log("");
     }
   }
   printTaskErrors(tasks, errorDivider) {
     const errorsQueue = [];
     for (const task of tasks) {
       task.result?.errors?.forEach((error) => {
-        const errorItem = error?.stackStr && errorsQueue.find((i) => {
-          const hasStr = i[0]?.stackStr === error.stackStr;
-          if (!hasStr) {
-            return false;
-          }
-          const currentProjectName = task?.projectName || task.file?.projectName || "";
-          const projectName = i[1][0]?.projectName || i[1][0].file?.projectName || "";
-          return projectName === currentProjectName;
-        });
-        if (errorItem) {
-          errorItem[1].push(task);
+        let previous;
+        if (error?.stackStr) {
+          previous = errorsQueue.find((i) => {
+            if (i[0]?.stackStr !== error.stackStr) {
+              return false;
+            }
+            const currentProjectName = task?.projectName || task.file?.projectName || "";
+            const projectName = i[1][0]?.projectName || i[1][0].file?.projectName || "";
+            return projectName === currentProjectName;
+          });
+        }
+        if (previous) {
+          previous[1].push(task);
         } else {
           errorsQueue.push([error, [task]]);
         }
@@ -3839,40 +3751,25 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
         const projectName = task?.projectName || task.file?.projectName || "";
         let name = getFullName(task, c.dim(" > "));
         if (filepath) {
-          name = `${name} ${c.dim(`[ ${this.relative(filepath)} ]`)}`;
+          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 screenshots = tasks2.filter((t) => t.meta?.failScreenshotPath).map((t) => t.meta?.failScreenshotPath);
-      const project = this.ctx.getProjectByTaskId(tasks2[0].id);
+      const screenshotPaths = tasks2.map((t) => t.meta?.failScreenshotPath).filter((screenshot) => screenshot != null);
       this.ctx.logger.printError(error, {
-        project,
+        project: this.ctx.getProjectByTaskId(tasks2[0].id),
         verbose: this.verbose,
-        screenshotPaths: screenshots,
+        screenshotPaths,
         task: tasks2[0]
       });
       errorDivider();
     }
   }
-  registerUnhandledRejection() {
-    const onUnhandledRejection = async (err) => {
-      process.exitCode = 1;
-      this.ctx.logger.printError(err, {
-        fullStack: true,
-        type: "Unhandled Rejection"
-      });
-      this.ctx.logger.error("\n\n");
-      process.exit();
-    };
-    process.on("unhandledRejection", onUnhandledRejection);
-    this._offUnhandledRejection = () => {
-      process.off("unhandledRejection", onUnhandledRejection);
-    };
-  }
+}
+function errorBanner(message) {
+  return c.red(divider(c.bold(c.inverse(` ${message} `))));
 }
 function padTitle(str) {
   return c.dim(`${str.padStart(11)} `);
@@ -3883,6 +3780,11 @@ function time(time2) {
   }
   return `${Math.round(time2)}ms`;
 }
+function sum(items, cb) {
+  return items.reduce((total, next) => {
+    return total + Math.max(cb(next) || 0, 0);
+  }, 0);
+}
 
 class BasicReporter extends BaseReporter {
   constructor() {
@@ -4135,7 +4037,7 @@ class DefaultReporter extends BaseReporter {
       this.rendererOptions.logger = this.ctx.logger;
       this.rendererOptions.showHeap = this.ctx.config.logHeapUsage;
       this.rendererOptions.slowTestThreshold = this.ctx.config.slowTestThreshold;
-      this.rendererOptions.mode = this.mode;
+      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();