vitest 3.0.0-beta.1 → 3.0.0-beta.3

package/dist/chunks/{cli-api.BKUOv0Nc.js → cli-api.CWDlED-m.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 { noop, isPrimitive, createDefer, toArray, deepMerge, nanoid, slash, deepClone, notNullish } 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 { e as groupBy, i as isPackageExists, f as requireMicromatch, V as VitestCache, h as configDefaults, g as getFilePoolName, j as isBrowserEnabled, m as mm, b as resolveConfig, w as wildcardPatternToRegExp, k as createPool, a as resolveApiServerConfig, c as coverageConfigDefaults, s as stdout } from './resolveConfig.3rGGWga5.js';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.CWCZimpS.js';
+import { v as version$1 } from './cac.e7qW4xLT.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.DKe7vK-G.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 require$$0$2 from 'stream';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
@@ -27,11 +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.C1d7TK-U.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
 import c from 'tinyrainbow';
-import { h as hash, i as isWindows } from './RandomSequencer.gisBJ77r.js';
-import { isCI } from 'std-env';
+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';
@@ -40,6 +39,7 @@ 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 readline from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 
@@ -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);
@@ -4947,17 +4947,18 @@ function setup(ctx, _server) {
         async getModuleGraph(project, id, browser) {
           return getModuleGraph(ctx, project, id, browser);
         },
-        updateSnapshot(file) {
+        async updateSnapshot(file) {
           if (!file) {
-            return ctx.updateSnapshot();
+            await ctx.updateSnapshot();
+          } else {
+            await ctx.updateSnapshot([file.filepath]);
           }
-          return ctx.updateSnapshot([file.filepath]);
         },
         getUnhandledErrors() {
           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 +5020,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) => {
@@ -5057,6 +5061,33 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
+class BrowserSessions {
+  sessions = /* @__PURE__ */ new Map();
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  createAsyncSession(method, sessionId, files, project) {
+    const defer = createDefer();
+    const timeout = setTimeout(() => {
+      defer.reject(new Error(`Failed to connect to the browser session "${sessionId}" within the timeout.`));
+    }, project.vitest.config.browser.connectTimeout ?? 6e4).unref();
+    this.sessions.set(sessionId, {
+      files,
+      method,
+      project,
+      connected: () => {
+        clearTimeout(timeout);
+      },
+      resolve: () => {
+        defer.resolve();
+        this.sessions.delete(sessionId);
+      },
+      reject: defer.reject
+    });
+    return defer;
+  }
+}
+
 class FilesNotFoundError extends Error {
   code = "VITEST_FILES_NOT_FOUND";
   constructor(mode) {
@@ -5088,41 +5119,6 @@ class RangeLocationFilterProvidedError extends Error {
   }
 }
 
-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;
-}
-
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 class VitestPackageInstaller {
   isPackageExists(name, options) {
@@ -5143,7 +5139,6 @@ class VitestPackageInstaller {
     if (/* @__PURE__ */ isPackageExists(dependency, { paths: [root, __dirname] })) {
       return true;
     }
-    const promptInstall = !isCI && process.stdout.isTTY;
     process.stderr.write(
       c.red(
         `${c.inverse(
@@ -5153,11 +5148,11 @@ class VitestPackageInstaller {
 `
       )
     );
-    if (!promptInstall) {
+    if (!isTTY) {
       return false;
     }
     const prompts = await import('./index.BJDntFik.js').then(function (n) { return n.i; });
-    const { install } = await prompts.prompt({
+    const { install } = await prompts.default({
       type: "confirm",
       name: "install",
       message: c.reset(`Do you want to install ${c.green(dependency)}?`)
@@ -9514,8 +9509,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
               )
             }
           },
@@ -9593,20 +9588,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;
-  /** @private */
-  testLocations;
-  // public readonly location: WorkspaceSpecLocation | undefined
-  constructor(project, moduleId, pool, testLocations) {
+  /**
+   * 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.testLocations = testLocations;
+    this.testLines = testLines;
   }
   toJSON() {
     return [
@@ -9615,7 +9621,7 @@ class TestSpecification {
         root: this.project.config.root
       },
       this.moduleId,
-      { pool: this.pool }
+      { pool: this.pool, testLines: this.testLines }
     ];
   }
   /**
@@ -9669,15 +9675,18 @@ 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;
+  /** @internal */
+  _config;
+  runner;
   closingPromise;
   testFilesList = null;
   typecheckFilesList = null;
   _globalSetups;
   _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
@@ -9705,7 +9714,7 @@ class TestProject {
       return this._provided;
     }
     return {
-      ...this.vitest.getRootTestProject().getProvidedContext(),
+      ...this.vitest.getRootProject().getProvidedContext(),
       ...this._provided
     };
   }
@@ -9713,12 +9722,12 @@ class TestProject {
    * Creates a new test specification. Specifications describe how to run tests.
    * @param moduleId The file path
    */
-  createSpecification(moduleId, pool, testLocations) {
+  createSpecification(moduleId, locations, pool) {
     return new TestSpecification(
       this,
       moduleId,
       pool || getFilePoolName(this, moduleId),
-      testLocations
+      locations
     );
   }
   toJSON() {
@@ -9735,6 +9744,11 @@ class TestProject {
     if (!this._vite) {
       throw new Error("The server was not set. It means that `project.vite` was called before the Vite server was established.");
     }
+    Object.defineProperty(this, "vite", {
+      configurable: true,
+      writable: true,
+      value: this._vite
+    });
     return this._vite;
   }
   /**
@@ -9766,7 +9780,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() {
@@ -9893,22 +9907,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 */
@@ -9926,25 +9939,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");
@@ -9968,11 +9988,19 @@ class TestProject {
     return testFiles;
   }
   /** @internal */
-  async _initBrowserServer() {
-    if (!this.isBrowserEnabled() || this.browser) {
+  _parentBrowser;
+  /** @internal */
+  _parent;
+  /** @internal */
+  _initParentBrowser = deduped(async () => {
+    if (!this.isBrowserEnabled() || this._parentBrowser) {
       return;
     }
-    await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.ctx.version);
+    await this.vitest.packageInstaller.ensureInstalled(
+      "@vitest/browser",
+      this.config.root,
+      this.vitest.version
+    );
     const { createBrowserServer, distRoot } = await import('@vitest/browser');
     const browser = await createBrowserServer(
       this,
@@ -9987,13 +10015,20 @@ class TestProject {
           }
         })
       ],
-      [CoverageTransform(this.ctx)]
+      [CoverageTransform(this.vitest)]
     );
-    this.browser = browser;
+    this._parentBrowser = browser;
     if (this.config.browser.ui) {
       setup(this.vitest, browser.vite);
     }
-  }
+  });
+  /** @internal */
+  _initBrowserServer = deduped(async () => {
+    await this._parent?._initParentBrowser();
+    if (!this.browser && this._parent?._parentBrowser) {
+      this.browser = this._parent._parentBrowser.spawn(this);
+    }
+  });
   /**
    * Closes the project and all associated resources. This can only be called once; the closing promise is cached until the server restarts.
    * If the resources are needed again, create a new project.
@@ -10014,6 +10049,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 || "";
@@ -10080,14 +10122,24 @@ class TestProject {
     return this._initBrowserProvider();
   }
   /** @internal */
-  async _initBrowserProvider() {
+  _initBrowserProvider = deduped(async () => {
     if (!this.isBrowserEnabled() || this.browser?.provider) {
       return;
     }
     if (!this.browser) {
       await this._initBrowserServer();
     }
-    await this.browser?.initBrowserProvider();
+    await this.browser?.initBrowserProvider(this);
+  });
+  /** @internal */
+  _provideObject(context) {
+    for (const _providedKey in context) {
+      const providedKey = _providedKey;
+      this.provide(
+        providedKey,
+        context[providedKey]
+      );
+    }
   }
   /** @internal */
   static _createBasicProject(vitest) {
@@ -10099,15 +10151,34 @@ class TestProject {
     project.runner = vitest.runner;
     project._vite = vitest.server;
     project._config = vitest.config;
-    for (const _providedKey in vitest.config.provide) {
-      const providedKey = _providedKey;
-      project.provide(
-        providedKey,
-        vitest.config.provide[providedKey]
-      );
-    }
+    project._provideObject(vitest.config.provide);
     return project;
   }
+  /** @internal */
+  static _cloneBrowserProject(parent, config) {
+    const clone = new TestProject(
+      parent.path,
+      parent.vitest
+    );
+    clone.vitenode = parent.vitenode;
+    clone.runner = parent.runner;
+    clone._vite = parent._vite;
+    clone._config = config;
+    clone._parent = parent;
+    clone._provideObject(config.provide);
+    return clone;
+  }
+}
+function deduped(cb) {
+  let _promise;
+  return (...args) => {
+    if (!_promise) {
+      _promise = cb(...args).finally(() => {
+        _promise = void 0;
+      });
+    }
+    return _promise;
+  };
 }
 async function initializeProject(workspacePath, ctx, options) {
   const project = new TestProject(workspacePath, ctx, options);
@@ -10192,6 +10263,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;
@@ -10373,23 +10630,161 @@ class StateManager {
   }
 }
 
-const ESCAPE_SYMBOL = "\\";
-const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
-const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*\]/;
-const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
-const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
-const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
-function isDynamicPattern(pattern, options = {}) {
-  if (pattern === "") {
-    return false;
-  }
-  if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
-    return true;
+class VitestWatcher {
+  constructor(vitest) {
+    this.vitest = vitest;
   }
-  if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
-    return true;
+  /**
+   * 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;
   }
-  if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+  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 = /\[[^[]*\]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+function isDynamicPattern(pattern, options = {}) {
+  if (pattern === "") {
+    return false;
+  }
+  if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+    return true;
+  }
+  if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+    return true;
+  }
+  if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
     return true;
   }
   if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
@@ -10454,8 +10849,8 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
     )));
   });
   for (const path of fileProjects) {
-    if (vitest.server.config.configFile === path) {
-      projectPromises.push(Promise.resolve(vitest._createRootProject()));
+    if (vitest.vite.config.configFile === path) {
+      projectPromises.push(Promise.resolve(vitest._ensureRootProject()));
       continue;
     }
     const configFile = path.endsWith("/") ? false : path;
@@ -10469,7 +10864,7 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
     );
   }
   if (!projectPromises.length) {
-    return [vitest._createRootProject()];
+    return resolveBrowserWorkspace(vitest, /* @__PURE__ */ new Set(), [vitest._ensureRootProject()]);
   }
   const resolvedProjects = await Promise.all(projectPromises);
   const names = /* @__PURE__ */ new Set();
@@ -10493,8 +10888,136 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
     }
     names.add(name);
   }
+  return resolveBrowserWorkspace(vitest, names, resolvedProjects);
+}
+async function resolveBrowserWorkspace(vitest, names, resolvedProjects) {
+  const filters = toArray(vitest.config.project).map((s) => wildcardPatternToRegExp(s));
+  const removeProjects = /* @__PURE__ */ new Set();
+  resolvedProjects.forEach((project) => {
+    if (!project.config.browser.enabled) {
+      return;
+    }
+    const configs = project.config.browser.instances || [];
+    if (configs.length === 0) {
+      configs.push({ browser: project.config.browser.name });
+      console.warn(
+        withLabel(
+          "yellow",
+          "Vitest",
+          [
+            `No browser "instances" were defined`,
+            project.name ? ` for the "${project.name}" project. ` : ". ",
+            `Running tests in "${project.config.browser.name}" browser. `,
+            'The "browser.name" field is deprecated since Vitest 3. ',
+            "Read more: https://vitest.dev/guide/browser/config#browser-instances"
+          ].filter(Boolean).join("")
+        )
+      );
+    }
+    const originalName = project.config.name;
+    const filteredConfigs = !filters.length ? configs : configs.filter((config) => {
+      const browser = config.browser;
+      const newName = config.name || (originalName ? `${originalName} (${browser})` : browser);
+      return filters.some((pattern) => pattern.test(newName));
+    });
+    if (!filteredConfigs.length) {
+      return;
+    }
+    if (project.config.browser.providerOptions) {
+      vitest.logger.warn(
+        withLabel("yellow", "Vitest", `"providerOptions"${originalName ? ` in "${originalName}" project` : ""} is ignored because it's overriden by the configs. To hide this warning, remove the "providerOptions" property from the browser configuration.`)
+      );
+    }
+    filteredConfigs.forEach((config, index) => {
+      const browser = config.browser;
+      if (!browser) {
+        const nth = index + 1;
+        const ending = nth === 2 ? "nd" : nth === 3 ? "rd" : "th";
+        throw new Error(`The browser configuration must have a "browser" property. The ${nth}${ending} item in "browser.instances" doesn't have it. Make sure your${originalName ? ` "${originalName}"` : ""} configuration is correct.`);
+      }
+      const name = config.name;
+      const newName = name || (originalName ? `${originalName} (${browser})` : browser);
+      if (names.has(newName)) {
+        throw new Error(
+          [
+            `Cannot define a nested project for a ${browser} browser. The project name "${newName}" was already defined. `,
+            'If you have multiple instances for the same browser, make sure to define a custom "name". ',
+            "All projects in a workspace should have unique names. Make sure your configuration is correct."
+          ].join("")
+        );
+      }
+      names.add(newName);
+      const clonedConfig = cloneConfig(project, config);
+      clonedConfig.name = newName;
+      const clone = TestProject._cloneBrowserProject(project, clonedConfig);
+      resolvedProjects.push(clone);
+    });
+    removeProjects.add(project);
+  });
+  resolvedProjects = resolvedProjects.filter((project) => !removeProjects.has(project));
+  const headedBrowserProjects = resolvedProjects.filter((project) => {
+    return project.config.browser.enabled && !project.config.browser.headless;
+  });
+  if (headedBrowserProjects.length > 1) {
+    const message = [
+      `Found multiple projects that run browser tests in headed mode: "${headedBrowserProjects.map((p) => p.name).join('", "')}".`,
+      ` Vitest cannot run multiple headed browsers at the same time.`
+    ].join("");
+    if (!isTTY) {
+      throw new Error(`${message} Please, filter projects with --browser=name or --project=name flag or run tests with "headless: true" option.`);
+    }
+    const prompts = await import('./index.BJDntFik.js').then(function (n) { return n.i; });
+    const { projectName } = await prompts.default({
+      type: "select",
+      name: "projectName",
+      choices: headedBrowserProjects.map((project) => ({
+        title: project.name,
+        value: project.name
+      })),
+      message: `${message} Select a single project to run or cancel and run tests with "headless: true" option. Note that you can also start tests with --browser=name or --project=name flag.`
+    });
+    if (!projectName) {
+      throw new Error("The test run was aborted.");
+    }
+    return resolvedProjects.filter((project) => project.name === projectName);
+  }
   return resolvedProjects;
 }
+function cloneConfig(project, { browser, ...config }) {
+  const {
+    locators,
+    viewport,
+    testerHtmlPath,
+    headless,
+    screenshotDirectory,
+    screenshotFailures,
+    // @ts-expect-error remove just in case
+    browser: _browser,
+    name,
+    ...overrideConfig
+  } = config;
+  const currentConfig = project.config.browser;
+  return mergeConfig({
+    ...deepClone(project.config),
+    browser: {
+      ...project.config.browser,
+      locators: locators ? {
+        testIdAttribute: locators.testIdAttribute ?? currentConfig.locators.testIdAttribute
+      } : project.config.browser.locators,
+      viewport: viewport ?? currentConfig.viewport,
+      testerHtmlPath: testerHtmlPath ?? currentConfig.testerHtmlPath,
+      screenshotDirectory: screenshotDirectory ?? currentConfig.screenshotDirectory,
+      screenshotFailures: screenshotFailures ?? currentConfig.screenshotFailures,
+      // TODO: test that CLI arg is preferred over the local config
+      headless: project.vitest._options?.browser?.headless ?? headless ?? currentConfig.headless,
+      name: browser,
+      providerOptions: config,
+      instances: void 0
+      // projects cannot spawn more configs
+    }
+    // TODO: should resolve, not merge/override
+  }, overrideConfig);
+}
 async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceDefinition) {
   const projectsOptions = [];
   const workspaceConfigFiles = [];
@@ -10529,8 +11052,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
       }));
@@ -10591,53 +11114,143 @@ 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;
+  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;
+  /**
+   * 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 = {};
-  server = void 0;
-  state = void 0;
-  snapshot = void 0;
-  cache = void 0;
-  reporters = void 0;
+  /** @internal */
   coverageProvider;
-  logger;
-  pool;
-  vitenode = void 0;
-  invalidates = /* @__PURE__ */ new Set();
-  changedTests = /* @__PURE__ */ new Set();
-  watchedTests = /* @__PURE__ */ new Set();
+  /** @internal */
   filenamePattern;
+  /** @internal */
   runningPromise;
+  /** @internal */
   closingPromise;
+  /** @internal */
   isCancelling = false;
-  isFirstRun = true;
-  restartsCount = 0;
-  runner = void 0;
-  packageInstaller;
-  /** TODO: rename to `_coreRootProject` */
   /** @internal */
   coreWorkspaceProject;
-  /** @private */
+  /** @internal */
   resolvedProjects = [];
-  projects = [];
-  distPath = distDir;
-  _cachedSpecs = /* @__PURE__ */ new Map();
-  _workspaceConfigPath;
-  /** @deprecated use `_cachedSpecs` */
-  projectTestFiles = this._cachedSpecs;
   /** @internal */
   _browserLastPort = defaultBrowserPort;
   /** @internal */
+  _browserSessions = new BrowserSessions();
+  /** @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) {
+  _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.unregisterWatcher?.();
+    this.watcher.unregisterWatcher();
     clearTimeout(this._rerunTimer);
     this.restartsCount += 1;
     this._browserLastPort = defaultBrowserPort;
@@ -10649,16 +11262,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;
@@ -10691,7 +11304,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();
@@ -10705,6 +11317,9 @@ class Vitest {
       this.projects = this.projects.filter(
         (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);
@@ -10712,19 +11327,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`.
    */
-  _createRootProject() {
+  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.`);
     }
@@ -10736,16 +11369,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;
+  }
+  /**
+   * 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);
@@ -10767,9 +11411,9 @@ class Vitest {
     const workspaceConfigPath = await this.resolveWorkspaceConfigPath();
     this._workspaceConfigPath = workspaceConfigPath;
     if (!workspaceConfigPath) {
-      return [this._createRootProject()];
+      return resolveBrowserWorkspace(this, /* @__PURE__ */ new Set(), [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.`);
     }
@@ -10780,6 +11424,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;
@@ -10794,16 +11445,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);
@@ -10836,31 +11490,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 {
@@ -10869,9 +11534,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);
@@ -10882,14 +11546,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 {
@@ -10898,105 +11571,60 @@ class Vitest {
     } finally {
       await this.report("onInit", this);
     }
-    await this.globTestFiles();
-    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);
-      }
+    await this.globTestSpecifications();
+    if (this.config.watch) {
+      await this.report("onWatcherStart");
     }
