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

package/dist/chunks/{cli-api.CB-jIbYQ.js → cli-api.CETCDGgZ.js}

@@ -1,19 +1,18 @@
 import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { createFileTask, limitConcurrency, getTasks, hasFailed, getTests, getNames } from '@vitest/runner/utils';
 import { normalize, relative, dirname, resolve, join, basename, isAbsolute } from 'pathe';
-import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.BoMDb1ip.js';
+import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.BWeNbfBa.js';
 import a, { resolve as resolve$1 } from 'node:path';
 import { noop, isPrimitive, toArray, deepMerge, nanoid, slash, notNullish, createDefer } from '@vitest/utils';
 import { f as findUp, p as prompt } from './index.BJDntFik.js';
 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 { SnapshotManager } from '@vitest/snapshot/manager';
-import { i as isPackageExists, e as requireMicromatch, V as VitestCache, f as configDefaults, g as getFilePoolName, h as isBrowserEnabled, m as mm, b as resolveConfig, w as wildcardPatternToRegExp, j as createPool, a as resolveApiServerConfig, c as coverageConfigDefaults, s as stdout } from './resolveConfig.CLnvCvEs.js';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.Cs06pOqp.js';
+import { v as version$1 } from './cac.Xzv7eNWw.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.bzFpKeaq.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.9ZEBV_TJ.js';
 import require$$0$2 from 'stream';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
@@ -27,10 +26,11 @@ 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.BA-_OKEx.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
 import c from 'tinyrainbow';
-import { h as hash, i as isWindows } from './RandomSequencer.BPedXEug.js';
+import { h as hash, i as isWindows } from './RandomSequencer.gisBJ77r.js';
 import { isCI } from 'std-env';
 import { rm } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
