vitest 3.0.0-beta.3 → 3.0.0

package/dist/chunks/{cli-api.CWDlED-m.js → cli-api.CmJw5Cd_.js}

@@ -1,18 +1,19 @@
 import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { normalize, relative, dirname, resolve, join, basename, isAbsolute } from 'pathe';
+import { extname, normalize, relative, dirname, resolve, join, basename, isAbsolute } from 'pathe';
 import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.BWeNbfBa.js';
 import a, { resolve as resolve$1 } from 'node:path';
-import { noop, isPrimitive, createDefer, toArray, deepMerge, nanoid, slash, deepClone, notNullish } from '@vitest/utils';
+import { noop, isPrimitive, createDefer, highlight, toArray, deepMerge, nanoid, slash, deepClone, notNullish } from '@vitest/utils';
 import { f as findUp, p as prompt } from './index.BJDntFik.js';
+import * as vite from 'vite';
 import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
 import { A as API_PATH, c as configFiles, a as defaultBrowserPort, w as workspacesFiles, d as defaultPort } from './constants.fzPh7AOq.js';
-import { createFileTask, limitConcurrency, getTasks, hasFailed, getTests } from '@vitest/runner/utils';
+import { generateFileHash, createFileTask, limitConcurrency, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.e7qW4xLT.js';
+import { v as version$1 } from './cac.DZC9WjGM.js';
 import { c as createBirpc } from './index.68735LiX.js';
-import { s as stringify, p as parse, i as generateCodeFrame, R as ReportersMap, h as BenchmarkReportsMap, f as TestModule, g as TestSuite, e as TestCase, L as Logger, j as BlobReporter, r as readBlobs } from './index.CzkCSFCy.js';
+import { s as stringify, p as parse, g as printError, h as generateCodeFrame, R as ReportersMap, b as BenchmarkReportsMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.TKSL1HjN.js';
 import require$$0$2 from 'stream';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
@@ -26,11 +27,13 @@ import require$$7 from 'url';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import { distDir, rootDir } from '../path.js';
-import { i as isPackageExists, e as requireMicromatch, V as VitestCache, f as configDefaults, g as getFilePoolName, h as isBrowserEnabled, m as mm, a as resolveConfig, j as groupBy, w as wildcardPatternToRegExp, k as createPool, b as resolveApiServerConfig, c as coverageConfigDefaults, s as stdout } from './resolveConfig.C1d7TK-U.js';
+import { R as RandomSequencer, i as isPackageExists, e as requireMicromatch, h as hash, V as VitestCache, f as configDefaults, g as getFilePoolName, j as isBrowserEnabled, m as mm, a as resolveConfig, k as groupBy, w as wildcardPatternToRegExp, l as createPool, b as resolveApiServerConfig, s as stdout } from './resolveConfig.CSLLD33d.js';
+import { i as isTTY, b as isWindows, c as convertTasksToEvents } from './typechecker.BJMkWMXo.js';
+import { Console } from 'node:console';
+import c from 'tinyrainbow';
+import { a as formatProjectName, w as withLabel, d as divider } from './utils.DJWL04yX.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
-import c from 'tinyrainbow';
-import { b as isTTY, h as hash, i as isWindows } from './RandomSequencer.C6x84bNN.js';
 import { rm } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
 import require$$0$4 from 'os';
@@ -39,7 +42,8 @@ import require$$0$6 from 'fs';
 import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
 import MagicString from 'magic-string';
-import { w as withLabel } from './utils.Coei4Wlj.js';
+import assert$1 from 'node:assert';
+import { serializeError } from '@vitest/utils/error';
 import readline from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 
@@ -4900,9 +4904,8 @@ function setup(ctx, _server) {
   function setupClient(ws) {
     const rpc = createBirpc(
       {
-        async onTaskUpdate(packs) {
-          ctx.state.updateTasks(packs);
-          await ctx.report("onTaskUpdate", packs);
+        async onTaskUpdate(packs, events) {
+          await ctx._testRun.updated(packs, events);
         },
         getFiles() {
           return ctx.state.getFiles();
@@ -4933,6 +4936,9 @@ function setup(ctx, _server) {
         getConfig() {
           return ctx.getRootProject().serializedConfig;
         },
+        getResolvedProjectNames() {
+          return ctx.resolvedProjects.map((p) => p.name);
+        },
         async getTransformResult(projectName, id, browser = false) {
           const project = ctx.getProjectByName(projectName);
           const result = browser ? await project.browser.vite.transformRequest(id) : await project.vitenode.transformRequest(id);
@@ -5109,7 +5115,7 @@ class LocationFilterFileNotFoundError extends Error {
 class IncludeTaskLocationDisabledError extends Error {
   code = "VITEST_INCLUDE_TASK_LOCATION_DISABLED";
   constructor() {
-    super("Recieved line number filters while `includeTaskLocation` option is disabled");
+    super("Received line number filters while `includeTaskLocation` option is disabled");
   }
 }
 class RangeLocationFilterProvidedError extends Error {
@@ -5119,6 +5125,292 @@ class RangeLocationFilterProvidedError extends Error {
   }
 }
 
+const HIGHLIGHT_SUPPORTED_EXTS = new Set(
+  ["js", "ts"].flatMap((lang) => [
+    `.${lang}`,
+    `.m${lang}`,
+    `.c${lang}`,
+    `.${lang}x`,
+    `.m${lang}x`,
+    `.c${lang}x`
+  ])
+);
+function highlightCode(id, source, colors) {
+  const ext = extname(id);
+  if (!HIGHLIGHT_SUPPORTED_EXTS.has(ext)) {
+    return source;
+  }
+  const isJsx = ext.endsWith("x");
+  return highlight(source, { jsx: isJsx, colors: c });
+}
+
+const PAD = "      ";
+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 HIDE_CURSOR = `${ESC$1}?25l`;
+const SHOW_CURSOR = `${ESC$1}?25h`;
+const CLEAR_SCREEN = "\x1Bc";
+class Logger {
+  constructor(ctx, outputStream = process.stdout, errorStream = process.stderr) {
+    this.ctx = ctx;
+    this.outputStream = outputStream;
+    this.errorStream = errorStream;
+    this.console = new Console({ stdout: outputStream, stderr: errorStream });
+    this._highlights.clear();
+    this.addCleanupListeners();
+    this.registerUnhandledRejection();
+    this.outputStream.write(HIDE_CURSOR);
+  }
+  _clearScreenPending;
+  _highlights = /* @__PURE__ */ new Map();
+  cleanupListeners = [];
+  console;
+  log(...args) {
+    this._clearScreen();
+    this.console.log(...args);
+  }
+  error(...args) {
+    this._clearScreen();
+    this.console.error(...args);
+  }
+  warn(...args) {
+    this._clearScreen();
+    this.console.warn(...args);
+  }
+  clearFullScreen(message = "") {
+    if (!this.ctx.config.clearScreen) {
+      this.console.log(message);
+      return;
+    }
+    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) {
+      this.console.log(message);
+      return;
+    }
+    this._clearScreenPending = message;
+    if (force) {
+      this._clearScreen();
+    }
+  }
+  _clearScreen() {
+    if (this._clearScreenPending == null) {
+      return;
+    }
+    const log = this._clearScreenPending;
+    this._clearScreenPending = void 0;
+    this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
+  }
+  printError(err, options = {}) {
+    printError(err, this.ctx, this, options);
+  }
+  clearHighlightCache(filename) {
+    if (filename) {
+      this._highlights.delete(filename);
+    } else {
+      this._highlights.clear();
+    }
+  }
+  highlight(filename, source) {
+    if (this._highlights.has(filename)) {
+      return this._highlights.get(filename);
+    }
+    const code = highlightCode(filename, source);
+    this._highlights.set(filename, code);
+    return code;
+  }
+  printNoTestFound(filters) {
+    const config = this.ctx.config;
+    if (config.watch && (config.changed || config.related?.length)) {
+      this.log(`No affected ${config.mode} files found
+`);
+    } else if (config.watch) {
+      this.log(
+        c.red(`No ${config.mode} files found. You can change the file name pattern by pressing "p"
+`)
+      );
+    } else {
+      if (config.passWithNoTests) {
+        this.log(`No ${config.mode} files found, exiting with code 0
+`);
+      } else {
+        this.error(
+          c.red(`No ${config.mode} files found, exiting with code 1
+`)
+        );
+      }
+    }
+    const comma = c.dim(", ");
+    if (filters?.length) {
+      this.console.error(c.dim("filter: ") + c.yellow(filters.join(comma)));
+    }
+    const projectsFilter = toArray(config.project);
+    if (projectsFilter.length) {
+      this.console.error(
+        c.dim("projects: ") + c.yellow(projectsFilter.join(comma))
+      );
+    }
+    this.ctx.projects.forEach((project) => {
+      const config2 = project.config;
+      const printConfig = !project.isRootProject() && project.name;
+      if (printConfig) {
+        this.console.error(`
+${formatProjectName(project.name)}
+`);
+      }
+      if (config2.include) {
+        this.console.error(
+          c.dim("include: ") + c.yellow(config2.include.join(comma))
+        );
+      }
+      if (config2.exclude) {
+        this.console.error(
+          c.dim("exclude:  ") + c.yellow(config2.exclude.join(comma))
+        );
+      }
+      if (config2.typecheck.enabled) {
+        this.console.error(
+          c.dim("typecheck include: ") + c.yellow(config2.typecheck.include.join(comma))
+        );
+        this.console.error(
+          c.dim("typecheck exclude: ") + c.yellow(config2.typecheck.exclude.join(comma))
+        );
+      }
+    });
+    this.console.error();
+  }
+  printBanner() {
+    this.log();
+    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(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`));
+    }
+    if (this.ctx.config.ui) {
+      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(PAD + c.dim(c.green(`API started at ${new URL("/", origin)}`)));
+    }
+    if (this.ctx.coverageProvider) {
+      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.`));
+    } 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 output = project.isRootProject() ? "" : formatProjectName(project.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(
+        `
+Vitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run.
+This might cause false positive tests. Resolve unhandled errors to make sure your tests are not affected.`
+      )
+    );
+    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.error(c.red(divider()));
+  }
+  printSourceTypeErrors(errors) {
+    const errorMessage = c.red(
+      c.bold(
+        `
+Vitest found ${errors.length} error${errors.length > 1 ? "s" : ""} not related to your test files.`
+      )
+    );
+    this.log(c.red(divider(c.bold(c.inverse(" Source Errors ")))));
+    this.log(errorMessage);
+    errors.forEach((err) => {
+      this.printError(err, { fullStack: true });
+    });
+    this.log(c.red(divider()));
+  }
+  getColumns() {
+    return "columns" in this.outputStream ? this.outputStream.columns : 80;
+  }
+  onTerminalCleanup(listener) {
+    this.cleanupListeners.push(listener);
+  }
+  addCleanupListeners() {
+    const cleanup = () => {
+      this.cleanupListeners.forEach((fn) => fn());
+      this.outputStream.write(SHOW_CURSOR);
+    };
+    const onExit = (signal, exitCode) => {
+      cleanup();
+      if (process.exitCode === void 0) {
+        process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
+      }
+      process.exit();
+    };
+    process.once("SIGINT", onExit);
+    process.once("SIGTERM", onExit);
+    process.once("exit", onExit);
+    this.ctx.onClose(() => {
+      process.off("SIGINT", onExit);
+      process.off("SIGTERM", onExit);
+      process.off("exit", onExit);
+      cleanup();
+    });
+  }
+  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);
+    });
+  }
+}
+
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 class VitestPackageInstaller {
   isPackageExists(name, options) {
@@ -5159,7 +5451,7 @@ class VitestPackageInstaller {
     });
     if (install) {
       const packageName = version ? `${dependency}@${version}` : dependency;
-      await (await import('./index.DQboAxJm.js')).installPackage(packageName, { dev: true });
+      await (await import('./index.D9C26wCk.js')).installPackage(packageName, { dev: true });
       process.stderr.write(
         c.yellow(
           `
@@ -8316,7 +8608,7 @@ function requireOut () {
 	        }
 	        win32.convertPathToPattern = convertPathToPattern;
 	    })(FastGlob.win32 || (FastGlob.win32 = {}));
-	})(FastGlob || (FastGlob = {}));
+	})(FastGlob);
 	function getWorks(source, _Provider, options) {
 	    const patterns = [].concat(source);
 	    const settings = new settings_1.default(options);
@@ -8669,6 +8961,10 @@ function silenceImportViteIgnoreWarning(logger) {
   };
 }
 
+function getDefaultServerConditions() {
+  return vite.defaultServerConditions ?? ["node"];
+}
+
 const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)";
 const cssLangRE = new RegExp(cssLangs);
 const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
@@ -9482,6 +9778,7 @@ function WorkspaceVitestPlugin(project, options) {
             name = options.workspacePath.toString();
           }
         }
+        const conditions = getDefaultServerConditions();
         const config = {
           root,
           resolve: {
@@ -9489,7 +9786,7 @@ function WorkspaceVitestPlugin(project, options) {
             // setting this option can bypass that and fallback to cjs version
             mainFields: [],
             alias: testConfig.alias,
-            conditions: ["node"]
+            conditions
           },
           esbuild: viteConfig.esbuild === false ? false : {
             // Lowest target Vitest supports is Node18
@@ -9522,7 +9819,7 @@ function WorkspaceVitestPlugin(project, options) {
                 // by default Vite resolves `module` field, which not always a native ESM module
                 // setting this option can bypass that and fallback to cjs version
                 mainFields: [],
-                conditions: ["node"]
+                conditions
               }
             }
           },
@@ -9588,6 +9885,10 @@ class TestSpecification {
    * @deprecated use `pool` instead
    */
   2;
+  /**
+   * The task ID associated with the test module.
+   */
+  taskId;
   /**
    * The test project that the module belongs to.
    */
@@ -9609,11 +9910,27 @@ class TestSpecification {
     this[0] = project;
     this[1] = moduleId;
     this[2] = { pool };
+    const name = project.config.name;
+    const hashName = pool !== "typescript" ? name : name ? `${name}:__typecheck__` : "__typecheck__";
+    this.taskId = generateFileHash(
+      relative(project.config.root, moduleId),
+      hashName
+    );
     this.project = project;
     this.moduleId = moduleId;
     this.pool = pool;
     this.testLines = testLines;
   }
+  /**
+   * Test module associated with the specification.
+   */
+  get testModule() {
+    const task = this.project.vitest.state.idMap.get(this.taskId);
+    if (!task) {
+      return void 0;
+    }
+    return this.project.vitest.state.getReportedEntity(task);
+  }
   toJSON() {
     return [
       {
@@ -9681,13 +9998,14 @@ class TestProject {
   typechecker;
   /** @internal */
   _config;
+  /** @internal */
+  _vite;
   runner;
   closingPromise;
   testFilesList = null;
   typecheckFilesList = null;
   _globalSetups;
   _provided = {};
-  _vite;
   // "provide" is a property, not a method to keep the context when destructed in the global setup,
   // making it a method would be a breaking change, and can be done in Vitest 3 at minimum
   /**
@@ -9770,7 +10088,7 @@ class TestProject {
    * Serialized project configuration. This is the config that tests receive.
    */
   get serializedConfig() {
-    return this._serializeOverridenConfig();
+    return this._serializeOverriddenConfig();
   }
   /** @deprecated use `vite` instead */
   get server() {
@@ -9914,19 +10232,19 @@ class TestProject {
    * Returns if the file is a test file. Requires `.globTestFiles()` to be called first.
    * @internal
    */
-  isCachedTestFile(testPath) {
+  _isCachedTestFile(testPath) {
     return !!this.testFilesList && this.testFilesList.includes(testPath);
   }
   /**
    * Returns if the file is a typecheck test file. Requires `.globTestFiles()` to be called first.
    * @internal
    */
-  isCachedTypecheckFile(testPath) {
+  _isCachedTypecheckFile(testPath) {
     return !!this.typecheckFilesList && this.typecheckFilesList.includes(testPath);
   }
   /** @deprecated use `serializedConfig` instead */
   getSerializableConfig() {
-    return this._serializeOverridenConfig();
+    return this._serializeOverriddenConfig();
   }
   /** @internal */
   async globFiles(include, exclude, cwd) {
@@ -9942,7 +10260,7 @@ class TestProject {
    * Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
    */
   matchesTestGlob(moduleId, source) {
-    if (this.isCachedTestFile(moduleId)) {
+    if (this._isCachedTestFile(moduleId)) {
       return true;
     }
     const relativeId = relative(this.config.dir || this.config.root, moduleId);
@@ -9987,9 +10305,7 @@ class TestProject {
     }
     return testFiles;
   }
-  /** @internal */
   _parentBrowser;
-  /** @internal */
   _parent;
   /** @internal */
   _initParentBrowser = deduped(async () => {
@@ -10027,6 +10343,7 @@ class TestProject {
     await this._parent?._initParentBrowser();
     if (!this.browser && this._parent?._parentBrowser) {
       this.browser = this._parent._parentBrowser.spawn(this);
+      await this.vitest.report("onBrowserInit", this);
     }
   });
   /**
@@ -10097,7 +10414,7 @@ class TestProject {
       }
     });
   }
-  _serializeOverridenConfig() {
+  _serializeOverriddenConfig() {
     const config = serializeConfig(
       this.config,
       this.vitest.config,
@@ -10182,7 +10499,7 @@ function deduped(cb) {
 }
 async function initializeProject(workspacePath, ctx, options) {
   const project = new TestProject(workspacePath, ctx, options);
-  const { extends: extendsConfig, configFile, ...restOptions } = options;
+  const { configFile, ...restOptions } = options;
   const config = {
     ...restOptions,
     configFile,
@@ -10310,10 +10627,10 @@ class VitestSpecifications {
     }
     const specs = [];
     for (const project of this.vitest.projects) {
-      if (project.isCachedTestFile(moduleId)) {
+      if (project._isCachedTestFile(moduleId)) {
         specs.push(project.createSpecification(moduleId));
       }
-      if (project.isCachedTypecheckFile(moduleId)) {
+      if (project._isCachedTypecheckFile(moduleId)) {
         specs.push(project.createSpecification(moduleId, [], "typescript"));
       }
     }
@@ -10449,6 +10766,411 @@ class VitestSpecifications {
   }
 }
 
+class ReportedTaskImplementation {
+  /**
+   * Task instance.
+   * @internal
+   */
+  task;
+  /**
+   * The project associated with the test or suite.
+   */
+  project;
+  /**
+   * Unique identifier.
+   * This ID is deterministic and will be the same for the same test across multiple runs.
+   * The ID is based on the project name, module url and test order.
+   */
+  id;
+  /**
+   * Location in the module where the test or suite is defined.
+   */
+  location;
+  /** @internal */
+  constructor(task, project) {
+    this.task = task;
+    this.project = project;
+    this.id = task.id;
+    this.location = task.location;
+  }
+  /**
+   * Checks if the test did not fail the suite.
+   * If the test is not finished yet or was skipped, it will return `true`.
+   */
+  ok() {
+    const result = this.task.result;
+    return !result || result.state !== "fail";
+  }
+  /**
+   * Creates a new reported task instance and stores it in the project's state for future use.
+   * @internal
+   */
+  static register(task, project) {
+    const state = new this(task, project);
+    storeTask(project, task, state);
+    return state;
+  }
+}
+class TestCase extends ReportedTaskImplementation {
+  #fullName;
+  type = "test";
+  /**
+   * Direct reference to the test module where the test or suite is defined.
+   */
+  module;
+  /**
+   * Name of the test.
+   */
+  name;
+  /**
+   * Options that the test was initiated with.
+   */
+  options;
+  /**
+   * Parent suite. If the test was called directly inside the module, the parent will be the module itself.
+   */
+  parent;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.name = task.name;
+    this.module = getReportedTask(project, task.file);
+    const suite = this.task.suite;
+    if (suite) {
+      this.parent = getReportedTask(project, suite);
+    } else {
+      this.parent = this.module;
+    }
+    this.options = buildOptions(task);
+  }
+  /**
+   * Full name of the test including all parent suites separated with `>`.
+   */
+  get fullName() {
+    if (this.#fullName === void 0) {
+      if (this.parent.type !== "module") {
+        this.#fullName = `${this.parent.fullName} > ${this.name}`;
+      } else {
+        this.#fullName = this.name;
+      }
+    }
+    return this.#fullName;
+  }
+  /**
+   * Test results.
+   * - **pending**: Test was collected, but didn't finish running yet.
+   * - **passed**: Test passed successfully
+   * - **failed**: Test failed to execute
+   * - **skipped**: Test was skipped during collection or dynamically with `ctx.skip()`.
+   */
+  result() {
+    const result = this.task.result;
+    const mode = result?.state || this.task.mode;
+    if (!result && (mode === "skip" || mode === "todo")) {
+      return {
+        state: "skipped",
+        note: void 0,
+        errors: void 0
+      };
+    }
+    if (!result || result.state === "run" || result.state === "queued") {
+      return {
+        state: "pending",
+        errors: 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 || []
+    };
+  }
+  /**
+   * Custom metadata that was attached to the test during its execution.
+   */
+  meta() {
+    return this.task.meta;
+  }
+  /**
+   * Useful information about the test like duration, memory usage, etc.
+   * Diagnostic is only available after the test has finished.
+   */
+  diagnostic() {
+    const result = this.task.result;
+    if (!result || !result.startTime) {
+      return void 0;
+    }
+    const duration = result.duration || 0;
+    const slow = duration > this.project.globalConfig.slowTestThreshold;
+    return {
+      slow,
+      heap: result.heap,
+      duration,
+      startTime: result.startTime,
+      retryCount: result.retryCount ?? 0,
+      repeatCount: result.repeatCount ?? 0,
+      flaky: !!result.retryCount && result.state === "pass" && result.retryCount > 0
+    };
+  }
+}
+class TestCollection {
+  #task;
+  #project;
+  constructor(task, project) {
+    this.#task = task;
+    this.#project = project;
+  }
+  /**
+   * Returns the test or suite at a specific index.
+   */
+  at(index) {
+    if (index < 0) {
+      index = this.size + index;
+    }
+    return getReportedTask(this.#project, this.#task.tasks[index]);
+  }
+  /**
+   * The number of tests and suites in the collection.
+   */
+  get size() {
+    return this.#task.tasks.length;
+  }
+  /**
+   * Returns the collection in array form for easier manipulation.
+   */
+  array() {
+    return Array.from(this);
+  }
+  /**
+   * Filters all tests that are part of this collection and its children.
+   */
+  *allTests(state) {
+    for (const child of this) {
+      if (child.type === "suite") {
+        yield* child.children.allTests(state);
+      } else if (state) {
+        const testState = child.result().state;
+        if (state === testState) {
+          yield child;
+        }
+      } else {
+        yield child;
+      }
+    }
+  }
+  /**
+   * Filters only the tests that are part of this collection.
+   */
+  *tests(state) {
+    for (const child of this) {
+      if (child.type !== "test") {
+        continue;
+      }
+      if (state) {
+        const testState = child.result().state;
+        if (state === testState) {
+          yield child;
+        }
+      } else {
+        yield child;
+      }
+    }
+  }
+  /**
+   * Filters only the suites that are part of this collection.
+   */
+  *suites() {
+    for (const child of this) {
+      if (child.type === "suite") {
+        yield child;
+      }
+    }
+  }
+  /**
+   * Filters all suites that are part of this collection and its children.
+   */
+  *allSuites() {
+    for (const child of this) {
+      if (child.type === "suite") {
+        yield child;
+        yield* child.children.allSuites();
+      }
+    }
+  }
+  *[Symbol.iterator]() {
+    for (const task of this.#task.tasks) {
+      yield getReportedTask(this.#project, task);
+    }
+  }
+}
+class SuiteImplementation extends ReportedTaskImplementation {
+  /**
+   * Collection of suites and tests that are part of this suite.
+   */
+  children;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.children = new TestCollection(task, project);
+  }
+  /**
+   * Errors that happened outside of the test run during collection, like syntax errors.
+   */
+  errors() {
+    return this.task.result?.errors || [];
+  }
+}
+class TestSuite extends SuiteImplementation {
+  #fullName;
+  type = "suite";
+  /**
+   * Name of the test or the suite.
+   */
+  name;
+  /**
+   * Direct reference to the test module where the test or suite is defined.
+   */
+  module;
+  /**
+   * Parent suite. If suite was called directly inside the module, the parent will be the module itself.
+   */
+  parent;
+  /**
+   * Options that suite was initiated with.
+   */
+  options;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.name = task.name;
+    this.module = getReportedTask(project, task.file);
+    const suite = this.task.suite;
+    if (suite) {
+      this.parent = getReportedTask(project, suite);
+    } else {
+      this.parent = this.module;
+    }
+    this.options = buildOptions(task);
+  }
+  /**
+   * Checks the running state of the suite.
+   */
+  state() {
+    return getSuiteState(this.task);
+  }
+  /**
+   * Full name of the suite including all parent suites separated with `>`.
+   */
+  get fullName() {
+    if (this.#fullName === void 0) {
+      if (this.parent.type !== "module") {
+        this.#fullName = `${this.parent.fullName} > ${this.name}`;
+      } else {
+        this.#fullName = this.name;
+      }
+    }
+    return this.#fullName;
+  }
+}
+class TestModule extends SuiteImplementation {
+  type = "module";
+  /**
+   * This is usually an absolute UNIX file path.
+   * It can be a virtual ID if the file is not on the disk.
+   * This value corresponds to the ID in the Vite's module graph.
+   */
+  moduleId;
+  /** @internal */
+  constructor(task, project) {
+    super(task, project);
+    this.moduleId = task.filepath;
+  }
+  /**
+   * Checks the running state of the test file.
+   */
+  state() {
+    const state = this.task.result?.state;
+    if (state === "queued") {
+      return "queued";
+    }
+    return getSuiteState(this.task);
+  }
+  /**
+   * Useful information about the module like duration, memory usage, etc.
+   * If the module was not executed yet, all diagnostic values will return `0`.
+   */
+  diagnostic() {
+    const setupDuration = this.task.setupDuration || 0;
+    const collectDuration = this.task.collectDuration || 0;
+    const prepareDuration = this.task.prepareDuration || 0;
+    const environmentSetupDuration = this.task.environmentLoad || 0;
+    const duration = this.task.result?.duration || 0;
+    return {
+      environmentSetupDuration,
+      prepareDuration,
+      collectDuration,
+      setupDuration,
+      duration
+    };
+  }
+}
+function buildOptions(task) {
+  return {
+    each: task.each,
+    fails: task.type === "test" && task.fails,
+    concurrent: task.concurrent,
+    shuffle: task.shuffle,
+    retry: task.retry,
+    repeats: task.repeats,
+    // runner types are too broad, but the public API should be more strict
+    // the queued state exists only on Files and this method is called
+    // only for tests and suites
+    mode: task.mode
+  };
+}
+function storeTask(project, runnerTask, reportedTask) {
+  project.vitest.state.reportedTasksMap.set(runnerTask, reportedTask);
+}
+function getReportedTask(project, runnerTask) {
+  const reportedTask = project.vitest.state.getReportedEntity(runnerTask);
+  if (!reportedTask) {
+    throw new Error(
+      `Task instance was not found for ${runnerTask.type} "${runnerTask.name}"`
+    );
+  }
+  return reportedTask;
+}
+function getSuiteState(task) {
+  const mode = task.mode;
+  const state = task.result?.state;
+  if (mode === "skip" || mode === "todo" || state === "skip" || state === "todo") {
+    return "skipped";
+  }
+  if (state == null || state === "run" || state === "only") {
+    return "pending";
+  }
+  if (state === "fail") {
+    return "failed";
+  }
+  if (state === "pass") {
+    return "passed";
+  }
+  throw new Error(`Unknown suite state: ${state}`);
+}
+
 function isAggregateError(err) {
   if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
     return true;
@@ -10630,6 +11352,127 @@ class StateManager {
   }
 }
 
+class TestRun {
+  constructor(vitest) {
+    this.vitest = vitest;
+  }
+  async start(specifications) {
+    const filepaths = specifications.map((spec) => spec.moduleId);
+    this.vitest.state.collectPaths(filepaths);
+    await this.vitest.report("onPathsCollected", Array.from(new Set(filepaths)));
+    await this.vitest.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
+    await this.vitest.report("onTestRunStart", [...specifications]);
+  }
+  async enqueued(project, file) {
+    this.vitest.state.collectFiles(project, [file]);
+    const testModule = this.vitest.state.getReportedEntity(file);
+    await this.vitest.report("onTestModuleQueued", testModule);
+  }
+  async collected(project, files) {
+    this.vitest.state.collectFiles(project, files);
+    await Promise.all([
+      this.vitest.report("onCollected", files),
+      ...files.map((file) => {
+        const testModule = this.vitest.state.getReportedEntity(file);
+        return this.vitest.report("onTestModuleCollected", testModule);
+      })
+    ]);
+  }
+  async log(log) {
+    this.vitest.state.updateUserLog(log);
+    await this.vitest.report("onUserConsoleLog", log);
+  }
+  async updated(update, events) {
+    this.vitest.state.updateTasks(update);
+    await this.vitest.report("onTaskUpdate", update);
+    for (const [id, event] of events) {
+      await this.reportEvent(id, event).catch((error) => {
+        this.vitest.state.catchError(serializeError(error), "Unhandled Reporter Error");
+      });
+    }
+  }
+  async end(specifications, errors, coverage) {
+    const modules = specifications.map((spec) => spec.testModule).filter((s) => s != null);
+    const files = modules.map((m) => m.task);
+    const state = this.vitest.isCancelling ? "interrupted" : process.exitCode ? "failed" : "passed";
+    try {
+      await Promise.all([
+        this.vitest.report("onTestRunEnd", modules, [...errors], state),
+        // TODO: in a perfect world, the coverage should be done in parallel to `onFinished`
+        this.vitest.report("onFinished", files, errors, coverage)
+      ]);
+    } finally {
+      if (coverage) {
+        await this.vitest.report("onCoverage", coverage);
+      }
+    }
+  }
+  async reportEvent(id, event) {
+    const task = this.vitest.state.idMap.get(id);
+    const entity = task && this.vitest.state.getReportedEntity(task);
+    assert$1(task && entity, `Entity must be found for task ${task?.name || id}`);
+    if (event === "suite-prepare" && entity.type === "suite") {
+      return await this.vitest.report("onTestSuiteReady", entity);
+    }
+    if (event === "suite-prepare" && entity.type === "module") {
+      return await this.vitest.report("onTestModuleStart", entity);
+    }
+    if (event === "suite-finished") {
+      assert$1(entity.type === "suite" || entity.type === "module", "Entity type must be suite or module");
+      if (entity.state() === "skipped") {
+        await this.reportChildren(entity.children);
+      } else {
+        for (const test of entity.children.tests("skipped")) {
+          if (test.task.result?.pending) {
+            continue;
+          }
+          await this.vitest.report("onTestCaseReady", test);
+          await this.vitest.report("onTestCaseResult", test);
+        }
+      }
+      if (entity.type === "module") {
+        await this.vitest.report("onTestModuleEnd", entity);
+      } else {
+        await this.vitest.report("onTestSuiteResult", entity);
+      }
+      return;
+    }
+    if (event === "test-prepare" && entity.type === "test") {
+      return await this.vitest.report("onTestCaseReady", entity);
+    }
+    if (event === "test-finished" && entity.type === "test") {
+      return await this.vitest.report("onTestCaseResult", entity);
+    }
+    if (event.startsWith("before-hook") || event.startsWith("after-hook")) {
+      const isBefore = event.startsWith("before-hook");
+      const hook = entity.type === "test" ? {
+        name: isBefore ? "beforeEach" : "afterEach",
+        entity
+      } : {
+        name: isBefore ? "beforeAll" : "afterAll",
+        entity
+      };
+      if (event.endsWith("-start")) {
+        await this.vitest.report("onHookStart", hook);
+      } else {
+        await this.vitest.report("onHookEnd", hook);
+      }
+    }
+  }
+  async reportChildren(children) {
+    for (const child of children) {
+      if (child.type === "test") {
+        await this.vitest.report("onTestCaseReady", child);
+        await this.vitest.report("onTestCaseResult", child);
+      } else {
+        await this.vitest.report("onTestSuiteReady", child);
+        await this.reportChildren(child.children);
+        await this.vitest.report("onTestSuiteResult", child);
+      }
+    }
+  }
+}
+
 class VitestWatcher {
   constructor(vitest) {
     this.vitest = vitest;
@@ -10730,7 +11573,7 @@ class VitestWatcher {
       return moduleGraph.getModulesByFile(filepath)?.size;
     });
     if (!projects.length) {
-      if (this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project.isCachedTestFile(filepath))) {
+      if (this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project._isCachedTestFile(filepath))) {
         this.changedTests.add(filepath);
         return true;
       }
@@ -10743,7 +11586,7 @@ class VitestWatcher {
         continue;
       }
       this.invalidates.add(filepath);
-      if (this.vitest.state.filesMap.has(filepath) || project.isCachedTestFile(filepath)) {
+      if (this.vitest.state.filesMap.has(filepath) || project._isCachedTestFile(filepath)) {
         this.changedTests.add(filepath);
         files.push(filepath);
         continue;
@@ -10839,13 +11682,12 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
   const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
   projectConfigs.forEach((options, index) => {
     const configRoot = workspaceConfigPath ? dirname(workspaceConfigPath) : vitest.config.root;
-    const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : false;
-    const rootOptions = options.extends === true ? vitest._options : {};
+    const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false;
     const root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
     projectPromises.push(concurrent(() => initializeProject(
       index,
       vitest,
-      mergeConfig(rootOptions, { ...options, root, configFile })
+      { ...options, root, configFile }
     )));
   });
   for (const path of fileProjects) {
@@ -11029,8 +11871,8 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceD
       if (!isDynamicPattern(stringOption)) {
         const file = resolve(vitest.config.root, stringOption);
         if (!existsSync(file)) {
-          const relativeWorkpaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
-          const note = workspaceConfigPath ? `Workspace config file "${relativeWorkpaceConfigPath}"` : "Inline workspace";
+          const relativeWorkSpaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
+          const note = workspaceConfigPath ? `Workspace config file "${relativeWorkSpaceConfigPath}"` : "Inline workspace";
           throw new Error(`${note} references a non-existing file or a directory: ${file}`);
         }
         const stats = await promises.stat(file);
@@ -11178,6 +12020,8 @@ class Vitest {
   vitenode = void 0;
   /** @internal */
   runner = void 0;
+  /** @internal */
+  _testRun = void 0;
   isFirstRun = true;
   restartsCount = 0;
   specifications;
@@ -11262,6 +12106,7 @@ class Vitest {
     this._workspaceConfigPath = void 0;
     this.coverageProvider = void 0;
     this.runningPromise = void 0;
+    this.coreWorkspaceProject = void 0;
     this.specifications.clearCache();
     this._onUserTestsRerun = [];
     const resolved = resolveConfig(this.mode, options, server.config, this.logger);
@@ -11270,6 +12115,7 @@ class Vitest {
     this._state = new StateManager();
     this._cache = new VitestCache(this.version);
     this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
+    this._testRun = new TestRun(this);
     if (this.config.watch) {
       this.watcher.registerWatcher();
     }
@@ -11455,43 +12301,35 @@ class Vitest {
     const { files, errors, coverages } = await readBlobs(this.version, directory || this.config.mergeReports, this.projects);
     await this.report("onInit", this);
     await this.report("onPathsCollected", files.flatMap((f) => f.filepath));
-    const workspaceSpecs = /* @__PURE__ */ new Map();
+    const specifications = [];
     for (const file of files) {
       const project = this.getProjectByName(file.projectName || "");
-      const specs = workspaceSpecs.get(project) || [];
-      specs.push(file);
-      workspaceSpecs.set(project, specs);
-    }
-    for (const [project, files2] of workspaceSpecs) {
-      const filepaths = files2.map((f) => f.filepath);
-      this.state.clearFiles(project, filepaths);
-      files2.forEach((file) => {
-        file.logs?.forEach((log) => this.state.updateUserLog(log));
-      });
-      this.state.collectFiles(project, files2);
+      const specification = project.createSpecification(file.filepath, void 0, file.pool);
+      specifications.push(specification);
     }
-    await this.report("onCollected", files).catch(noop);
+    await this.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
+    await this._testRun.start(specifications).catch(noop);
     for (const file of files) {
+      const project = this.getProjectByName(file.projectName || "");
+      await this._testRun.enqueued(project, file).catch(noop);
+      await this._testRun.collected(project, [file]).catch(noop);
       const logs = [];
-      const taskPacks = [];
-      const tasks = getTasks(file);
-      for (const task of tasks) {
+      const { packs, events } = convertTasksToEvents(file, (task) => {
         if (task.logs) {
           logs.push(...task.logs);
         }
-        taskPacks.push([task.id, task.result, task.meta]);
-      }
+      });
       logs.sort((log1, log2) => log1.time - log2.time);
       for (const log of logs) {
-        await this.report("onUserConsoleLog", log).catch(noop);
+        await this._testRun.log(log).catch(noop);
       }
-      await this.report("onTaskUpdate", taskPacks).catch(noop);
+      await this._testRun.updated(packs, events).catch(noop);
     }
     if (hasFailed(files)) {
       process.exitCode = 1;
     }
     this._checkUnhandledErrors(errors);
-    await this.report("onFinished", files, errors);
+    await this._testRun.end(specifications, errors).catch(noop);
     await this.initCoverageProvider();
     await this.coverageProvider?.mergeReports?.(coverages);
     return {
@@ -11537,12 +12375,16 @@ class Vitest {
     this.filenamePattern = filters && filters?.length > 0 ? filters : void 0;
     const files = await this.specifications.getRelevantTestSpecifications(filters);
     if (!files.length) {
+      const throwAnError = !this.config.watch || !(this.config.changed || this.config.related?.length);
+      await this._testRun.start([]);
       const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
-      await this.reportCoverage(coverage, true);
-      this.logger.printNoTestFound(filters);
-      if (!this.config.watch || !(this.config.changed || this.config.related?.length)) {
+      if (throwAnError) {
         const exitCode = this.config.passWithNoTests ? 0 : 1;
         process.exitCode = exitCode;
+      }
+      await this._testRun.end([], [], coverage);
+      await this.reportCoverage(coverage, true);
+      if (throwAnError) {
         throw new FilesNotFoundError(this.mode);
       }
     }
@@ -11587,7 +12429,7 @@ class Vitest {
     return this.getModuleSpecifications(file);
   }
   /**
-   * Get test specifications assosiated with the given module. If module is not a test file, an empty array is returned.
+   * Get test specifications associated with the given module. If module is not a test file, an empty array is returned.
    *
    * **Note:** this method relies on a cache generated by `globTestSpecifications`. If the file was not processed yet, use `project.matchesGlobPattern` instead.
    * @param moduleId The module ID to get test specifications for.
@@ -11596,7 +12438,7 @@ class Vitest {
     return this.specifications.getModuleSpecifications(moduleId);
   }
   /**
-   * Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache alltogether.
+   * Vitest automatically caches test specifications for each file. This method clears the cache for the given file or the whole cache altogether.
    */
   clearSpecificationsCache(moduleId) {
     this.specifications.clearCache(moduleId);
@@ -11627,10 +12469,7 @@ class Vitest {
     return result;
   }
   async runFiles(specs, allTestsRun) {
-    const filepaths = specs.map((spec) => spec.moduleId);
-    this.state.collectPaths(filepaths);
-    await this.report("onPathsCollected", filepaths);
-    await this.report("onSpecsCollected", specs.map((spec) => spec.toJSON()));
+    await this._testRun.start(specs);
     await this.runningPromise;
     this._onCancelListeners = [];
     this.isCancelling = false;
@@ -11663,11 +12502,10 @@ class Vitest {
           unhandledErrors: this.state.getUnhandledErrors()
         };
       } finally {
-        const files = Array.from(new Set(specs.map((spec) => spec.moduleId)));
-        const errors = this.state.getUnhandledErrors();
         const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
+        const errors = this.state.getUnhandledErrors();
         this._checkUnhandledErrors(errors);
-        await this.report("onFinished", this.state.getFiles(files), errors, coverage);
+        await this._testRun.end(specs, errors, coverage);
         await this.reportCoverage(coverage, allTestsRun);
       }
     })().finally(() => {
@@ -11723,6 +12561,7 @@ class Vitest {
   async cancelCurrentRun(reason) {
     this.isCancelling = true;
     await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason)));
+    await this.runningPromise;
   }
   /** @internal */
   async _initBrowserServers() {
@@ -11836,12 +12675,14 @@ class Vitest {
       // environment is resolved inside a worker thread
       snapshotEnvironment: null
     };
+    this.snapshot.options.updateSnapshot = "all";
   }
   /**
    * Disable the mode that allows updating snapshots when running tests.
    */
   resetSnapshotUpdate() {
     delete this.configOverride.snapshotOptions;
+    this.snapshot.options.updateSnapshot = this.config.snapshotOptions.updateSnapshot;
   }
   /**
    * Set the global test name pattern to a regexp.
@@ -11975,7 +12816,6 @@ class Vitest {
               this.logger.error("error during close", r.reason);
             }
           });
-          this.logger.logUpdate.done();
         });
       })();
     }
@@ -11991,7 +12831,7 @@ class Vitest {
         console.warn(`close timed out after ${this.config.teardownTimeout}ms`);
         this.state.getProcessTimeoutCauses().forEach((cause) => console.warn(cause));
         if (!this.pool) {
-          const runningServers = [this.vite, ...this.resolvedProjects.map((p) => p.vite)].filter(Boolean).length;
+          const runningServers = [this._vite, ...this.resolvedProjects.map((p) => p._vite)].filter(Boolean).length;
           if (runningServers === 1) {
             console.warn("Tests closed successfully but something prevents Vite server from exiting");
           } else if (runningServers > 1) {
@@ -11999,7 +12839,9 @@ class Vitest {
           } else {
             console.warn("Tests closed successfully but something prevents the main process from exiting");
           }
-          console.warn('You can try to identify the cause by enabling "hanging-process" reporter. See https://vitest.dev/config/#reporters');
+          if (!this.reporters.some((r) => r instanceof HangingProcessReporter)) {
+            console.warn('You can try to identify the cause by enabling "hanging-process" reporter. See https://vitest.dev/config/#reporters');
+          }
         }
         process.exit();
       });
@@ -12119,6 +12961,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
         if (testConfig.ui && testConfig.open) {
           open = testConfig.uiBase ?? "/__vitest__/";
         }
+        const conditions = getDefaultServerConditions();
         const config = {
           root: viteConfig.test?.root || options.root,
           esbuild: viteConfig.esbuild === false ? false : {
@@ -12133,7 +12976,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             // setting this option can bypass that and fallback to cjs version
             mainFields: [],
             alias: testConfig.alias,
-            conditions: ["node"]
+            conditions
           },
           server: {
             ...testConfig.api,
@@ -12162,7 +13005,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
                 // by default Vite resolves `module` field, which not always a native ESM module
                 // setting this option can bypass that and fallback to cjs version
                 mainFields: [],
-                conditions: ["node"]
+                conditions
               }
             }
           },
@@ -12187,11 +13030,6 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           }
         );
         config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
-        if (userConfig.coverage?.enabled && !userConfig.coverage.exclude && userConfig.include && config.test) {
-          config.test.coverage = {
-            exclude: [...coverageConfigDefaults.exclude, ...userConfig.include]
-          };
-        }
         if (viteConfig.ssr?.noExternal !== true) {
           const inline = testConfig.server?.deps?.inline;
           if (inline === true) {
@@ -12504,13 +13342,11 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
   async function _keypressHandler(str, key) {
     if (str === "" || str === "\x1B" || key && key.ctrl && key.name === "c") {
       if (!ctx.isCancelling) {
-        ctx.logger.logUpdate.clear();
         ctx.logger.log(
           c.red("Cancelling test run. Press CTRL+c again to exit forcefully.\n")
         );
         process.exitCode = 130;
         await ctx.cancelCurrentRun("keyboard-input");
-        await ctx.runningPromise;
       }
       return ctx.exit(true);
     }
@@ -12809,7 +13645,7 @@ function formatCollectedAsJSON(files) {
   const results = [];
   files.forEach((file) => {
     for (const test of file.children.allTests()) {
-      if (test.skipped()) {
+      if (test.result().state === "skipped") {
         continue;
       }
       const result = {
@@ -12831,7 +13667,7 @@ function formatCollectedAsString(testModules) {
   const results = [];
   testModules.forEach((testModule) => {
     for (const test of testModule.children.allTests()) {
-      if (test.skipped()) {
+      if (test.result().state === "skipped") {
         continue;
       }
       const fullName = `${test.module.task.name} > ${test.fullName}`;
@@ -12870,4 +13706,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, registerConsoleShortcuts as d, createViteLogger as e, cliApi as f, resolveFsAllow as r, startVitest as s };
+export { FilesNotFoundError as F, GitNotFoundError as G, TestModule as T, Vitest as V, VitestPlugin as a, VitestPackageInstaller as b, createVitest as c, registerConsoleShortcuts as d, createViteLogger as e, cliApi as f, resolveFsAllow as r, startVitest as s };