-    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);
@@ -11011,8 +11639,8 @@ 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();
         if (!this.isFirstRun && this.config.coverage.cleanOnRerun) {
@@ -11030,11 +11658,15 @@ class Vitest {
         }
         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);
+        this._checkUnhandledErrors(errors);
         await this.report("onFinished", this.state.getFiles(files), errors, coverage);
         await this.reportCoverage(coverage, allTestsRun);
       }
@@ -11046,8 +11678,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 = [];
@@ -11056,13 +11692,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");
       }
@@ -11070,6 +11706,10 @@ class Vitest {
       if (hasFailed(files)) {
         process.exitCode = 1;
       }
+      return {
+        testModules: this.state.getTestModules(),
+        unhandledErrors: this.state.getUnhandledErrors()
+      };
     })().finally(() => {
       this.runningPromise = void 0;
       this.config.changed = false;
@@ -11077,31 +11717,46 @@ class Vitest {
     });
     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);
+    const testResult = await this.runFiles(specifications, allTestsRun);
     await this.report("onWatcherStart", this.state.getFiles(files));
+    return testResult;
   }
-  isSuite(task) {
-    return Object.hasOwnProperty.call(task, "tasks");
-  }
+  /** @internal */
   async rerunTask(id) {
     const task = this.state.idMap.get(id);
     if (!task) {
@@ -11110,9 +11765,10 @@ 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;
@@ -11120,9 +11776,10 @@ class Vitest {
       this.configOverride.project = pattern;
     }
     this.projects = this.resolvedProjects.filter((p) => p.name === pattern);
-    const files = (await this.globTestSpecs()).map((spec) => spec.moduleId);
+    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;
@@ -11140,31 +11797,71 @@ 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);
   }