@@ -4931,7 +4931,7 @@ function setup(ctx, _server) {
           await ctx.rerunTask(id);
         },
         getConfig() {
-          return ctx.getRootTestProject().serializedConfig;
+          return ctx.getRootProject().serializedConfig;
         },
         async getTransformResult(projectName, id, browser = false) {
           const project = ctx.getProjectByName(projectName);
@@ -4957,7 +4957,7 @@ function setup(ctx, _server) {
           return ctx.state.getUnhandledErrors();
         },
         async getTestFiles() {
-          const spec = await ctx.globTestSpecs();
+          const spec = await ctx.globTestSpecifications();
           return spec.map((spec2) => [
             {
               name: spec2.project.config.name,
@@ -5019,15 +5019,18 @@ class WebSocketReporter {
       return;
     }
     packs.forEach(([taskId, result]) => {
-      const project = this.ctx.getProjectByTaskId(taskId);
       const task = this.ctx.state.idMap.get(taskId);
       const isBrowser = task && task.file.pool === "browser";
       result?.errors?.forEach((error) => {
         if (isPrimitive(error)) {
           return;
         }
-        const stacks = isBrowser ? project.browser?.parseErrorStacktrace(error) : parseErrorStacktrace(error);
-        error.stacks = stacks;
+        if (isBrowser) {
+          const project = this.ctx.getProjectByName(task.file.projectName || "");
+          error.stacks = project.browser?.parseErrorStacktrace(error);
+        } else {
+          error.stacks = parseErrorStacktrace(error);
+        }
       });
     });
     this.clients.forEach((client) => {
@@ -5069,6 +5072,24 @@ class GitNotFoundError extends Error {
     super("Could not find Git root. Have you initialized git with `git init`?");
   }
 }
+class LocationFilterFileNotFoundError extends Error {
+  code = "VITEST_LOCATION_FILTER_FILE_NOT_FOUND";
+  constructor(filename) {
+    super(`Couldn't find file ${filename}. Note when specifying the test location you have to specify the full test filename.`);
+  }
+}
+class IncludeTaskLocationDisabledError extends Error {
+  code = "VITEST_INCLUDE_TASK_LOCATION_DISABLED";
+  constructor() {
+    super("Recieved line number filters while `includeTaskLocation` option is disabled");
+  }
+}
+class RangeLocationFilterProvidedError extends Error {
+  code = "VITEST_RANGE_LOCATION_FILTER_PROVIDED";
+  constructor(filter) {
+    super(`Found "-" in location filter ${filter}.  Note that range location filters are not supported.  Consider specifying the exact line numbers of your tests.`);
+  }
+}
 
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 class VitestPackageInstaller {
@@ -5111,7 +5132,7 @@ class VitestPackageInstaller {
     });
     if (install) {
       const packageName = version ? `${dependency}@${version}` : dependency;
-      await (await import('./index.CqYx2Nsr.js')).installPackage(packageName, { dev: true });
+      await (await import('./index.DQboAxJm.js')).installPackage(packageName, { dev: true });
       process.stderr.write(
         c.yellow(
           `
@@ -8703,7 +8724,7 @@ function requireJsTokens () {
 	// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
 	// License: MIT.
 	var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
-	RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]|[^\/\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
+	RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
 	Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
 	Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
 	StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
@@ -9461,8 +9482,8 @@ function WorkspaceVitestPlugin(project, options) {
             middlewareMode: true,
             fs: {
               allow: resolveFsAllow(
-                project.ctx.config.root,
-                project.ctx.server.config.configFile
+                project.vitest.config.root,
+                project.vitest.server.config.configFile
               )
             }
           },
@@ -9540,17 +9561,31 @@ class TestSpecification {
    * @deprecated use `pool` instead
    */
   2;
+  /**
+   * The test project that the module belongs to.
+   */
   project;
+  /**
+   * The ID of the module in the Vite module graph. It is usually an absolute file path.
+   */
   moduleId;
+  /**
+   * The current test pool. It's possible to have multiple pools in a single test project with `poolMatchGlob` and `typecheck.enabled`.
+   * @experimental In Vitest 4, the project will only support a single pool and this property will be removed.
+   */
   pool;
-  // public readonly location: WorkspaceSpecLocation | undefined
-  constructor(project, moduleId, pool) {
+  /**
+   * Line numbers of the test locations to run.
+   */
+  testLines;
+  constructor(project, moduleId, pool, testLines) {
     this[0] = project;
     this[1] = moduleId;
     this[2] = { pool };
     this.project = project;
     this.moduleId = moduleId;
     this.pool = pool;
+    this.testLines = testLines;
   }
   toJSON() {
     return [
@@ -9559,7 +9594,7 @@ class TestSpecification {
         root: this.project.config.root
       },
       this.moduleId,
-      { pool: this.pool }
+      { pool: this.pool, testLines: this.testLines }
     ];
   }
   /**
@@ -9613,9 +9648,11 @@ class TestProject {
    * Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
    */
   tmpDir = join(tmpdir(), nanoid());
+  /** @internal */
   vitenode;
-  runner;
+  /** @internal */
   typechecker;
+  runner;
   closingPromise;
   testFilesList = null;
   typecheckFilesList = null;
@@ -9623,10 +9660,12 @@ class TestProject {
   _provided = {};
   _config;
   _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
   /**
    * Provide a value to the test context. This value will be available to all tests with `inject`.
    */
-  provide(key, value) {
+  provide = (key, value) => {
     try {
       structuredClone(value);
     } catch (err) {
@@ -9638,7 +9677,7 @@ class TestProject {
       );
     }
     this._provided[key] = value;
-  }
+  };
   /**
    * Get the provided context. The project context is merged with the global context.
    */
@@ -9647,7 +9686,7 @@ class TestProject {
       return this._provided;
     }
     return {
-      ...this.vitest.getRootTestProject().getProvidedContext(),
+      ...this.vitest.getRootProject().getProvidedContext(),
       ...this._provided
     };
   }
@@ -9655,11 +9694,12 @@ class TestProject {
    * Creates a new test specification. Specifications describe how to run tests.
    * @param moduleId The file path
    */
-  createSpecification(moduleId, pool) {
+  createSpecification(moduleId, locations, pool) {
     return new TestSpecification(
       this,
       moduleId,
-      pool || getFilePoolName(this, moduleId)
+      pool || getFilePoolName(this, moduleId),
+      locations
     );
   }
   toJSON() {
@@ -9707,7 +9747,7 @@ class TestProject {
    * Check if this is the root project. The root project is the one that has the root config.
    */
   isRootProject() {
-    return this.vitest.getRootTestProject() === this;
+    return this.vitest.getRootProject() === this;
   }
   /** @deprecated use `isRootProject` instead */
   isCore() {
@@ -9731,11 +9771,7 @@ class TestProject {
       this.config.globalSetup
     );
     for (const globalSetupFile of this._globalSetups) {
-      const teardown = await globalSetupFile.setup?.({
-        provide: (key, value) => this.provide(key, value),
-        config: this.config,
-        onTestsRerun: (cb) => this.vitest.onTestsRerun(cb)
-      });
+      const teardown = await globalSetupFile.setup?.(this);
       if (teardown == null || !!globalSetupFile.teardown) {
         continue;
       }
@@ -9747,6 +9783,9 @@ class TestProject {
       globalSetupFile.teardown = teardown;
     }
   }
+  onTestsRerun(cb) {
+    this.vitest.onTestsRerun(cb);
+  }
   /** @deprecated */
   teardownGlobalSetup() {
     return this._teardownGlobalSetup();
@@ -9835,22 +9874,21 @@ class TestProject {
   isBrowserEnabled() {
     return isBrowserEnabled(this.config);
   }
-  /** @internal */
-  _markTestFile(testPath) {
+  markTestFile(testPath) {
     this.testFilesList?.push(testPath);
   }
   /**
    * Returns if the file is a test file. Requires `.globTestFiles()` to be called first.
    * @internal
    */
-  isTestFile(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
    */
-  isTypecheckFile(testPath) {
+  isCachedTypecheckFile(testPath) {
     return !!this.typecheckFilesList && this.typecheckFilesList.includes(testPath);
   }
   /** @deprecated use `serializedConfig` instead */
@@ -9868,25 +9906,32 @@ class TestProject {
     return files.map((file) => slash(a.resolve(cwd, file)));
   }
   /**
-   * Test if a file matches the test globs. This does the actual glob matching unlike `isTestFile`.
+   * Test if a file matches the test globs. This does the actual glob matching if the test is not cached, unlike `isCachedTestFile`.
    */
-  matchesTestGlob(filepath, source) {
-    const relativeId = relative(this.config.dir || this.config.root, filepath);
+  matchesTestGlob(moduleId, source) {
+    if (this.isCachedTestFile(moduleId)) {
+      return true;
+    }
+    const relativeId = relative(this.config.dir || this.config.root, moduleId);
     if (mm.isMatch(relativeId, this.config.exclude)) {
       return false;
     }
     if (mm.isMatch(relativeId, this.config.include)) {
+      this.markTestFile(moduleId);
       return true;
     }
     if (this.config.includeSource?.length && mm.isMatch(relativeId, this.config.includeSource)) {
-      const code = source || readFileSync(filepath, "utf-8");
-      return this.isInSourceTestCode(code);
+      const code = source?.() || readFileSync(moduleId, "utf-8");
+      if (this.isInSourceTestCode(code)) {
+        this.markTestFile(moduleId);
+        return true;
+      }
     }
     return false;
   }
   /** @deprecated use `matchesTestGlob` instead */
   async isTargetFile(id, source) {
-    return this.matchesTestGlob(id, source);
+    return this.matchesTestGlob(id, source ? () => source : void 0);
   }
   isInSourceTestCode(code) {
     return code.includes("import.meta.vitest");
@@ -9956,6 +10001,13 @@ class TestProject {
     }
     return this.closingPromise;
   }
+  /**
+   * Import a file using Vite module runner.
+   * @param moduleId The ID of the module in Vite module graph
+   */
+  import(moduleId) {
+    return this.runner.executeId(moduleId);
+  }
   /** @deprecated use `name` instead */
   getName() {
     return this.config.name || "";
@@ -10053,18 +10105,15 @@ class TestProject {
 }
 async function initializeProject(workspacePath, ctx, options) {
   const project = new TestProject(workspacePath, ctx, options);
-  const { extends: extendsConfig, workspaceConfigPath, ...restOptions } = options;
-  const root = options.root || (typeof workspacePath === "number" ? void 0 : workspacePath.endsWith("/") ? workspacePath : dirname(workspacePath));
-  const configFile = extendsConfig ? resolve(dirname(workspaceConfigPath), extendsConfig) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
+  const { extends: extendsConfig, configFile, ...restOptions } = options;
   const config = {
     ...restOptions,
-    root,
     configFile,
     // this will make "mode": "test" | "benchmark" inside defineConfig
     mode: options.test?.mode || options.mode || ctx.config.mode,
     plugins: [
       ...options.plugins || [],
-      WorkspaceVitestPlugin(project, { ...options, root, workspacePath })
+      WorkspaceVitestPlugin(project, { ...options, workspacePath })
     ]
   };
   await createViteServer(config);
@@ -10137,6 +10186,192 @@ function createBenchmarkReporters(reporterReferences, runner) {
   return Promise.all(promisedReporters);
 }
 
+function parseFilter(filter) {
+  const colonIndex = filter.lastIndexOf(":");
+  if (colonIndex === -1) {
+    return { filename: filter };
+  }
+  const [parsedFilename, lineNumber] = [
+    filter.substring(0, colonIndex),
+    filter.substring(colonIndex + 1)
+  ];
+  if (lineNumber.match(/^\d+$/)) {
+    return {
+      filename: parsedFilename,
+      lineNumber: Number.parseInt(lineNumber)
+    };
+  } else if (lineNumber.match(/^\d+-\d+$/)) {
+    throw new RangeLocationFilterProvidedError(filter);
+  } else {
+    return { filename: filter };
+  }
+}
+function groupFilters(filters) {
+  const groupedFilters_ = groupBy(filters, (f) => f.filename);
+  const groupedFilters = Object.fromEntries(
+    Object.entries(groupedFilters_).map((entry) => {
+      const [filename, filters2] = entry;
+      const testLocations = filters2.map((f) => f.lineNumber);
+      return [
+        filename,
+        testLocations.filter((l) => l !== void 0)
+      ];
+    })
+  );
+  return groupedFilters;
+}
+
+class VitestSpecifications {
+  constructor(vitest) {
+    this.vitest = vitest;
+  }
+  _cachedSpecs = /* @__PURE__ */ new Map();
+  getModuleSpecifications(moduleId) {
+    const _cached = this.getCachedSpecifications(moduleId);
+    if (_cached) {
+      return _cached;
+    }
+    const specs = [];
+    for (const project of this.vitest.projects) {
+      if (project.isCachedTestFile(moduleId)) {
+        specs.push(project.createSpecification(moduleId));
+      }
+      if (project.isCachedTypecheckFile(moduleId)) {
+        specs.push(project.createSpecification(moduleId, [], "typescript"));
+      }
+    }
+    specs.forEach((spec) => this.ensureSpecificationCached(spec));
+    return specs;
+  }
+  async getRelevantTestSpecifications(filters = []) {
+    return this.filterTestsBySource(
+      await this.globTestSpecifications(filters)
+    );
+  }
+  async globTestSpecifications(filters = []) {
+    const files = [];
+    const dir = process.cwd();
+    const parsedFilters = filters.map((f) => parseFilter(f));
+    if (!this.vitest.config.includeTaskLocation && parsedFilters.some((f) => f.lineNumber !== void 0)) {
+      throw new IncludeTaskLocationDisabledError();
+    }
+    const testLines = groupFilters(parsedFilters.map(
+      (f) => ({ ...f, filename: resolve(dir, f.filename) })
+    ));
+    const testLocHasMatch = {};
+    await Promise.all(this.vitest.projects.map(async (project) => {
+      const { testFiles, typecheckTestFiles } = await project.globTestFiles(
+        parsedFilters.map((f) => f.filename)
+      );
+      testFiles.forEach((file) => {
+        const lines = testLines[file];
+        testLocHasMatch[file] = true;
+        const spec = project.createSpecification(file, lines);
+        this.ensureSpecificationCached(spec);
+        files.push(spec);
+      });
+      typecheckTestFiles.forEach((file) => {
+        const lines = testLines[file];
+        testLocHasMatch[file] = true;
+        const spec = project.createSpecification(file, lines, "typescript");
+        this.ensureSpecificationCached(spec);
+        files.push(spec);
+      });
+    }));
+    Object.entries(testLines).forEach(([filepath, loc]) => {
+      if (loc.length !== 0 && !testLocHasMatch[filepath]) {
+        throw new LocationFilterFileNotFoundError(
+          relative(dir, filepath)
+        );
+      }
+    });
+    return files;
+  }
+  clearCache(moduleId) {
+    if (moduleId) {
+      this._cachedSpecs.delete(moduleId);
+    } else {
+      this._cachedSpecs.clear();
+    }
+  }
+  getCachedSpecifications(moduleId) {
+    return this._cachedSpecs.get(moduleId);
+  }
+  ensureSpecificationCached(spec) {
+    const file = spec.moduleId;
+    const specs = this._cachedSpecs.get(file) || [];
+    const index = specs.findIndex((_s) => _s.project === spec.project && _s.pool === spec.pool);
+    if (index === -1) {
+      specs.push(spec);
+      this._cachedSpecs.set(file, specs);
+    } else {
+      specs.splice(index, 1, spec);
+    }
+    return specs;
+  }
+  async filterTestsBySource(specs) {
+    if (this.vitest.config.changed && !this.vitest.config.related) {
+      const { VitestGit } = await import('./git.B5SDxu-n.js');
+      const vitestGit = new VitestGit(this.vitest.config.root);
+      const related2 = await vitestGit.findChangedFiles({
+        changedSince: this.vitest.config.changed
+      });
+      if (!related2) {
+        process.exitCode = 1;
+        throw new GitNotFoundError();
+      }
+      this.vitest.config.related = Array.from(new Set(related2));
+    }
+    const related = this.vitest.config.related;
+    if (!related) {
+      return specs;
+    }
+    const forceRerunTriggers = this.vitest.config.forceRerunTriggers;
+    if (forceRerunTriggers.length && mm(related, forceRerunTriggers).length) {
+      return specs;
+    }
+    if (!this.vitest.config.watch && !related.length) {
+      return [];
+    }
+    const testGraphs = await Promise.all(
+      specs.map(async (spec) => {
+        const deps = await this.getTestDependencies(spec);
+        return [spec, deps];
+      })
+    );
+    const runningTests = [];
+    for (const [specification, deps] of testGraphs) {
+      if (related.some((path) => path === specification.moduleId || deps.has(path))) {
+        runningTests.push(specification);
+      }
+    }
+    return runningTests;
+  }
+  async getTestDependencies(spec, deps = /* @__PURE__ */ new Set()) {
+    const addImports = async (project, filepath) => {
+      if (deps.has(filepath)) {
+        return;
+      }
+      deps.add(filepath);
+      const mod = project.vite.moduleGraph.getModuleById(filepath);
+      const transformed = mod?.ssrTransformResult || await project.vitenode.transformRequest(filepath);
+      if (!transformed) {
+        return;
+      }
+      const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
+      await Promise.all(dependencies.map(async (dep) => {
+        const fsPath = dep.startsWith("/@fs/") ? dep.slice(isWindows ? 5 : 4) : join(project.config.root, dep);
+        if (!fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) {
+          await addImports(project, fsPath);
+        }
+      }));
+    };
+    await addImports(spec.project, spec.moduleId);
+    deps.delete(spec.moduleId);
+    return deps;
+  }
+}
+
 function isAggregateError(err) {
   if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
     return true;
@@ -10318,6 +10553,144 @@ class StateManager {
   }
 }
 
+class VitestWatcher {
+  constructor(vitest) {
+    this.vitest = vitest;
+  }
+  /**
+   * Modules that will be invalidated on the next run.
+   */
+  invalidates = /* @__PURE__ */ new Set();
+  /**
+   * Test files that have changed and need to be rerun.
+   */
+  changedTests = /* @__PURE__ */ new Set();
+  _onRerun = [];
+  /**
+   * Register a handler that will be called when test files need to be rerun.
+   * The callback can receive several files in case the changed file is imported by several test files.
+   * Several invocations of this method will add multiple handlers.
+   * @internal
+   */
+  onWatcherRerun(cb) {
+    this._onRerun.push(cb);
+    return this;
+  }
+  unregisterWatcher = noop;
+  registerWatcher() {
+    const watcher = this.vitest.vite.watcher;
+    if (this.vitest.config.forceRerunTriggers.length) {
+      watcher.add(this.vitest.config.forceRerunTriggers);
+    }
+    watcher.on("change", this.onChange);
+    watcher.on("unlink", this.onUnlink);
+    watcher.on("add", this.onAdd);
+    this.unregisterWatcher = () => {
+      watcher.off("change", this.onChange);
+      watcher.off("unlink", this.onUnlink);
+      watcher.off("add", this.onAdd);
+      this.unregisterWatcher = noop;
+    };
+    return this;
+  }
+  scheduleRerun(file) {
+    this._onRerun.forEach((cb) => cb(file));
+  }
+  onChange = (id) => {
+    id = slash(id);
+    this.vitest.logger.clearHighlightCache(id);
+    this.vitest.invalidateFile(id);
+    const needsRerun = this.handleFileChanged(id);
+    if (needsRerun) {
+      this.scheduleRerun(id);
+    }
+  };
+  onUnlink = (id) => {
+    id = slash(id);
+    this.vitest.logger.clearHighlightCache(id);
+    this.invalidates.add(id);
+    if (this.vitest.state.filesMap.has(id)) {
+      this.vitest.state.filesMap.delete(id);
+      this.vitest.cache.results.removeFromCache(id);
+      this.vitest.cache.stats.removeStats(id);
+      this.changedTests.delete(id);
+      this.vitest.report("onTestRemoved", id);
+    }
+  };
+  onAdd = (id) => {
+    id = slash(id);
+    this.vitest.invalidateFile(id);
+    let fileContent;
+    const matchingProjects = [];
+    this.vitest.projects.forEach((project) => {
+      if (project.matchesTestGlob(id, () => fileContent ??= readFileSync(id, "utf-8"))) {
+        matchingProjects.push(project);
+      }
+    });
+    if (matchingProjects.length > 0) {
+      this.changedTests.add(id);
+      this.scheduleRerun(id);
+    } else {
+      const needsRerun = this.handleFileChanged(id);
+      if (needsRerun) {
+        this.scheduleRerun(id);
+      }
+    }
+  };
+  /**
+   * @returns A value indicating whether rerun is needed (changedTests was mutated)
+   */
+  handleFileChanged(filepath) {
+    if (this.changedTests.has(filepath) || this.invalidates.has(filepath)) {
+      return false;
+    }
+    if (mm.isMatch(filepath, this.vitest.config.forceRerunTriggers)) {
+      this.vitest.state.getFilepaths().forEach((file) => this.changedTests.add(file));
+      return true;
+    }
+    const projects = this.vitest.projects.filter((project) => {
+      const moduleGraph = project.browser?.vite.moduleGraph || project.vite.moduleGraph;
+      return moduleGraph.getModulesByFile(filepath)?.size;
+    });
+    if (!projects.length) {
+      if (this.vitest.state.filesMap.has(filepath) || this.vitest.projects.some((project) => project.isCachedTestFile(filepath))) {
+        this.changedTests.add(filepath);
+        return true;
+      }
+      return false;
+    }
+    const files = [];
+    for (const project of projects) {
+      const mods = project.browser?.vite.moduleGraph.getModulesByFile(filepath) || project.vite.moduleGraph.getModulesByFile(filepath);
+      if (!mods || !mods.size) {
+        continue;
+      }
+      this.invalidates.add(filepath);
+      if (this.vitest.state.filesMap.has(filepath) || project.isCachedTestFile(filepath)) {
+        this.changedTests.add(filepath);
+        files.push(filepath);
+        continue;
+      }
+      let rerun = false;
+      for (const mod of mods) {
+        mod.importers.forEach((i) => {
+          if (!i.file) {
+            return;
+          }
+          const needsRerun = this.handleFileChanged(i.file);
+          if (needsRerun) {
+            rerun = true;
+          }
+        });
+      }
+      if (rerun) {
+        files.push(filepath);
+      }
+    }
+    return !!files.length;
+  }
+}
+
 const ESCAPE_SYMBOL = "\\";
 const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
 const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*\]/;
@@ -10387,35 +10760,41 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
   const projectPromises = [];
   const fileProjects = [...configFiles, ...nonConfigDirectories];
   const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
-  for (const filepath of fileProjects) {
-    if (vitest.server.config.configFile === filepath) {
-      projectPromises.push(concurrent(() => vitest._createCoreProject()));
+  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 root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
+    projectPromises.push(concurrent(() => initializeProject(
+      index,
+      vitest,
+      mergeConfig(rootOptions, { ...options, root, configFile })
+    )));
+  });
+  for (const path of fileProjects) {
+    if (vitest.vite.config.configFile === path) {
+      projectPromises.push(Promise.resolve(vitest._ensureRootProject()));
       continue;
     }
+    const configFile = path.endsWith("/") ? false : path;
+    const root = path.endsWith("/") ? path : dirname(path);
     projectPromises.push(
       concurrent(() => initializeProject(
-        filepath,
+        path,
         vitest,
-        { workspaceConfigPath, test: cliOverrides }
+        { root, configFile, test: cliOverrides }
       ))
     );
   }
-  projectConfigs.forEach((options, index) => {
-    projectPromises.push(concurrent(() => initializeProject(
-      index,
-      vitest,
-      mergeConfig(options, { workspaceConfigPath, test: cliOverrides })
-    )));
-  });
   if (!projectPromises.length) {
-    return [await vitest._createCoreProject()];
+    return [vitest._ensureRootProject()];
   }
   const resolvedProjects = await Promise.all(projectPromises);
   const names = /* @__PURE__ */ new Set();
   for (const project of resolvedProjects) {
-    const name = project.getName();
+    const name = project.name;
     if (names.has(name)) {
-      const duplicate = resolvedProjects.find((p) => p.getName() === name && p !== project);
+      const duplicate = resolvedProjects.find((p) => p.name === name && p !== project);
       const filesError = fileProjects.length ? [
         "\n\nYour config matched these files:\n",
         fileProjects.map((p) => ` - ${relative(vitest.config.root, p)}`).join("\n"),
@@ -10439,14 +10818,15 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceD
   const workspaceConfigFiles = [];
   const workspaceGlobMatches = [];
   const nonConfigProjectDirectories = [];
-  const relativeWorkpaceConfigPath = relative(vitest.config.root, workspaceConfigPath);
   for (const definition of workspaceDefinition) {
     if (typeof definition === "string") {
       const stringOption = definition.replace("<rootDir>", vitest.config.root);
       if (!isDynamicPattern(stringOption)) {
         const file = resolve(vitest.config.root, stringOption);
         if (!existsSync(file)) {
-          throw new Error(`Workspace config file "${relativeWorkpaceConfigPath}" references a non-existing file or a directory: ${file}`);
+          const relativeWorkpaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
+          const note = workspaceConfigPath ? `Workspace config file "${relativeWorkpaceConfigPath}"` : "Inline workspace";
+          throw new Error(`${note} references a non-existing file or a directory: ${file}`);
         }
         const stats = await promises.stat(file);
         if (stats.isFile()) {
@@ -10467,8 +10847,8 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceD
       }
     } else if (typeof definition === "function") {
       projectsOptions.push(await definition({
-        command: vitest.server.config.command,
-        mode: vitest.server.config.mode,
+        command: vitest.vite.config.command,
+        mode: vitest.vite.config.mode,
         isPreview: false,
         isSsrBuild: false
       }));
@@ -10494,16 +10874,16 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceD
       ]
     };
     const workspacesFs = await fg.glob(workspaceGlobMatches, globOptions);
-    await Promise.all(workspacesFs.map(async (filepath) => {
-      if (filepath.endsWith("/")) {
-        const configFile = await resolveDirectoryConfig(filepath);
+    await Promise.all(workspacesFs.map(async (path) => {
+      if (path.endsWith("/")) {
+        const configFile = await resolveDirectoryConfig(path);
         if (configFile) {
           workspaceConfigFiles.push(configFile);
         } else {
-          nonConfigProjectDirectories.push(filepath);
+          nonConfigProjectDirectories.push(path);
         }
       } else {
-        workspaceConfigFiles.push(filepath);
+        workspaceConfigFiles.push(path);
       }
     }));
   }
@@ -10529,49 +10909,141 @@ class Vitest {
     this.mode = mode;
     this.logger = new Logger(this, options.stdout, options.stderr);
     this.packageInstaller = options.packageInstaller || new VitestPackageInstaller();
+    this.specifications = new VitestSpecifications(this);
+    this.watcher = new VitestWatcher(this).onWatcherRerun(
+      (file) => this.scheduleRerun([file])
+      // TODO: error handling
+    );
   }
+  /**
+   * Current Vitest version.
+   * @example '2.0.0'
+   */
   version = version$1;
-  config = void 0;
-  configOverride = {};
-  server = void 0;
-  state = void 0;
-  snapshot = void 0;
-  cache = void 0;
-  reporters = void 0;
-  coverageProvider;
+  static version = version$1;
+  /**
+   * The logger instance used to log messages. It's recommended to use this logger instead of `console`.
+   * It's possible to override stdout and stderr streams when initiating Vitest.
+   * @example
+   * new Vitest('test', {
+   *   stdout: new Writable(),
+   * })
+   */
   logger;
-  pool;
-  vitenode = void 0;
-  invalidates = /* @__PURE__ */ new Set();
-  changedTests = /* @__PURE__ */ new Set();
-  watchedTests = /* @__PURE__ */ new Set();
-  filenamePattern;
-  runningPromise;
-  closingPromise;
-  isCancelling = false;
-  isFirstRun = true;
-  restartsCount = 0;
-  runner = void 0;
+  /**
+   * The package installer instance used to install Vitest packages.
+   * @example
+   * await vitest.packageInstaller.ensureInstalled('@vitest/browser', process.cwd())
+   */
   packageInstaller;
+  /**
+   * A path to the built Vitest directory. This is usually a folder in `node_modules`.
+   */
+  distPath = distDir;
+  /**
+   * A list of projects that are currently running.
+   * If projects were filtered with `--project` flag, they won't appear here.
+   */
+  projects = [];
+  /** @internal */
+  configOverride = {};
+  /** @internal */
+  coverageProvider;
+  /** @internal */
+  filenamePattern;
+  /** @internal */
+  runningPromise;
+  /** @internal */
+  closingPromise;
+  /** @internal */
+  isCancelling = false;
   /** @internal */
   coreWorkspaceProject;
-  /** @private */
+  /** @internal */
   resolvedProjects = [];
-  projects = [];
-  distPath = distDir;
-  _cachedSpecs = /* @__PURE__ */ new Map();
-  _workspaceConfigPath;
-  /** @deprecated use `_cachedSpecs` */
-  projectTestFiles = this._cachedSpecs;
-  /** @private */
+  /** @internal */
   _browserLastPort = defaultBrowserPort;
+  /** @internal */
+  _options = {};
+  /** @internal */
+  reporters = void 0;
+  /** @internal */
+  vitenode = void 0;
+  /** @internal */
+  runner = void 0;
+  isFirstRun = true;
+  restartsCount = 0;
+  specifications;
+  watcher;
+  pool;
+  _config;
+  _vite;
+  _state;
+  _cache;
+  _snapshot;
+  _workspaceConfigPath;
   _onRestartListeners = [];
   _onClose = [];
   _onSetServer = [];
   _onCancelListeners = [];
   _onUserTestsRerun = [];
-  async setServer(options, server, cliOptions) {
-    this.unregisterWatcher?.();
+  _onFilterWatchedSpecification = [];
+  /** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
+  get invalidates() {
+    return this.watcher.invalidates;
+  }
+  /** @deprecated will be removed in 4.0, use `onFilterWatchedSpecification` instead */
+  get changedTests() {
+    return this.watcher.changedTests;
+  }
+  /**
+   * The global config.
+   */
+  get config() {
+    assert(this._config, "config");
+    return this._config;
+  }
+  /** @deprecated use `vitest.vite` instead */
+  get server() {
+    return this._vite;
+  }
+  /**
+   * Global Vite's dev server instance.
+   */
+  get vite() {
+    assert(this._vite, "vite", "server");
+    return this._vite;
+  }
+  /**
+   * The global test state manager.
+   * @experimental The State API is experimental and not subject to semver.
+   */
+  get state() {
+    assert(this._state, "state");
+    return this._state;
+  }
+  /**
+   * The global snapshot manager. You can access the current state on `snapshot.summary`.
+   */
+  get snapshot() {
+    assert(this._snapshot, "snapshot", "snapshot manager");
+    return this._snapshot;
+  }
+  /**
+   * Test results and test file stats cache. Primarily used by the sequencer to sort tests.
+   */
+  get cache() {
+    assert(this._cache, "cache");
+    return this._cache;
+  }
+  /** @deprecated internal */
+  setServer(options, server, cliOptions) {
+    return this._setServer(options, server, cliOptions);
+  }
+  /** @internal */
+  async _setServer(options, server, cliOptions) {
+    this._options = options;
+    this.watcher.unregisterWatcher();
     clearTimeout(this._rerunTimer);
     this.restartsCount += 1;
     this._browserLastPort = defaultBrowserPort;
@@ -10583,16 +11055,16 @@ class Vitest {
     this._workspaceConfigPath = void 0;
     this.coverageProvider = void 0;
     this.runningPromise = void 0;
-    this._cachedSpecs.clear();
+    this.specifications.clearCache();
     this._onUserTestsRerun = [];
     const resolved = resolveConfig(this.mode, options, server.config, this.logger);
-    this.server = server;
-    this.config = resolved;
-    this.state = new StateManager();
-    this.cache = new VitestCache(this.version);
-    this.snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
+    this._vite = server;
+    this._config = resolved;
+    this._state = new StateManager();
+    this._cache = new VitestCache(this.version);
+    this._snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
     if (this.config.watch) {
-      this.registerWatcher();
+      this.watcher.registerWatcher();
     }
     this.vitenode = new ViteNodeServer(server, this.config.server);
     const node = this.vitenode;
@@ -10616,7 +11088,7 @@ class Vitest {
       };
       server.watcher.on("change", async (file) => {
         file = normalize(file);
-        const isConfig = file === server.config.configFile || this.resolvedProjects.some((p) => p.server.config.configFile === file) || file === this._workspaceConfigPath;
+        const isConfig = file === server.config.configFile || this.resolvedProjects.some((p) => p.vite.config.configFile === file) || file === this._workspaceConfigPath;
         if (isConfig) {
           await Promise.all(this._onRestartListeners.map((fn) => fn("config")));
           this.report("onServerRestart", "config");
@@ -10625,7 +11097,6 @@ class Vitest {
         }
       });
     }
-    this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
     this.cache.results.setConfig(resolved.root, resolved.cache);
     try {
       await this.cache.results.readFromCache();
@@ -10637,8 +11108,11 @@ class Vitest {
     const filters = toArray(resolved.project).map((s) => wildcardPatternToRegExp(s));
     if (filters.length > 0) {
       this.projects = this.projects.filter(
-        (p) => filters.some((pattern) => pattern.test(p.getName()))
+        (p) => filters.some((pattern) => pattern.test(p.name))
       );
+      if (!this.projects.length) {
+        throw new Error(`No projects matched the filter "${toArray(resolved.project).join('", "')}".`);
+      }
     }
     if (!this.coreWorkspaceProject) {
       this.coreWorkspaceProject = TestProject._createBasicProject(this);
@@ -10646,19 +11120,37 @@ class Vitest {
     if (this.config.testNamePattern) {
       this.configOverride.testNamePattern = this.config.testNamePattern;
     }
+    this.reporters = resolved.mode === "benchmark" ? await createBenchmarkReporters(toArray(resolved.benchmark?.reporters), this.runner) : await createReporters(resolved.reporters, this);
     await Promise.all(this._onSetServer.map((fn) => fn()));
   }
-  provide(key, value) {
-    this.getRootTestProject().provide(key, value);
-  }
   /**
-   * @internal
+   * Provide a value to the test context. This value will be available to all tests with `inject`.
    */
-  _createCoreProject() {
+  provide = (key, value) => {
+    this.getRootProject().provide(key, value);
+  };
+  /**
+   * Get global provided context.
+   */
+  getProvidedContext() {
+    return this.getRootProject().getProvidedContext();
+  }
+  /** @internal */
+  _ensureRootProject() {
+    if (this.coreWorkspaceProject) {
+      return this.coreWorkspaceProject;
+    }
     this.coreWorkspaceProject = TestProject._createBasicProject(this);
     return this.coreWorkspaceProject;
   }
-  getRootTestProject() {
+  /** @deprecated use `getRootProject` instead */
+  getCoreWorkspaceProject() {
+    return this.getRootProject();
+  }
+  /**
+   * Return project that has the root (or "global") config.
+   */
+  getRootProject() {
     if (!this.coreWorkspaceProject) {
       throw new Error(`Root project is not initialized. This means that the Vite server was not established yet and the the workspace config is not resolved.`);
     }
@@ -10670,16 +11162,27 @@ class Vitest {
   getProjectByTaskId(taskId) {
     const task = this.state.idMap.get(taskId);
     const projectName = task.projectName || task?.file?.projectName || "";
-    return this.projects.find((p) => p.name === projectName) || this.getRootTestProject() || this.projects[0];
+    return this.getProjectByName(projectName);
   }
-  getProjectByName(name = "") {
-    return this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
+  getProjectByName(name) {
+    const project = this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
+    if (!project) {
+      throw new Error(`Project "${name}" was not found.`);
+    }
+    return project;
   }
-  async getWorkspaceConfigPath() {
-    if (this.config.workspace) {
+  /**
+   * Import a file using Vite module runner. The file will be transformed by Vite and executed in a separate context.
+   * @param moduleId The ID of the module in Vite module graph
+   */
+  import(moduleId) {
+    return this.runner.executeId(moduleId);
+  }
+  async resolveWorkspaceConfigPath() {
+    if (typeof this.config.workspace === "string") {
       return this.config.workspace;
     }
-    const configDir = this.server.config.configFile ? dirname(this.server.config.configFile) : this.config.root;
+    const configDir = this.vite.config.configFile ? dirname(this.vite.config.configFile) : this.config.root;
     const rootFiles = await promises.readdir(configDir);
     const workspaceConfigName = workspacesFiles.find((configFile) => {
       return rootFiles.includes(configFile);
@@ -10690,12 +11193,20 @@ class Vitest {
     return join(configDir, workspaceConfigName);
   }
   async resolveWorkspace(cliOptions) {
-    const workspaceConfigPath = await this.getWorkspaceConfigPath();
+    if (Array.isArray(this.config.workspace)) {
+      return resolveWorkspace(
+        this,
+        cliOptions,
+        void 0,
+        this.config.workspace
+      );
+    }
+    const workspaceConfigPath = await this.resolveWorkspaceConfigPath();
     this._workspaceConfigPath = workspaceConfigPath;
     if (!workspaceConfigPath) {
-      return [this._createCoreProject()];
+      return [this._ensureRootProject()];
     }
-    const workspaceModule = await this.runner.executeFile(workspaceConfigPath);
+    const workspaceModule = await this.import(workspaceConfigPath);
     if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) {
       throw new TypeError(`Workspace config file "${workspaceConfigPath}" must export a default array of project paths.`);
     }
@@ -10706,6 +11217,13 @@ class Vitest {
       workspaceModule.default
     );
   }
+  /**
+   * Glob test files in every project and create a TestSpecification for each file and pool.
+   * @param filters String filters to match the test files.
+   */
+  async globTestSpecifications(filters = []) {
+    return this.specifications.globTestSpecifications(filters);
+  }
   async initCoverageProvider() {
     if (this.coverageProvider !== void 0) {
       return;
@@ -10720,16 +11238,19 @@ class Vitest {
     }
     return this.coverageProvider;
   }
-  async mergeReports() {
+  /**
+   * Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
+   */
+  async mergeReports(directory) {
     if (this.reporters.some((r) => r instanceof BlobReporter)) {
       throw new Error("Cannot merge reports when `--reporter=blob` is used. Remove blob reporter from the config first.");
     }
-    const { files, errors, coverages } = await readBlobs(this.version, this.config.mergeReports, this.projects);
+    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();
     for (const file of files) {
-      const project = this.getProjectByName(file.projectName);
+      const project = this.getProjectByName(file.projectName || "");
       const specs = workspaceSpecs.get(project) || [];
       specs.push(file);
       workspaceSpecs.set(project, specs);
@@ -10762,31 +11283,42 @@ class Vitest {
     if (hasFailed(files)) {
       process.exitCode = 1;
     }
-    this.checkUnhandledErrors(errors);
+    this._checkUnhandledErrors(errors);
     await this.report("onFinished", files, errors);
     await this.initCoverageProvider();
     await this.coverageProvider?.mergeReports?.(coverages);
+    return {
+      testModules: this.state.getTestModules(),
+      unhandledErrors: this.state.getUnhandledErrors()
+    };
   }
   async collect(filters) {
     this._onClose = [];
-    const files = await this.filterTestsBySource(
-      await this.globTestFiles(filters)
-    );
+    const files = await this.specifications.getRelevantTestSpecifications(filters);
     if (!files.length) {
-      return { tests: [], errors: [] };
+      return { testModules: [], unhandledErrors: [] };
     }
-    await this.collectFiles(files);
-    return {
-      tests: this.state.getFiles(),
-      errors: this.state.getUnhandledErrors()
-    };
+    return this.collectTests(files);
   }
-  async listFiles(filters) {
-    const files = await this.filterTestsBySource(
-      await this.globTestFiles(filters)
-    );
-    return files;
+  /** @deprecated use `getRelevantTestSpecifications` instead */
+  listFiles(filters) {
+    return this.getRelevantTestSpecifications(filters);
   }
+  /**
+   * Returns the list of test files that match the config and filters.
+   * @param filters String filters to match the test files
+   */
+  getRelevantTestSpecifications(filters) {
+    return this.specifications.getRelevantTestSpecifications(filters);
+  }
+  /**
+   * Initialize reporters, the coverage provider, and run tests.
+   * This method can throw an error:
+   *   - `FilesNotFoundError` if no tests are found
+   *   - `GitNotFoundError` if `--related` flag is used, but git repository is not initialized
+   *   - `Error` from the user reporters
+   * @param filters String filters to match the test files
+   */
   async start(filters) {
     this._onClose = [];
     try {
@@ -10795,9 +11327,8 @@ class Vitest {
     } finally {
       await this.report("onInit", this);
     }
-    const files = await this.filterTestsBySource(
-      await this.globTestFiles(filters)
-    );
+    this.filenamePattern = filters && filters?.length > 0 ? filters : void 0;
+    const files = await this.specifications.getRelevantTestSpecifications(filters);
     if (!files.length) {
       const coverage = await this.coverageProvider?.generateCoverage?.({ allTestsRun: true });
       await this.reportCoverage(coverage, true);
@@ -10808,14 +11339,23 @@ class Vitest {
         throw new FilesNotFoundError(this.mode);
       }
     }
+    let testModules = {
+      testModules: [],
+      unhandledErrors: []
+    };
     if (files.length) {
       await this.cache.stats.populateStats(this.config.root, files);
-      await this.runFiles(files, true);
+      testModules = await this.runFiles(files, true);
     }
     if (this.config.watch) {
       await this.report("onWatcherStart");
     }
+    return testModules;
   }
+  /**
+   * Initialize reporters and the coverage provider. This method doesn't run any tests.
+   * If the `--watch` flag is provided, Vitest will still run changed tests even if this method was not called.
+   */
   async init() {
     this._onClose = [];
     try {
@@ -10824,105 +11364,60 @@ class Vitest {
     } finally {
       await this.report("onInit", this);
     }
-    await this.globTestFiles();
+    await this.globTestSpecifications();
     if (this.config.watch) {
       await this.report("onWatcherStart");
     }
   }
-  async getTestDependencies(spec, deps = /* @__PURE__ */ new Set()) {
-    const addImports = async (project, filepath) => {
-      if (deps.has(filepath)) {
-        return;
-      }
-      deps.add(filepath);
-      const mod = project.vite.moduleGraph.getModuleById(filepath);
-      const transformed = mod?.ssrTransformResult || await project.vitenode.transformRequest(filepath);
-      if (!transformed) {
-        return;
-      }
-      const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
-      await Promise.all(dependencies.map(async (dep) => {
-        const path = await project.vite.pluginContainer.resolveId(dep, filepath, { ssr: true });
-        const fsPath = path && !path.external && path.id.split("?")[0];
-        if (fsPath && !fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) {
-          await addImports(project, fsPath);
-        }
-      }));
-    };
-    await addImports(spec.project, spec.moduleId);
-    deps.delete(spec.moduleId);
-    return deps;
-  }
-  async filterTestsBySource(specs) {
-    if (this.config.changed && !this.config.related) {
-      const { VitestGit } = await import('./git.B5SDxu-n.js');
-      const vitestGit = new VitestGit(this.config.root);
-      const related2 = await vitestGit.findChangedFiles({
-        changedSince: this.config.changed
-      });
-      if (!related2) {
-        process.exitCode = 1;
-        throw new GitNotFoundError();
-      }
-      this.config.related = Array.from(new Set(related2));
-    }
-    const related = this.config.related;
-    if (!related) {
-      return specs;
-    }
-    const forceRerunTriggers = this.config.forceRerunTriggers;
-    if (forceRerunTriggers.length && mm(related, forceRerunTriggers).length) {
-      return specs;
-    }
-    if (!this.config.watch && !related.length) {
-      return [];
-    }
-    const testGraphs = await Promise.all(
-      specs.map(async (spec) => {
-        const deps = await this.getTestDependencies(spec);
-        return [spec, deps];
-      })
-    );
-    const runningTests = [];
-    for (const [filepath, deps] of testGraphs) {
-      if (related.some((path) => path === filepath[1] || deps.has(path))) {
-        runningTests.push(filepath);
-      }
-    }
-    return runningTests;
-  }
   /**
-   * @deprecated remove when vscode extension supports "getFileWorkspaceSpecs"
+   * @deprecated remove when vscode extension supports "getModuleSpecifications"
    */
   getProjectsByTestFile(file) {
-    return this.getFileWorkspaceSpecs(file);
+    return this.getModuleSpecifications(file);
   }
+  /** @deprecated */
   getFileWorkspaceSpecs(file) {
-    const _cached = this._cachedSpecs.get(file);
-    if (_cached) {
-      return _cached;
-    }
-    const specs = [];
-    for (const project of this.projects) {
-      if (project.isTestFile(file)) {
-        specs.push(project.createSpecification(file));
-      }
-      if (project.isTypecheckFile(file)) {
-        specs.push(project.createSpecification(file, "typescript"));
-      }
-    }
-    specs.forEach((spec) => this.ensureSpecCached(spec));
-    return specs;
+    return this.getModuleSpecifications(file);
   }
-  async initializeGlobalSetup(paths) {
-    const projects = new Set(paths.map((spec) => spec.project));
-    const coreProject = this.getRootTestProject();
-    if (!projects.has(coreProject)) {
-      projects.add(coreProject);
-    }
-    for (const project of projects) {
-      await project._initializeGlobalSetup();
-    }
+  /**
+   * Get test specifications assosiated 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.
+   */
+  getModuleSpecifications(moduleId) {
+    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.
+   */
+  clearSpecificationsCache(moduleId) {
+    this.specifications.clearCache(moduleId);
+  }
+  /**
+   * Run tests for the given test specifications. This does not trigger `onWatcher*` events.
+   * @param specifications A list of specifications to run.
+   * @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+   */
+  runTestSpecifications(specifications, allTestsRun = false) {
+    specifications.forEach((spec) => this.specifications.ensureSpecificationCached(spec));
+    return this.runFiles(specifications, allTestsRun);
+  }
+  /**
+   * Rerun files and trigger `onWatcherRerun`, `onWatcherStart` and `onTestsRerun` events.
+   * @param specifications A list of specifications to run.
+   * @param allTestsRun Indicates whether all tests were run. This only matters for coverage.
+   */
+  async rerunTestSpecifications(specifications, allTestsRun = false) {
+    this.configOverride.testNamePattern = void 0;
+    const files = specifications.map((spec) => spec.moduleId);
+    await Promise.all([
+      this.report("onWatcherRerun", files, "rerun test"),
+      ...this._onUserTestsRerun.map((fn) => fn(specifications))
+    ]);
+    const result = await this.runTestSpecifications(specifications, allTestsRun);
+    await this.report("onWatcherStart", this.state.getFiles(files));
+    return result;
   }
   async runFiles(specs, allTestsRun) {
     const filepaths = specs.map((spec) => spec.moduleId);
@@ -10933,35 +11428,42 @@ class Vitest {
     this._onCancelListeners = [];
     this.isCancelling = false;
     this.runningPromise = (async () => {
-      if (!this.pool) {
-        this.pool = createPool(this);
-      }
-      const invalidates = Array.from(this.invalidates);
-      this.invalidates.clear();
-      this.snapshot.clear();
-      this.state.clearErrors();
-      if (!this.isFirstRun && this.config.coverage.cleanOnRerun) {
-        await this.coverageProvider?.clean();
-      }
-      await this.initializeGlobalSetup(specs);
       try {
-        await this.pool.runTests(specs, invalidates);
-      } catch (err) {
-        this.state.catchError(err, "Unhandled Error");
-      }
-      const files = this.state.getFiles();
-      if (hasFailed(files)) {
-        process.exitCode = 1;
+        if (!this.pool) {
+          this.pool = createPool(this);
+        }
+        const invalidates = Array.from(this.watcher.invalidates);
+        this.watcher.invalidates.clear();
+        this.snapshot.clear();
+        this.state.clearErrors();
+        if (!this.isFirstRun && this.config.coverage.cleanOnRerun) {
+          await this.coverageProvider?.clean();
+        }
+        await this.initializeGlobalSetup(specs);
+        try {
+          await this.pool.runTests(specs, invalidates);
+        } catch (err) {
+          this.state.catchError(err, "Unhandled Error");
+        }
+        const files = this.state.getFiles();
+        if (hasFailed(files)) {
+          process.exitCode = 1;
+        }
+        this.cache.results.updateResults(files);
+        await this.cache.results.writeToCache();
+        return {
+          testModules: this.state.getTestModules(),
+          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 });
+        this._checkUnhandledErrors(errors);
+        await this.report("onFinished", this.state.getFiles(files), errors, coverage);
+        await this.reportCoverage(coverage, allTestsRun);
       }
-      this.cache.results.updateResults(files);
-      await this.cache.results.writeToCache();
-    })().finally(async () => {
-      const files = Array.from(new Set(specs.map((spec) => spec.moduleId)));
-      const errors = this.state.getUnhandledErrors();
-      const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
-      this.checkUnhandledErrors(errors);
-      await this.report("onFinished", this.state.getFiles(files), errors, coverage);
-      await this.reportCoverage(coverage, allTestsRun);
+    })().finally(() => {
       this.runningPromise = void 0;
       this.isFirstRun = false;
       this.config.changed = false;
@@ -10969,8 +11471,12 @@ class Vitest {
     });
     return await this.runningPromise;
   }
-  async collectFiles(specs) {
-    const filepaths = specs.map((spec) => spec.moduleId);
+  /**
+   * Collect tests in specified modules. Vitest will run the files to collect tests.
+   * @param specifications A list of specifications to run.
+   */
+  async collectTests(specifications) {
+    const filepaths = specifications.map((spec) => spec.moduleId);
     this.state.collectPaths(filepaths);
     await this.runningPromise;
     this._onCancelListeners = [];
@@ -10979,13 +11485,13 @@ class Vitest {
       if (!this.pool) {
         this.pool = createPool(this);
       }
-      const invalidates = Array.from(this.invalidates);
-      this.invalidates.clear();
+      const invalidates = Array.from(this.watcher.invalidates);
+      this.watcher.invalidates.clear();
       this.snapshot.clear();
       this.state.clearErrors();
-      await this.initializeGlobalSetup(specs);
+      await this.initializeGlobalSetup(specifications);
       try {
-        await this.pool.collectTests(specs, invalidates);
+        await this.pool.collectTests(specifications, invalidates);
       } catch (err) {
         this.state.catchError(err, "Unhandled Error");
       }
@@ -10993,38 +11499,56 @@ class Vitest {
       if (hasFailed(files)) {
         process.exitCode = 1;
       }
-    })().finally(async () => {
+      return {
+        testModules: this.state.getTestModules(),
+        unhandledErrors: this.state.getUnhandledErrors()
+      };
+    })().finally(() => {
       this.runningPromise = void 0;
       this.config.changed = false;
       this.config.related = void 0;
     });
     return await this.runningPromise;
   }
+  /**
+   * Gracefully cancel the current test run. Vitest will wait until all running tests are finished before cancelling.
+   */
   async cancelCurrentRun(reason) {
     this.isCancelling = true;
     await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason)));
   }
-  async initBrowserServers() {
+  /** @internal */
+  async _initBrowserServers() {
     await Promise.all(this.projects.map((p) => p._initBrowserServer()));
   }
+  async initializeGlobalSetup(paths) {
+    const projects = new Set(paths.map((spec) => spec.project));
+    const coreProject = this.getRootProject();
+    if (!projects.has(coreProject)) {
+      projects.add(coreProject);
+    }
+    for (const project of projects) {
+      await project._initializeGlobalSetup();
+    }
+  }
+  /** @internal */
   async rerunFiles(files = this.state.getFilepaths(), trigger, allTestsRun = true, resetTestNamePattern = false) {
     if (resetTestNamePattern) {
       this.configOverride.testNamePattern = void 0;
     }
     if (this.filenamePattern) {
-      const filteredFiles = await this.globTestFiles([this.filenamePattern]);
-      files = files.filter((file) => filteredFiles.some((f) => f[1] === file));
+      const filteredFiles = await this.globTestSpecifications(this.filenamePattern);
+      files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file));
     }
+    const specifications = files.flatMap((file) => this.getModuleSpecifications(file));
     await Promise.all([
       this.report("onWatcherRerun", files, trigger),
-      ...this._onUserTestsRerun.map((fn) => fn(files))
+      ...this._onUserTestsRerun.map((fn) => fn(specifications))
     ]);
-    await this.runFiles(files.flatMap((file) => this.getProjectsByTestFile(file)), allTestsRun);
+    await this.runFiles(specifications, allTestsRun);
     await this.report("onWatcherStart", this.state.getFiles(files));
   }
-  isSuite(task) {
-    return Object.hasOwnProperty.call(task, "tasks");
-  }
+  /** @internal */
   async rerunTask(id) {
     const task = this.state.idMap.get(id);
     if (!task) {
@@ -11033,19 +11557,21 @@ class Vitest {
     await this.changeNamePattern(
       task.name,
       [task.file.filepath],
-      this.isSuite(task) ? "rerun suite" : "rerun test"
+      "tasks" in task ? "rerun suite" : "rerun test"
     );
   }
+  /** @internal */
   async changeProjectName(pattern) {
     if (pattern === "") {
       delete this.configOverride.project;
     } else {
       this.configOverride.project = pattern;
     }
-    this.projects = this.resolvedProjects.filter((p) => p.getName() === pattern);
-    const files = (await this.globTestSpecs()).map((spec) => spec.moduleId);
+    this.projects = this.resolvedProjects.filter((p) => p.name === pattern);
+    const files = (await this.globTestSpecifications()).map((spec) => spec.moduleId);
     await this.rerunFiles(files, "change project filter", pattern === "");
   }
+  /** @internal */
   async changeNamePattern(pattern, files = this.state.getFilepaths(), trigger) {
     if (pattern === "") {
       this.filenamePattern = void 0;
@@ -11063,31 +11589,68 @@ class Vitest {
     }
     await this.rerunFiles(files, trigger, pattern === "");
   }
+  /** @internal */
   async changeFilenamePattern(pattern, files = this.state.getFilepaths()) {
-    this.filenamePattern = pattern;
-    const trigger = this.filenamePattern ? "change filename pattern" : "reset filename pattern";
+    this.filenamePattern = pattern ? [pattern] : [];
+    const trigger = this.filenamePattern.length ? "change filename pattern" : "reset filename pattern";
     await this.rerunFiles(files, trigger, pattern === "");
   }
+  /** @internal */
   async rerunFailed() {
     await this.rerunFiles(this.state.getFailedFilepaths(), "rerun failed", false);
   }
+  /** @internal */
   async updateSnapshot(files) {
     files = files || [
       ...this.state.getFailedFilepaths(),
       ...this.snapshot.summary.uncheckedKeysByFile.map((s) => s.filePath)
     ];
+    this.enableSnapshotUpdate();
+    try {
+      await this.rerunFiles(files, "update snapshot", false);
+    } finally {
+      this.resetSnapshotUpdate();
+    }
+  }
+  /**
+   * Enable the mode that allows updating snapshots when running tests.
+   * This method doesn't run any tests.
+   *
+   * Every test that runs after this method is called will update snapshots.
+   * To disable the mode, call `resetSnapshotUpdate`.
+   */
+  enableSnapshotUpdate() {
     this.configOverride.snapshotOptions = {
       updateSnapshot: "all",
       // environment is resolved inside a worker thread
       snapshotEnvironment: null
     };
-    try {
-      await this.rerunFiles(files, "update snapshot", false);
-    } finally {
-      delete this.configOverride.snapshotOptions;
+  }
+  /**
+   * Disable the mode that allows updating snapshots when running tests.
+   */
+  resetSnapshotUpdate() {
+    delete this.configOverride.snapshotOptions;
+  }
+  /**
+   * Set the global test name pattern to a regexp.
+   * This method doesn't run any tests.
+   */
+  setGlobalTestNamePattern(pattern) {
+    if (pattern instanceof RegExp) {
+      this.configOverride.testNamePattern = pattern;
+    } else {
+      this.configOverride.testNamePattern = pattern ? new RegExp(pattern) : void 0;
     }
   }
+  /**
+   * Resets the global test name pattern. This method doesn't run any tests.
+   */
+  resetGlobalTestNamePattern() {
+    this.configOverride.testNamePattern = void 0;
+  }
   _rerunTimer;
+  // we can't use a single `triggerId` yet because vscode extension relies on this
   async scheduleRerun(triggerId) {
     const currentCount = this.restartsCount;
     clearTimeout(this._rerunTimer);
@@ -11097,15 +11660,8 @@ class Vitest {
       return;
     }
     this._rerunTimer = setTimeout(async () => {
-      if (this.watchedTests.size) {
-        this.changedTests.forEach((test) => {
-          if (!this.watchedTests.has(test)) {
-            this.changedTests.delete(test);
-          }
-        });
-      }
-      if (this.changedTests.size === 0) {
-        this.invalidates.clear();
+      if (this.watcher.changedTests.size === 0) {
+        this.watcher.invalidates.clear();
         return;
       }
       if (this.restartsCount !== currentCount) {
@@ -11113,161 +11669,54 @@ class Vitest {
       }
       this.isFirstRun = false;
       this.snapshot.clear();
-      let files = Array.from(this.changedTests);
+      let files = Array.from(this.watcher.changedTests);
       if (this.filenamePattern) {
-        const filteredFiles = await this.globTestFiles([this.filenamePattern]);
-        files = files.filter((file) => filteredFiles.some((f) => f[1] === file));
+        const filteredFiles = await this.globTestSpecifications(this.filenamePattern);
+        files = files.filter((file) => filteredFiles.some((f) => f.moduleId === file));
         if (files.length === 0) {
           return;
         }
       }
-      this.changedTests.clear();
+      this.watcher.changedTests.clear();
       const triggerIds = new Set(triggerId.map((id) => relative(this.config.root, id)));
       const triggerLabel = Array.from(triggerIds).join(", ");
+      const specifications = files.flatMap((file) => this.getModuleSpecifications(file)).filter((specification) => {
+        if (this._onFilterWatchedSpecification.length === 0) {
+          return true;
+        }
+        return this._onFilterWatchedSpecification.every((fn) => fn(specification));
+      });
       await Promise.all([
         this.report("onWatcherRerun", files, triggerLabel),
-        ...this._onUserTestsRerun.map((fn) => fn(files))
+        ...this._onUserTestsRerun.map((fn) => fn(specifications))
       ]);
-      await this.runFiles(files.flatMap((file) => this.getProjectsByTestFile(file)), false);
+      await this.runFiles(specifications, false);
       await this.report("onWatcherStart", this.state.getFiles(files));
     }, WATCHER_DEBOUNCE);
   }
-  getModuleProjects(filepath) {
-    return this.projects.filter((project) => {
-      return project.getModulesByFilepath(filepath).size;
-    });
-  }
   /**
-   * Watch only the specified tests. If no tests are provided, all tests will be watched.
+   * Invalidate a file in all projects.
    */
-  watchTests(tests) {
-    this.watchedTests = new Set(
-      tests.map((test) => slash(test))
-    );
-  }
-  updateLastChanged(filepath) {
-    const projects = this.getModuleProjects(filepath);
-    projects.forEach(({ server, browser }) => {
-      const serverMods = server.moduleGraph.getModulesByFile(filepath);
-      serverMods?.forEach((mod) => server.moduleGraph.invalidateModule(mod));
+  invalidateFile(filepath) {
+    this.projects.forEach(({ vite, browser }) => {
+      const serverMods = vite.moduleGraph.getModulesByFile(filepath);
+      serverMods?.forEach((mod) => vite.moduleGraph.invalidateModule(mod));
       if (browser) {
         const browserMods = browser.vite.moduleGraph.getModulesByFile(filepath);
         browserMods?.forEach((mod) => browser.vite.moduleGraph.invalidateModule(mod));
       }
     });
   }
-  onChange = (id) => {
-    id = slash(id);
-    this.logger.clearHighlightCache(id);
-    this.updateLastChanged(id);
-    const needsRerun = this.handleFileChanged(id);
-    if (needsRerun.length) {
-      this.scheduleRerun(needsRerun);
-    }
-  };
-  onUnlink = (id) => {
-    id = slash(id);
-    this.logger.clearHighlightCache(id);
-    this.invalidates.add(id);
-    if (this.state.filesMap.has(id)) {
-      this.state.filesMap.delete(id);
-      this.cache.results.removeFromCache(id);
-      this.cache.stats.removeStats(id);
-      this.changedTests.delete(id);
-      this.report("onTestRemoved", id);
-    }
-  };
-  onAdd = async (id) => {
-    id = slash(id);
-    this.updateLastChanged(id);
-    const fileContent = readFileSync(id, "utf-8");
-    const matchingProjects = [];
-    this.projects.forEach((project) => {
-      if (project.matchesTestGlob(id, fileContent)) {
-        matchingProjects.push(project);
-        project._markTestFile(id);
-      }
-    });
-    if (matchingProjects.length > 0) {
-      this.changedTests.add(id);
-      this.scheduleRerun([id]);
-    } else {
-      const needsRerun = this.handleFileChanged(id);
-      if (needsRerun.length) {
-        this.scheduleRerun(needsRerun);
-      }
-    }
-  };
-  checkUnhandledErrors(errors) {
+  /** @deprecated use `invalidateFile` */
+  updateLastChanged(filepath) {
+    this.invalidateFile(filepath);
+  }
+  /** @internal */
+  _checkUnhandledErrors(errors) {
     if (errors.length && !this.config.dangerouslyIgnoreUnhandledErrors) {
       process.exitCode = 1;
     }
   }
-  unregisterWatcher = noop;
-  registerWatcher() {
-    const watcher = this.server.watcher;
-    if (this.config.forceRerunTriggers.length) {
-      watcher.add(this.config.forceRerunTriggers);
-    }
-    watcher.on("change", this.onChange);
-    watcher.on("unlink", this.onUnlink);
-    watcher.on("add", this.onAdd);
-    this.unregisterWatcher = () => {
-      watcher.off("change", this.onChange);
-      watcher.off("unlink", this.onUnlink);
-      watcher.off("add", this.onAdd);
-      this.unregisterWatcher = noop;
-    };
-  }
-  /**
-   * @returns A value indicating whether rerun is needed (changedTests was mutated)
-   */
-  handleFileChanged(filepath) {
-    if (this.changedTests.has(filepath) || this.invalidates.has(filepath)) {
-      return [];
-    }
-    if (mm.isMatch(filepath, this.config.forceRerunTriggers)) {
-      this.state.getFilepaths().forEach((file) => this.changedTests.add(file));
-      return [filepath];
-    }
-    const projects = this.getModuleProjects(filepath);
-    if (!projects.length) {
-      if (this.state.filesMap.has(filepath) || this.projects.some((project) => project.isTestFile(filepath))) {
-        this.changedTests.add(filepath);
-        return [filepath];
-      }
-      return [];
-    }
-    const files = [];
-    for (const project of projects) {
-      const mods = project.getModulesByFilepath(filepath);
-      if (!mods.size) {
-        continue;
-      }
-      this.invalidates.add(filepath);
-      if (this.state.filesMap.has(filepath) || project.isTestFile(filepath)) {
-        this.changedTests.add(filepath);
-        files.push(filepath);
-        continue;
-      }
-      let rerun = false;
-      for (const mod of mods) {
-        mod.importers.forEach((i) => {
-          if (!i.file) {
-            return;
-          }
-          const heedsRerun = this.handleFileChanged(i.file);
-          if (heedsRerun.length) {
-            rerun = true;
-          }
-        });
-      }
-      if (rerun) {
-        files.push(filepath);
-      }
-    }
-    return Array.from(new Set(files));
-  }
   async reportCoverage(coverage, allTestsRun) {
     if (this.state.getCountOfFailedTests() > 0) {
       await this.coverageProvider?.onTestFailure?.();
@@ -11284,19 +11733,23 @@ class Vitest {
       }
     }
   }
+  /**
+   * Closes all projects and their associated resources.
+   * This can only be called once; the closing promise is cached until the server restarts.
+   */
   async close() {
     if (!this.closingPromise) {
       this.closingPromise = (async () => {
         const teardownProjects = [...this.projects];
-        if (!teardownProjects.includes(this.coreWorkspaceProject)) {
+        if (this.coreWorkspaceProject && !teardownProjects.includes(this.coreWorkspaceProject)) {
           teardownProjects.push(this.coreWorkspaceProject);
         }
         for (const project of teardownProjects.reverse()) {
           await project._teardownGlobalSetup();
         }
         const closePromises = this.resolvedProjects.map((w) => w.close());
-        if (!this.resolvedProjects.includes(this.coreWorkspaceProject)) {
-          closePromises.push(this.coreWorkspaceProject.close().then(() => this.server = void 0));
+        if (this.coreWorkspaceProject && !this.resolvedProjects.includes(this.coreWorkspaceProject)) {
+          closePromises.push(this.coreWorkspaceProject.close().then(() => this._vite = void 0));
         }
         if (this.pool) {
           closePromises.push((async () => {
@@ -11318,7 +11771,8 @@ class Vitest {
     return this.closingPromise;
   }
   /**
-   * Close the thread pool and exit the process
+   * Closes all projects and exit the process
+   * @param force If true, the process will exit immediately after closing the projects.
    */
   async exit(force = false) {
     setTimeout(() => {
@@ -11326,7 +11780,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.server, ...this.resolvedProjects.map((p) => p.server)].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) {
@@ -11344,72 +11798,90 @@ class Vitest {
       process.exit();
     }
   }
+  /** @internal */
   async report(name, ...args) {
     await Promise.all(this.reporters.map((r) => r[name]?.(
       ...args
     )));
   }
-  async getTestFilepaths() {
-    return this.globTestSpecs().then((specs) => specs.map((spec) => spec.moduleId));
+  /** @internal */
+  async _globTestFilepaths() {
+    const specifications = await this.globTestSpecifications();
+    return Array.from(new Set(specifications.map((spec) => spec.moduleId)));
   }
+  /**
+   * @deprecated use `globTestSpecifications` instead
+   */
   async globTestSpecs(filters = []) {
-    const files = [];
-    await Promise.all(this.projects.map(async (project) => {
-      const { testFiles, typecheckTestFiles } = await project.globTestFiles(filters);
-      testFiles.forEach((file) => {
-        const spec = project.createSpecification(file);
-        this.ensureSpecCached(spec);
-        files.push(spec);
-      });
-      typecheckTestFiles.forEach((file) => {
-        const spec = project.createSpecification(file, "typescript");
-        this.ensureSpecCached(spec);
-        files.push(spec);
-      });
-    }));
-    return files;
+    return this.globTestSpecifications(filters);
   }
   /**
-   * @deprecated use `globTestSpecs` instead
+   * @deprecated use `globTestSpecifications` instead
    */
   async globTestFiles(filters = []) {
-    return this.globTestSpecs(filters);
+    return this.globTestSpecifications(filters);
   }
-  ensureSpecCached(spec) {
-    const file = spec[1];
-    const specs = this._cachedSpecs.get(file) || [];
-    const included = specs.some((_s) => _s[0] === spec[0] && _s[2].pool === spec[2].pool);
-    if (!included) {
-      specs.push(spec);
-      this._cachedSpecs.set(file, specs);
-    }
+  /** @deprecated filter by `this.projects` yourself */
+  getModuleProjects(filepath) {
+    return this.projects.filter((project) => {
+      return project.getModulesByFilepath(filepath).size;
+    });
   }
-  // The server needs to be running for communication
+  /**
+   * Should the server be kept running after the tests are done.
+   */
   shouldKeepServer() {
     return !!this.config?.watch;
   }
+  /**
+   * Register a handler that will be called when the server is restarted due to a config change.
+   */
   onServerRestart(fn) {
     this._onRestartListeners.push(fn);
   }
-  onAfterSetServer(fn) {
-    this._onSetServer.push(fn);
-  }
+  /**
+   * Register a handler that will be called when the test run is cancelled with `vitest.cancelCurrentRun`.
+   */
   onCancel(fn) {
     this._onCancelListeners.push(fn);
   }
+  /**
+   * Register a handler that will be called when the server is closed.
+   */
   onClose(fn) {
     this._onClose.push(fn);
   }
+  /**
+   * Register a handler that will be called when the tests are rerunning.
+   */
   onTestsRerun(fn) {
     this._onUserTestsRerun.push(fn);
   }
+  /**
+   * Register a handler that will be called when a file is changed.
+   * This callback should return `true` of `false` indicating whether the test file needs to be rerun.
+   * @example
+   * const testsToRun = [resolve('./test.spec.ts')]
+   * vitest.onFilterWatchedSpecification(specification => testsToRun.includes(specification.moduleId))
+   */
+  onFilterWatchedSpecification(fn) {
+    this._onFilterWatchedSpecification.push(fn);
+  }
+  /** @internal */
+  onAfterSetServer(fn) {
+    this._onSetServer.push(fn);
+  }
+}
+function assert(condition, property, name = property) {
+  if (!condition) {
+    throw new Error(`The ${name} was not set. It means that \`vitest.${property}\` was called before the Vite server was established. Either await the Vitest promise or check that it is initialized with \`vitest.ready()\` before accessing \`vitest.${property}\`.`);
+  }
 }
 
 async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
   const userConfig = deepMerge({}, options);
-  const getRoot = () => ctx.config?.root || options.root || process.cwd();
   async function UIPlugin() {
-    await ctx.packageInstaller.ensureInstalled("@vitest/ui", getRoot(), ctx.version);
+    await ctx.packageInstaller.ensureInstalled("@vitest/ui", options.root || process.cwd(), ctx.version);
     return (await import('@vitest/ui')).default(ctx);
   }
   return [
@@ -11459,7 +11931,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             ws: testConfig.api?.middlewareMode ? false : void 0,
             preTransformRequests: false,
             fs: {
-              allow: resolveFsAllow(getRoot(), testConfig.config)
+              allow: resolveFsAllow(options.root || process.cwd(), testConfig.config)
             }
           },
           build: {
@@ -11535,7 +12007,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           config.css.modules ??= {};
           if (config.css.modules) {
             config.css.modules.generateScopedName = (name, filename) => {
-              const root = getRoot();
+              const root = ctx.config.root || options.root || process.cwd();
               return generateScopedClassName(
                 classNameStrategy,
                 name,
@@ -11566,6 +12038,11 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
           viteConfig.server.watch = null;
         }
         hijackVitePluginInject(viteConfig);
+        Object.defineProperty(viteConfig, "_vitest", {
+          value: options,
+          enumerable: false,
+          configurable: true
+        });
       },
       configureServer: {
         // runs after vite:import-analysis as it relies on `server` instance on Vite 5
@@ -11576,7 +12053,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
               console.log("[debug] watcher is ready");
             });
           }
-          await ctx.setServer(options, server, userConfig);
+          await ctx._setServer(options, server, userConfig);
           if (options.api && options.watch) {
             (await Promise.resolve().then(function () { return setup$1; })).setup(ctx);
           }
@@ -11848,7 +12325,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
       return ctx.updateSnapshot();
     }
     if (name === "a" || name === "return") {
-      const files = await ctx.getTestFilepaths();
+      const files = await ctx._globTestFilepaths();
       return ctx.changeNamePattern("", files, "rerun all tests");
     }
     if (name === "r") {
@@ -11867,7 +12344,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
       return inputFilePattern();
     }
     if (name === "b") {
-      await ctx.initBrowserServers();
+      await ctx._initBrowserServers();
       ctx.projects.forEach((project) => {
         ctx.logger.log();
         ctx.logger.printBrowserBanner(project);
@@ -11900,7 +12377,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout2) {
       return;
     }
     const files = ctx.state.getFilepaths();
-    const cliFiles = ctx.config.standalone && !files.length ? await ctx.getTestFilepaths() : void 0;
+    const cliFiles = ctx.config.standalone && !files.length ? await ctx._globTestFilepaths() : void 0;
     await ctx.changeNamePattern(
       filter?.trim() || "",
       cliFiles,
@@ -12013,6 +12490,10 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
       ctx.logger.error(e.message);
       return ctx;
     }
+    if (e instanceof IncludeTaskLocationDisabledError || e instanceof RangeLocationFilterProvidedError || e instanceof LocationFilterFileNotFoundError) {
+      ctx.logger.printError(e, { verbose: false });
+      return ctx;
+    }
     process.exitCode = 1;
     ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });
     ctx.logger.error("\n\n");
@@ -12050,11 +12531,10 @@ async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions) {
 function processCollected(ctx, files, options) {
   let errorsPrinted = false;
   forEachSuite(files, (suite) => {
-    const errors = suite.result?.errors || [];
-    errors.forEach((error) => {
+    suite.errors().forEach((error) => {
       errorsPrinted = true;
       ctx.logger.printError(error, {
-        project: ctx.getProjectByName(suite.file.projectName)
+        project: suite.project
       });
     });
   });
@@ -12112,43 +12592,50 @@ function processJsonOutput(files, options) {
     writeFileSync(jsonPath, JSON.stringify(formatCollectedAsJSON(files), null, 2));
   }
 }
-function forEachSuite(tasks, callback) {
-  tasks.forEach((task) => {
-    if (task.type === "suite") {
-      callback(task);
-      forEachSuite(task.tasks, callback);
+function forEachSuite(modules, callback) {
+  modules.forEach((testModule) => {
+    callback(testModule);
+    for (const suite of testModule.children.allSuites()) {
+      callback(suite);
     }
   });
 }
 function formatCollectedAsJSON(files) {
-  return files.map((file) => {
-    const tests = getTests(file).filter((test) => test.mode === "run" || test.mode === "only");
-    return tests.map((test) => {
+  const results = [];
+  files.forEach((file) => {
+    for (const test of file.children.allTests()) {
+      if (test.skipped()) {
+        continue;
+      }
       const result = {
-        name: getNames(test).slice(1).join(" > "),
-        file: file.filepath
+        name: test.fullName,
+        file: test.module.moduleId
       };
-      if (test.file.projectName) {
-        result.projectName = test.file.projectName;
+      if (test.project.name) {
+        result.projectName = test.project.name;
       }
       if (test.location) {
         result.location = test.location;
       }
-      return result;
-    });
-  }).flat();
+      results.push(result);
+    }
+  });
+  return results;
 }
-function formatCollectedAsString(files) {
-  return files.map((file) => {
-    const tests = getTests(file).filter((test) => test.mode === "run" || test.mode === "only");
-    return tests.map((test) => {
-      const name = getNames(test).join(" > ");
-      if (test.file.projectName) {
-        return `[${test.file.projectName}] ${name}`;
+function formatCollectedAsString(testModules) {
+  const results = [];
+  testModules.forEach((testModule) => {
+    for (const test of testModule.children.allTests()) {
+      if (test.skipped()) {
+        continue;
       }
-      return name;
-    });
-  }).flat();
+      const fullName = `${test.module.task.name} > ${test.fullName}`;
+      results.push(
+        (test.project.name ? `[${test.project.name}] ` : "") + fullName
+      );
+    }
+  });
+  return results;
 }
 const envPackageNames = {
   "jsdom": "jsdom",
@@ -12178,4 +12665,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, TestSpecification as T, VitestPackageInstaller as V, VitestPlugin as a, registerConsoleShortcuts as b, createVitest as c, createViteLogger as d, cliApi as e, resolveFsAllow as r, startVitest as s };
+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 };