vitest 2.1.2 → 2.1.3

package/dist/coverage.d.ts

@@ -1,12 +1,12 @@
 import * as vite from 'vite';
-import { B as BaseCoverageOptions, R as ResolvedCoverageOptions, V as Vitest } from './chunks/reporters.DAfKSDh5.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.CzISCQ7o.js';
+import { R as ResolvedCoverageOptions, V as Vitest, a as ReportContext } from './chunks/reporters.C4ZHgdxQ.js';
 import '@vitest/runner';
 import '@vitest/pretty-format';
 import './chunks/config.Crbj2GAb.js';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.CzISCQ7o.js';
 import 'node:stream';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
@@ -129,39 +129,76 @@ interface ResolvedThreshold {
     name: string;
     thresholds: Partial<Record<Threshold, number | undefined>>;
 }
-declare class BaseCoverageProvider {
-    /**
-     * Check if current coverage is above configured thresholds and bump the thresholds if needed
-     */
-    updateThresholds({ thresholds: allThresholds, perFile, configurationFile, onUpdate, }: {
-        thresholds: ResolvedThreshold[];
-        perFile?: boolean;
-        configurationFile: unknown;
-        onUpdate: () => void;
-    }): void;
-    /**
-     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-     */
-    checkThresholds({ thresholds: allThresholds, perFile, onError, }: {
-        thresholds: ResolvedThreshold[];
-        perFile?: boolean;
-        onError: (error: string) => void;
-    }): void;
+/**
+ * Holds info about raw coverage results that are stored on file system:
+ *
+ * ```json
+ * "project-a": {
+ *   "web": {
+ *     "tests/math.test.ts": "coverage-1.json",
+ *     "tests/utils.test.ts": "coverage-2.json",
+ * //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+ *   },
+ *   "ssr": { ... },
+ *   "browser": { ... },
+ * },
+ * "project-b": ...
+ * ```
+ */
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta['projectName']> | symbol, Record<AfterSuiteRunMeta['transformMode'], {
+    [TestFilenames: string]: string;
+}>>;
+declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istanbul' | 'v8'>> {
+    ctx: Vitest;
+    readonly name: 'v8' | 'istanbul';
+    version: string;
+    options: Options;
+    coverageFiles: CoverageFiles;
+    pendingPromises: Promise<void>[];
+    coverageFilesDirectory: string;
+    _initialize(ctx: Vitest): void;
+    createCoverageMap(): CoverageMap;
+    generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
+    parseConfigModule(_: string): Promise<{
+        generate: () => {
+            code: string;
+        };
+    }>;
+    resolveOptions(): Options;
+    clean(clean?: boolean): Promise<void>;
+    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+    readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+        /** Callback invoked with a single coverage result */
+        onFileRead: (data: CoverageType) => void;
+        /** Callback invoked once all results of a project for specific transform mode are read */
+        onFinished: (project: Vitest['projects'][number], transformMode: AfterSuiteRunMeta['transformMode']) => Promise<void>;
+        onDebug: ((...logs: any[]) => void) & {
+            enabled: boolean;
+        };
+    }): Promise<void>;
+    cleanAfterRun(): Promise<void>;
+    onTestFailure(): Promise<void>;
+    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+    reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
     /**
      * Constructs collected coverage and users' threshold options into separate sets
      * where each threshold set holds their own coverage maps. Threshold set is either
      * for specific files defined by glob pattern or global for all other files.
      */
-    resolveThresholds({ coverageMap, thresholds, createCoverageMap, root, }: {
-        coverageMap: CoverageMap;
-        thresholds: NonNullable<BaseCoverageOptions['thresholds']>;
-        createCoverageMap: () => CoverageMap;
-        root: string;
-    }): ResolvedThreshold[];
+    private resolveThresholds;
+    /**
+     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+     */
+    private checkThresholds;
     /**
-     * Resolve reporters from various configuration options
+     * Check if current coverage is above configured thresholds and bump the thresholds if needed
      */