+  /**
+   * Update snapshots in specified files. If no files are provided, it will update files with failed tests and obsolete snapshots.
+   * @param files The list of files on the file system
+   */
   async updateSnapshot(files) {
     files = files || [
       ...this.state.getFailedFilepaths(),
       ...this.snapshot.summary.uncheckedKeysByFile.map((s) => s.filePath)
     ];
+    this.enableSnapshotUpdate();
+    try {
+      return 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);
@@ -11174,15 +11871,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) {
@@ -11190,161 +11880,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?.();
@@ -11361,19 +11944,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 () => {
@@ -11395,7 +11982,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(() => {
@@ -11403,7 +11991,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) {
@@ -11421,94 +12009,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 = [];
-    const dir = process.cwd();
-    const parsedFilters = filters.map((f) => parseFilter(f));
-    if (!this.config.includeTaskLocation && parsedFilters.some((f) => f.lineNumber !== void 0)) {
-      throw new IncludeTaskLocationDisabledError();
-    }
-    const testLocations = groupFilters(parsedFilters.map(
-      (f) => ({ ...f, filename: slash(resolve$1(dir, f.filename)) })
-    ));
-    const testLocHasMatch = {};
-    await Promise.all(this.projects.map(async (project) => {
-      const { testFiles, typecheckTestFiles } = await project.globTestFiles(
-        parsedFilters.map((f) => f.filename)
-      );
-      testFiles.forEach((file) => {
-        const loc = testLocations[file];
-        testLocHasMatch[file] = true;
-        const spec = project.createSpecification(file, void 0, loc);
-        this.ensureSpecCached(spec);
-        files.push(spec);
-      });
-      typecheckTestFiles.forEach((file) => {
-        const loc = testLocations[file];
-        testLocHasMatch[file] = true;
-        const spec = project.createSpecification(file, "typescript", loc);
-        this.ensureSpecCached(spec);
-        files.push(spec);
-      });
-    }));
-    Object.entries(testLocations).forEach(([filepath, loc]) => {
-      if (loc.length !== 0 && !testLocHasMatch[filepath]) {
-        throw new LocationFilterFileNotFoundError(
-          relative(dir, filepath)
-        );
-      }
-    });
-    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 [
@@ -11558,7 +12142,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: {
@@ -11634,7 +12218,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,
@@ -11665,6 +12249,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
@@ -11675,7 +12264,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);
           }
@@ -11947,7 +12536,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") {
@@ -11966,7 +12555,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);
@@ -11999,7 +12588,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,
@@ -12136,12 +12725,6 @@ async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions) {
     options.watch = false;
   }
   const root = resolve(options.root || process.cwd());
-  if (typeof options.browser === "object" && !("enabled" in options.browser)) {
-    options.browser.enabled = true;
-  }
-  if (typeof options.typecheck?.only === "boolean") {
-    options.typecheck.enabled ??= true;
-  }
   const ctx = await createVitest(mode, options, viteOverrides, vitestOptions);
   const environmentPackage = getEnvPackageName(ctx.config.environment);
   if (environmentPackage && !await ctx.packageInstaller.ensureInstalled(environmentPackage, root)) {
@@ -12153,11 +12736,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
       });
     });
   });
@@ -12215,43 +12797,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",
@@ -12281,4 +12870,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 };