vitest 0.29.8 → 0.30.0

package/dist/index.d.ts

@@ -1,26 +1,29 @@
-import { Test } from '@vitest/runner';
 export { SequenceHooks, SequenceSetupFiles, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, A as AfterSuiteRunMeta, U as UserConsoleLog, a as ResolvedConfig, b as ModuleGraphData, S as SnapshotResult, c as Reporter } from './types-94cfe4b4.js';
-export { A as AfterSuiteRunMeta, k as ApiConfig, H as ArgumentsType, G as Arrayable, D as Awaitable, a2 as BaseCoverageOptions, a9 as BenchFunction, a7 as Benchmark, B as BenchmarkAPI, a8 as BenchmarkResult, a6 as BenchmarkUserOptions, h as BuiltinEnvironment, j as CSSModuleScopeStrategy, C as CollectLineNumbers, e as CollectLines, L as Constructable, g as Context, q as ContextRPC, p as ContextTestEnvironment, a4 as CoverageC8Options, a3 as CoverageIstanbulOptions, a0 as CoverageOptions, Y as CoverageProvider, _ as CoverageProviderModule, $ as CoverageReporter, a5 as CustomProviderOptions, Q as Environment, E as EnvironmentOptions, P as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, O as ModuleCache, b as ModuleGraphData, K as MutableArray, N as Nullable, X as OnServerRestartHandler, d as RawErrsMap, Z as ReportContext, c as Reporter, y as ResolveIdFunction, a as ResolvedConfig, a1 as ResolvedCoverageOptions, f as RootAndTarget, R as RuntimeConfig, o as RuntimeRPC, s as SnapshotData, v as SnapshotMatchOptions, S as SnapshotResult, u as SnapshotStateOptions, x as SnapshotSummary, t as SnapshotUpdateState, T as TscErrorInfo, m as TypecheckConfig, w as UncheckedSnapshot, n as UserConfig, U as UserConsoleLog, r as Vitest, V as VitestEnvironment, i as VitestPool, l as VitestRunMode, W as WorkerContext, z as WorkerGlobalState } from './types-94cfe4b4.js';
+import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, A as AfterSuiteRunMeta, U as UserConsoleLog, a as ResolvedConfig, b as ModuleGraphData, c as Reporter } from './types-f03c83c4.js';
+export { n as ApiConfig, D as ArgumentsType, z as Arrayable, y as Awaitable, a0 as BaseCoverageOptions, a7 as BenchFunction, a5 as Benchmark, a6 as BenchmarkResult, a4 as BenchmarkUserOptions, k as BuiltinEnvironment, m as CSSModuleScopeStrategy, C as ChaiConfig, f as CollectLineNumbers, h as CollectLines, H as Constructable, j as Context, u as ContextRPC, t as ContextTestEnvironment, a2 as CoverageC8Options, a1 as CoverageIstanbulOptions, _ as CoverageOptions, S as CoverageProvider, Y as CoverageProviderModule, Z as CoverageReporter, a3 as CustomProviderOptions, O as Environment, E as EnvironmentOptions, L as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, K as ModuleCache, G as MutableArray, N as Nullable, Q as OnServerRestartHandler, P as ProjectConfig, e as RawErrsMap, X as ReportContext, w as ResolveIdFunction, $ as ResolvedCoverageOptions, i as RootAndTarget, r as RuntimeRPC, T as TscErrorInfo, p as TypecheckConfig, q as UserConfig, v as Vitest, V as VitestEnvironment, l as VitestPool, o as VitestRunMode, W as WorkerContext, x as WorkerGlobalState, d as createExpect, g as expect, s as setupChaiConfig } from './types-f03c83c4.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, EnhancedSpy } from '@vitest/spy';
 export { EnhancedSpy, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
-export { S as SnapshotEnvironment } from './env-afee91f0.js';
+export { SnapshotEnvironment } from '@vitest/snapshot/environment';
 import { File, TaskResultPack } from '@vitest/runner/types';
 export { DoneCallback, File, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, RuntimeContext, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TestOptions } from '@vitest/runner/types';
+import { SnapshotResult } from '@vitest/snapshot';
+export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
 import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
+export { UserWorkspaceConfig } from './config.js';
 export { ErrorWithDiff, ParsedStack } from '@vitest/runner/utils';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 import '@vitest/expect';
 import '@vitest/utils';
 import 'vite-node/client';
+import '@vitest/snapshot/manager';
 import 'node:worker_threads';
 import 'vite-node';
 import 'source-map';
-import 'node:fs';
 import 'vite-node/server';
+import 'node:fs';
 
 declare type Not<T extends boolean> = T extends true ? false : true;
 declare type And<Types extends boolean[]> = Types[number] extends true ? true : false;
@@ -181,9 +184,6 @@ declare function runOnce<T>(fn: (() => T), key?: string): T;
  */
 declare function isFirstRun(): boolean;
 
-declare function createExpect(test?: Test): Vi.ExpectStatic;
-declare const globalExpect: Vi.ExpectStatic;
-
 interface VitestUtils {
     useFakeTimers(config?: FakeTimerInstallOpts): this;
     useRealTimers(): this;
@@ -323,7 +323,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;
 
 interface TransformResultWithSource extends TransformResult {
@@ -339,6 +339,7 @@ interface WebSocketHandlers {
     getPaths(): string[];
     getConfig(): ResolvedConfig;
     resolveSnapshotPath(testPath: string): string;
+    resolveSnapshotRawPath(testPath: string, rawPath: string): string;
     getModuleGraph(id: string): Promise<ModuleGraphData>;
     getTransformResult(id: string): Promise<TransformResultWithSource | undefined>;
     readFile(id: string): Promise<string | null>;
@@ -352,4 +353,4 @@ interface WebSocketHandlers {
 interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog' | 'onPathsCollected'> {
 }
 
-export { AssertType, ExpectTypeOf, TransformResultWithSource, WebSocketEvents, WebSocketHandlers, assertType, bench, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest };
+export { AfterSuiteRunMeta, AssertType, BenchmarkAPI, ExpectTypeOf, ModuleGraphData, Reporter, ResolvedConfig, RuntimeConfig, TransformResultWithSource, UserConsoleLog, WebSocketEvents, WebSocketHandlers, assertType, bench, expectTypeOf, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest };

package/dist/index.js

@@ -1,23 +1,21 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench, c as createExpect, g as expect, a as vi, v as vitest } from './chunk-utils-import.e488ace3.js';
-export { i as isFirstRun, r as runOnce } from './chunk-integrations-run-once.ea614f17.js';
-import { d as dist } from './chunk-integrations-utils.23c19408.js';
-export { b as assertType, g as getRunningMode, a as isWatchMode } from './chunk-integrations-utils.23c19408.js';
+export { e as bench, c as createExpect, d as expect, s as setupChaiConfig, v as vi, f as vitest } from './vendor-vi.a3ff54b1.js';
+export { i as isFirstRun, a as runOnce } from './vendor-run-once.69ce7172.js';
+import { d as dist } from './vendor-index.81b9e499.js';
+export { b as assertType, g as getRunningMode, a as isWatchMode } from './vendor-index.81b9e499.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './chunk-utils-env.6b856dbf.js';
+import './vendor-index.fad2598b.js';
 import 'pathe';
 import 'std-env';
-import './chunk-utils-global.fd174983.js';
-import './vendor-_commonjsHelpers.addc3445.js';
+import './vendor-global.6795f91f.js';
+import './vendor-_commonjsHelpers.76cdd49e.js';
 import '@vitest/expect';
-import './chunk-runtime-rpc.d6aa57f8.js';
-import './chunk-snapshot-env.a347d647.js';
-import './chunk-utils-base.b5ddfcc9.js';
-import './chunk-utils-tasks.8781fd71.js';
+import '@vitest/snapshot';
+import './vendor-tasks.042d6084.js';
 import 'util';
 import '@vitest/spy';
 

package/dist/loader.js

@@ -1,22 +1,405 @@
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { readFile } from 'node:fs/promises';
-import { i as isNodeBuiltin, h as hasCJSSyntax } from './vendor-index.bdee400f.js';
-import { normalizeModuleId } from 'vite-node/utils';
-import './chunk-utils-env.6b856dbf.js';
-import { g as getWorkerState } from './chunk-utils-global.fd174983.js';
 import 'acorn';
-import 'node:module';
+import { builtinModules } from 'node:module';
 import 'node:fs';
 import 'pathe';
-import 'node:assert';
-import 'node:process';
+import assert from 'node:assert';
+import process$1 from 'node:process';
 import 'node:path';
-import 'node:v8';
-import 'node:util';
+import v8 from 'node:v8';
+import { format, inspect } from 'node:util';
+import { normalizeModuleId } from 'vite-node/utils';
+import './vendor-index.fad2598b.js';
+import { g as getWorkerState } from './vendor-global.6795f91f.js';
 import 'std-env';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 
+const BUILTIN_MODULES = new Set(builtinModules);
+
+/**
+ * @typedef ErrnoExceptionFields
+ * @property {number | undefined} [errnode]
+ * @property {string | undefined} [code]
+ * @property {string | undefined} [path]
+ * @property {string | undefined} [syscall]
+ * @property {string | undefined} [url]
+ *
+ * @typedef {Error & ErrnoExceptionFields} ErrnoException
+ */
+
+const isWindows = process$1.platform === 'win32';
+
+const own$1 = {}.hasOwnProperty;
+
+/**
+ * Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
+ * We cannot use Intl.ListFormat because it's not available in
+ * --without-intl builds.
+ *
+ * @param {Array<string>} array
+ *   An array of strings.
+ * @param {string} [type]
+ *   The list type to be inserted before the last element.
+ * @returns {string}
+ */
+function formatList(array, type = 'and') {
+  return array.length < 3
+    ? array.join(` ${type} `)
+    : `${array.slice(0, -1).join(', ')}, ${type} ${array[array.length - 1]}`
+}
+
+/** @type {Map<string, MessageFunction|string>} */
+const messages = new Map();
+const nodeInternalPrefix = '__node_internal_';
+/** @type {number} */
+let userStackTraceLimit;
+
+createError(
+  'ERR_INVALID_MODULE_SPECIFIER',
+  /**
+   * @param {string} request
+   * @param {string} reason
+   * @param {string} [base]
+   */
+  (request, reason, base = undefined) => {
+    return `Invalid module "${request}" ${reason}${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  TypeError
+);
+
+createError(
+  'ERR_INVALID_PACKAGE_CONFIG',
+  /**
+   * @param {string} path
+   * @param {string} [base]
+   * @param {string} [message]
+   */
+  (path, base, message) => {
+    return `Invalid package config ${path}${
+      base ? ` while importing ${base}` : ''
+    }${message ? `. ${message}` : ''}`
+  },
+  Error
+);
+
+createError(
+  'ERR_INVALID_PACKAGE_TARGET',
+  /**
+   * @param {string} pkgPath
+   * @param {string} key
+   * @param {unknown} target
+   * @param {boolean} [isImport=false]
+   * @param {string} [base]
+   */
+  (pkgPath, key, target, isImport = false, base = undefined) => {
+    const relError =
+      typeof target === 'string' &&
+      !isImport &&
+      target.length > 0 &&
+      !target.startsWith('./');
+    if (key === '.') {
+      assert(isImport === false);
+      return (
+        `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
+        `in the package config ${pkgPath}package.json${
+          base ? ` imported from ${base}` : ''
+        }${relError ? '; targets must start with "./"' : ''}`
+      )
+    }
+
+    return `Invalid "${
+      isImport ? 'imports' : 'exports'
+    }" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${pkgPath}package.json${
+      base ? ` imported from ${base}` : ''
+    }${relError ? '; targets must start with "./"' : ''}`
+  },
+  Error
+);
+
+createError(
+  'ERR_MODULE_NOT_FOUND',
+  /**
+   * @param {string} path
+   * @param {string} base
+   * @param {string} [type]
+   */
+  (path, base, type = 'package') => {
+    return `Cannot find ${type} '${path}' imported from ${base}`
+  },
+  Error
+);
+
+createError(
+  'ERR_NETWORK_IMPORT_DISALLOWED',
+  "import of '%s' by %s is not supported: %s",
+  Error
+);
+
+createError(
+  'ERR_PACKAGE_IMPORT_NOT_DEFINED',
+  /**
+   * @param {string} specifier
+   * @param {string} packagePath
+   * @param {string} base
+   */
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${
+      packagePath ? ` in package ${packagePath}package.json` : ''
+    } imported from ${base}`
+  },
+  TypeError
+);
+
+createError(
+  'ERR_PACKAGE_PATH_NOT_EXPORTED',
+  /**
+   * @param {string} pkgPath
+   * @param {string} subpath
+   * @param {string} [base]
+   */
+  (pkgPath, subpath, base = undefined) => {
+    if (subpath === '.')
+      return `No "exports" main defined in ${pkgPath}package.json${
+        base ? ` imported from ${base}` : ''
+      }`
+    return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  Error
+);
+
+createError(
+  'ERR_UNSUPPORTED_DIR_IMPORT',
+  "Directory import '%s' is not supported " +
+    'resolving ES modules imported from %s',
+  Error
+);
+
+createError(
+  'ERR_UNKNOWN_FILE_EXTENSION',
+  /**
+   * @param {string} ext
+   * @param {string} path
+   */
+  (ext, path) => {
+    return `Unknown file extension "${ext}" for ${path}`
+  },
+  TypeError
+);
+
+createError(
+  'ERR_INVALID_ARG_VALUE',
+  /**
+   * @param {string} name
+   * @param {unknown} value
+   * @param {string} [reason='is invalid']
+   */
+  (name, value, reason = 'is invalid') => {
+    let inspected = inspect(value);
+
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+
+    const type = name.includes('.') ? 'property' : 'argument';
+
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`
+  },
+  TypeError
+  // Note: extra classes have been shaken out.
+  // , RangeError
+);
+
+createError(
+  'ERR_UNSUPPORTED_ESM_URL_SCHEME',
+  /**
+   * @param {URL} url
+   * @param {Array<string>} supported
+   */
+  (url, supported) => {
+    let message = `Only URLs with a scheme in: ${formatList(
+      supported
+    )} are supported by the default ESM loader`;
+
+    if (isWindows && url.protocol.length === 2) {
+      message += '. On Windows, absolute paths must be valid file:// URLs';
+    }
+
+    message += `. Received protocol '${url.protocol}'`;
+    return message
+  },
+  Error
+);
+
+/**
+ * Utility function for registering the error codes. Only used here. Exported
+ * *only* to allow for testing.
+ * @param {string} sym
+ * @param {MessageFunction|string} value
+ * @param {ErrorConstructor} def
+ * @returns {new (...args: Array<any>) => Error}
+ */
+function createError(sym, value, def) {
+  // Special case for SystemError that formats the error message differently
+  // The SystemErrors only have SystemError as their base classes.
+  messages.set(sym, value);
+
+  return makeNodeErrorWithCode(def, sym)
+}
+
+/**
+ * @param {ErrorConstructor} Base
+ * @param {string} key
+ * @returns {ErrorConstructor}
+ */
+function makeNodeErrorWithCode(Base, key) {
+  // @ts-expect-error It’s a Node error.
+  return NodeError
+  /**
+   * @param {Array<unknown>} args
+   */
+  function NodeError(...args) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    // Reset the limit and setting the name property.
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, args, error);
+    Object.defineProperties(error, {
+      // Note: no need to implement `kIsNodeError` symbol, would be hard,
+      // probably.
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        /** @this {Error} */
+        value() {
+          return `${this.name} [${key}]: ${this.message}`
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+
+    captureLargerStackTrace(error);
+    // @ts-expect-error It’s a Node error.
+    error.code = key;
+    return error
+  }
+}
+
+/**
+ * @returns {boolean}
+ */
+function isErrorStackTraceLimitWritable() {
+  // Do no touch Error.stackTraceLimit as V8 would attempt to install
+  // it again during deserialization.
+  try {
+    // @ts-expect-error: not in types?
+    if (v8.startupSnapshot.isBuildingSnapshot()) {
+      return false
+    }
+  } catch {}
+
+  const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
+  if (desc === undefined) {
+    return Object.isExtensible(Error)
+  }
+
+  return own$1.call(desc, 'writable') && desc.writable !== undefined
+    ? desc.writable
+    : desc.set !== undefined
+}
+
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ * @template {(...args: unknown[]) => unknown} T
+ * @param {T} fn
+ * @returns {T}
+ */
+function hideStackFrames(fn) {
+  // We rename the functions that will be hidden to cut off the stacktrace
+  // at the outermost one
+  const hidden = nodeInternalPrefix + fn.name;
+  Object.defineProperty(fn, 'name', {value: hidden});
+  return fn
+}
+
+const captureLargerStackTrace = hideStackFrames(
+  /**
+   * @param {Error} error
+   * @returns {Error}
+   */
+  // @ts-expect-error: fine
+  function (error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+
+    Error.captureStackTrace(error);
+
+    // Reset the limit
+    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+
+    return error
+  }
+);
+
+/**
+ * @param {string} key
+ * @param {Array<unknown>} args
+ * @param {Error} self
+ * @returns {string}
+ */
+function getMessage(key, args, self) {
+  const message = messages.get(key);
+  assert(typeof message !== 'undefined', 'expected `message` to be found');
+
+  if (typeof message === 'function') {
+    assert(
+      message.length <= args.length, // Default options do not count.
+      `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+        `match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, args)
+  }
+
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  assert(
+    expectedLength === args.length,
+    `Code: ${key}; The provided arguments length (${args.length}) does not ` +
+      `match the required ones (${expectedLength}).`
+  );
+  if (args.length === 0) return message
+
+  args.unshift(message);
+  return Reflect.apply(format, null, args)
+}
+function isNodeBuiltin(id = "") {
+  id = id.replace(/^node:/, "").split("/")[0];
+  return BUILTIN_MODULES.has(id);
+}
+pathToFileURL(process.cwd());
+const CJS_RE = /([\s;]|^)(module.exports\b|exports\.\w|require\s*\(|global\.\w)/m;
+function hasCJSSyntax(code) {
+  return CJS_RE.test(code);
+}
+
 var ModuleFormat = /* @__PURE__ */ ((ModuleFormat2) => {
   ModuleFormat2["Builtin"] = "builtin";
   ModuleFormat2["Commonjs"] = "commonjs";
@@ -31,7 +414,7 @@ function hasESMSyntax(code) {
   return ESM_RE.test(code);
 }
 const cache = /* @__PURE__ */ new Map();
-const getPotentialSource = async (filepath, result) => {
+async function getPotentialSource(filepath, result) {
   var _a;
   if (!result.url.startsWith("file://") || result.format === "module")
     return null;
@@ -39,15 +422,15 @@ const getPotentialSource = async (filepath, result) => {
   if (source == null)
     source = await readFile(filepath, "utf8");
   return source;
-};
-const detectESM = (url, source) => {
+}
+function detectESM(url, source) {
   const cached = cache.get(url);
   if (cached)
     return cached.isPseudoESM;
   if (!source)
     return false;
   return hasESMSyntax(source) && !hasCJSSyntax(source);
-};
+}
 const resolve = async (url, context, next) => {
   const { parentURL } = context;
   const state = getWorkerState();

package/dist/node.d.ts

@@ -1,18 +1,21 @@
-import { l as VitestRunMode, n as UserConfig, r as Vitest, aa as MockFactory, ab as MockMap, ac as TestSequencer } from './types-94cfe4b4.js';
-export { ac as TestSequencer, ae as TestSequencerConstructor, r as Vitest, ad as startVitest } from './types-94cfe4b4.js';
+import { o as VitestRunMode, q as UserConfig, v as Vitest, a8 as MockFactory, a9 as MockMap, aa as TestSequencer, ab as WorkspaceSpec } from './types-f03c83c4.js';
+export { ae as TestSequencerConstructor, ac as VitestWorkspace, ad as startVitest } from './types-f03c83c4.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeRunnerOptions } from 'vite-node';
 import '@vitest/expect';
+import '@vitest/snapshot';
 import '@vitest/runner';
 import '@vitest/runner/types';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'tinybench';
+import '@vitest/snapshot/manager';
 import 'node:worker_threads';
 import 'source-map';
-import 'node:fs';
 import 'vite-node/server';
+import 'node:fs';
+import 'chai';
 
 declare function createVitest(mode: VitestRunMode, options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
 
@@ -25,7 +28,6 @@ declare class VitestMocker {
     private resolveCache;
     constructor(executor: VitestExecutor);
     private get root();
-    private get base();
     private get mockMap();
     private get moduleCache();
     private deleteCachedItem;
@@ -66,8 +68,8 @@ declare class VitestExecutor extends ViteNodeRunner {
 declare class BaseSequencer implements TestSequencer {
     protected ctx: Vitest;
     constructor(ctx: Vitest);
-    shard(files: string[]): Promise<string[]>;
-    sort(files: string[]): Promise<string[]>;
+    shard(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
+    sort(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
 }
 
-export { BaseSequencer, ExecuteOptions, VitestExecutor, VitestPlugin, createVitest };
+export { BaseSequencer, ExecuteOptions, TestSequencer, Vitest, VitestExecutor, VitestPlugin, WorkspaceSpec, createVitest };

package/dist/node.js

@@ -1,17 +1,17 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-node-pkg.30d8b37e.js';
-export { V as VitestExecutor } from './chunk-runtime-mocker.3283818a.js';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './vendor-cli-api.c04eaa34.js';
+export { V as VitestExecutor } from './vendor-execute.8eaab47b.js';
 import 'pathe';
-import './chunk-constants.bc18a549.js';
-import './chunk-integrations-coverage.d93ee824.js';
-import './chunk-env-node.affdd278.js';
+import './vendor-constants.538d9b49.js';
+import './vendor-coverage.a585b712.js';
+import './vendor-index.75f2b63d.js';
 import 'node:console';
 import 'local-pkg';
 import 'picocolors';
-import './chunk-utils-env.6b856dbf.js';
+import './vendor-index.fad2598b.js';
 import 'std-env';
 import '@vitest/runner/utils';
-import './chunk-utils-global.fd174983.js';
 import '@vitest/utils';
+import './vendor-global.6795f91f.js';
 import 'vite';
 import 'node:path';
 import 'node:url';
@@ -23,39 +23,36 @@ import 'util';
 import 'stream';
 import 'events';
 import 'fs';
-import './vendor-_commonjsHelpers.addc3445.js';
+import './vendor-_commonjsHelpers.76cdd49e.js';
 import 'vite-node/utils';
 import 'vite-node/client';
-import 'node:fs/promises';
-import './vendor-index.2cbcdd1e.js';
-import 'node:buffer';
+import '@vitest/snapshot/manager';
+import './vendor-paths.84fc7a99.js';
+import 'node:v8';
 import 'node:child_process';
-import 'child_process';
+import './vendor-index.4f82d248.js';
+import 'node:worker_threads';
 import 'node:os';
+import 'tinypool';
+import 'node:perf_hooks';
+import './vendor-tasks.042d6084.js';
+import 'node:module';
+import 'node:crypto';
+import './vendor-index.c1e09929.js';
+import 'node:buffer';
+import 'child_process';
 import 'assert';
 import 'buffer';
+import 'node:util';
+import 'node:fs/promises';
 import 'source-map';
 import 'module';
 import 'acorn';
 import 'acorn-walk';
-import './chunk-utils-base.b5ddfcc9.js';
-import 'crypto';
-import './chunk-paths.e36446b4.js';
-import 'node:v8';
-import './vendor-index.783e7f3e.js';
-import 'node:worker_threads';
-import 'tinypool';
-import 'perf_hooks';
-import './chunk-utils-tasks.8781fd71.js';
-import '@vitest/utils/diff';
-import 'vite-node/server';
-import './vendor-magic-string.es.b3bc5745.js';
-import 'node:module';
-import 'node:crypto';
+import 'magic-string';
 import 'strip-literal';
+import 'vite-node/server';
+import 'node:readline';
 import 'readline';
-import './vendor-index.bdee400f.js';
-import 'node:assert';
-import 'node:util';
 import '@vitest/spy';
-import './chunk-runtime-rpc.d6aa57f8.js';
+import './vendor-rpc.4d3d7a54.js';