vitest 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { TaskPopulated, File, TaskResultPack, CancelReason } from '@vitest/runner';
 export { Custom, DoneCallback, ExtendedContext, File, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, RuntimeContext, SequenceHooks, SequenceSetupFiles, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskContext, TaskCustomOptions, TaskMeta, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench } from './suite-ad69b7cd.js';
+export { b as bench } from './suite-vfxzpeqE.js';
 import { ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, ExpectStatic, JestAssertion } from '@vitest/expect';
-import { F as FakeTimerInstallOpts, M as MockFactoryWithHelper, l as RuntimeConfig, f as ProvidedContext, A as AfterSuiteRunMeta, m as UserConsoleLog, R as ResolvedConfig, n as ModuleGraphData, o as Reporter } from './reporters-50c2bd49.js';
-export { G as ApiConfig, a5 as ArgumentsType, a4 as Arrayable, a2 as Awaitable, B as BaseCoverageOptions, aj as BenchFunction, ah as Benchmark, ak as BenchmarkAPI, ai as BenchmarkResult, ag as BenchmarkUserOptions, y as BuiltinEnvironment, D as CSSModuleScopeStrategy, r as CollectLineNumbers, t as CollectLines, a7 as Constructable, v as Context, Z as ContextRPC, X as ContextTestEnvironment, ae as CoverageIstanbulOptions, b as CoverageOptions, c as CoverageProvider, d as CoverageProviderModule, ad as CoverageReporter, C as CoverageV8Options, af as CustomProviderOptions, K as DepsOptimizationOptions, E as Environment, I as EnvironmentOptions, a9 as EnvironmentReturn, H as HappyDOMOptions, N as InlineConfig, J as JSDOMOptions, a8 as ModuleCache, a6 as MutableArray, a3 as Nullable, ab as OnServerRestartHandler, w as Pool, x as PoolOptions, P as ProjectConfig, p as RawErrsMap, ac as ReportContext, $ as ResolveIdFunction, a as ResolvedCoverageOptions, Y as ResolvedTestEnvironment, u as RootAndTarget, S as RunnerRPC, Q as RuntimeRPC, L as TransformModePatterns, q as TscErrorInfo, O as TypecheckConfig, U as UserConfig, e as Vitest, z as VitestEnvironment, V as VitestRunMode, aa as VmEnvironmentReturn, _ as WorkerContext, a1 as WorkerGlobalState, a0 as WorkerRPC } from './reporters-50c2bd49.js';
+import { F as FakeTimerInstallOpts, M as MockFactoryWithHelper, n as RuntimeConfig, f as ProvidedContext, A as AfterSuiteRunMeta, o as UserConsoleLog, R as ResolvedConfig, p as ModuleGraphData, q as Reporter } from './reporters-vMlHjCdM.js';
+export { K as ApiConfig, a6 as ArgumentsType, a5 as Arrayable, a3 as Awaitable, B as BaseCoverageOptions, ak as BenchFunction, ai as Benchmark, al as BenchmarkAPI, aj as BenchmarkResult, ah as BenchmarkUserOptions, D as BuiltinEnvironment, I as CSSModuleScopeStrategy, u as CollectLineNumbers, v as CollectLines, a8 as Constructable, x as Context, _ as ContextRPC, Y as ContextTestEnvironment, af as CoverageIstanbulOptions, b as CoverageOptions, c as CoverageProvider, d as CoverageProviderModule, ae as CoverageReporter, C as CoverageV8Options, ag as CustomProviderOptions, N as DepsOptimizationOptions, E as Environment, L as EnvironmentOptions, aa as EnvironmentReturn, H as HappyDOMOptions, Q as InlineConfig, J as JSDOMOptions, a9 as ModuleCache, a7 as MutableArray, a4 as Nullable, ac as OnServerRestartHandler, y as Pool, z as PoolOptions, P as ProjectConfig, r as RawErrsMap, ad as ReportContext, a0 as ResolveIdFunction, a as ResolvedCoverageOptions, Z as ResolvedTestEnvironment, w as RootAndTarget, X as RunnerRPC, g as RuntimeRPC, O as TransformModePatterns, t as TscErrorInfo, S as TypecheckConfig, U as UserConfig, e as Vitest, G as VitestEnvironment, V as VitestRunMode, ab as VmEnvironmentReturn, $ as WorkerContext, a2 as WorkerGlobalState, a1 as WorkerRPC } from './reporters-vMlHjCdM.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
 export { SnapshotEnvironment } from '@vitest/snapshot/environment';
