@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/index.d.ts

@@ -1,22 +1,24 @@
-import { M as ModuleDefinitionDurationsDiagnostic, U as UntrackedModuleDefinitionDiagnostic, S as SerializedTestSpecification, a as ModuleDefinitionDiagnostic, b as ModuleDefinitionLocation, c as SourceModuleDiagnostic, d as SourceModuleLocations } from './chunks/browser.d.ChKACdzH.js';
-export { B as BrowserTesterOptions } from './chunks/browser.d.ChKACdzH.js';
-import './chunks/global.d.B15mdLcR.js';
+import { M as ModuleDefinitionDurationsDiagnostic, U as UntrackedModuleDefinitionDiagnostic, S as SerializedTestSpecification, a as ModuleDefinitionDiagnostic, b as ModuleDefinitionLocation, c as SourceModuleDiagnostic, d as SourceModuleLocations } from './chunks/browser.d.X3SXoOCV.js';
+export { B as BrowserTesterOptions } from './chunks/browser.d.X3SXoOCV.js';
+import './chunks/global.d.x-ILCfAE.js';
 import { File, TestAnnotation, TestArtifact, TaskResultPack, TaskEventPack, Test, TaskPopulated } from './@vitest/runner/index.js';
-export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestAnnotationArtifact, TestArtifact, TestArtifactBase, TestArtifactLocation, TestArtifactRegistry, TestAttachment, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from './@vitest/runner/index.js';
+export { CancelReason, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteOptions, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestAnnotationArtifact, TestArtifact, TestArtifactBase, TestArtifactLocation, TestArtifactRegistry, TestAttachment, TestContext, TestFunction, TestOptions, VitestRunnerConfig as TestRunnerConfig, TestTags, VitestRunner as VitestTestRunner, afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from './@vitest/runner/index.js';
 import { Awaitable } from './@vitest/utils/index.js';
 export { ParsedStack, SerializedError, TestError } from './@vitest/utils/index.js';
-import { b as BirpcReturn } from './chunks/worker.d.Dyxm8DEL.js';
-export { C as ContextRPC, c as ContextTestEnvironment, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.Dyxm8DEL.js';
-import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.Cy95HiCx.js';
-export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.d.Cy95HiCx.js';
-import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/rpc.d.RH3apGEf.js';
-export { A as AfterSuiteRunMeta, a as RunnerRPC, R as RuntimeRPC } from './chunks/rpc.d.RH3apGEf.js';
+import { b as BirpcReturn } from './chunks/worker.d.B84sVRy0.js';
+export { C as ContextRPC, c as ContextTestEnvironment, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.B84sVRy0.js';
+import { S as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.EJLVE3es.js';
+export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.d.EJLVE3es.js';
+import { U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/rpc.d.BFMWpdph.js';
+export { A as AfterSuiteRunMeta, a as RunnerRPC, R as RuntimeRPC } from './chunks/rpc.d.BFMWpdph.js';
 import { ExpectStatic } from './@vitest/expect/index.js';
-export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, Matchers, chai } from './@vitest/expect/index.js';
+export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, RawMatcherFn as Matcher, ExpectationResult as MatcherResult, MatcherState, Matchers, chai } from './@vitest/expect/index.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from './@vitest/spy/index.js';
 export { Mock, MockContext, MockInstance, MockResult, MockResultIncomplete, MockResultReturn, MockResultThrow, MockSettledResult, MockSettledResultFulfilled, MockSettledResultIncomplete, MockSettledResultRejected, Mocked, MockedClass, MockedFunction, MockedObject } from './@vitest/spy/index.js';
-export { b as bench } from './chunks/suite.d.BJWk38HB.js';
+import { ModuleMockFactoryWithHelper, ModuleMockOptions } from './@vitest/mocker/index.js';
+export { b as bench } from './chunks/suite.d.udJtyAgw.js';
 export { V as EvaluatedModules } from './chunks/evaluatedModules.d.BxJ5omdx.js';
+export { NodeBenchmarkRunner as BenchmarkRunner, VitestTestRunner as TestRunner } from './runners.js';
 export { a as BenchFunction, b as Benchmark, c as BenchmarkAPI, B as BenchmarkResult } from './chunks/benchmark.d.DAaHLpsq.js';
 export { ExpectTypeOf, expectTypeOf } from './vendor/expect-type.mjs';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from './@vitest/snapshot/index.js';
@@ -55,7 +57,6 @@ interface TransformResultWithSource {
 	untrackedModules?: UntrackedModuleDefinitionDiagnostic[];
 }
 interface WebSocketHandlers {
-	onTaskUpdate: (packs: TaskResultPack[], events: TaskEventPack[]) => void;
 	getFiles: () => File[];
 	getTestFiles: () => Promise<SerializedTestSpecification[]>;
 	getPaths: () => string[];
@@ -98,12 +99,6 @@ declare const should: () => Chai.Should;
 */
 declare function inject<T extends keyof ProvidedContext & string>(key: T): ProvidedContext[T];
 
-type Promisable<T> = T | Promise<T>;
-type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Promisable<Partial<M>>;
-interface MockOptions {
-	spy?: boolean;
-}
-
 type WaitForCallback<T> = () => T | Promise<T>;
 interface WaitForOptions {
 	/**
@@ -149,12 +144,12 @@ interface VitestUtils {
 	runOnlyPendingTimersAsync: () => Promise<VitestUtils>;
 	/**
 	* This method will invoke every initiated timer until the timer queue is empty. It means that every timer called during `runAllTimers` will be fired.
-	* If you have an infinite interval, it will throw after 10,000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/#faketimers-looplimit)).
+	* If you have an infinite interval, it will throw after 10,000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/faketimers#faketimers-looplimit)).
 	*/
 	runAllTimers: () => VitestUtils;
 	/**
 	* This method will asynchronously invoke every initiated timer until the timer queue is empty. It means that every timer called during `runAllTimersAsync` will be fired even asynchronous timers.
-	* If you have an infinite interval, it will throw after 10 000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/#faketimers-looplimit)).
+	* If you have an infinite interval, it will throw after 10 000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/faketimers#faketimers-looplimit)).
 	*/
 	runAllTimersAsync: () => Promise<VitestUtils>;
 	/**
@@ -203,6 +198,15 @@ interface VitestUtils {
 	*/
 	clearAllTimers: () => VitestUtils;
 	/**
+	* Controls how fake timers are advanced.
+	* @param mode The mode to use for advancing timers.
+	* - `manual`: The default behavior. Timers will only advance when you call one of `vi.advanceTimers...()` methods.
+	* - `nextTimerAsync`: Timers will be advanced automatically to the next available timer after each macrotask.
+	* - `interval`: Timers are advanced automatically by a specified interval.
+	* @param interval The interval in milliseconds to use when `mode` is `'interval'`.
+	*/
+	setTimerTickMode: ((mode: "manual" | "nextTimerAsync") => VitestUtils) & ((mode: "interval", interval?: number) => VitestUtils);
+	/**
 	* Creates a spy on a method or getter/setter of an object similar to [`vi.fn()`](https://vitest.dev/api/vi#vi-fn). It returns a [mock function](https://vitest.dev/api/mock).
 	* @example
 	* ```ts
@@ -261,6 +265,39 @@ interface VitestUtils {
 	*/
 	waitFor: typeof waitFor;
 	/**
+	* Wraps a function to create an assertion helper. When an assertion fails inside the helper,
+	* the error stack trace will point to where the helper was called, not inside the helper itself.
+	* Works with both synchronous and asynchronous functions, and supports `expect.soft()`.
+	*
+	* @example
+	* ```ts
+	* const myEqual = vi.defineHelper((x, y) => {
+	*   expect(x).toEqual(y)
+	* })
+	*
+	* test('example', () => {
+	*   myEqual('left', 'right') // Error points to this line
+	* })
+	* ```
+	* Example output:
+	* ```
+	* FAIL  example.test.ts > example
+	* AssertionError: expected 'left' to deeply equal 'right'
+	*
+	* Expected: "right"
+	* Received: "left"
+	*
+	*  ❯ example.test.ts:6:3
+	*       4| test('example', () => {
+	*       5|   myEqual('left', 'right')
+	*        |   ^
+	*       6| })
+	* ```
+	* @param fn The assertion function to wrap
+	* @returns A wrapped function with the same signature
+	*/
+	defineHelper: <F extends (...args: any) => any>(fn: F) => F;
+	/**
 	* This is similar to [`vi.waitFor`](https://vitest.dev/api/vi#vi-waitfor), but if the callback throws any errors, execution is immediately interrupted and an error message is received.
 	*
 	* If the callback returns a falsy value, the next check will continue until a truthy value is returned. This is useful when you need to wait for something to exist before taking the next step.
@@ -296,8 +333,8 @@ interface VitestUtils {
 	* @param path Path to the module. Can be aliased, if your Vitest config supports it
 	* @param factory Mocked module factory. The result of this function will be an exports object
 	*/
-	mock(path: string, factory?: MockFactoryWithHelper | MockOptions): void;
-	mock<T>(module: Promise<T>, factory?: MockFactoryWithHelper<T> | MockOptions): void;
+	mock(path: string, factory?: ModuleMockFactoryWithHelper | ModuleMockOptions): void;
+	mock<T>(module: Promise<T>, factory?: ModuleMockFactoryWithHelper<T> | ModuleMockOptions): void;
 	/**
 	* Removes module from mocked registry. All calls to import will return the original module even if it was mocked before.
 	*
@@ -314,9 +351,11 @@ interface VitestUtils {
 	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking/modules).
 	* @param path Path to the module. Can be aliased, if your Vitest config supports it
 	* @param factory Mocked module factory. The result of this function will be an exports object
+	*
+	* @returns A disposable object that calls {@link doUnmock()} when disposed
 	*/
-	doMock(path: string, factory?: MockFactoryWithHelper | MockOptions): void;
-	doMock<T>(module: Promise<T>, factory?: MockFactoryWithHelper<T> | MockOptions): void;
+	doMock(path: string, factory?: ModuleMockFactoryWithHelper | ModuleMockOptions): Disposable;
+	doMock<T>(module: Promise<T>, factory?: ModuleMockFactoryWithHelper<T> | ModuleMockOptions): Disposable;
 	/**
 	* Removes module from mocked registry. All subsequent calls to import will return original module.
 	*
@@ -387,12 +426,12 @@ interface VitestUtils {
 	* @param value - The object to be mocked
 	* @returns A deeply mocked version of the input object
 	*/
-	mockObject: <T>(value: T, options?: MockOptions) => MaybeMockedDeep<T>;
+	mockObject: <T>(value: T, options?: ModuleMockOptions) => MaybeMockedDeep<T>;
 	/**
 	* Type helper for TypeScript. Just returns the object that was passed.
 	*
 	* When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will only make TypeScript believe that
-	* the first level values are mocked. You can pass down `{ deep: true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually is.
+	* the first level values are mocked. You can pass down `{ partial: true, deep: true }` to make nested objects also partial recursively.
 	* @example
 	* ```ts
 	* import example from './example.js'

package/dist/index.js

@@ -1,19 +1,20 @@
-export { b as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, d as vitest } from './chunks/vi.2VT5v0um.js';
-export { b as bench } from './chunks/benchmark.B3N2zMcH.js';
+export { N as BenchmarkRunner, T as TestRunner, a as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, b as vitest } from './chunks/test.CTcmp4Su.js';
+export { b as bench } from './chunks/benchmark.D0SlKNbZ.js';
 export { V as EvaluatedModules } from './chunks/evaluatedModules.Dg1zASAC.js';
-export { a as assertType } from './chunks/index.Z5E_ObnR.js';
+export { a as assertType } from './chunks/index.DlDSLQD3.js';
 export { expectTypeOf } from './vendor/expect-type.mjs';
-export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from './@vitest/runner/index.js';
+export { afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from './@vitest/runner/index.js';
 export { chai } from './@vitest/expect/index.js';
-import './chunks/utils.DvEY5TfP.js';
+import './@vitest/utils/helpers.js';
 import './@vitest/utils/timers.js';
+import './chunks/utils.BX5Fg8C4.js';
 import './@vitest/runner/utils.js';
-import './@vitest/snapshot/index.js';
 import './@vitest/utils/error.js';
-import './@vitest/utils/helpers.js';
+import './vendor/pathe.mjs';
+import './@vitest/snapshot/index.js';
 import './@vitest/spy/index.js';
 import './@vitest/utils/offset.js';
 import './@vitest/utils/source-map.js';
 import './chunks/_commonjsHelpers.D26ty3Ew.js';
-import './chunks/date.Bq6ZW5rf.js';
-import './vendor/pathe.mjs';
+import './chunks/rpc.MzXet3jl.js';
+import './chunks/index.Chj8NDwU.js';

package/dist/locators.d.ts

@@ -1,4 +1,4 @@
-import { UserEventClickOptions, UserEventClearOptions, UserEventHoverOptions, UserEventFillOptions, UserEventUploadOptions, UserEventDragAndDropOptions, UserEventSelectOptions, LocatorScreenshotOptions, LocatorByRoleOptions, LocatorOptions } from 'vitest/browser';
+import { UserEventClickOptions, UserEventWheelOptions, UserEventClearOptions, UserEventHoverOptions, UserEventFillOptions, UserEventUploadOptions, UserEventDragAndDropOptions, UserEventSelectOptions, LocatorScreenshotOptions, MarkOptions, LocatorByRoleOptions, LocatorOptions, SelectorOptions } from 'vitest/browser';
 
 type ClauseCombinator = '' | '>' | '+' | '~' | '>=';
 type CSSFunctionArgument = CSSComplexSelector | number | string;
@@ -299,19 +299,23 @@ interface SelectorEngine {
 declare function convertElementToCssSelector(element: Element): string;
 declare function processTimeoutOptions<T extends {
 	timeout?: number;
-}>(options_?: T): T | undefined;
+}>(options_: T | undefined): T | undefined;
 declare function getIframeScale(): number;
 
+declare function ensureAwaited<T>(promise: (error?: Error) => Promise<T>): Promise<T>;
+
 declare const selectorEngine: Ivya;
 declare abstract class Locator {
 	abstract selector: string;
 	private _parsedSelector;
 	protected _container?: Element | undefined;
 	protected _pwSelector?: string | undefined;
+	protected _errorSource?: Error;
 	constructor();
 	click(options?: UserEventClickOptions): Promise<void>;
 	dblClick(options?: UserEventClickOptions): Promise<void>;
 	tripleClick(options?: UserEventClickOptions): Promise<void>;
+	wheel(options: UserEventWheelOptions): Promise<void>;
 	clear(options?: UserEventClearOptions): Promise<void>;
 	hover(options?: UserEventHoverOptions): Promise<void>;
 	unhover(options?: UserEventHoverOptions): Promise<void>;
@@ -326,6 +330,7 @@ declare abstract class Locator {
 		base64: string;
 	}>;
 	screenshot(options?: LocatorScreenshotOptions): Promise<string>;
+	mark(name: string, options?: MarkOptions): Promise<void>;
 	protected abstract locator(selector: string): Locator;
 	protected abstract elementLocator(element: Element): Locator;
 	getByRole(role: string, options?: LocatorByRoleOptions): Locator;
@@ -348,7 +353,13 @@ declare abstract class Locator {
 	last(): Locator;
 	toString(): string;
 	toJSON(): string;
+	findElement(options_?: SelectorOptions): Promise<HTMLElement | SVGElement>;
 	protected triggerCommand<T>(command: string, ...args: any[]): Promise<T>;
 }
+declare function triggerCommandWithTrace<T>(options: {
+	name: string;
+	arguments: unknown[];
+	errorSource?: Error | undefined;
+}): Promise<T>;
 
-export { Locator, convertElementToCssSelector, getByAltTextSelector, getByLabelSelector, getByPlaceholderSelector, getByRoleSelector, getByTestIdSelector, getByTextSelector, getByTitleSelector, getIframeScale, processTimeoutOptions, selectorEngine };
+export { Locator, convertElementToCssSelector, ensureAwaited, getByAltTextSelector, getByLabelSelector, getByPlaceholderSelector, getByRoleSelector, getByTestIdSelector, getByTextSelector, getByTitleSelector, getIframeScale, processTimeoutOptions, selectorEngine, triggerCommandWithTrace };

package/dist/locators.js

@@ -1 +1 @@
-export{L as Locator,n as convertElementToCssSelector,q as getByAltTextSelector,r as getByLabelSelector,t as getByPlaceholderSelector,u as getByRoleSelector,v as getByTestIdSelector,w as getByTextSelector,x as getByTitleSelector,o as getIframeScale,p as processTimeoutOptions,s as selectorEngine}from"./index-D6m36C6U.js";import"vitest/browser";import"vitest/internal/browser";
+export{L as Locator,o as convertElementToCssSelector,q as ensureAwaited,r as getByAltTextSelector,s as getByLabelSelector,t as getByPlaceholderSelector,u as getByRoleSelector,v as getByTestIdSelector,w as getByTextSelector,x as getByTitleSelector,y as getIframeScale,p as processTimeoutOptions,z as selectorEngine,A as triggerCommandWithTrace}from"./index-5Pe7X7sp.js";import"vitest/browser";import"vitest/internal/browser";

package/dist/module-evaluator.d.ts

@@ -1,7 +1,7 @@
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode } from '@voidzero-dev/vite-plus-core/module-runner';
 import { V as VitestEvaluatedModules } from './chunks/evaluatedModules.d.BxJ5omdx.js';
 import vm from 'node:vm';
-import { R as RuntimeRPC } from './chunks/rpc.d.RH3apGEf.js';
+import { R as RuntimeRPC } from './chunks/rpc.d.BFMWpdph.js';
 import './@vitest/runner/index.js';
 import './@vitest/snapshot/index.js';
 import './chunks/traces.d.402V_yFI.js';
@@ -82,6 +82,15 @@ declare module "vite/module-runner" {
 	}
 }
 
+declare module "vite/module-runner" {
+	interface EvaluatedModuleNode {
+		/**
+		* @internal
+		*/
+		mockedExports?: Record<string, any>;
+	}
+}
+
 interface VitestVmOptions {
 	context: vm.Context;
 	externalModulesExecutor: ExternalModulesExecutor;
@@ -110,6 +119,7 @@ declare class VitestModuleEvaluator implements ModuleEvaluator {
 	private convertIdToImportUrl;
 	runExternalModule(id: string): Promise<any>;
 	runInlinedModule(context: ModuleRunnerContext, code: string, module: Readonly<EvaluatedModuleNode>): Promise<any>;
+	private _createCJSGlobals;
 	private _runInlinedModule;
 	private createRequire;
 	private shouldInterop;

package/dist/module-evaluator.js

@@ -106,8 +106,7 @@ class VitestModuleEvaluator {
   async runInlinedModule(context, code, module) {
     return this._otel.$("vitest.module.inline", (span) => this._runInlinedModule(context, code, module, span));
   }
-  async _runInlinedModule(context, code, module, span) {
-    context.__vite_ssr_import_meta__.env = this.env;
+  _createCJSGlobals(context, module, span) {
     const { Reflect, Proxy, Object } = this.primitives;
     const exportsObject = context[ssrModuleExportsKey];
     const SYMBOL_NOT_DEFINED = Symbol("not defined");
@@ -143,46 +142,57 @@ class VitestModuleEvaluator {
         return true;
       }
     });
-    const moduleProxy = {
-      set exports(value) {
-        span.addEvent("`module.exports` is assigned directly, copying all properties to `exports`");
-        exportAll(cjsExports, value);
-        exportsObject.default = value;
-        moduleExports = value;
+    return {
+      exports: cjsExports,
+      module: {
+        set exports(value) {
+          span.addEvent("`module.exports` is assigned directly, copying all properties to `exports`");
+          exportAll(cjsExports, value);
+          exportsObject.default = value;
+          moduleExports = value;
+        },
+        get exports() {
+          return cjsExports;
+        }
       },
-      get exports() {
-        return cjsExports;
-      }
+      require: this.createRequire(context[ssrImportMetaKey].url),
+      __filename: context[ssrImportMetaKey].filename,
+      __dirname: context[ssrImportMetaKey].dirname
     };
+  }
+  async _runInlinedModule(context, code, module, span) {
     const meta = context[ssrImportMetaKey];
+    meta.env = this.env;
     if (this.options.getCurrentTestFilepath?.() === module.file) {
       const globalNamespace = this.vm?.context || globalThis;
       Object.defineProperty(meta, "vitest", { get: () => globalNamespace.__vitest_index__ });
     }
-    const filename = meta.filename;
-    const dirname = meta.dirname;
-    span.setAttributes({ "code.file.path": filename });
-    const require = this.createRequire(meta.url);
+    span.setAttribute("code.file.path", meta.filename);
     const argumentsList = [
       ssrModuleExportsKey,
       ssrImportMetaKey,
       ssrImportKey,
       ssrDynamicImportKey,
       ssrExportAllKey,
-      "__vite_ssr_exportName__",
+      "__vite_ssr_exportName__"
+    ];
+    const cjsGlobals = this._createCJSGlobals(context, module, span);
+    argumentsList.push(
+      // TODO@discuss deprecate in Vitest 5, remove in Vitest 6(?)
+      // backwards compat for vite-node
       "__filename",
       "__dirname",
       "module",
       "exports",
       "require"
-    ];
+    );
     if (this.compiledFunctionArgumentsNames) argumentsList.push(...this.compiledFunctionArgumentsNames);
     span.setAttribute("vitest.module.arguments", argumentsList);
     // add 'use strict' since ESM enables it by default
     const codeDefinition = `'use strict';async (${argumentsList.join(",")})=>{{`;
     const wrappedCode = `${codeDefinition}${code}\n}}`;
     const options = {
-      filename: module.id,
+      filename: module.id.startsWith("mock:") ? module.id.slice(5) : module.id,
       lineOffset: 0,
       columnOffset: -codeDefinition.length
     };
@@ -200,16 +210,16 @@ class VitestModuleEvaluator {
         context[ssrDynamicImportKey],
         context[ssrExportAllKey],
         // vite 7 support, remove when vite 7+ is supported
-        context.__vite_ssr_exportName__ || ((name, getter) => Object.defineProperty(exportsObject, name, {
+        context.__vite_ssr_exportName__ || ((name, getter) => Object.defineProperty(context[ssrModuleExportsKey], name, {
           enumerable: true,
           configurable: true,
           get: getter
         })),
-        filename,
-        dirname,
-        moduleProxy,
-        cjsExports,
-        require,
+        cjsGlobals.__filename,
+        cjsGlobals.__dirname,
+        cjsGlobals.module,
+        cjsGlobals.exports,
+        cjsGlobals.require,
         ...this.compiledFunctionArgumentsValues
       );
     } finally {
@@ -218,8 +228,15 @@ class VitestModuleEvaluator {
       this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
     }
   }
-  createRequire(filename) {
-    return this.vm ? this.vm.externalModulesExecutor.createRequire(filename) : createRequire(filename);
+  createRequire(url) {
+    if (url.startsWith("data:")) {
+      const _require = (id) => {
+        throw new SyntaxError(`require() is not supported in virtual modules. Trying to call require("${id}") in ${url}`);
+      };
+      _require.resolve = _require;
+      return _require;
+    }
+    return this.vm ? this.vm.externalModulesExecutor.createRequire(url) : createRequire(url);
   }
   shouldInterop(path, mod) {
     if (this.options.interopDefault === false) return false;

package/dist/node.d.ts

@@ -3,25 +3,24 @@ import { InlineConfig, UserConfig as UserConfig$1, Plugin, ResolvedConfig as Res
 export { vite as Vite };
 export { esbuildVersion, isCSSRequest, isFileLoadingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from '@voidzero-dev/vite-plus-core';
 import { IncomingMessage } from 'node:http';
-import { h as ResolvedConfig, f as UserConfig, i as VitestRunMode, j as VitestOptions, V as Vitest, A as ApiConfig, k as TestSpecification, T as TestProject, P as PoolWorker, l as PoolOptions, m as WorkerRequest, n as TestSequencer, L as Logger } from './chunks/reporters.d.CWXNI2jG.js';
-export { at as BaseCoverageOptions, Y as BenchmarkUserOptions, Z as BrowserBuiltinProvider, $ as BrowserCommand, a0 as BrowserCommandContext, a1 as BrowserConfigOptions, a2 as BrowserInstanceOption, a3 as BrowserModuleMocker, a4 as BrowserOrchestrator, a5 as BrowserProvider, a6 as BrowserProviderOption, a7 as BrowserScript, a8 as BrowserServerFactory, a9 as BrowserServerOptions, aa as BrowserServerState, ab as BrowserServerStateSession, ai as BuiltinEnvironment, ac as CDPSession, aj as CSSModuleScopeStrategy, au as CoverageIstanbulOptions, av as CoverageOptions, aw as CoverageProvider, ax as CoverageProviderModule, ay as CoverageReporter, c as CoverageV8Options, az as CustomProviderOptions, ak as DepsOptimizationOptions, al as EnvironmentOptions, H as HTMLOptions, I as InlineConfig, t as JUnitOptions, J as JsonOptions, M as ModuleDiagnostic, O as OnServerRestartHandler, o as OnTestsRerunHandler, ad as ParentProjectBrowser, am as Pool, q as PoolRunnerInitializer, r as PoolTask, ae as ProjectBrowser, an as ProjectConfig, a as ReportContext, aB as ReportedHookContext, aC as Reporter, ap as ResolveSnapshotPathHandler, aq as ResolveSnapshotPathHandlerContext, af as ResolvedBrowserOptions, R as ResolvedCoverageOptions, ao as ResolvedProjectConfig, S as SerializedTestProject, u as TaskOptions, v as TestCase, w as TestCollection, x as TestDiagnostic, y as TestModule, z as TestModuleState, B as TestResult, D as TestResultFailed, E as TestResultPassed, F as TestResultSkipped, aD as TestRunEndReason, aA as TestRunResult, X as TestSequencerConstructor, G as TestState, K as TestSuite, N as TestSuiteState, ag as ToMatchScreenshotComparators, ah as ToMatchScreenshotOptions, ar as TypecheckConfig, U as UserWorkspaceConfig, as as VitestEnvironment, p as VitestPackageInstaller, W as WatcherTriggerPattern, s as WorkerResponse, _ as _BrowserNames, Q as experimental_getRunnerTask } from './chunks/reporters.d.CWXNI2jG.js';
-export { C as CacheKeyIdGenerator, a as CacheKeyIdGeneratorContext, V as VitestPluginContext } from './chunks/plugin.d.CtqpEehP.js';
+import { f as ResolvedConfig, e as UserConfig, g as VitestRunMode, h as VitestOptions, V as Vitest, A as ApiConfig, L as Logger, i as TestSpecification, T as TestProject, P as PoolWorker, j as PoolOptions, k as WorkerRequest, l as TestSequencer } from './chunks/reporters.d.DVUYHHhe.js';
+export { m as AgentReporter, B as BaseCoverageOptions, n as BaseReporter, o as BenchmarkBuiltinReporters, p as BenchmarkReporter, q as BenchmarkReportsMap, r as BenchmarkUserOptions, s as BrowserBuiltinProvider, t as BrowserCommand, u as BrowserCommandContext, v as BrowserConfigOptions, w as BrowserInstanceOption, x as BrowserModuleMocker, y as BrowserOrchestrator, z as BrowserProvider, D as BrowserProviderOption, E as BrowserScript, F as BrowserServerFactory, G as BrowserServerOptions, H as BrowserServerState, J as BrowserServerStateSession, K as BuiltinEnvironment, M as BuiltinReporterOptions, N as BuiltinReporters, O as CSSModuleScopeStrategy, Q as CoverageIstanbulOptions, S as CoverageOptions, X as CoverageProvider, Y as CoverageProviderModule, Z as CoverageReporter, C as CoverageV8Options, _ as CustomProviderOptions, $ as DefaultReporter, a0 as DepsOptimizationOptions, a1 as DotReporter, a2 as EnvironmentOptions, a3 as GithubActionsReporter, a4 as HTMLOptions, a5 as HangingProcessReporter, I as InlineConfig, a6 as JUnitOptions, a7 as JUnitReporter, a8 as JsonAssertionResult, a9 as JsonOptions, aa as JsonReporter, ab as JsonTestResult, ac as JsonTestResults, ad as ModuleDiagnostic, ae as OnServerRestartHandler, af as OnTestsRerunHandler, ag as ParentProjectBrowser, ah as Pool, ai as PoolRunnerInitializer, aj as PoolTask, ak as ProjectBrowser, al as ProjectConfig, am as ReportContext, an as ReportedHookContext, ao as Reporter, ap as ReportersMap, aq as ResolveSnapshotPathHandler, ar as ResolveSnapshotPathHandlerContext, as as ResolvedBrowserOptions, R as ResolvedCoverageOptions, at as ResolvedProjectConfig, au as SerializedTestProject, av as TapFlatReporter, aw as TapReporter, ax as TaskOptions, ay as TestCase, az as TestCollection, aA as TestDiagnostic, aB as TestModule, aC as TestModuleState, aD as TestResult, aE as TestResultFailed, aF as TestResultPassed, aG as TestResultSkipped, aH as TestRunEndReason, aI as TestRunResult, aJ as TestSequencerConstructor, aK as TestSpecificationOptions, aL as TestState, aM as TestSuite, aN as TestSuiteState, aO as ToMatchScreenshotComparators, aP as ToMatchScreenshotOptions, aQ as TypecheckConfig, U as UserWorkspaceConfig, aR as VerboseBenchmarkReporter, aS as VerboseReporter, aT as VitestEnvironment, aU as VitestPackageInstaller, W as WatcherTriggerPattern, aV as WorkerResponse, aW as _BrowserNames, aX as experimental_getRunnerTask } from './chunks/reporters.d.DVUYHHhe.js';
+export { C as CacheKeyIdGenerator, a as CacheKeyIdGeneratorContext, V as VitestPluginContext } from './chunks/plugin.d.BuW-flqo.js';
+export { BaseCoverageProvider } from './coverage.js';
 import { Awaitable } from './@vitest/utils/index.js';
 export { SerializedError } from './@vitest/utils/index.js';
-import { R as RuntimeRPC } from './chunks/rpc.d.RH3apGEf.js';
+import { R as RuntimeRPC } from './chunks/rpc.d.BFMWpdph.js';
 import { Writable } from 'node:stream';
-import { C as ContextRPC } from './chunks/worker.d.Dyxm8DEL.js';
-export { T as TestExecutionType } from './chunks/worker.d.Dyxm8DEL.js';
+import { C as ContextRPC } from './chunks/worker.d.B84sVRy0.js';
+export { T as TestExecutionType } from './chunks/worker.d.B84sVRy0.js';
 import { Debugger } from './vendor/obug.mjs';
-import './chunks/global.d.B15mdLcR.js';
+import './chunks/global.d.x-ILCfAE.js';
 export { Task as RunnerTask, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SequenceHooks, SequenceSetupFiles } from './@vitest/runner/index.js';
-export { b as RuntimeConfig } from './chunks/config.d.Cy95HiCx.js';
+export { b as RuntimeConfig } from './chunks/config.d.EJLVE3es.js';
 export { generateFileHash } from './@vitest/runner/utils.js';
-import './chunks/browser.d.ChKACdzH.js';
+export { CDPSession } from './@vitest/browser/index.js';
+import './chunks/browser.d.X3SXoOCV.js';
 import './chunks/traces.d.402V_yFI.js';
-import './@vitest/mocker/index.js';
-import './@vitest/utils/source-map.js';
-import './@vitest/browser/index.js';
 import './@vitest/pretty-format/index.js';
 import './@vitest/snapshot/index.js';
 import './@vitest/utils/diff.js';
@@ -29,6 +28,8 @@ import './@vitest/expect/index.js';
 import 'vitest/optional-types.js';
 import './chunks/benchmark.d.DAaHLpsq.js';
 import './vendor/tinybench.mjs';
+import './@vitest/mocker/index.js';
+import './@vitest/utils/source-map.js';
 import './chunks/coverage.d.BZtK59WP.js';
 import './@vitest/snapshot/manager.js';
 import 'node:console';
@@ -82,7 +83,17 @@ interface CliOptions extends UserConfig {
 	*/
 	filesOnly?: boolean;
 	/**
-	* Override vite config's configLoader from cli.
+	* Parse files statically instead of running them to collect tests
+	* @experimental
+	*/
+	staticParse?: boolean;
+	/**
+	* How many tests to process at the same time
+	* @experimental
+	*/
+	staticParseConcurrency?: number;
+	/**
+	* Override vite config's configLoader from CLI.
 	* Use `bundle` to bundle the config with esbuild or `runner` (experimental) to process it on the fly (default: `bundle`).
 	* This is only available with **vite version 6.1.0** and above.
 	* @experimental
@@ -106,7 +117,10 @@ declare function parseCLI(argv: string | string[], config?: CliParseOptions): {
 	options: CliOptions;
 };
 
-declare function resolveApiServerConfig<Options extends ApiConfig & Omit<UserConfig, "expect">>(options: Options, defaultPort: number): ApiConfig | undefined;
+/**
+* @deprecated Internal function
+*/
+declare function resolveApiServerConfig<Options extends ApiConfig & Omit<UserConfig, "expect">>(options: Options, defaultPort: number, parentApi?: ApiConfig, logger?: Logger): ApiConfig | undefined;
 
 declare function createVitest(mode: VitestRunMode, options: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
 

package/dist/node.js

@@ -1,37 +1,53 @@
 import * as vite from '@voidzero-dev/vite-plus-core';
 import { resolveConfig as resolveConfig$1, mergeConfig } from '@voidzero-dev/vite-plus-core';
 export { esbuildVersion, isCSSRequest, isFileLoadingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from '@voidzero-dev/vite-plus-core';
-import { V as Vitest, a as VitestPlugin } from './chunks/cli-api.B7PN_QUv.js';
-export { f as ForksPoolWorker, G as GitNotFoundError, F as TestsNotFoundError, T as ThreadsPoolWorker, h as TypecheckPoolWorker, b as VitestPackageInstaller, j as VmForksPoolWorker, k as VmThreadsPoolWorker, p as createDebugger, d as createMethodsRPC, o as createViteLogger, c as createVitest, e as escapeTestName, l as experimental_getRunnerTask, g as getFilePoolName, n as isFileServingAllowed, i as isValidApiRequest, m as registerConsoleShortcuts, r as resolveFsAllow, s as startVitest } from './chunks/cli-api.B7PN_QUv.js';
-export { p as parseCLI } from './chunks/cac.DVeoLl0M.js';
-import { r as resolveConfig$2 } from './chunks/coverage.AVPTjMgw.js';
-export { b as BaseSequencer, a as resolveApiServerConfig } from './chunks/coverage.AVPTjMgw.js';
+import { V as Vitest, a as VitestPlugin } from './chunks/cli-api.DuT9iuvY.js';
+export { F as ForksPoolWorker, G as GitNotFoundError, b as TestsNotFoundError, T as ThreadsPoolWorker, c as TypecheckPoolWorker, d as VitestPackageInstaller, e as VmForksPoolWorker, f as VmThreadsPoolWorker, g as createDebugger, h as createMethodsRPC, i as createViteLogger, j as createVitest, k as escapeTestName, l as experimental_getRunnerTask, m as getFilePoolName, n as isFileServingAllowed, o as isValidApiRequest, r as registerConsoleShortcuts, p as resolveFsAllow, s as startVitest } from './chunks/cli-api.DuT9iuvY.js';
+export { p as parseCLI } from './chunks/cac.CWGDZnXT.js';
+import { r as resolveConfig$2 } from './chunks/coverage.Bri33R1t.js';
+export { B as BaseCoverageProvider, a as BaseSequencer, b as resolveApiServerConfig } from './chunks/coverage.Bri33R1t.js';
 import { slash, deepClone } from './@vitest/utils/helpers.js';
-import { a as any } from './chunks/index.D4KonVSU.js';
+import { a as any } from './chunks/index.og1WyBLx.js';
 import { resolve } from './vendor/pathe.mjs';
-import { c as configFiles } from './chunks/constants.D_Q9UYh-.js';
+import { c as configFiles } from './chunks/constants.CPYnjOGj.js';
+export { A as AgentReporter, D as DefaultReporter, a as DotReporter, G as GithubActionsReporter, H as HangingProcessReporter, J as JUnitReporter, b as JsonReporter, R as ReportersMap, T as TapFlatReporter, c as TapReporter, V as VerboseReporter } from './chunks/index.DXMFO5MJ.js';
 export { distDir, rootDir } from './path.js';
 export { generateFileHash } from './@vitest/runner/utils.js';
+export { B as BenchmarkReporter, a as BenchmarkReportsMap, V as VerboseBenchmarkReporter } from './chunks/index.CEzQDJGb.js';
 import 'node:fs';
 import './chunks/coverage.D_JHT54q.js';
 import 'node:path';
+import './chunks/index.BCY_7LL2.js';
+import 'node:module';
+import 'node:process';
+import 'node:fs/promises';
+import 'node:url';
+import 'node:assert';
+import 'node:v8';
+import 'node:util';
 import 'node:os';
 import './@vitest/snapshot/manager.js';
-import 'node:perf_hooks';
-import './chunks/index.Chj8NDwU.js';
-import './chunks/index.M8mOzt4Y.js';
-import 'node:fs/promises';
-import './@vitest/utils/source-map.js';
+import './@vitest/utils/serialize.js';
+import './chunks/nativeModuleRunner.BIakptoF.js';
+import '@voidzero-dev/vite-plus-core/module-runner';
+import './chunks/traces.CCmnQaNT.js';
+import './vendor/obug.mjs';
 import './vendor/tinyrainbow.mjs';
+import '#module-evaluator';
+import 'node:console';
+import './chunks/_commonjsHelpers.D26ty3Ew.js';
 import './chunks/env.D4Lgay0q.js';
 import './vendor/std-env.mjs';
-import 'node:util';
-import 'node:console';
-import 'node:stream';
-import './@vitest/utils/display.js';
-import './vendor/tinyexec.mjs';
-import './@vitest/utils/offset.js';
-import 'node:module';
+import 'node:tty';
+import 'node:crypto';
+import 'node:events';
+import './chunks/index.Chj8NDwU.js';
+import './chunks/modules.BJuCwlRJ.js';
+import 'node:child_process';
+import 'node:worker_threads';
+import './vendor/picomatch.mjs';
+import './vendor/tinyglobby.mjs';
+import 'node:perf_hooks';
 import 'events';
 import 'https';
 import 'http';
@@ -42,34 +58,20 @@ import 'stream';
 import 'url';
 import 'zlib';
 import 'buffer';
-import './chunks/_commonjsHelpers.D26ty3Ew.js';
-import 'node:crypto';
-import './chunks/traces.CCmnQaNT.js';
-import './vendor/obug.mjs';
-import '#module-evaluator';
-import '@voidzero-dev/vite-plus-core/module-runner';
-import './@vitest/utils/highlight.js';
-import 'node:url';
-import 'node:tty';
-import 'node:events';
-import './chunks/modules.BJuCwlRJ.js';
-import 'node:child_process';
-import 'node:worker_threads';
-import './vendor/picomatch.mjs';
-import './vendor/tinyglobby.mjs';
+import './chunks/defaults.CdU2lD-q.js';
 import './vendor/magic-string.mjs';
 import './@vitest/mocker/node.js';
-import './chunks/defaults.BOqNVLsY.js';
 import './@vitest/utils/constants.js';
 import './@vitest/utils/resolver.js';
 import './vendor/es-module-lexer.mjs';
-import './chunks/index.C5r1PdPD.js';
-import 'node:assert';
-import './@vitest/utils/serialize.js';
+import './@vitest/utils/source-map.js';
+import './@vitest/utils/source-map/node.js';
 import 'node:readline';
-import 'node:process';
-import 'node:v8';
 import 'readline';
+import 'node:stream';
+import './@vitest/utils/display.js';
+import './vendor/tinyexec.mjs';
+import './@vitest/utils/offset.js';
 
 // this is only exported as a public function and not used inside vitest
 async function resolveConfig(options = {}, viteOverrides = {}) {