vitest 2.1.5 → 2.2.0-beta.2

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

@@ -8,12 +8,12 @@ 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 { SnapshotManager } from '@vitest/snapshot/manager';
-import { i as isPackageExists, e as requireMicromatch, V as VitestCache, f as configDefaults, m as mm, b as resolveConfig, h as isBrowserEnabled, w as wildcardPatternToRegExp, g as getFilePoolName, j as createPool, a as resolveApiServerConfig, c as coverageConfigDefaults, s as stdout } from './resolveConfig.RxKrDli4.js';
+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.DWAW3Uh5.js';
+import { v as version$1 } from './cac.Cs06pOqp.js';
 import { c as createBirpc } from './index.68735LiX.js';
-import { s as stringify, p as parse, R as ReportersMap, h as BenchmarkReportsMap, f as TestModule, g as TestSuite, e as TestCase, j as generateCodeFrame, i as TestProject, L as Logger, k as BlobReporter, r as readBlobs } from './index.DsZFoqi9.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 require$$0$2 from 'stream';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
@@ -30,7 +30,7 @@ import { distDir, rootDir } from '../path.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
 import c from 'tinyrainbow';
-import { h as hash, i as isWindows } from './RandomSequencer.CMRlh2v4.js';
+import { h as hash, i as isWindows } from './RandomSequencer.BPedXEug.js';
 import { isCI } from 'std-env';
 import { rm } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
@@ -4845,7 +4845,7 @@ async function getModuleGraph(ctx, projectName, id, browser = false) {
   if (browser && project.browser) {
     await get(project.browser.vite.moduleGraph.getModuleById(id));
   } else {
-    await get(project.server.moduleGraph.getModuleById(id));
+    await get(project.vite.moduleGraph.getModuleById(id));
   }
   return {
     graph,
@@ -4924,11 +4924,14 @@ function setup(ctx, _server) {
           }
           return promises.writeFile(id, content, "utf-8");
         },
-        async rerun(files) {
-          await ctx.rerunFiles(files);
+        async rerun(files, resetTestNamePattern) {
+          await ctx.rerunFiles(files, void 0, true, resetTestNamePattern);
+        },
+        async rerunTask(id) {
+          await ctx.rerunTask(id);
         },
         getConfig() {
-          return ctx.getCoreWorkspaceProject().getSerializableConfig();
+          return ctx.getRootTestProject().serializedConfig;
         },
         async getTransformResult(projectName, id, browser = false) {
           const project = ctx.getProjectByName(projectName);
@@ -5123,249 +5126,6 @@ Package ${packageName} installed, re-run the command to start.
   }
 }
 
-async function loadCustomReporterModule(path, runner) {
-  let customReporterModule;
-  try {
-    customReporterModule = await runner.executeId(path);
-  } catch (customReporterModuleError) {
-    throw new Error(`Failed to load custom Reporter from ${path}`, {
-      cause: customReporterModuleError
-    });
-  }
-  if (customReporterModule.default === null || customReporterModule.default === void 0) {
-    throw new Error(
-      `Custom reporter loaded from ${path} was not the default export`
-    );
-  }
-  return customReporterModule.default;
-}
-function createReporters(reporterReferences, ctx) {
-  const runner = ctx.runner;
-  const promisedReporters = reporterReferences.map(
-    async (referenceOrInstance) => {
-      if (Array.isArray(referenceOrInstance)) {
-        const [reporterName, reporterOptions] = referenceOrInstance;
-        if (reporterName === "html") {
-          await ctx.packageInstaller.ensureInstalled("@vitest/ui", runner.root, ctx.version);
-          const CustomReporter = await loadCustomReporterModule(
-            "@vitest/ui/reporter",
-            runner
-          );
-          return new CustomReporter(reporterOptions);
-        } else if (reporterName in ReportersMap) {
-          const BuiltinReporter = ReportersMap[reporterName];
-          return new BuiltinReporter(reporterOptions);
-        } else {
-          const CustomReporter = await loadCustomReporterModule(
-            reporterName,
-            runner
-          );
-          return new CustomReporter(reporterOptions);
-        }
-      }
-      return referenceOrInstance;
-    }
-  );
-  return Promise.all(promisedReporters);
-}
-function createBenchmarkReporters(reporterReferences, runner) {
-  const promisedReporters = reporterReferences.map(
-    async (referenceOrInstance) => {
-      if (typeof referenceOrInstance === "string") {
-        if (referenceOrInstance in BenchmarkReportsMap) {
-          const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
-          return new BuiltinReporter();
-        } else {
-          const CustomReporter = await loadCustomReporterModule(
-            referenceOrInstance,
-            runner
-          );
-          return new CustomReporter();
-        }
-      }
-      return referenceOrInstance;
-    }
-  );
-  return Promise.all(promisedReporters);
-}
-
-function isAggregateError(err) {
-  if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
-    return true;
-  }
-  return err instanceof Error && "errors" in err;
-}
-class StateManager {
-  filesMap = /* @__PURE__ */ new Map();
-  pathsSet = /* @__PURE__ */ new Set();
-  idMap = /* @__PURE__ */ new Map();
-  taskFileMap = /* @__PURE__ */ new WeakMap();
-  errorsSet = /* @__PURE__ */ new Set();
-  processTimeoutCauses = /* @__PURE__ */ new Set();
-  reportedTasksMap = /* @__PURE__ */ new WeakMap();
-  catchError(err, type) {
-    if (isAggregateError(err)) {
-      return err.errors.forEach((error) => this.catchError(error, type));
-    }
-    if (err === Object(err)) {
-      err.type = type;
-    } else {
-      err = { type, message: err };
-    }
-    const _err = err;
-    if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
-      const task = this.idMap.get(_err.taskId);
-      if (task) {
-        task.mode = "skip";
-        task.result ??= { state: "skip" };
-        task.result.state = "skip";
-      }
-      return;
-    }
-    this.errorsSet.add(err);
-  }
-  clearErrors() {
-    this.errorsSet.clear();
-  }
-  getUnhandledErrors() {
-    return Array.from(this.errorsSet.values());
-  }
-  addProcessTimeoutCause(cause) {
-    this.processTimeoutCauses.add(cause);
-  }
-  getProcessTimeoutCauses() {
-    return Array.from(this.processTimeoutCauses.values());
-  }
-  getPaths() {
-    return Array.from(this.pathsSet);
-  }
-  /**
-   * Return files that were running or collected.
-   */
-  getFiles(keys) {
-    if (keys) {
-      return keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local);
-    }
-    return Array.from(this.filesMap.values()).flat().filter((file) => !file.local).sort((f1, f2) => {
-      if (f1.meta?.typecheck && f2.meta?.typecheck) {
-        return 0;
-      }
-      if (f1.meta?.typecheck) {
-        return -1;
-      }
-      return 1;
-    });
-  }
-  getFilepaths() {
-    return Array.from(this.filesMap.keys());
-  }
-  getFailedFilepaths() {
-    return this.getFiles().filter((i) => i.result?.state === "fail").map((i) => i.filepath);
-  }
-  collectPaths(paths = []) {
-    paths.forEach((path) => {
-      this.pathsSet.add(path);
-    });
-  }
-  collectFiles(project, files = []) {
-    files.forEach((file) => {
-      const existing = this.filesMap.get(file.filepath) || [];
-      const otherFiles = existing.filter(
-        (i) => i.projectName !== file.projectName || i.meta.typecheck !== file.meta.typecheck
-      );
-      const currentFile = existing.find(
-        (i) => i.projectName === file.projectName
-      );
-      if (currentFile) {
-        file.logs = currentFile.logs;
-      }
-      otherFiles.push(file);
-      this.filesMap.set(file.filepath, otherFiles);
-      this.updateId(file, project);
-    });
-  }
-  clearFiles(project, paths = []) {
-    paths.forEach((path) => {
-      const files = this.filesMap.get(path);
-      const fileTask = createFileTask(
-        path,
-        project.config.root,
-        project.config.name
-      );
-      fileTask.local = true;
-      TestModule.register(fileTask, project);
-      this.idMap.set(fileTask.id, fileTask);
-      if (!files) {
-        this.filesMap.set(path, [fileTask]);
-        return;
-      }
-      const filtered = files.filter(
-        (file) => file.projectName !== project.config.name
-      );
-      if (!filtered.length) {
-        this.filesMap.set(path, [fileTask]);
-      } else {
-        this.filesMap.set(path, [...filtered, fileTask]);
-      }
-    });
-  }
-  updateId(task, project) {
-    if (this.idMap.get(task.id) === task) {
-      return;
-    }
-    if (task.type === "suite" && "filepath" in task) {
-      TestModule.register(task, project);
-    } else if (task.type === "suite") {
-      TestSuite.register(task, project);
-    } else {
-      TestCase.register(task, project);
-    }
-    this.idMap.set(task.id, task);
-    if (task.type === "suite") {
-      task.tasks.forEach((task2) => {
-        this.updateId(task2, project);
-      });
-    }
-  }
-  getReportedEntity(task) {
-    return this.reportedTasksMap.get(task);
-  }
-  updateTasks(packs) {
-    for (const [id, result, meta] of packs) {
-      const task = this.idMap.get(id);
-      if (task) {
-        task.result = result;
-        task.meta = meta;
-        if (result?.state === "skip") {
-          task.mode = "skip";
-        }
-      }
-    }
-  }
-  updateUserLog(log) {
-    const task = log.taskId && this.idMap.get(log.taskId);
-    if (task) {
-      if (!task.logs) {
-        task.logs = [];
-      }
-      task.logs.push(log);
-    }
-  }
-  getCountOfFailedTests() {
-    return Array.from(this.idMap.values()).filter(
-      (t) => t.result?.state === "fail"
-    ).length;
-  }
-  cancelFiles(files, project) {
-    this.collectFiles(
-      project,
-      files.map(
-        (filepath) => createFileTask(filepath, project.config.root, project.config.name)
-      )
-    );
-  }
-}
-
 var tasks = {};
 
 var utils$1 = {};