@@ -34,6 +34,19 @@ declare type Secret = typeof secret;
 declare type IsNever<T> = [T] extends [never] ? true : false;
 declare type IsAny<T> = [T] extends [Secret] ? Not<IsNever<T>> : false;
 declare type IsUnknown<T> = [unknown] extends [T] ? Not<IsAny<T>> : false;
+declare type PrintType<T> = IsUnknown<T> extends true ? 'unknown' : IsNever<T> extends true ? 'never' : IsAny<T> extends true ? never : boolean extends T ? 'boolean' : T extends boolean ? `literal boolean: ${T}` : string extends T ? 'string' : T extends string ? `literal string: ${T}` : number extends T ? 'number' : T extends number ? `literal number: ${T}` : T extends null ? 'null' : T extends undefined ? 'undefined' : T extends (...args: any[]) => any ? 'function' : '...';
+/** Subjective "useful" keys from a type. For objects it's just `keyof` but for tuples/arrays it's the number keys
+ * @example
+ * UsefulKeys<{a: 1; b: 2}> // 'a' | 'b'
+ * UsefulKeys<['a', 'b']> // '0' | '1'
+ * UsefulKeys<string[]> // number
+ */
+declare type UsefulKeys<T> = T extends any[] ? {
+    [K in keyof T]: K;
+}[number] : keyof T;
+declare type MismatchInfo<Actual, Expected> = And<[Extends<PrintType<Actual>, '...'>, Not<IsAny<Actual>>]> extends true ? And<[Extends<any[], Actual>, Extends<any[], Expected>]> extends true ? Array<MismatchInfo<Extract<Actual, any[]>[number], Extract<Expected, any[]>[number]>> : {
+    [K in UsefulKeys<Actual> | UsefulKeys<Expected>]: MismatchInfo<K extends keyof Actual ? Actual[K] : never, K extends keyof Expected ? Expected[K] : never>;
+} : StrictEqualUsingBranding<Actual, Expected> extends true ? Actual : `Expected: ${PrintType<Expected>}, Actual: ${PrintType<Exclude<Actual, Expected>>}`;
 /**
  * Recursively walk a type and replace it with a branded type related to the original. This is useful for
  * equality-checking stricter than `A extends B ? B extends A ? true : false : false`, because it detects
@@ -41,6 +54,9 @@ declare type IsUnknown<T> = [unknown] extends [T] ? Not<IsAny<T>> : false;
  * - `any` vs `unknown`
  * - `{ readonly a: string }` vs `{ a: string }`
  * - `{ a?: string }` vs `{ a: string | undefined }`
+ *
+ * Note: not very performant for complex types - this should only be used when you know you need it. If doing
+ * an equality check, it's almost always better to use `StrictEqualUsingTSInternalIdenticalToOperator`.
  */
 declare type DeepBrand<T> = IsNever<T> extends true ? {
     type: 'never';
@@ -60,6 +76,7 @@ declare type DeepBrand<T> = IsNever<T> extends true ? {
     params: DeepBrand<P>;
     return: DeepBrand<R>;
     this: DeepBrand<ThisParameterType<T>>;
+    props: DeepBrand<Omit<T, keyof Function>>;
 } : T extends any[] ? {
     type: 'array';
     items: {
@@ -87,43 +104,162 @@ declare type ReadonlyKeys<T> = Extract<{
     }> extends true ? never : K;
 }[keyof T], keyof T>;
 declare type ReadonlyEquivalent<X, Y> = Extends<(<T>() => T extends X ? true : false), (<T>() => T extends Y ? true : false)>;
+/** Returns true if `L extends R`. Explicitly checks for `never` since that can give unexpected results. */
 declare type Extends<L, R> = IsNever<L> extends true ? IsNever<R> : [L] extends [R] ? true : false;
-declare type StrictExtends<L, R> = Extends<DeepBrand<L>, DeepBrand<R>>;
-declare type StrictEqual<L, R> = (<T>() => T extends (L & T) | T ? true : false) extends <T>() => T extends (R & T) | T ? true : false ? IsNever<L> extends IsNever<R> ? true : false : false;
-declare type Equal<Left, Right, Branded = true> = Branded extends true ? And<[StrictExtends<Left, Right>, StrictExtends<Right, Left>]> : StrictEqual<Left, Right>;
+declare type ExtendsUsingBranding<L, R> = Extends<DeepBrand<L>, DeepBrand<R>>;
+declare type ExtendsExcludingAnyOrNever<L, R> = IsAny<L> extends true ? IsAny<R> : Extends<L, R>;
+declare type StrictEqualUsingTSInternalIdenticalToOperator<L, R> = (<T>() => T extends (L & T) | T ? true : false) extends <T>() => T extends (R & T) | T ? true : false ? IsNever<L> extends IsNever<R> ? true : false : false;
+declare type StrictEqualUsingBranding<Left, Right> = And<[
+    ExtendsUsingBranding<Left, Right>,
+    ExtendsUsingBranding<Right, Left>
+]>;
 declare type Params<Actual> = Actual extends (...args: infer P) => any ? P : never;
 declare type ConstructorParams<Actual> = Actual extends new (...args: infer P) => any ? Actual extends new () => any ? P | [] : P : never;
-declare type MismatchArgs<ActualResult extends boolean, ExpectedResult extends boolean> = Eq<ActualResult, ExpectedResult> extends true ? [] : [never];
-interface ExpectTypeOfOptions {
+declare const mismatch: unique symbol;
+declare type Mismatch = {
+    [mismatch]: 'mismatch';
+};
+/** A type which should match anything passed as a value but *doesn't* match `Mismatch` - helps TypeScript select the right overload for `toEqualTypeOf` and `toMatchTypeOf`. */
+declare const avalue: unique symbol;
+declare type AValue = {
+    [avalue]?: undefined;
+} | string | number | boolean | symbol | bigint | null | undefined | void;
+declare type MismatchArgs<ActualResult extends boolean, ExpectedResult extends boolean> = Eq<ActualResult, ExpectedResult> extends true ? [] : [Mismatch];
+declare const inverted: unique symbol;
+declare type Inverted<T> = {
+    [inverted]: T;
+};
+declare const expectNull: unique symbol;
+declare type ExpectNull<T> = {
+    [expectNull]: T;
+    result: ExtendsExcludingAnyOrNever<T, null>;
+};
+declare const expectUndefined: unique symbol;
+declare type ExpectUndefined<T> = {
+    [expectUndefined]: T;
+    result: ExtendsExcludingAnyOrNever<T, undefined>;
+};
+declare const expectNumber: unique symbol;
+declare type ExpectNumber<T> = {
+    [expectNumber]: T;
+    result: ExtendsExcludingAnyOrNever<T, number>;
+};
+declare const expectString: unique symbol;
+declare type ExpectString<T> = {
+    [expectString]: T;
+    result: ExtendsExcludingAnyOrNever<T, string>;
+};
+declare const expectBoolean: unique symbol;
+declare type ExpectBoolean<T> = {
+    [expectBoolean]: T;
+    result: ExtendsExcludingAnyOrNever<T, boolean>;
+};
+declare const expectVoid: unique symbol;
+declare type ExpectVoid<T> = {
+    [expectVoid]: T;
+    result: ExtendsExcludingAnyOrNever<T, void>;
+};
+declare const expectFunction: unique symbol;
+declare type ExpectFunction<T> = {
+    [expectFunction]: T;
+    result: ExtendsExcludingAnyOrNever<T, (...args: any[]) => any>;
+};
+declare const expectObject: unique symbol;
+declare type ExpectObject<T> = {
+    [expectObject]: T;
+    result: ExtendsExcludingAnyOrNever<T, object>;
+};
+declare const expectArray: unique symbol;
+declare type ExpectArray<T> = {
+    [expectArray]: T;
+    result: ExtendsExcludingAnyOrNever<T, any[]>;
+};
+declare const expectSymbol: unique symbol;
+declare type ExpectSymbol<T> = {
+    [expectSymbol]: T;
+    result: ExtendsExcludingAnyOrNever<T, symbol>;
+};
+declare const expectAny: unique symbol;
+declare type ExpectAny<T> = {
+    [expectAny]: T;
+    result: IsAny<T>;
+};
+declare const expectUnknown: unique symbol;
+declare type ExpectUnknown<T> = {
+    [expectUnknown]: T;
+    result: IsUnknown<T>;
+};
+declare const expectNever: unique symbol;
+declare type ExpectNever<T> = {
+    [expectNever]: T;
+    result: IsNever<T>;
+};
+declare const expectNullable: unique symbol;
+declare type ExpectNullable<T> = {
+    [expectNullable]: T;
+    result: Not<StrictEqualUsingBranding<T, NonNullable<T>>>;
+};
+declare type Scolder<Expecter extends {
+    result: boolean;
+}, Options extends {
     positive: boolean;
-    branded: boolean;
-}
-interface ExpectTypeOf<Actual, Options extends ExpectTypeOfOptions> {
-    toBeAny: (...MISMATCH: MismatchArgs<IsAny<Actual>, Options['positive']>) => true;
-    toBeUnknown: (...MISMATCH: MismatchArgs<IsUnknown<Actual>, Options['positive']>) => true;
-    toBeNever: (...MISMATCH: MismatchArgs<IsNever<Actual>, Options['positive']>) => true;
-    toBeFunction: (...MISMATCH: MismatchArgs<Extends<Actual, (...args: any[]) => any>, Options['positive']>) => true;
-    toBeObject: (...MISMATCH: MismatchArgs<Extends<Actual, object>, Options['positive']>) => true;
-    toBeArray: (...MISMATCH: MismatchArgs<Extends<Actual, any[]>, Options['positive']>) => true;
-    toBeNumber: (...MISMATCH: MismatchArgs<Extends<Actual, number>, Options['positive']>) => true;
-    toBeString: (...MISMATCH: MismatchArgs<Extends<Actual, string>, Options['positive']>) => true;
-    toBeBoolean: (...MISMATCH: MismatchArgs<Extends<Actual, boolean>, Options['positive']>) => true;
-    toBeVoid: (...MISMATCH: MismatchArgs<Extends<Actual, void>, Options['positive']>) => true;
-    toBeSymbol: (...MISMATCH: MismatchArgs<Extends<Actual, symbol>, Options['positive']>) => true;
-    toBeNull: (...MISMATCH: MismatchArgs<Extends<Actual, null>, Options['positive']>) => true;
-    toBeUndefined: (...MISMATCH: MismatchArgs<Extends<Actual, undefined>, Options['positive']>) => true;
-    toBeNullable: (...MISMATCH: MismatchArgs<Not<Equal<Actual, NonNullable<Actual>, Options['branded']>>, Options['positive']>) => true;
+}> = Expecter['result'] extends Options['positive'] ? () => true : Options['positive'] extends true ? Expecter : Inverted<Expecter>;
+interface PositiveExpectTypeOf<Actual> extends BaseExpectTypeOf<Actual, {
+    positive: true;
+    branded: false;
+}> {
+    toEqualTypeOf: {
+        <Expected extends StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : MismatchInfo<Actual, Expected>>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`.
+        ...MISMATCH: MismatchArgs<StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
+        <Expected extends StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : MismatchInfo<Actual, Expected>>(...MISMATCH: MismatchArgs<StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
+    };
     toMatchTypeOf: {
-        <Expected>(...MISMATCH: MismatchArgs<Extends<Actual, Expected>, Options['positive']>): true;
-        <Expected>(expected: Expected, ...MISMATCH: MismatchArgs<Extends<Actual, Expected>, Options['positive']>): true;
+        <Expected extends Extends<Actual, Expected> extends true ? unknown : MismatchInfo<Actual, Expected>>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`.
+        ...MISMATCH: MismatchArgs<Extends<Actual, Expected>, true>): true;
+        <Expected extends Extends<Actual, Expected> extends true ? unknown : MismatchInfo<Actual, Expected>>(...MISMATCH: MismatchArgs<Extends<Actual, Expected>, true>): true;
     };
+    toHaveProperty: <K extends keyof Actual>(key: K, ...MISMATCH: MismatchArgs<Extends<K, keyof Actual>, true>) => K extends keyof Actual ? PositiveExpectTypeOf<Actual[K]> : true;
+    not: NegativeExpectTypeOf<Actual>;
+    branded: {
+        toEqualTypeOf: <Expected extends StrictEqualUsingBranding<Actual, Expected> extends true ? unknown : MismatchInfo<Actual, Expected>>(...MISMATCH: MismatchArgs<StrictEqualUsingBranding<Actual, Expected>, true>) => true;
+    };
+}
+interface NegativeExpectTypeOf<Actual> extends BaseExpectTypeOf<Actual, {
+    positive: false;
+}> {
     toEqualTypeOf: {
-        <Expected>(...MISMATCH: MismatchArgs<Equal<Actual, Expected, Options['branded']>, Options['positive']>): true;
-        <Expected>(expected: Expected, ...MISMATCH: MismatchArgs<Equal<Actual, Expected, Options['branded']>, Options['positive']>): true;
+        <Expected>(value: Expected & AValue, ...MISMATCH: MismatchArgs<StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
+        <Expected>(...MISMATCH: MismatchArgs<StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
+    };
+    toMatchTypeOf: {
+        <Expected>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`.
+        ...MISMATCH: MismatchArgs<Extends<Actual, Expected>, false>): true;
+        <Expected>(...MISMATCH: MismatchArgs<Extends<Actual, Expected>, false>): true;
     };
+    toHaveProperty: <K extends string | number | symbol>(key: K, ...MISMATCH: MismatchArgs<Extends<K, keyof Actual>, false>) => true;
+}
+declare type ExpectTypeOf<Actual, Options extends {
+    positive: boolean;
+}> = Options['positive'] extends true ? PositiveExpectTypeOf<Actual> : NegativeExpectTypeOf<Actual>;
+interface BaseExpectTypeOf<Actual, Options extends {
+    positive: boolean;
+}> {
+    toBeAny: Scolder<ExpectAny<Actual>, Options>;
+    toBeUnknown: Scolder<ExpectUnknown<Actual>, Options>;
+    toBeNever: Scolder<ExpectNever<Actual>, Options>;
+    toBeFunction: Scolder<ExpectFunction<Actual>, Options>;
+    toBeObject: Scolder<ExpectObject<Actual>, Options>;
+    toBeArray: Scolder<ExpectArray<Actual>, Options>;
+    toBeNumber: Scolder<ExpectNumber<Actual>, Options>;
+    toBeString: Scolder<ExpectString<Actual>, Options>;
+    toBeBoolean: Scolder<ExpectBoolean<Actual>, Options>;
+    toBeVoid: Scolder<ExpectVoid<Actual>, Options>;
+    toBeSymbol: Scolder<ExpectSymbol<Actual>, Options>;
+    toBeNull: Scolder<ExpectNull<Actual>, Options>;
+    toBeUndefined: Scolder<ExpectUndefined<Actual>, Options>;
+    toBeNullable: Scolder<ExpectNullable<Actual>, Options>;
     toBeCallableWith: Options['positive'] extends true ? (...args: Params<Actual>) => true : never;
     toBeConstructibleWith: Options['positive'] extends true ? (...args: ConstructorParams<Actual>) => true : never;
-    toHaveProperty: <K extends string>(key: K, ...MISMATCH: MismatchArgs<Extends<K, keyof Actual>, Options['positive']>) => K extends keyof Actual ? ExpectTypeOf<Actual[K], Options> : true;
     extract: <V>(v?: V) => ExpectTypeOf<Extract<Actual, V>, Options>;
     exclude: <V>(v?: V) => ExpectTypeOf<Exclude<Actual, V>, Options>;
     parameter: <K extends keyof Params<Actual>>(number: K) => ExpectTypeOf<Params<Actual>[K], Options>;
@@ -136,14 +272,6 @@ interface ExpectTypeOf<Actual, Options extends ExpectTypeOfOptions> {
     items: Actual extends ArrayLike<infer R> ? ExpectTypeOf<R, Options> : never;
     guards: Actual extends (v: any, ...args: any[]) => v is infer T ? ExpectTypeOf<T, Options> : never;
     asserts: Actual extends (v: any, ...args: any[]) => asserts v is infer T ? unknown extends T ? never : ExpectTypeOf<T, Options> : never;
-    branded: Omit<ExpectTypeOf<Actual, {
-        positive: Options['positive'];
-        branded: true;
-    }>, 'branded'>;
-    not: Omit<ExpectTypeOf<Actual, {
-        positive: Not<Options['positive']>;
-        branded: Options['branded'];
-    }>, 'not'>;
 }
 declare type _ExpectTypeOf = {
     <Actual>(actual: Actual): ExpectTypeOf<Actual, {
@@ -223,7 +351,8 @@ declare function waitFor<T>(callback: WaitForCallback<T>, options?: number | Wai
 type WaitUntilCallback<T> = () => T | Promise<T>;
 interface WaitUntilOptions extends Pick<WaitForOptions, 'interval' | 'timeout'> {
 }
-declare function waitUntil<T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions): Promise<T>;
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+declare function waitUntil<T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions): Promise<Truthy<T>>;
 
 type ESModuleExports = Record<string, unknown>;
 interface VitestUtils {

package/dist/index.js

@@ -1,25 +1,25 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench } from './vendor-benchmark.b6befc50.js';
-export { i as isFirstRun, r as runOnce } from './vendor-run-once.fb836747.js';
-export { c as createExpect, a as expect, v as vi, b as vitest } from './vendor-vi.3baa7c4a.js';
-import { d as dist } from './vendor-index.72df742e.js';
-export { c as assertType, g as getRunningMode, a as inject, b as isWatchMode } from './vendor-index.72df742e.js';
+export { b as bench } from './vendor/benchmark.WVm6DARl.js';
+export { i as isFirstRun, r as runOnce } from './vendor/run-once.X3E7xx3F.js';
+export { c as createExpect, a as expect, v as vi, b as vitest } from './vendor/vi.JXuS6emb.js';
+import { d as dist } from './vendor/index.VL3WbvjT.js';
+export { c as assertType, g as getRunningMode, a as inject, b as isWatchMode } from './vendor/index.VL3WbvjT.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './vendor-index.2b92937b.js';
+import './vendor/index.XU72Rmy8.js';
 import 'pathe';
 import 'std-env';
-import './vendor-global.c3664e75.js';
-import './vendor-_commonjsHelpers.7d1333e8.js';
+import './vendor/global.L7JRz1qU.js';
+import './vendor/_commonjsHelpers.jjO7Zipk.js';
 import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './vendor-tasks.f9d75aed.js';
+import './vendor/tasks.IknbGB2n.js';
 import '@vitest/utils/source-map';
-import './vendor-date.6e993429.js';
+import './vendor/date.Ns1pGd_X.js';
 import '@vitest/spy';
 
 

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { V as VitestRunMode, U as UserConfig, e as Vitest, R as ResolvedConfig, f as ProvidedContext, T as TestSequencer, W as WorkspaceSpec } from './reporters-50c2bd49.js';
-export { j as BrowserProvider, i as BrowserProviderInitializationOptions, k as BrowserProviderOptions, h as TestSequencerConstructor, g as WorkspaceProject, s as startVitest } from './reporters-50c2bd49.js';
+import { V as VitestRunMode, U as UserConfig, e as Vitest, R as ResolvedConfig, f as ProvidedContext, W as WorkspaceProject, g as RuntimeRPC, T as TestSequencer, h as WorkspaceSpec } from './reporters-vMlHjCdM.js';
+export { l as BrowserProvider, k as BrowserProviderInitializationOptions, m as BrowserProviderOptions, i as ProcessPool, j as TestSequencerConstructor, s as startVitest } from './reporters-vMlHjCdM.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import '@vitest/runner';
 import 'vite-node';
@@ -26,6 +26,8 @@ interface GlobalSetupContext {
     provide<T extends keyof ProvidedContext>(key: T, value: ProvidedContext[T]): void;
 }
 
+declare function createMethodsRPC(project: WorkspaceProject): RuntimeRPC;
+
 declare class BaseSequencer implements TestSequencer {
     protected ctx: Vitest;
     constructor(ctx: Vitest);
@@ -33,6 +35,4 @@ declare class BaseSequencer implements TestSequencer {
     sort(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
 }
 
-declare function ensurePackageInstalled(dependency: string, root: string): Promise<boolean>;
-
-export { BaseSequencer, type GlobalSetupContext, TestSequencer, Vitest, VitestPlugin, WorkspaceSpec, createVitest, ensurePackageInstalled, registerConsoleShortcuts };
+export { BaseSequencer, type GlobalSetupContext, TestSequencer, Vitest, VitestPlugin, WorkspaceProject, WorkspaceSpec, createMethodsRPC, createVitest, registerConsoleShortcuts };

package/dist/node.js

@@ -1,14 +1,15 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, e as ensurePackageInstalled, r as registerConsoleShortcuts, s as startVitest } from './vendor-node.65461b16.js';
+export { B as BaseSequencer, V as VitestPlugin, a as createMethodsRPC, c as createVitest, r as registerConsoleShortcuts, s as startVitest } from './vendor/node.1xm0UoNi.js';
 import 'pathe';
 import 'vite';
 import 'node:path';
 import 'node:url';
 import 'node:process';
 import 'node:fs';
-import './vendor-constants.538d9b49.js';
-import './vendor-_commonjsHelpers.7d1333e8.js';
+import './vendor/constants.WSvnD_fn.js';
+import './vendor/_commonjsHelpers.jjO7Zipk.js';
 import 'os';
 import 'path';
+import './vendor/index.xL8XjTLv.js';
 import 'util';
 import 'stream';
 import 'events';
@@ -18,44 +19,38 @@ import 'vite-node/utils';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
-import './vendor-index.2b92937b.js';
+import './vendor/index.XU72Rmy8.js';
 import 'std-env';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './vendor-global.c3664e75.js';
-import './vendor-coverage.78040316.js';
-import './vendor-paths.84fc7a99.js';
+import './vendor/global.L7JRz1qU.js';
+import './vendor/coverage.v6aD8iAh.js';
+import './paths.js';
 import 'node:v8';
 import 'node:os';
 import 'node:events';
 import 'tinypool';
-import './vendor-index.1ca68bd5.js';
-import './vendor-base.9c08bbd0.js';
+import './vendor/index.cAUulNDf.js';
+import './vendor/base._79unx2z.js';
 import 'node:worker_threads';
 import 'node:fs/promises';
 import 'node:perf_hooks';
-import './vendor-index.8efe7746.js';
-import 'node:buffer';
-import 'node:child_process';
-import 'child_process';
-import 'assert';
-import 'buffer';
-import 'node:util';
+import 'execa';
 import '@vitest/utils/source-map';
 import 'local-pkg';
 import 'module';
-import 'acorn';
 import 'acorn-walk';
-import './vendor-reporters.d24d80a4.js';
-import './chunk-runtime-console.f3263f87.js';
+import './vendor/reporters.pr8MinP9.js';
+import './chunks/runtime-console.hf2msWA9.js';
 import 'node:stream';
 import 'node:console';
-import './vendor-date.6e993429.js';
-import './vendor-tasks.f9d75aed.js';
+import './vendor/date.Ns1pGd_X.js';
+import './vendor/tasks.IknbGB2n.js';
 import 'node:module';
 import 'node:crypto';
+import 'assert';
 import 'magic-string';
 import 'strip-literal';
-import './vendor-environments.dcc4a34e.js';
+import './vendor/environments.ewIbzajW.js';
 import 'node:readline';
 import 'readline';

package/dist/{vendor-paths.84fc7a99.js → paths.js}

@@ -4,4 +4,4 @@ import { resolve } from 'pathe';
 const rootDir = resolve(url.fileURLToPath(import.meta.url), "../../");
 const distDir = resolve(url.fileURLToPath(import.meta.url), "../../dist");
 
-export { distDir as d, rootDir as r };
+export { distDir, rootDir };