vitest 0.15.2 → 0.17.1

package/dist/{chunk-vite-node-utils.1bbdb2c1.mjs → chunk-vite-node-utils.0f776286.mjs}

@@ -1,7 +1,7 @@
 import { builtinModules, createRequire } from 'module';
 import { pathToFileURL, fileURLToPath as fileURLToPath$2, URL as URL$1 } from 'url';
 import vm from 'vm';
-import { o as isAbsolute$2, m as resolve, j as join$2, I as extname$2, d as dirname$2 } from './chunk-utils-global.79a8b1cc.mjs';
+import { t as isAbsolute$2, q as resolve, j as join$2, L as extname$2, d as dirname$2 } from './chunk-utils-global.4828c2e2.mjs';
 import path from 'path';
 import fs, { realpathSync, statSync, Stats, promises, existsSync } from 'fs';
 import assert from 'assert';
@@ -8851,7 +8851,7 @@ function mergeSlashes(str) {
 function normalizeRequestId(id, base) {
   if (base && id.startsWith(base))
     id = `/${id.slice(base.length)}`;
-  return id.replace(/^\/@id\/__x00__/, "\0").replace(/^\/@id\//, "").replace(/^__vite-browser-external:/, "").replace(/^(node|file):/, "").replace(/^\/+/, "/").replace(/\?v=\w+/, "?").replace(/&v=\w+/, "").replace(/\?t=\w+/, "?").replace(/&t=\w+/, "").replace(/\?import/, "?").replace(/&import/, "").replace(/\?+$/, "");
+  return id.replace(/^\/@id\/__x00__/, "\0").replace(/^\/@id\//, "").replace(/^__vite-browser-external:/, "").replace(/^(node|file):/, "").replace(/^\/+/, "/").replace(/\?v=\w+/, "?").replace(/&v=\w+/, "").replace(/\?t=\w+/, "?").replace(/&t=\w+/, "").replace(/\?import/, "?").replace(/&import/, "").replace(/\?&/, "?").replace(/\?+$/, "");
 }
 function normalizeModuleId(id) {
   return id.replace(/\\/g, "/").replace(/^\/@fs\//, "/").replace(/^file:\//, "/").replace(/^\/+/, "/");
@@ -8860,10 +8860,10 @@ function isPrimitive(v) {
   return v !== Object(v);
 }
 function toFilePath(id, root) {
-  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname$2(root)) && dirname$2(root) !== "/" ? id : id.startsWith("/") ? slash(resolve(root, id.slice(1))) : id;
+  let absolute = id.startsWith("/@fs/") ? id.slice(4) : id.startsWith(root) ? id : id.startsWith("/") ? resolve(root, id.slice(1)) : id;
   if (absolute.startsWith("//"))
     absolute = absolute.slice(1);
-  return isWindows && absolute.startsWith("/") ? fileURLToPath$2(pathToFileURL(absolute.slice(1)).href) : absolute;
+  return isWindows && absolute.startsWith("/") ? slash(fileURLToPath$2(pathToFileURL(absolute.slice(1)).href)) : absolute;
 }
 let SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";
@@ -8946,31 +8946,34 @@ class ViteNodeRunner {
     return await this.cachedRequest(id, []);
   }
   async cachedRequest(rawId, callstack) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const id = normalizeRequestId(rawId, this.options.base);
     const fsPath = toFilePath(id, this.root);
-    if ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.promise)
-      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.promise;
+    if (callstack.includes(fsPath) && ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.exports))
+      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.exports;
+    if ((_c = this.moduleCache.get(fsPath)) == null ? void 0 : _c.promise)
+      return (_d = this.moduleCache.get(fsPath)) == null ? void 0 : _d.promise;
     const promise = this.directRequest(id, fsPath, callstack);
     this.moduleCache.set(fsPath, { promise });
     return await promise;
   }
   async directRequest(id, fsPath, _callstack) {
-    const callstack = [..._callstack, normalizeModuleId(id)];
+    const callstack = [..._callstack, fsPath];
     const request = async (dep) => {
       var _a;
+      const fsPath2 = toFilePath(normalizeRequestId(dep, this.options.base), this.root);
       const getStack = () => {
         return `stack:
-${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`;
+${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
       };
       let debugTimer;
       if (this.debug)
-        debugTimer = setTimeout(() => this.debugLog(() => `module ${dep} takes over 2s to load.
+        debugTimer = setTimeout(() => this.debugLog(() => `module ${fsPath2} takes over 2s to load.
 ${getStack()}`), 2e3);
       try {
-        if (callstack.includes(normalizeModuleId(dep))) {
+        if (callstack.includes(fsPath2)) {
           this.debugLog(() => `circular dependency, ${getStack()}`);
-          const depExports = (_a = this.moduleCache.get(dep)) == null ? void 0 : _a.exports;
+          const depExports = (_a = this.moduleCache.get(fsPath2)) == null ? void 0 : _a.exports;
           if (depExports)
             return depExports;
           throw new Error(`[vite-node] Failed to resolve circular dependency, ${getStack()}`);
@@ -9007,9 +9010,10 @@ ${getStack()}`), 2e3);
     if (transformed == null)
       throw new Error(`[vite-node] Failed to load ${id}`);
     const url = pathToFileURL(fsPath).href;
+    const meta = { url };
     const exports = /* @__PURE__ */ Object.create(null);
     exports[Symbol.toStringTag] = "Module";
-    this.moduleCache.set(id, { code: transformed, exports });
+    this.moduleCache.set(fsPath, { code: transformed, exports });
     const __filename = fileURLToPath$2(url);
     const moduleProxy = {
       set exports(value) {
@@ -9020,12 +9024,23 @@ ${getStack()}`), 2e3);
         return exports;
       }
     };
+    let hotContext;
+    if (this.options.createHotContext) {
+      Object.defineProperty(meta, "hot", {
+        enumerable: true,
+        get: () => {
+          var _a, _b;
+          hotContext || (hotContext = (_b = (_a = this.options).createHotContext) == null ? void 0 : _b.call(_a, this, `/@fs/${fsPath}`));
+          return hotContext;
+        }
+      });
+    }
     const context = this.prepareContext({
       __vite_ssr_import__: request,
       __vite_ssr_dynamic_import__: request,
       __vite_ssr_exports__: exports,
       __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
-      __vite_ssr_import_meta__: { url },
+      __vite_ssr_import_meta__: meta,
       __vitest_resolve_id__: resolveId,
       require: createRequire(url),
       exports,

package/dist/cli.mjs

@@ -1,33 +1,33 @@
 import { EventEmitter } from 'events';
-import { p as picocolors } from './chunk-utils-global.79a8b1cc.mjs';
-import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.0ec89ad1.mjs';
+import { p as picocolors } from './chunk-utils-global.4828c2e2.mjs';
+import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.0fc8ed68.mjs';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import 'vite';
-import 'url';
-import 'process';
+import './chunk-env-node.aa51c4cc.mjs';
 import 'fs';
-import './chunk-defaults.dc6dc23d.mjs';
 import 'module';
-import './chunk-constants.7b9cfc82.mjs';
+import 'url';
+import 'vite';
+import 'process';
+import './chunk-constants.27550afb.mjs';
 import 'readline';
 import 'os';
 import 'util';
 import 'stream';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-vite-node-utils.1bbdb2c1.mjs';
+import './chunk-vite-node-utils.0f776286.mjs';
 import 'vm';
 import 'assert';
 import 'debug';
 import 'worker_threads';
-import 'crypto';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-source-map.2556cba8.mjs';
-import './vendor-index.e5dc6622.mjs';
+import './chunk-utils-source-map.a9047343.mjs';
+import './vendor-index.a2a385d8.mjs';
 import 'child_process';
 import 'buffer';
+import 'crypto';
 import './chunk-magic-string.efe26975.mjs';
 import './vendor-index.98e769c1.mjs';
 
@@ -645,7 +645,7 @@ class CAC extends EventEmitter {
 const cac = (name = "") => new CAC(name);
 
 const cli = cac("vitest");
-cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-t, --testNamePattern <pattern>", "run tests with full names matching the specified pattern").option("--dir <path>", "base directory to scan for the test files").option("--ui", "enable UI").option("--open", "open UI automatically (default: !process.env.CI))").option("--api [api]", "serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "enabled threads (default: true)").option("--silent", "silent console output from tests").option("--isolate", "isolate environment for each test file (default: true)").option("--reporter <name>", "reporter").option("--outputTruncateLength <length>", "diff output length (default: 80)").option("--outputDiffLines <lines>", "number of diff output lines (default: 15)").option("--outputFile <filename/-s>", "write test results to a file when the --reporter=json or --reporter=junit option is also specified, use cac's dot notation for individual outputs of mutliple reporters").option("--coverage", "use c8 for coverage").option("--run", "do not watch").option("--mode <name>", "override Vite mode (default: test)").option("--globals", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment (default: node)").option("--passWithNoTests", "pass when no tests found").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").help();
+cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-t, --testNamePattern <pattern>", "run tests with full names matching the specified pattern").option("--dir <path>", "base directory to scan for the test files").option("--ui", "enable UI").option("--open", "open UI automatically (default: !process.env.CI))").option("--api [api]", "serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "enabled threads (default: true)").option("--silent", "silent console output from tests").option("--isolate", "isolate environment for each test file (default: true)").option("--reporter <name>", "reporter").option("--outputTruncateLength <length>", "diff output length (default: 80)").option("--outputDiffLines <lines>", "number of diff output lines (default: 15)").option("--outputFile <filename/-s>", "write test results to a file when the --reporter=json or --reporter=junit option is also specified, use cac's dot notation for individual outputs of mutliple reporters").option("--coverage", "use c8 for coverage").option("--run", "do not watch").option("--mode <name>", "override Vite mode (default: test)").option("--globals", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment (default: node)").option("--passWithNoTests", "pass when no tests found").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order)").help();
 cli.command("run [...filters]").action(run);
 cli.command("related [...filters]").action(runRelated);
 cli.command("watch [...filters]").action(start);

package/dist/config.cjs

@@ -55,7 +55,11 @@ const config = {
   hookTimeout: 1e4,
   isolate: true,
   watchExclude: ["**/node_modules/**", "**/dist/**"],
-  forceRerunTriggers: [],
+  forceRerunTriggers: [
+    "**/package.json/**",
+    "**/vitest.config.*/**",
+    "**/vite.config.*/**"
+  ],
   update: false,
   reporters: [],
   silent: false,

package/dist/config.d.ts

@@ -83,7 +83,7 @@ declare const config: {
     hookTimeout: number;
     isolate: boolean;
     watchExclude: string[];
-    forceRerunTriggers: never[];
+    forceRerunTriggers: string[];
     update: boolean;
     reporters: never[];
     silent: boolean;

package/dist/config.mjs

@@ -51,7 +51,11 @@ const config = {
   hookTimeout: 1e4,
   isolate: true,
   watchExclude: ["**/node_modules/**", "**/dist/**"],
-  forceRerunTriggers: [],
+  forceRerunTriggers: [
+    "**/package.json/**",
+    "**/vitest.config.*/**",
+    "**/vite.config.*/**"
+  ],
   update: false,
   reporters: [],
   silent: false,

package/dist/entry.mjs

@@ -1,17 +1,17 @@
-export { r as run } from './vendor-entry.efeeaa5c.mjs';
+export { r as run } from './vendor-entry.1ad8a08d.mjs';
 import 'fs';
-import './chunk-utils-global.79a8b1cc.mjs';
+import './chunk-utils-global.4828c2e2.mjs';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './chunk-runtime-chain.7103058b.mjs';
+import './chunk-env-node.aa51c4cc.mjs';
+import 'module';
+import 'url';
+import './chunk-runtime-chain.6d23d202.mjs';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.5e78af38.mjs';
-import './chunk-utils-source-map.2556cba8.mjs';
+import './chunk-runtime-rpc.d986adb9.mjs';
+import './chunk-utils-source-map.a9047343.mjs';
 import './chunk-integrations-spy.674b628e.mjs';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.dc6dc23d.mjs';
-import 'module';
-import 'url';

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { ViteDevServer, TransformResult, CommonServerOptions } from 'vite';
+import { Stats } from 'fs';
 import { SpyImpl } from 'tinyspy';
 import { MessagePort } from 'worker_threads';
 export { assert, default as chai, should } from 'chai';
@@ -156,6 +157,87 @@ interface FakeTimerInstallOpts {
     shouldClearNativeTimers?: boolean | undefined;
 }
 
+interface UpdatePayload {
+  type: 'update'
+  updates: Update[]
+}
+
+interface Update {
+  type: 'js-update' | 'css-update'
+  path: string
+  acceptedPath: string
+  timestamp: number
+}
+
+interface PrunePayload {
+  type: 'prune'
+  paths: string[]
+}
+
+interface FullReloadPayload {
+  type: 'full-reload'
+  path?: string
+}
+
+interface ErrorPayload {
+  type: 'error'
+  err: {
+    [name: string]: any
+    message: string
+    stack: string
+    id?: string
+    frame?: string
+    plugin?: string
+    pluginCode?: string
+    loc?: {
+      file?: string
+      line: number
+      column: number
+    }
+  }
+}
+
+interface CustomEventMap {
+  'vite:beforeUpdate': UpdatePayload
+  'vite:beforePrune': PrunePayload
+  'vite:beforeFullReload': FullReloadPayload
+  'vite:error': ErrorPayload
+}
+
+type InferCustomEventPayload<T extends string> =
+  T extends keyof CustomEventMap ? CustomEventMap[T] : any
+
+type ModuleNamespace = Record<string, any> & {
+  [Symbol.toStringTag]: 'Module'
+}
+
+interface ViteHotContext {
+  readonly data: any
+
+  accept(): void
+  accept(cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(
+    deps: readonly string[],
+    cb: (mods: Array<ModuleNamespace | undefined>) => void
+  ): void
+
+  acceptExports(exportNames: string | readonly string[]): void
+  acceptExports(
+    exportNames: string | readonly string[],
+    cb: (mod: ModuleNamespace | undefined) => void
+  ): void
+
+  dispose(cb: (data: any) => void): void
+  decline(): void
+  invalidate(): void
+
+  on<T extends string>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void
+  ): void
+  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
+}
 declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
     normalizePath(fsPath: string): string;
     set(fsPath: string, mod: Partial<ModuleCache$1>): this;
@@ -217,8 +299,10 @@ interface FetchResult {
     externalize?: string;
     map?: RawSourceMap;
 }
+declare type HotContext = Omit<ViteHotContext, 'acceptDeps' | 'decline'>;
 declare type FetchFunction = (id: string) => Promise<FetchResult>;
 declare type ResolveIdFunction$1 = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+declare type CreateHotContextFunction = (runner: ViteNodeRunner, url: string) => HotContext;
 interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
@@ -228,6 +312,7 @@ interface ViteNodeRunnerOptions {
     root: string;
     fetchModule: FetchFunction;
     resolveId?: ResolveIdFunction$1;
+    createHotContext?: CreateHotContextFunction;
     base?: string;
     moduleCache?: ModuleCacheMap;
     interopDefault?: boolean;
@@ -295,11 +380,42 @@ interface WorkerPool {
     close: () => Promise<void>;
 }
 
+interface SuiteResultCache {
+    failed: boolean;
+    duration: number;
+}
+declare class ResultsCache {
+    private cache;
+    private cachePath;
+    private version;
+    private root;
+    setConfig(root: string, config: ResolvedConfig['cache']): void;
+    getResults(fsPath: string): SuiteResultCache | undefined;
+    readFromCache(): Promise<void>;
+    updateResults(files: File[]): void;
+    removeFromCache(filepath: string): void;
+    writeToCache(): Promise<void>;
+}
+
+declare type FileStatsCache = Pick<Stats, 'size'>;
+declare class FilesStatsCache {
+    cache: Map<string, FileStatsCache>;
+    getStats(fsPath: string): FileStatsCache | undefined;
+    updateStats(fsPath: string): Promise<void>;
+    removeStats(fsPath: string): void;
+}
+
 declare class StateManager {
     filesMap: Map<string, File>;
     idMap: Map<string, Task>;
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
+    results: ResultsCache;
+    stats: FilesStatsCache;
+    getFileTestResults(id: string): SuiteResultCache | undefined;
+    getFileStats(id: string): {
+        size: number;
+    } | undefined;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
@@ -342,7 +458,7 @@ declare class Vitest {
     start(filters?: string[]): Promise<void>;
     private getTestDependencies;
     filterTestsBySource(tests: string[]): Promise<string[]>;
-    runFiles(files: string[]): Promise<void>;
+    runFiles(paths: string[]): Promise<void>;
     rerunFiles(files?: string[], trigger?: string): Promise<void>;
     changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
     rerunFailed(): Promise<void>;
@@ -370,6 +486,18 @@ declare class Vitest {
 
 declare type MockMap = Map<string, Record<string, string | null | (() => unknown)>>;
 
+interface TestSequencer {
+    /**
+     * Slicing tests into shards. Will be run before `sort`.
+     * Only run, if `shard` is defined.
+     */
+    shard(files: string[]): Awaitable<string[]>;
+    sort(files: string[]): Awaitable<string[]>;
+}
+interface TestSequencerContructor {
+    new (ctx: Vitest): TestSequencer;
+}
+
 declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
@@ -496,7 +624,7 @@ declare type DeepMerge<F, S> = MergeInsertions<{
 declare type MutableArray<T extends readonly any[]> = {
     -readonly [k in keyof T]: T[k];
 };
-interface Constructable {
+interface Constructable$1 {
     new (...args: any[]): any;
 }
 interface ModuleCache {
@@ -699,6 +827,7 @@ interface TaskBase {
     name: string;
     mode: RunMode;
     concurrent?: boolean;
+    shuffle?: boolean;
     suite?: Suite;
     file?: File;
     result?: TaskResult;
@@ -760,7 +889,7 @@ declare type TestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only
     skipIf(condition: any): TestAPI<ExtraContext>;
     runIf(condition: any): TestAPI<ExtraContext>;
 };
-declare type SuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo', [
+declare type SuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
     name: string,
     factory?: SuiteFactory
 ], SuiteCollector<ExtraContext>> & {
@@ -768,14 +897,14 @@ declare type SuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'onl
     skipIf(condition: any): SuiteAPI<ExtraContext>;
     runIf(condition: any): SuiteAPI<ExtraContext>;
 };
-declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return | void>;
+declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
+declare type HookCleanupCallback = (() => Awaitable<unknown>) | void;
 interface SuiteHooks {
-    beforeAll: HookListener<[Suite | File], () => Awaitable<void>>[];
+    beforeAll: HookListener<[Suite | File], HookCleanupCallback>[];
     afterAll: HookListener<[Suite | File]>[];
-    beforeEach: HookListener<[TestContext, Suite], () => Awaitable<void>>[];
+    beforeEach: HookListener<[TestContext, Suite], HookCleanupCallback>[];
     afterEach: HookListener<[TestContext, Suite]>[];
 }
-declare type HookCleanupCallback = (() => Awaitable<void>) | void;
 interface SuiteCollector<ExtraContext = {}> {
     readonly name: string;
     readonly mode: RunMode;
@@ -865,7 +994,7 @@ interface SnapshotSummary {
     updated: number;
 }
 
-declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom';
+declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 declare type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
 
 interface EnvironmentOptions {
@@ -943,7 +1072,7 @@ interface InlineConfig {
     /**
      * Running environment
      *
-     * Supports 'node', 'jsdom', 'happy-dom'
+     * Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'
      *
      * @default 'node'
      */
@@ -1168,6 +1297,35 @@ interface InlineConfig {
      * @default 5
      */
     maxConcurrency?: number;
+    /**
+     * Options for configuring cache policy.
+     * @default { dir: 'node_modules/.vitest' }
+     */
+    cache?: false | {
+        dir?: string;
+    };
+    /**
+     * Options for configuring the order of running tests.
+     */
+    sequence?: {
+        /**
+         * Class that handles sorting and sharding algorithm.
+         * If you only need to change sorting, you can extend
+         * your custom sequencer from `BaseSequencer` from `vitest/node`.
+         * @default BaseSequencer
+         */
+        sequencer?: TestSequencerContructor;
+        /**
+         * Should tests run in random order.
+         * @default false
+         */
+        shuffle?: boolean;
+        /**
+         * Seed for the random number generator.
+         * @default Date.now()
+         */
+        seed?: number;
+    };
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -1207,7 +1365,7 @@ interface UserConfig extends InlineConfig {
      */
     shard?: string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'shard'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'shard' | 'cache' | 'sequence'> {
     base?: string;
     config?: string;
     filters?: string[];
@@ -1222,6 +1380,14 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
         index: number;
         count: number;
     };
+    cache: {
+        dir: string;
+    } | false;
+    sequence: {
+        sequencer: TestSequencerContructor;
+        shuffle?: boolean;
+        seed?: number;
+    };
 }
 
 declare type VitestInlineConfig = InlineConfig;
@@ -1460,8 +1626,8 @@ declare global {
             nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void;
             toHaveBeenLastCalledWith<E extends any[]>(...args: E): void;
             lastCalledWith<E extends any[]>(...args: E): void;
-            toThrow(expected?: string | Constructable | RegExp | Error): void;
-            toThrowError(expected?: string | Constructable | RegExp | Error): void;
+            toThrow(expected?: string | Constructable$1 | RegExp | Error): void;
+            toThrowError(expected?: string | Constructable$1 | RegExp | Error): void;
             toReturn(): void;
             toHaveReturned(): void;
             toReturnTimes(times: number): void;
@@ -1499,7 +1665,6 @@ declare type BirpcReturn<RemoteFunctions> = {
 
 interface WorkerContext {
     workerId: number;
-    poolId: number;
     port: MessagePort;
     config: ResolvedConfig;
     files: string[];
@@ -1542,7 +1707,7 @@ interface MockResultThrow {
     value: any;
 }
 declare type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
-interface SpyContext<TArgs, TReturns> {
+interface MockContext<TArgs, TReturns> {
     calls: TArgs[];
     instances: TReturns[];
     invocationCallOrder: number[];
@@ -1560,10 +1725,9 @@ declare type Classes<T> = {
     [K in keyof T]: T[K] extends new (...args: any[]) => any ? K : never;
 }[keyof T] & (string | symbol);
 interface SpyInstance<TArgs extends any[] = any[], TReturns = any> {
-    (...args: TArgs): TReturns;
     getMockName(): string;
     mockName(n: string): this;
-    mock: SpyContext<TArgs, TReturns>;
+    mock: MockContext<TArgs, TReturns>;
     mockClear(): this;
     mockReset(): this;
     mockRestore(): void;
@@ -1578,15 +1742,17 @@ interface SpyInstance<TArgs extends any[] = any[], TReturns = any> {
     mockRejectedValue(obj: any): this;
     mockRejectedValueOnce(obj: any): this;
 }
-interface SpyInstanceFn<TArgs extends any[] = any, TReturns = any> extends SpyInstance<TArgs, TReturns> {
-    (...args: TArgs): TReturns;
+interface MockInstance<A extends any[] = any[], R = any> extends SpyInstance<A, R> {
+}
+interface Mock<TArgs extends any[] = any, TReturns = any> extends SpyInstance<TArgs, TReturns> {
     new (...args: TArgs): TReturns;
+    (...args: TArgs): TReturns;
 }
-declare type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R ? SpyInstanceFn<ConstructorParameters<T>, R> : T;
-declare type MockedFunction<T extends Procedure> = SpyInstanceFn<Parameters<T>, ReturnType<T>> & {
+declare type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R ? Mock<ConstructorParameters<T>, R> : T;
+declare type MockedFunction<T extends Procedure> = Mock<Parameters<T>, ReturnType<T>> & {
     [K in keyof T]: T[K];
 };
-declare type MockedFunctionDeep<T extends Procedure> = SpyInstanceFn<Parameters<T>, ReturnType<T>> & MockedObjectDeep<T>;
+declare type MockedFunctionDeep<T extends Procedure> = Mock<Parameters<T>, ReturnType<T>> & MockedObjectDeep<T>;
 declare type MockedObject<T> = MaybeMockedConstructor<T> & {
     [K in Methods<T>]: T[K] extends Procedure ? MockedFunction<T[K]> : T[K];
 } & {
@@ -1599,12 +1765,23 @@ declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
 };
 declare type MaybeMockedDeep<T> = T extends Procedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
 declare type MaybeMocked<T> = T extends Procedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+interface Constructable {
+    new (...args: any[]): any;
+}
+declare type MockedClass<T extends Constructable> = MockInstance<InstanceType<T>, T extends new (...args: infer P) => any ? P : never> & {
+    prototype: T extends {
+        prototype: any;
+    } ? Mocked<T['prototype']> : never;
+} & T;
+declare type Mocked<T> = {
+    [P in keyof T]: T[P] extends (...args: infer Args) => infer Returns ? MockInstance<Args, Returns> : T[P] extends Constructable ? MockedClass<T[P]> : T[P];
+} & T;
 declare type EnhancedSpy<TArgs extends any[] = any[], TReturns = any> = SpyInstance<TArgs, TReturns> & SpyImpl<TArgs, TReturns>;
 declare function spyOn<T, S extends Properties<Required<T>>>(obj: T, methodName: S, accessType: 'get'): SpyInstance<[], T[S]>;
 declare function spyOn<T, G extends Properties<Required<T>>>(obj: T, methodName: G, accessType: 'set'): SpyInstance<[T[G]], void>;
 declare function spyOn<T, M extends (Methods<Required<T>> | Classes<Required<T>>)>(obj: T, methodName: M): Required<T>[M] extends (...args: infer A) => infer R | (new (...args: infer A) => infer R) ? SpyInstance<A, R> : never;
-declare function fn<TArgs extends any[] = any[], R = any>(): SpyInstanceFn<TArgs, R>;
-declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): SpyInstanceFn<TArgs, R>;
+declare function fn<TArgs extends any[] = any[], R = any>(): Mock<TArgs, R>;
+declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): Mock<TArgs, R>;
 
 declare const suite: SuiteAPI<{}>;
 declare const test: TestAPI<{}>;
@@ -1761,4 +1938,4 @@ interface WebSocketHandlers {
 interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog'> {
 }
 
-export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable, CoverageReporter, DeepMerge, DoneCallback, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookCleanupCallback, HookListener, InlineConfig, JSDOMOptions, MergeInsertions, MockedFunction, MockedObject, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyContext, SpyInstance, SpyInstanceFn, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, Vitest, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerGlobalState, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, createExpect, describe, globalExpect as expect, getRunningMode, isFirstRun, isWatchMode, it, runOnce, suite, test, vi, vitest, withCallback };
+export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable$1 as Constructable, CoverageReporter, DeepMerge, DoneCallback, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookCleanupCallback, HookListener, InlineConfig, JSDOMOptions, MergeInsertions, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyInstance, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, Vitest, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerGlobalState, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, createExpect, describe, globalExpect as expect, getRunningMode, isFirstRun, isWatchMode, it, runOnce, suite, test, vi, vitest, withCallback };

package/dist/index.mjs

@@ -1,13 +1,13 @@
-export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.7103058b.mjs';
+export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.6d23d202.mjs';
 export { assert, default as chai, should } from 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.5e78af38.mjs';
-import './chunk-utils-global.79a8b1cc.mjs';
+import './chunk-runtime-rpc.d986adb9.mjs';
+import './chunk-utils-global.4828c2e2.mjs';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
-import './chunk-utils-source-map.2556cba8.mjs';
+import './chunk-utils-source-map.a9047343.mjs';
 import './chunk-integrations-spy.674b628e.mjs';
 import 'tinyspy';
 import 'util';