-    resolveReporters(configReporters: NonNullable<BaseCoverageOptions['reporter']>): ResolvedCoverageOptions['reporter'];
+    updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
+        thresholds: ResolvedThreshold[];
+        configurationFile: unknown;
+        onUpdate: () => void;
+    }): Promise<void>;
+    mergeReports(coverageMaps: unknown[]): Promise<void>;
     hasTerminalReporter(reporters: ResolvedCoverageOptions['reporter']): boolean;
     toSlices<T>(array: T[], size: number): T[][];
     createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<vite.TransformResult | null | undefined>;

package/dist/coverage.js

@@ -1,7 +1,8 @@
-import { relative } from 'pathe';
-import { m as mm, r as resolveCoverageReporters } from './chunks/resolveConfig.D1DENLPF.js';
+import { existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
+import { resolve, relative } from 'pathe';
+import { c as coverageConfigDefaults, r as resolveCoverageReporters, m as mm } from './chunks/resolveConfig.Dha6ilPI.js';
+import c from 'tinyrainbow';
 import 'node:path';
-import 'node:fs';
 import 'node:fs/promises';
 import 'node:process';
 import 'node:module';
@@ -9,7 +10,6 @@ import 'node:url';
 import 'node:assert';
 import 'node:v8';
 import 'node:util';
-import 'tinyrainbow';
 import './chunks/constants.fzPh7AOq.js';
 import 'node:os';
 import './chunks/env.CmHVDJnw.js';
@@ -42,98 +42,176 @@ const THRESHOLD_KEYS = [
   "branches"
 ];
 const GLOBAL_THRESHOLDS_KEY = "global";
+const DEFAULT_PROJECT = Symbol.for("default-project");
+let uniqueId = 0;
 class BaseCoverageProvider {
-  /**
-   * Check if current coverage is above configured thresholds and bump the thresholds if needed
-   */
-  updateThresholds({
-    thresholds: allThresholds,
-    perFile,
-    configurationFile,
-    onUpdate
-  }) {
-    let updatedThresholds = false;
-    const config = resolveConfig(configurationFile);
-    assertConfigurationModule(config);
-    for (const { coverageMap, thresholds, name } of allThresholds) {
-      const summaries = perFile ? coverageMap.files().map(
-        (file) => coverageMap.fileCoverageFor(file).toSummary()
-      ) : [coverageMap.getCoverageSummary()];
-      const thresholdsToUpdate = [];
-      for (const key of THRESHOLD_KEYS) {
-        const threshold = thresholds[key] ?? 100;
-        const actual = Math.min(
-          ...summaries.map((summary) => summary[key].pct)
-        );
-        if (actual > threshold) {
-          thresholdsToUpdate.push([key, actual]);
-        }
-      }
-      if (thresholdsToUpdate.length === 0) {
-        continue;
-      }
-      updatedThresholds = true;
-      for (const [threshold, newValue] of thresholdsToUpdate) {
-        if (name === GLOBAL_THRESHOLDS_KEY) {
-          config.test.coverage.thresholds[threshold] = newValue;
-        } else {
-          const glob = config.test.coverage.thresholds[name];
-          glob[threshold] = newValue;
-        }
+  ctx;
+  name;
+  version;
+  options;
+  coverageFiles = /* @__PURE__ */ new Map();
+  pendingPromises = [];
+  coverageFilesDirectory;
+  _initialize(ctx) {
+    this.ctx = ctx;
+    if (ctx.version !== this.version) {
+      ctx.logger.warn(
+        c.yellow(
+          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
+Running mixed versions is not supported and may lead into bugs
+Update your dependencies and make sure the versions match.`
+        )
+      );
+    }
+    const config = ctx.config.coverage;
+    this.options = {
+      ...coverageConfigDefaults,
+      // User's options
+      ...config,
+      // Resolved fields
+      provider: this.name,
+      reportsDirectory: resolve(
+        ctx.config.root,
+        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
+      ),
+      reporter: resolveCoverageReporters(
+        config.reporter || coverageConfigDefaults.reporter
+      ),
+      thresholds: config.thresholds && {
+        ...config.thresholds,
+        lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
+        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
+        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
+        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
       }
+    };
+    const shard = this.ctx.config.shard;
+    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
+    this.coverageFilesDirectory = resolve(
+      this.options.reportsDirectory,
+      tempDirectory
+    );
+  }
+  createCoverageMap() {
+    throw new Error("BaseReporter's createCoverageMap was not overwritten");
+  }
+  async generateReports(_, __) {
+    throw new Error("BaseReporter's generateReports was not overwritten");
+  }
+  async parseConfigModule(_) {
+    throw new Error("BaseReporter's parseConfigModule was not overwritten");
+  }
+  resolveOptions() {
+    return this.options;
+  }
+  async clean(clean = true) {
+    if (clean && existsSync(this.options.reportsDirectory)) {
+      await promises.rm(this.options.reportsDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
     }
-    if (updatedThresholds) {
-      console.log(
-        "Updating thresholds to configuration file. You may want to push with updated coverage thresholds."
-      );
-      onUpdate();
+    if (existsSync(this.coverageFilesDirectory)) {
+      await promises.rm(this.coverageFilesDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
     }
+    await promises.mkdir(this.coverageFilesDirectory, { recursive: true });
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    this.pendingPromises = [];
   }
-  /**
-   * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-   */
-  checkThresholds({
-    thresholds: allThresholds,
-    perFile,
-    onError
-  }) {
-    for (const { coverageMap, thresholds, name } of allThresholds) {
-      if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) {
-        continue;
-      }
-      const summaries = perFile ? coverageMap.files().map((file) => ({
-        file,
-        summary: coverageMap.fileCoverageFor(file).toSummary()
-      })) : [
-        {
-          file: null,
-          summary: coverageMap.getCoverageSummary()
-        }
-      ];
-      for (const { summary, file } of summaries) {
-        for (const thresholdKey of [
-          "lines",
-          "functions",
-          "statements",
-          "branches"
-        ]) {
-          const threshold = thresholds[thresholdKey];
-          if (threshold !== void 0) {
-            const coverage = summary.data[thresholdKey].pct;
-            if (coverage < threshold) {
-              process.exitCode = 1;
-              let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
-              if (perFile && file) {
-                errorMessage += ` for ${relative("./", file).replace(
-                  /\\/g,
-                  "/"
-                )}`;
-              }
-              onError(errorMessage);
-            }
+  onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
+    if (!coverage) {
+      return;
+    }
+    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
+      throw new Error(`Invalid transform mode: ${transformMode}`);
+    }
+    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
+    if (!entry) {
+      entry = { web: {}, ssr: {}, browser: {} };
+      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
+    }
+    const testFilenames = testFiles.join();
+    const filename = resolve(
+      this.coverageFilesDirectory,
+      `coverage-${uniqueId++}.json`
+    );
+    entry[transformMode][testFilenames] = filename;
+    const promise = promises.writeFile(filename, JSON.stringify(coverage), "utf-8");
+    this.pendingPromises.push(promise);
+  }
+  async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
+    let index = 0;
+    const total = this.pendingPromises.length;
+    await Promise.all(this.pendingPromises);
+    this.pendingPromises = [];
+    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
+      for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
+        const filenames = Object.values(coverageByTestfiles);
+        const project = this.ctx.getProjectByName(projectName);
+        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
+          if (onDebug.enabled) {
+            index += chunk.length;
+            onDebug("Covered files %d/%d", index, total);
           }
+          await Promise.all(
+            chunk.map(async (filename) => {
+              const contents = await promises.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              onFileRead(coverage);
+            })
+          );
         }
+        await onFinished(project, transformMode);
+      }
+    }
+  }
+  async cleanAfterRun() {
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    await promises.rm(this.coverageFilesDirectory, { recursive: true });
+    if (readdirSync(this.options.reportsDirectory).length === 0) {
+      await promises.rm(this.options.reportsDirectory, { recursive: true });
+    }
+  }
+  async onTestFailure() {
+    if (!this.options.reportOnFailure) {
+      await this.cleanAfterRun();
+    }
+  }
+  async reportCoverage(coverageMap, { allTestsRun }) {
+    await this.generateReports(
+      coverageMap || this.createCoverageMap(),
+      allTestsRun
+    );
+    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
+    if (!keepResults) {
+      await this.cleanAfterRun();
+    }
+  }
+  async reportThresholds(coverageMap, allTestsRun) {
+    const resolvedThresholds = this.resolveThresholds(coverageMap);
+    this.checkThresholds(resolvedThresholds);
+    if (this.options.thresholds?.autoUpdate && allTestsRun) {
+      if (!this.ctx.server.config.configFile) {
+        throw new Error(
+          'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
+        );
       }
+      const configFilePath = this.ctx.server.config.configFile;
+      const configModule = await this.parseConfigModule(configFilePath);
+      await this.updateThresholds({
+        thresholds: resolvedThresholds,
+        configurationFile: configModule,
+        onUpdate: () => writeFileSync(
+          configFilePath,
+          configModule.generate().code,
+          "utf-8"
+        )
+      });
     }
   }
   /**
@@ -141,26 +219,19 @@ class BaseCoverageProvider {
    * where each threshold set holds their own coverage maps. Threshold set is either
    * for specific files defined by glob pattern or global for all other files.
    */
-  resolveThresholds({
-    coverageMap,
-    thresholds,
-    createCoverageMap,
-    root
-  }) {
+  resolveThresholds(coverageMap) {
     const resolvedThresholds = [];
     const files = coverageMap.files();
-    const globalCoverageMap = createCoverageMap();
-    for (const key of Object.keys(
-      thresholds
-    )) {
+    const globalCoverageMap = this.createCoverageMap();
+    for (const key of Object.keys(this.options.thresholds)) {
       if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) {
         continue;
       }
       const glob = key;
-      const globThresholds = resolveGlobThresholds(thresholds[glob]);
-      const globCoverageMap = createCoverageMap();
+      const globThresholds = resolveGlobThresholds(this.options.thresholds[glob]);
+      const globCoverageMap = this.createCoverageMap();
       const matchingFiles = files.filter(
-        (file) => mm.isMatch(relative(root, file), glob)
+        (file) => mm.isMatch(relative(this.ctx.config.root, file), glob)
       );
       for (const file of matchingFiles) {
         const fileCoverage = coverageMap.fileCoverageFor(file);
@@ -180,19 +251,89 @@ class BaseCoverageProvider {
       name: GLOBAL_THRESHOLDS_KEY,
       coverageMap: globalCoverageMap,
       thresholds: {
-        branches: thresholds.branches,
-        functions: thresholds.functions,
-        lines: thresholds.lines,
-        statements: thresholds.statements
+        branches: this.options.thresholds?.branches,
+        functions: this.options.thresholds?.functions,
+        lines: this.options.thresholds?.lines,
+        statements: this.options.thresholds?.statements
       }
     });
     return resolvedThresholds;
   }
   /**
-   * Resolve reporters from various configuration options
+   * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+   */
+  checkThresholds(allThresholds) {
+    for (const { coverageMap, thresholds, name } of allThresholds) {
+      if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) {
+        continue;
+      }
+      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map((file) => ({
+        file,
+        summary: coverageMap.fileCoverageFor(file).toSummary()
+      })) : [{ file: null, summary: coverageMap.getCoverageSummary() }];
+      for (const { summary, file } of summaries) {
+        for (const thresholdKey of THRESHOLD_KEYS) {
+          const threshold = thresholds[thresholdKey];
+          if (threshold !== void 0) {
+            const coverage = summary.data[thresholdKey].pct;
+            if (coverage < threshold) {
+              process.exitCode = 1;
+              let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
+              if (this.options.thresholds?.perFile && file) {
+                errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+              }
+              this.ctx.logger.error(errorMessage);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Check if current coverage is above configured thresholds and bump the thresholds if needed
    */
-  resolveReporters(configReporters) {
-    return resolveCoverageReporters(configReporters);
+  async updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }) {
+    let updatedThresholds = false;
+    const config = resolveConfig(configurationFile);
+    assertConfigurationModule(config);
+    for (const { coverageMap, thresholds, name } of allThresholds) {
+      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map(
+        (file) => coverageMap.fileCoverageFor(file).toSummary()
+      ) : [coverageMap.getCoverageSummary()];
+      const thresholdsToUpdate = [];
+      for (const key of THRESHOLD_KEYS) {
+        const threshold = thresholds[key] ?? 100;
+        const actual = Math.min(
+          ...summaries.map((summary) => summary[key].pct)
+        );
+        if (actual > threshold) {
+          thresholdsToUpdate.push([key, actual]);
+        }
+      }
+      if (thresholdsToUpdate.length === 0) {
+        continue;
+      }
+      updatedThresholds = true;
+      for (const [threshold, newValue] of thresholdsToUpdate) {
+        if (name === GLOBAL_THRESHOLDS_KEY) {
+          config.test.coverage.thresholds[threshold] = newValue;
+        } else {
+          const glob = config.test.coverage.thresholds[name];
+          glob[threshold] = newValue;
+        }
+      }
+    }
+    if (updatedThresholds) {
+      this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
+      onUpdate();
+    }
+  }
+  async mergeReports(coverageMaps) {
+    const coverageMap = this.createCoverageMap();
+    for (const coverage of coverageMaps) {
+      coverageMap.merge(coverage);
+    }
+    await this.generateReports(coverageMap, true);
   }
   hasTerminalReporter(reporters) {
     return reporters.some(

package/dist/execute.d.ts

@@ -1,7 +1,7 @@
 import vm from 'node:vm';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeRunnerOptions } from 'vite-node';
-import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.Chrs-_NL.js';
+import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.B6RjTtbk.js';
 import * as _vitest_mocker from '@vitest/mocker';
 import { MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './chunks/mocker.cRtM890J.js';

package/dist/index.d.ts

@@ -1,25 +1,25 @@
-import './chunks/vite.8fk186v-.js';
+import './chunks/vite.YH7MrecS.js';
 import { Plugin } from '@vitest/pretty-format';
 import { SnapshotState } from '@vitest/snapshot';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
 import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, ExpectPollOptions, ExpectStatic, JestAssertion } from '@vitest/expect';
-import { e as VitestEnvironment$1, S as SerializedTestSpecification, f as RawErrsMap$1, T as TscErrorInfo$1, g as CollectLineNumbers$1, h as CollectLines$1, i as RootAndTarget$1, j as Context$1, C as CoverageProvider$1, k as ReportContext$1, a as CoverageProviderModule$1, l as CoverageReporter$1, m as CoverageProviderName, n as CoverageOptions$1, R as ResolvedCoverageOptions$1, B as BaseCoverageOptions$1, o as CoverageIstanbulOptions$1, b as CoverageV8Options$1, p as CustomProviderOptions$1, q as Reporter$1, V as Vitest$1, r as BrowserScript$1, s as BrowserConfigOptions$1, t as BuiltinEnvironment$1, P as Pool$1, u as PoolOptions$1, v as CSSModuleScopeStrategy$1, A as ApiConfig$1, w as VitestRunMode$1, D as DepsOptimizationOptions$1, x as TransformModePatterns$1, I as InlineConfig$1, y as TypecheckConfig$1, z as UserConfig$1, E as ResolvedConfig$1, F as ProjectConfig$1, U as UserWorkspaceConfig$1, G as BenchmarkUserOptions$1 } from './chunks/reporters.DAfKSDh5.js';
+import { f as VitestEnvironment$1, S as SerializedTestSpecification, g as RawErrsMap$1, T as TscErrorInfo$1, h as CollectLineNumbers$1, i as CollectLines$1, j as RootAndTarget$1, k as Context$1, C as CoverageProvider$1, a as ReportContext$1, b as CoverageProviderModule$1, l as CoverageReporter$1, m as CoverageProviderName, n as CoverageOptions$1, R as ResolvedCoverageOptions$1, B as BaseCoverageOptions$1, o as CoverageIstanbulOptions$1, c as CoverageV8Options$1, p as CustomProviderOptions$1, q as Reporter$1, V as Vitest$1, r as BrowserScript$1, s as BrowserConfigOptions$1, t as BuiltinEnvironment$1, P as Pool$1, u as PoolOptions$1, v as CSSModuleScopeStrategy$1, A as ApiConfig$1, w as VitestRunMode$1, D as DepsOptimizationOptions$1, x as TransformModePatterns$1, I as InlineConfig$1, y as TypecheckConfig$1, z as UserConfig$1, E as ResolvedConfig$1, F as ProjectConfig$1, U as UserWorkspaceConfig$1, G as BenchmarkUserOptions$1 } from './chunks/reporters.C4ZHgdxQ.js';
 import { B as BenchmarkResult } from './chunks/benchmark.JVlTzojj.js';
 export { b as BenchFunction, a as Benchmark, c as BenchmarkAPI } from './chunks/benchmark.JVlTzojj.js';
 import { U as UserConsoleLog, P as ProvidedContext, M as ModuleGraphData, b as Awaitable$1, N as Nullable$1, c as Arrayable$1, d as ArgumentsType$1, e as MutableArray$1, C as Constructable$1, O as OnServerRestartHandler$1, a as EnvironmentReturn$1, V as VmEnvironmentReturn$1, E as Environment$1, R as ResolvedTestEnvironment$1, J as JSDOMOptions$1, H as HappyDOMOptions$1, f as EnvironmentOptions$1 } from './chunks/environment.CzISCQ7o.js';
 export { A as AfterSuiteRunMeta, g as ModuleCache } from './chunks/environment.CzISCQ7o.js';
-import { TaskPopulated, TaskResultPack, File as File$1, Suite as Suite$1, Test as Test$1, Custom as Custom$1, Task as Task$1, SequenceHooks as SequenceHooks$1, SequenceSetupFiles as SequenceSetupFiles$1 } from '@vitest/runner';
-export { CancelReason, DoneCallback, ExtendedContext, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, Custom as RunnerCustomCase, Task as RunnerTask, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, RuntimeContext, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, TaskBase, TaskContext, TaskCustomOptions, TaskMeta, TaskResult, TaskResultPack, TaskState, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { TaskPopulated, TaskResultPack as TaskResultPack$1, File as File$1, Suite as Suite$1, Test as Test$1, Custom as Custom$1, Task as Task$1, TaskBase as TaskBase$1, TaskResult as TaskResult$1, DoneCallback as DoneCallback$1, RuntimeContext as RuntimeContext$1, SuiteHooks as SuiteHooks$1, SequenceHooks as SequenceHooks$1, SequenceSetupFiles as SequenceSetupFiles$1 } from '@vitest/runner';
+export { CancelReason, ExtendedContext, HookCleanupCallback, HookListener, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Custom as RunnerCustomCase, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskContext, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { a as BirpcReturn, b as WorkerRPC$1 } from './chunks/worker.B6RjTtbk.js';
+export { C as ContextRPC, e as ContextTestEnvironment, d as ResolveIdFunction, c as RunnerRPC, R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.B6RjTtbk.js';
+import { W as WorkerContext$1 } from './chunks/worker.CcJLfX8w.js';
 export { b as bench } from './chunks/suite.BMWOKiTe.js';
 import { F as FakeTimerInstallOpts, R as RuntimeOptions, S as SerializedConfig } from './chunks/config.Crbj2GAb.js';
 export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.Crbj2GAb.js';
 import { M as MockFactoryWithHelper, a as MockOptions } from './chunks/mocker.cRtM890J.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
-import { a as BirpcReturn } from './chunks/worker.Chrs-_NL.js';
-export { C as ContextRPC, e as ContextTestEnvironment, c as ResolveIdFunction, b as RunnerRPC, R as RuntimeRPC, W as WorkerGlobalState, d as WorkerRPC } from './chunks/worker.Chrs-_NL.js';
-export { W as WorkerContext } from './chunks/worker.Qtv8v5nL.js';
 export { ErrorWithDiff, ParsedStack, SerializedError, TestError } from '@vitest/utils';
 export { DiffOptions } from '@vitest/utils/diff';
 import * as chai from 'chai';
@@ -35,9 +35,9 @@ import 'vite-node/server';
 import '@vitest/utils/source-map';
 import 'node:fs';
 import '@vitest/runner/utils';
+import 'node:worker_threads';
 import '@vitest/snapshot/environment';
 import '@vitest/mocker';
-import 'node:worker_threads';
 
 declare global {
     namespace Chai {
@@ -1508,7 +1508,7 @@ interface VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
-declare function getRunningMode(): "run" | "watch";
+declare function getRunningMode(): "watch" | "run";
 declare function isWatchMode(): boolean;
 
 /**
@@ -1543,7 +1543,7 @@ interface TransformResultWithSource {
     source?: string;
 }
 interface WebSocketHandlers {
-    onTaskUpdate: (packs: TaskResultPack[]) => void;
+    onTaskUpdate: (packs: TaskResultPack$1[]) => void;
     getFiles: () => File$1[];
     getTestFiles: () => Promise<SerializedTestSpecification[]>;
     getPaths: () => string[];
@@ -1559,7 +1559,7 @@ interface WebSocketHandlers {
 interface WebSocketEvents {
     onCollected?: (files?: File$1[]) => Awaitable$1<void>;
     onFinished?: (files: File$1[], errors: unknown[], coverage?: unknown) => Awaitable$1<void>;
-    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable$1<void>;
+    onTaskUpdate?: (packs: TaskResultPack$1[]) => Awaitable$1<void>;
     onUserConsoleLog?: (log: UserConsoleLog) => Awaitable$1<void>;
     onPathsCollected?: (paths?: string[]) => Awaitable$1<void>;
     onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable$1<void>;
@@ -1589,6 +1589,23 @@ type Test = Test$1;
 type Custom = Custom$1;
 /** @deprecated use `RunnerTask` instead */
 type Task = Task$1;
+/** @deprecated use `RunnerTaskBase` instead */
+type TaskBase = TaskBase$1;
+/** @deprecated use `RunnerTaskResult` instead */
+type TaskResult = TaskResult$1;
+/** @deprecated use `RunnerTaskResultPack` instead */
+type TaskResultPack = TaskResultPack$1;
+/** @deprecated don't use `DoneCallback` since it's not supported */
+type DoneCallback = DoneCallback$1;
+/** @deprecated internal type, don't use it */
+type RuntimeContext = RuntimeContext$1;
+/** @deprecated internal type, don't use it */
+type SuiteHooks = SuiteHooks$1;
+
+/** @deprecated import from `vitest/node` instead */
+type WorkerContext = WorkerContext$1;
+/** @deprecated import from `vitest/node` instead */
+type WorkerRPC = WorkerRPC$1;
 
 /** @deprecated do not use, internal helper */
 type Awaitable<T> = Awaitable$1<T>;
@@ -1690,4 +1707,4 @@ type SerializableSpec = SerializedTestSpecification;
 /** @deprecated import from `vitest/node` instead */
 type BenchmarkUserOptions = BenchmarkUserOptions$1;
 
-export { type ApiConfig, type ArgumentsType, type Arrayable, type AssertType, type Awaitable, type BaseCoverageOptions, BenchmarkResult, type BenchmarkUserOptions, type BrowserConfigOptions, type BrowserScript, type BrowserUI, type BuiltinEnvironment, type CSSModuleScopeStrategy, type CollectLineNumbers, type CollectLines, type Constructable, type Context, type CoverageIstanbulOptions, type CoverageOptions, type CoverageProvider, type CoverageProviderModule, type CoverageReporter, type CoverageV8Options, type Custom, type CustomProviderOptions, type DepsOptimizationOptions, type Environment, type EnvironmentOptions, type EnvironmentReturn, type ExpectTypeOf, type File, type HappyDOMOptions, type InlineConfig, type JSDOMOptions, ModuleGraphData, type MutableArray, type Nullable, type OnServerRestartHandler, type Pool, type PoolOptions, type ProjectConfig, ProvidedContext, type RawErrsMap, type ReportContext, type Reporter, type ResolvedConfig, type ResolvedCoverageOptions, type ResolvedTestEnvironment, type RootAndTarget, type SequenceHooks, type SequenceSetupFiles, type SerializableSpec, SerializedConfig, SerializedTestSpecification, type Suite, type Task, type Test, type TransformModePatterns, type TransformResultWithSource, type TscErrorInfo, type TypecheckConfig, type UserConfig, UserConsoleLog, type UserWorkspaceConfig, type Vitest, type VitestEnvironment, type VitestRunMode, type VitestUtils, type VmEnvironmentReturn, type WebSocketEvents, type WebSocketHandlers, type WebSocketRPC, assertType, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, inject, isFirstRun, isWatchMode, runOnce, vi, vitest };
+export { type ApiConfig, type ArgumentsType, type Arrayable, type AssertType, type Awaitable, type BaseCoverageOptions, BenchmarkResult, type BenchmarkUserOptions, type BrowserConfigOptions, type BrowserScript, type BrowserUI, type BuiltinEnvironment, type CSSModuleScopeStrategy, type CollectLineNumbers, type CollectLines, type Constructable, type Context, type CoverageIstanbulOptions, type CoverageOptions, type CoverageProvider, type CoverageProviderModule, type CoverageReporter, type CoverageV8Options, type Custom, type CustomProviderOptions, type DepsOptimizationOptions, type DoneCallback, type Environment, type EnvironmentOptions, type EnvironmentReturn, type ExpectTypeOf, type File, type HappyDOMOptions, type InlineConfig, type JSDOMOptions, ModuleGraphData, type MutableArray, type Nullable, type OnServerRestartHandler, type Pool, type PoolOptions, type ProjectConfig, ProvidedContext, type RawErrsMap, type ReportContext, type Reporter, type ResolvedConfig, type ResolvedCoverageOptions, type ResolvedTestEnvironment, type RootAndTarget, type RuntimeContext, type SequenceHooks, type SequenceSetupFiles, type SerializableSpec, SerializedConfig, SerializedTestSpecification, type Suite, type SuiteHooks, type Task, type TaskBase, type TaskResult, type TaskResultPack, type Test, type TransformModePatterns, type TransformResultWithSource, type TscErrorInfo, type TypecheckConfig, type UserConfig, UserConsoleLog, type UserWorkspaceConfig, type Vitest, type VitestEnvironment, type VitestRunMode, type VitestUtils, type VmEnvironmentReturn, type WebSocketEvents, type WebSocketHandlers, type WebSocketRPC, type WorkerContext, type WorkerRPC, assertType, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, inject, isFirstRun, isWatchMode, runOnce, vi, vitest };