@@ -8559,6 +8319,7 @@ function serializeConfig(config, coreConfig, viteConfig) {
     pool: config.pool,
     expect: config.expect,
     snapshotSerializers: config.snapshotSerializers,
+    // TODO: non serializable function?
     diff: config.diff,
     retry: config.retry,
     disableConsoleIntercept: config.disableConsoleIntercept,
@@ -9445,7 +9206,7 @@ function NormalizeURLPlugin() {
   };
 }
 
-function resolveOptimizerConfig(_testOptions, viteOptions, testConfig) {
+function resolveOptimizerConfig(_testOptions, viteOptions, testConfig, viteCacheDir) {
   const testOptions = _testOptions || {};
   const newConfig = {};
   const [major, minor, fix] = version.split(".").map(Number);
@@ -9466,7 +9227,6 @@ function resolveOptimizerConfig(_testOptions, viteOptions, testConfig) {
     };
   } else {
     const root = testConfig.root ?? process.cwd();
-    const cacheDir = testConfig.cache !== false ? testConfig.cache?.dir : void 0;
     const currentInclude = testOptions.include || viteOptions?.include || [];
     const exclude = [
       "vitest",
@@ -9482,7 +9242,7 @@ function resolveOptimizerConfig(_testOptions, viteOptions, testConfig) {
     const include = (testOptions.include || viteOptions?.include || []).filter(
       (n) => !exclude.includes(n)
     );
-    newConfig.cacheDir = cacheDir ?? VitestCache.resolveCacheDir(root, cacheDir, testConfig.name);
+    newConfig.cacheDir = testConfig.cache !== false && testConfig.cache?.dir || VitestCache.resolveCacheDir(root, viteCacheDir, testConfig.name);
     newConfig.optimizeDeps = {
       ...viteOptions,
       ...testOptions,
@@ -9565,12 +9325,14 @@ function VitestOptimizer() {
         const webOptimizer = resolveOptimizerConfig(
           testConfig.deps?.optimizer?.web,
           viteConfig.optimizeDeps,
-          testConfig
+          testConfig,
+          viteConfig.cacheDir
         );
         const ssrOptimizer = resolveOptimizerConfig(
           testConfig.deps?.optimizer?.ssr,
           viteConfig.ssr?.optimizeDeps,
-          testConfig
+          testConfig,
+          viteConfig.cacheDir
         );
         viteConfig.cacheDir = webOptimizer.cacheDir || ssrOptimizer.cacheDir || viteConfig.cacheDir;
         viteConfig.optimizeDeps = webOptimizer.optimizeDeps;
@@ -9751,7 +9513,7 @@ function WorkspaceVitestPlugin(project, options) {
       },
       async configureServer(server) {
         const options2 = deepMerge({}, configDefaults, server.config.test || {});
-        await project.setServer(options2, server);
+        await project._configureServer(options2, server);
         await server.watcher.close();
       }
     },
@@ -9782,11 +9544,11 @@ class TestSpecification {
   moduleId;
   pool;
   // public readonly location: WorkspaceSpecLocation | undefined
-  constructor(workspaceProject, moduleId, pool) {
-    this[0] = workspaceProject;
+  constructor(project, moduleId, pool) {
+    this[0] = project;
     this[1] = moduleId;
     this[2] = { pool };
-    this.project = workspaceProject.testProject;
+    this.project = project;
     this.moduleId = moduleId;
     this.pool = pool;
   }
@@ -9805,7 +9567,7 @@ class TestSpecification {
    * @deprecated
    */
   *[Symbol.iterator]() {
-    yield this.project.workspaceProject;
+    yield this.project;
     yield this.moduleId;
     yield this.pool;
   }
@@ -9824,51 +9586,46 @@ async function createViteServer(inlineConfig) {
   return server;
 }
 
-async function initializeProject(workspacePath, ctx, options) {
-  const project = new WorkspaceProject(workspacePath, ctx, options);
-  const root = options.root || (typeof workspacePath === "number" ? void 0 : workspacePath.endsWith("/") ? workspacePath : dirname(workspacePath));
-  const configFile = options.extends ? resolve(dirname(options.workspaceConfigPath), options.extends) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
-  const config = {
-    ...options,
-    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 })
-    ]
-  };
-  await createViteServer(config);
-  return project;
-}
-class WorkspaceProject {
-  constructor(path2, ctx, options) {
+class TestProject {
+  constructor(path2, vitest, options) {
     this.path = path2;
-    this.ctx = ctx;
     this.options = options;
+    this.vitest = vitest;
+    this.ctx = vitest;
+    this.globalConfig = vitest.config;
   }
-  configOverride;
-  config;
-  server;
+  /**
+   * The global Vitest instance.
+   * @experimental The public Vitest API is experimental and does not follow semver.
+   */
+  vitest;
+  /**
+   * Resolved global configuration. If there are no workspace projects, this will be the same as `config`.
+   */
+  globalConfig;
+  /**
+   * Browser instance if the browser is enabled. This is initialized when the tests run for the first time.
+   */
+  browser;
+  /** @deprecated use `vitest` instead */
+  ctx;
+  /**
+   * Temporary directory for the project. This is unique for each project. Vitest stores transformed content here.
+   */
+  tmpDir = join(tmpdir(), nanoid());
   vitenode;
   runner;
-  browser;
   typechecker;
   closingPromise;
   testFilesList = null;
   typecheckFilesList = null;
-  testProject;
-  id = nanoid();
-  tmpDir = join(tmpdir(), this.id);
   _globalSetups;
   _provided = {};
-  getName() {
-    return this.config.name || "";
-  }
-  isCore() {
-    return this.ctx.getCoreWorkspaceProject() === this;
-  }
+  _config;
+  _vite;
+  /**
+   * Provide a value to the test context. This value will be available to all tests with `inject`.
+   */
   provide(key, value) {
     try {
       structuredClone(value);
@@ -9882,19 +9639,90 @@ class WorkspaceProject {
     }
     this._provided[key] = value;
   }
+  /**
+   * Get the provided context. The project context is merged with the global context.
+   */
   getProvidedContext() {
-    if (this.isCore()) {
+    if (this.isRootProject()) {
       return this._provided;
     }
     return {
-      ...this.ctx.getCoreWorkspaceProject().getProvidedContext(),
+      ...this.vitest.getRootTestProject().getProvidedContext(),
       ...this._provided
     };
   }
+  /**
+   * Creates a new test specification. Specifications describe how to run tests.
+   * @param moduleId The file path
+   */
+  createSpecification(moduleId, pool) {
+    return new TestSpecification(
+      this,
+      moduleId,
+      pool || getFilePoolName(this, moduleId)
+    );
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      serializedConfig: this.serializedConfig,
+      context: this.getProvidedContext()
+    };
+  }
+  /**
+   * Vite's dev server instance. Every workspace project has its own server.
+   */
+  get vite() {
+    if (!this._vite) {
+      throw new Error("The server was not set. It means that `project.vite` was called before the Vite server was established.");
+    }
+    return this._vite;
+  }
+  /**
+   * Resolved project configuration.
+   */
+  get config() {
+    if (!this._config) {
+      throw new Error("The config was not set. It means that `project.config` was called before the Vite server was established.");
+    }
+    return this._config;
+  }
+  /**
+   * The name of the project or an empty string if not set.
+   */
+  get name() {
+    return this.config.name || "";
+  }
+  /**
+   * Serialized project configuration. This is the config that tests receive.
+   */
+  get serializedConfig() {
+    return this._serializeOverridenConfig();
+  }
+  /** @deprecated use `vite` instead */
+  get server() {
+    return this._vite;
+  }
+  /**
+   * Check if this is the root project. The root project is the one that has the root config.
+   */
+  isRootProject() {
+    return this.vitest.getRootTestProject() === this;
+  }
+  /** @deprecated use `isRootProject` instead */
+  isCore() {
+    return this.isRootProject();
+  }
+  /** @deprecated use `createSpecification` instead */
   createSpec(moduleId, pool) {
     return new TestSpecification(this, moduleId, pool);
   }
-  async initializeGlobalSetup() {
+  /** @deprecated */
+  initializeGlobalSetup() {
+    return this._initializeGlobalSetup();
+  }
+  /** @internal */
+  async _initializeGlobalSetup() {
     if (this._globalSetups) {
       return;
     }
@@ -9905,7 +9733,8 @@ class WorkspaceProject {
     for (const globalSetupFile of this._globalSetups) {
       const teardown = await globalSetupFile.setup?.({
         provide: (key, value) => this.provide(key, value),
-        config: this.config
+        config: this.config,
+        onTestsRerun: (cb) => this.vitest.onTestsRerun(cb)
       });
       if (teardown == null || !!globalSetupFile.teardown) {
         continue;
@@ -9918,7 +9747,12 @@ class WorkspaceProject {
       globalSetupFile.teardown = teardown;
     }
   }
-  async teardownGlobalSetup() {
+  /** @deprecated */
+  teardownGlobalSetup() {
+    return this._teardownGlobalSetup();
+  }
+  /** @internal */
+  async _teardownGlobalSetup() {
     if (!this._globalSetups) {
       return;
     }
@@ -9926,24 +9760,33 @@ class WorkspaceProject {
       await globalSetupFile.teardown?.();
     }
   }
+  /** @deprecated use `vitest.logger` instead */
   get logger() {
-    return this.ctx.logger;
+    return this.vitest.logger;
   }
   // it's possible that file path was imported with different queries (?raw, ?url, etc)
+  /** @deprecated use `.vite` or `.browser.vite` directly */
   getModulesByFilepath(file) {
     const set = this.server.moduleGraph.getModulesByFile(file) || this.browser?.vite.moduleGraph.getModulesByFile(file);
     return set || /* @__PURE__ */ new Set();
   }
+  /** @deprecated use `.vite` or `.browser.vite` directly */
   getModuleById(id) {
     return this.server.moduleGraph.getModuleById(id) || this.browser?.vite.moduleGraph.getModuleById(id);
   }
+  /** @deprecated use `.vite` or `.browser.vite` directly */
   getSourceMapModuleById(id) {
     const mod = this.server.moduleGraph.getModuleById(id);
     return mod?.ssrTransformResult?.map || mod?.transformResult?.map;
   }
+  /** @deprecated use `vitest.reporters` instead */
   get reporters() {
     return this.ctx.reporters;
   }
+  /**
+   * Get all files in the project that match the globs in the config and the filters.
+   * @param filters String filters to match the test files.
+   */
   async globTestFiles(filters = []) {
     const dir = this.config.dir || this.config.root;
     const { include, exclude, includeSource } = this.config;
@@ -9977,7 +9820,7 @@ class WorkspaceProject {
         files.map(async (file) => {
           try {
             const code = await promises.readFile(file, "utf-8");
-            if (this.isInSourceTestFile(code)) {
+            if (this.isInSourceTestCode(code)) {
               testFiles.push(file);
             }
           } catch {
@@ -9989,12 +9832,32 @@ class WorkspaceProject {
     this.testFilesList = testFiles;
     return testFiles;
   }
-  isTestFile(id) {
-    return this.testFilesList && this.testFilesList.includes(id);
+  isBrowserEnabled() {
+    return isBrowserEnabled(this.config);
+  }
+  /** @internal */
+  _markTestFile(testPath) {
+    this.testFilesList?.push(testPath);
   }
-  isTypecheckFile(id) {
-    return this.typecheckFilesList && this.typecheckFilesList.includes(id);
+  /**
+   * Returns if the file is a test file. Requires `.globTestFiles()` to be called first.
+   * @internal
+   */
+  isTestFile(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) {
+    return !!this.typecheckFilesList && this.typecheckFilesList.includes(testPath);
+  }
+  /** @deprecated use `serializedConfig` instead */
+  getSerializableConfig() {
+    return this._serializeOverridenConfig();
+  }
+  /** @internal */
   async globFiles(include, exclude, cwd) {
     const globOptions = {
       dot: true,
@@ -10004,8 +9867,11 @@ class WorkspaceProject {
     const files = await fg(include, globOptions);
     return files.map((file) => slash(a.resolve(cwd, file)));
   }
-  async isTargetFile(id, source) {
-    const relativeId = relative(this.config.dir || this.config.root, id);
+  /**
+   * Test if a file matches the test globs. This does the actual glob matching unlike `isTestFile`.
+   */
+  matchesTestGlob(filepath, source) {
+    const relativeId = relative(this.config.dir || this.config.root, filepath);
     if (mm.isMatch(relativeId, this.config.exclude)) {
       return false;
     }
@@ -10013,12 +9879,16 @@ class WorkspaceProject {
       return true;
     }
     if (this.config.includeSource?.length && mm.isMatch(relativeId, this.config.includeSource)) {
-      source = source || await promises.readFile(id, "utf-8");
-      return this.isInSourceTestFile(source);
+      const code = source || readFileSync(filepath, "utf-8");
+      return this.isInSourceTestCode(code);
     }
     return false;
   }
-  isInSourceTestFile(code) {
+  /** @deprecated use `matchesTestGlob` instead */
+  async isTargetFile(id, source) {
+    return this.matchesTestGlob(id, source);
+  }
+  isInSourceTestCode(code) {
     return code.includes("import.meta.vitest");
   }
   filterFiles(testFiles, filters, dir) {
@@ -10039,15 +9909,16 @@ class WorkspaceProject {
     }
     return testFiles;
   }
-  async initBrowserServer() {
+  /** @internal */
+  async _initBrowserServer() {
     if (!this.isBrowserEnabled() || this.browser) {
       return;
     }
-    await this.ctx.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.ctx.version);
+    await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.ctx.version);
     const { createBrowserServer, distRoot } = await import('@vitest/browser');
     const browser = await createBrowserServer(
       this,
-      this.server.config.configFile,
+      this.vite.config.configFile,
       [
         ...MocksPlugins({
           filter(id) {
@@ -10062,40 +9933,47 @@ class WorkspaceProject {
     );
     this.browser = browser;
     if (this.config.browser.ui) {
-      setup(this.ctx, browser.vite);
+      setup(this.vitest, browser.vite);
     }
   }
-  static createBasicProject(ctx) {
-    const project = new WorkspaceProject(
-      ctx.config.name || ctx.config.root,
-      ctx
-    );
-    project.vitenode = ctx.vitenode;
-    project.server = ctx.server;
-    project.runner = ctx.runner;
-    project.config = ctx.config;
-    for (const _providedKey in ctx.config.provide) {
-      const providedKey = _providedKey;
-      project.provide(
-        providedKey,
-        ctx.config.provide[providedKey]
-      );
+  /**
+   * 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.
+   */
+  close() {
+    if (!this.closingPromise) {
+      this.closingPromise = Promise.all(
+        [
+          this.vite?.close(),
+          this.typechecker?.stop(),
+          this.browser?.close(),
+          this.clearTmpDir()
+        ].filter(Boolean)
+      ).then(() => {
+        this._provided = {};
+        this._vite = void 0;
+      });
     }
-    project.testProject = new TestProject(project);
-    return project;
+    return this.closingPromise;
+  }
+  /** @deprecated use `name` instead */
+  getName() {
+    return this.config.name || "";
   }
-  static async createCoreProject(ctx) {
-    return WorkspaceProject.createBasicProject(ctx);
+  /** @deprecated internal */
+  setServer(options, server) {
+    return this._configureServer(options, server);
   }
-  async setServer(options, server) {
-    this.config = resolveConfig(
-      this.ctx.mode,
+  /** @internal */
+  async _configureServer(options, server) {
+    this._config = resolveConfig(
+      this.vitest.mode,
       {
         ...options,
-        coverage: this.ctx.config.coverage
+        coverage: this.vitest.config.coverage
       },
       server.config,
-      this.ctx.logger
+      this.vitest.logger
     );
     for (const _providedKey in this.config.provide) {
       const providedKey = _providedKey;
@@ -10105,8 +9983,7 @@ class WorkspaceProject {
       );
     }
     this.closingPromise = void 0;
-    this.testProject = new TestProject(this);
-    this.server = server;
+    this._vite = server;
     this.vitenode = new ViteNodeServer(server, this.config.server);
     const node = this.vitenode;
     this.runner = new ViteNodeRunner({
@@ -10120,51 +9997,325 @@ class WorkspaceProject {
       }
     });
   }
-  isBrowserEnabled() {
-    return isBrowserEnabled(this.config);
-  }
-  getSerializableConfig() {
+  _serializeOverridenConfig() {
     const config = serializeConfig(
       this.config,
-      this.ctx.config,
-      this.server.config
+      this.vitest.config,
+      this.vite.config
     );
-    if (!this.ctx.configOverride) {
+    if (!this.vitest.configOverride) {
       return config;
     }
     return deepMerge(
       config,
-      this.ctx.configOverride
+      this.vitest.configOverride
     );
   }
-  close() {
-    if (!this.closingPromise) {
-      this.closingPromise = Promise.all(
-        [
-          this.server?.close(),
-          this.typechecker?.stop(),
-          this.browser?.close(),
-          this.clearTmpDir()
-        ].filter(Boolean)
-      ).then(() => this._provided = {});
-    }
-    return this.closingPromise;
-  }
   async clearTmpDir() {
     try {
       await rm(this.tmpDir, { recursive: true });
     } catch {
     }
   }
-  async initBrowserProvider() {
+  /** @deprecated */
+  initBrowserProvider() {
+    return this._initBrowserProvider();
+  }
+  /** @internal */
+  async _initBrowserProvider() {
     if (!this.isBrowserEnabled() || this.browser?.provider) {
       return;
     }
     if (!this.browser) {
-      await this.initBrowserServer();
+      await this._initBrowserServer();
     }
     await this.browser?.initBrowserProvider();
   }
+  /** @internal */
+  static _createBasicProject(vitest) {
+    const project = new TestProject(
+      vitest.config.name || vitest.config.root,
+      vitest
+    );
+    project.vitenode = vitest.vitenode;
+    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]
+      );
+    }
+    return project;
+  }
+}
+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 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 })
+    ]
+  };
+  await createViteServer(config);
+  return project;
+}
+
+async function loadCustomReporterModule(path, runner) {
+  let customReporterModule;
+  try {
+    customReporterModule = await runner.executeId(path);
+  } catch (customReporterModuleError) {
+    throw new Error(`Failed to load custom Reporter from ${path}`, {
+      cause: customReporterModuleError
+    });
+  }
+  if (customReporterModule.default === null || customReporterModule.default === void 0) {
+    throw new Error(
+      `Custom reporter loaded from ${path} was not the default export`
+    );
+  }
+  return customReporterModule.default;
+}
+function createReporters(reporterReferences, ctx) {
+  const runner = ctx.runner;
+  const promisedReporters = reporterReferences.map(
+    async (referenceOrInstance) => {
+      if (Array.isArray(referenceOrInstance)) {
+        const [reporterName, reporterOptions] = referenceOrInstance;
+        if (reporterName === "html") {
+          await ctx.packageInstaller.ensureInstalled("@vitest/ui", runner.root, ctx.version);
+          const CustomReporter = await loadCustomReporterModule(
+            "@vitest/ui/reporter",
+            runner
+          );
+          return new CustomReporter(reporterOptions);
+        } else if (reporterName in ReportersMap) {
+          const BuiltinReporter = ReportersMap[reporterName];
+          return new BuiltinReporter(reporterOptions);
+        } else {
+          const CustomReporter = await loadCustomReporterModule(
+            reporterName,
+            runner
+          );
+          return new CustomReporter(reporterOptions);
+        }
+      }
+      return referenceOrInstance;
+    }
+  );
+  return Promise.all(promisedReporters);
+}
+function createBenchmarkReporters(reporterReferences, runner) {
+  const promisedReporters = reporterReferences.map(
+    async (referenceOrInstance) => {
+      if (typeof referenceOrInstance === "string") {
+        if (referenceOrInstance in BenchmarkReportsMap) {
+          const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
+          return new BuiltinReporter();
+        } else {
+          const CustomReporter = await loadCustomReporterModule(
+            referenceOrInstance,
+            runner
+          );
+          return new CustomReporter();
+        }
+      }
+      return referenceOrInstance;
+    }
+  );
+  return Promise.all(promisedReporters);
+}
+
+function isAggregateError(err) {
+  if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
+    return true;
+  }
+  return err instanceof Error && "errors" in err;
+}
+class StateManager {
+  filesMap = /* @__PURE__ */ new Map();
+  pathsSet = /* @__PURE__ */ new Set();
+  idMap = /* @__PURE__ */ new Map();
+  taskFileMap = /* @__PURE__ */ new WeakMap();
+  errorsSet = /* @__PURE__ */ new Set();
+  processTimeoutCauses = /* @__PURE__ */ new Set();
+  reportedTasksMap = /* @__PURE__ */ new WeakMap();
+  catchError(err, type) {
+    if (isAggregateError(err)) {
+      return err.errors.forEach((error) => this.catchError(error, type));
+    }
+    if (err === Object(err)) {
+      err.type = type;
+    } else {
+      err = { type, message: err };
+    }
+    const _err = err;
+    if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
+      const task = this.idMap.get(_err.taskId);
+      if (task) {
+        task.mode = "skip";
+        task.result ??= { state: "skip" };
+        task.result.state = "skip";
+        task.result.note = _err.note;
+      }
+      return;
+    }
+    this.errorsSet.add(err);
+  }
+  clearErrors() {
+    this.errorsSet.clear();
+  }
+  getUnhandledErrors() {
+    return Array.from(this.errorsSet.values());
+  }
+  addProcessTimeoutCause(cause) {
+    this.processTimeoutCauses.add(cause);
+  }
+  getProcessTimeoutCauses() {
+    return Array.from(this.processTimeoutCauses.values());
+  }
+  getPaths() {
+    return Array.from(this.pathsSet);
+  }
+  /**
+   * Return files that were running or collected.
+   */
+  getFiles(keys) {
+    if (keys) {
+      return keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local);
+    }
+    return Array.from(this.filesMap.values()).flat().filter((file) => !file.local).sort((f1, f2) => {
+      if (f1.meta?.typecheck && f2.meta?.typecheck) {
+        return 0;
+      }
+      if (f1.meta?.typecheck) {
+        return -1;
+      }
+      return 1;
+    });
+  }
+  getTestModules(keys) {
+    return this.getFiles(keys).map((file) => this.getReportedEntity(file));
+  }
+  getFilepaths() {
+    return Array.from(this.filesMap.keys());
+  }
+  getFailedFilepaths() {
+    return this.getFiles().filter((i) => i.result?.state === "fail").map((i) => i.filepath);
+  }
+  collectPaths(paths = []) {
+    paths.forEach((path) => {
+      this.pathsSet.add(path);
+    });
+  }
+  collectFiles(project, files = []) {
+    files.forEach((file) => {
+      const existing = this.filesMap.get(file.filepath) || [];
+      const otherFiles = existing.filter(
+        (i) => i.projectName !== file.projectName || i.meta.typecheck !== file.meta.typecheck
+      );
+      const currentFile = existing.find(
+        (i) => i.projectName === file.projectName
+      );
+      if (currentFile) {
+        file.logs = currentFile.logs;
+      }
+      otherFiles.push(file);
+      this.filesMap.set(file.filepath, otherFiles);
+      this.updateId(file, project);
+    });
+  }
+  clearFiles(project, paths = []) {
+    paths.forEach((path) => {
+      const files = this.filesMap.get(path);
+      const fileTask = createFileTask(
+        path,
+        project.config.root,
+        project.config.name
+      );
+      fileTask.local = true;
+      TestModule.register(fileTask, project);
+      this.idMap.set(fileTask.id, fileTask);
+      if (!files) {
+        this.filesMap.set(path, [fileTask]);
+        return;
+      }
+      const filtered = files.filter(
+        (file) => file.projectName !== project.config.name
+      );
+      if (!filtered.length) {
+        this.filesMap.set(path, [fileTask]);
+      } else {
+        this.filesMap.set(path, [...filtered, fileTask]);
+      }
+    });
+  }
+  updateId(task, project) {
+    if (this.idMap.get(task.id) === task) {
+      return;
+    }
+    if (task.type === "suite" && "filepath" in task) {
+      TestModule.register(task, project);
+    } else if (task.type === "suite") {
+      TestSuite.register(task, project);
+    } else {
+      TestCase.register(task, project);
+    }
+    this.idMap.set(task.id, task);
+    if (task.type === "suite") {
+      task.tasks.forEach((task2) => {
+        this.updateId(task2, project);
+      });
+    }
+  }
+  getReportedEntity(task) {
+    return this.reportedTasksMap.get(task);
+  }
+  updateTasks(packs) {
+    for (const [id, result, meta] of packs) {
+      const task = this.idMap.get(id);
+      if (task) {
+        task.result = result;
+        task.meta = meta;
+        if (result?.state === "skip") {
+          task.mode = "skip";
+        }
+      }
+    }
+  }
+  updateUserLog(log) {
+    const task = log.taskId && this.idMap.get(log.taskId);
+    if (task) {
+      if (!task.logs) {
+        task.logs = [];
+      }
+      task.logs.push(log);
+    }
+  }
+  getCountOfFailedTests() {
+    return Array.from(this.idMap.values()).filter(
+      (t) => t.result?.state === "fail"
+    ).length;
+  }
+  cancelFiles(files, project) {
+    this.collectFiles(
+      project,
+      files.map(
+        (filepath) => createFileTask(filepath, project.config.root, project.config.name)
+      )
+    );
+  }
 }
 
 const ESCAPE_SYMBOL = "\\";
@@ -10205,7 +10356,7 @@ function hasBraceExpansion(pattern) {
 }
 
 async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspaceDefinition) {
-  const { configFiles, projectConfigs, nonConfigDirectories } = await resolveWorkspaceProjectConfigs(
+  const { configFiles, projectConfigs, nonConfigDirectories } = await resolveTestProjectConfigs(
     vitest,
     workspaceConfigPath,
     workspaceDefinition
@@ -10272,9 +10423,9 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
       ].join("") : [" "];
       throw new Error([
         `Project name "${name}"`,
-        project.server.config.configFile ? ` from "${relative(vitest.config.root, project.server.config.configFile)}"` : "",
+        project.vite.config.configFile ? ` from "${relative(vitest.config.root, project.vite.config.configFile)}"` : "",
         " is not unique.",
-        duplicate?.server.config.configFile ? ` The project is already defined by "${relative(vitest.config.root, duplicate.server.config.configFile)}".` : "",
+        duplicate?.vite.config.configFile ? ` The project is already defined by "${relative(vitest.config.root, duplicate.vite.config.configFile)}".` : "",
         filesError,
         "All projects in a workspace should have unique names. Make sure your configuration is correct."
       ].join(""));
@@ -10283,7 +10434,7 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
   }
   return resolvedProjects;
 }
-async function resolveWorkspaceProjectConfigs(vitest, workspaceConfigPath, workspaceDefinition) {
+async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceDefinition) {
   const projectsOptions = [];
   const workspaceConfigFiles = [];
   const workspaceGlobMatches = [];
@@ -10402,6 +10553,7 @@ class Vitest {
   restartsCount = 0;
   runner = void 0;
   packageInstaller;
+  /** @internal */
   coreWorkspaceProject;
   /** @private */
   resolvedProjects = [];
@@ -10417,6 +10569,7 @@ class Vitest {
   _onClose = [];
   _onSetServer = [];
   _onCancelListeners = [];
+  _onUserTestsRerun = [];
   async setServer(options, server, cliOptions) {
     this.unregisterWatcher?.();
     clearTimeout(this._rerunTimer);
@@ -10431,6 +10584,7 @@ class Vitest {
     this.coverageProvider = void 0;
     this.runningPromise = void 0;
     this._cachedSpecs.clear();
+    this._onUserTestsRerun = [];
     const resolved = resolveConfig(this.mode, options, server.config, this.logger);
     this.server = server;
     this.config = resolved;
@@ -10487,7 +10641,7 @@ class Vitest {
       );
     }
     if (!this.coreWorkspaceProject) {
-      this.coreWorkspaceProject = WorkspaceProject.createBasicProject(this);
+      this.coreWorkspaceProject = TestProject._createBasicProject(this);
     }
     if (this.config.testNamePattern) {
       this.configOverride.testNamePattern = this.config.testNamePattern;
@@ -10495,22 +10649,19 @@ class Vitest {
     await Promise.all(this._onSetServer.map((fn) => fn()));
   }
   provide(key, value) {
-    this.getCoreWorkspaceProject().provide(key, value);
-  }
-  /**
-   * @deprecated internal, use `_createCoreProject` instead
-   */
-  createCoreProject() {
-    return this._createCoreProject();
+    this.getRootTestProject().provide(key, value);
   }
   /**
    * @internal
    */
-  async _createCoreProject() {
-    this.coreWorkspaceProject = await WorkspaceProject.createCoreProject(this);
+  _createCoreProject() {
+    this.coreWorkspaceProject = TestProject._createBasicProject(this);
     return this.coreWorkspaceProject;
   }
-  getCoreWorkspaceProject() {
+  getRootTestProject() {
+    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.`);
+    }
     return this.coreWorkspaceProject;
   }
   /**
@@ -10519,10 +10670,10 @@ class Vitest {
   getProjectByTaskId(taskId) {
     const task = this.state.idMap.get(taskId);
     const projectName = task.projectName || task?.file?.projectName || "";
-    return this.projects.find((p) => p.getName() === projectName) || this.getCoreWorkspaceProject() || this.projects[0];
+    return this.projects.find((p) => p.name === projectName) || this.getRootTestProject() || this.projects[0];
   }
   getProjectByName(name = "") {
-    return this.projects.find((p) => p.getName() === name) || this.getCoreWorkspaceProject() || this.projects[0];
+    return this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
   }
   async getWorkspaceConfigPath() {
     if (this.config.workspace) {
@@ -10542,7 +10693,7 @@ class Vitest {
     const workspaceConfigPath = await this.getWorkspaceConfigPath();
     this._workspaceConfigPath = workspaceConfigPath;
     if (!workspaceConfigPath) {
-      return [await this._createCoreProject()];
+      return [this._createCoreProject()];
     }
     const workspaceModule = await this.runner.executeFile(workspaceConfigPath);
     if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) {
@@ -10684,21 +10835,21 @@ class Vitest {
         return;
       }
       deps.add(filepath);
-      const mod = project.server.moduleGraph.getModuleById(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.server.pluginContainer.resolveId(dep, filepath, { ssr: true });
+        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.workspaceProject, spec.moduleId);
+    await addImports(spec.project, spec.moduleId);
     deps.delete(spec.moduleId);
     return deps;
   }
@@ -10754,24 +10905,23 @@ class Vitest {
     const specs = [];
     for (const project of this.projects) {
       if (project.isTestFile(file)) {
-        const pool = getFilePoolName(project, file);
-        specs.push(project.createSpec(file, pool));
+        specs.push(project.createSpecification(file));
       }
       if (project.isTypecheckFile(file)) {
-        specs.push(project.createSpec(file, "typescript"));
+        specs.push(project.createSpecification(file, "typescript"));
       }
     }
     specs.forEach((spec) => this.ensureSpecCached(spec));
     return specs;
   }
   async initializeGlobalSetup(paths) {
-    const projects = new Set(paths.map((spec) => spec.project.workspaceProject));
-    const coreProject = this.getCoreWorkspaceProject();
+    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();
+      await project._initializeGlobalSetup();
     }
   }
   async runFiles(specs, allTestsRun) {
@@ -10855,17 +11005,37 @@ class Vitest {
     await Promise.all(this._onCancelListeners.splice(0).map((listener) => listener(reason)));
   }
   async initBrowserServers() {
-    await Promise.all(this.projects.map((p) => p.initBrowserServer()));
+    await Promise.all(this.projects.map((p) => p._initBrowserServer()));
   }
-  async rerunFiles(files = this.state.getFilepaths(), trigger, allTestsRun = true) {
+  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));
     }
-    await this.report("onWatcherRerun", files, trigger);
+    await Promise.all([
+      this.report("onWatcherRerun", files, trigger),
+      ...this._onUserTestsRerun.map((fn) => fn(files))
+    ]);
     await this.runFiles(files.flatMap((file) => this.getProjectsByTestFile(file)), allTestsRun);
     await this.report("onWatcherStart", this.state.getFiles(files));
   }
+  isSuite(task) {
+    return Object.hasOwnProperty.call(task, "tasks");
+  }
+  async rerunTask(id) {
+    const task = this.state.idMap.get(id);
+    if (!task) {
+      throw new Error(`Task ${id} was not found`);
+    }
+    await this.changeNamePattern(
+      task.name,
+      [task.file.filepath],
+      this.isSuite(task) ? "rerun suite" : "rerun test"
+    );
+  }
   async changeProjectName(pattern) {
     if (pattern === "") {
       delete this.configOverride.project;
@@ -10954,7 +11124,10 @@ class Vitest {
       this.changedTests.clear();
       const triggerIds = new Set(triggerId.map((id) => relative(this.config.root, id)));
       const triggerLabel = Array.from(triggerIds).join(", ");
-      await this.report("onWatcherRerun", files, triggerLabel);
+      await Promise.all([
+        this.report("onWatcherRerun", files, triggerLabel),
+        ...this._onUserTestsRerun.map((fn) => fn(files))
+      ]);
       await this.runFiles(files.flatMap((file) => this.getProjectsByTestFile(file)), false);
       await this.report("onWatcherStart", this.state.getFiles(files));
     }, WATCHER_DEBOUNCE);
@@ -11007,13 +11180,14 @@ class Vitest {
   onAdd = async (id) => {
     id = slash(id);
     this.updateLastChanged(id);
+    const fileContent = readFileSync(id, "utf-8");
     const matchingProjects = [];
-    await Promise.all(this.projects.map(async (project) => {
-      if (await project.isTargetFile(id)) {
+    this.projects.forEach((project) => {
+      if (project.matchesTestGlob(id, fileContent)) {
         matchingProjects.push(project);
-        project.testFilesList?.push(id);
+        project._markTestFile(id);
       }
-    }));
+    });
     if (matchingProjects.length > 0) {
       this.changedTests.add(id);
       this.scheduleRerun([id]);
@@ -11117,10 +11291,10 @@ class Vitest {
         if (!teardownProjects.includes(this.coreWorkspaceProject)) {
           teardownProjects.push(this.coreWorkspaceProject);
         }
-        for await (const project of teardownProjects.reverse()) {
-          await project.teardownGlobalSetup();
+        for (const project of teardownProjects.reverse()) {
+          await project._teardownGlobalSetup();
         }
-        const closePromises = this.resolvedProjects.map((w) => w.close().then(() => w.server = void 0));
+        const closePromises = this.resolvedProjects.map((w) => w.close());
         if (!this.resolvedProjects.includes(this.coreWorkspaceProject)) {
           closePromises.push(this.coreWorkspaceProject.close().then(() => this.server = void 0));
         }
@@ -11183,13 +11357,12 @@ class Vitest {
     await Promise.all(this.projects.map(async (project) => {
       const { testFiles, typecheckTestFiles } = await project.globTestFiles(filters);
       testFiles.forEach((file) => {
-        const pool = getFilePoolName(project, file);
-        const spec = project.createSpec(file, pool);
+        const spec = project.createSpecification(file);
         this.ensureSpecCached(spec);
         files.push(spec);
       });
       typecheckTestFiles.forEach((file) => {
-        const spec = project.createSpec(file, "typescript");
+        const spec = project.createSpecification(file, "typescript");
         this.ensureSpecCached(spec);
         files.push(spec);
       });
@@ -11197,7 +11370,7 @@ class Vitest {
     return files;
   }
   /**
-   * @deprecated use globTestSpecs instead
+   * @deprecated use `globTestSpecs` instead
    */
   async globTestFiles(filters = []) {
     return this.globTestSpecs(filters);
@@ -11227,6 +11400,9 @@ class Vitest {
   onClose(fn) {
     this._onClose.push(fn);
   }
+  onTestsRerun(fn) {
+    this._onUserTestsRerun.push(fn);
+  }
 }
 
 async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
@@ -11315,7 +11491,9 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
               forks: {
                 isolate: options.poolOptions?.forks?.isolate ?? options.isolate ?? testConfig.poolOptions?.forks?.isolate ?? viteConfig.test?.isolate
               }
-            }
+            },
+            root: testConfig.root ?? viteConfig.test?.root,
+            deps: testConfig.deps ?? viteConfig.test?.deps
           }
         };
         config.customLogger = createViteLogger(