vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/utils.CAioKnHs.js

@@ -1,61 +0,0 @@
-import { parseRegexp } from '@vitest/utils';
-
-const REGEXP_WRAP_PREFIX = "$$vitest:";
-// Store global APIs in case process is overwritten by tests
-const processSend = process.send?.bind(process);
-const processOn = process.on?.bind(process);
-const processOff = process.off?.bind(process);
-const dispose = [];
-function createThreadsRpcOptions({ port }) {
-	return {
-		post: (v) => {
-			port.postMessage(v);
-		},
-		on: (fn) => {
-			port.addListener("message", fn);
-		}
-	};
-}
-function disposeInternalListeners() {
-	for (const fn of dispose) try {
-		fn();
-	} catch {}
-	dispose.length = 0;
-}
-function createForksRpcOptions(nodeV8) {
-	return {
-		serialize: nodeV8.serialize,
-		deserialize: (v) => nodeV8.deserialize(Buffer.from(v)),
-		post(v) {
-			processSend(v);
-		},
-		on(fn) {
-			const handler = (message, ...extras) => {
-				// Do not react on Tinypool's internal messaging
-				if (message?.__tinypool_worker_message__) return;
-				return fn(message, ...extras);
-			};
-			processOn("message", handler);
-			dispose.push(() => processOff("message", handler));
-		}
-	};
-}
-/**
-* Reverts the wrapping done by `utils/config-helpers.ts`'s `wrapSerializableConfig`
-*/
-function unwrapSerializableConfig(config) {
-	if (config.testNamePattern && typeof config.testNamePattern === "string") {
-		const testNamePattern = config.testNamePattern;
-		if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) config.testNamePattern = parseRegexp(testNamePattern.slice(REGEXP_WRAP_PREFIX.length));
-	}
-	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
-		const { keys, original } = config.defines;
-		const defines = {};
-		// Apply all keys from the original. Entries which had undefined value are missing from original now
-		for (const key of keys) defines[key] = original[key];
-		config.defines = defines;
-	}
-	return config;
-}
-
-export { createThreadsRpcOptions as a, createForksRpcOptions as c, disposeInternalListeners as d, unwrapSerializableConfig as u };

package/dist/chunks/worker.d.CmvJfRGs.d.ts

@@ -1,8 +0,0 @@
-import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.d.DoNjFAiv.js';
-
-interface WorkerContext extends ContextRPC {
-	port: MessagePort;
-}
-
-export type { WorkerContext as W };

package/dist/chunks/worker.d.DoNjFAiv.d.ts

@@ -1,169 +0,0 @@
-import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
-import { a as SerializedConfig } from './config.d.HJdfX-8k.js';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.CUq4cUgQ.js';
-import { SnapshotResult } from '@vitest/snapshot';
-
-type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
-type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
-type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
-type BirpcResolver = (name: string, resolved: (...args: unknown[]) => unknown) => ((...args: unknown[]) => unknown) | undefined;
-interface ChannelOptions {
-    /**
-     * Function to post raw message
-     */
-    post: (data: any, ...extras: any[]) => any | Promise<any>;
-    /**
-     * Listener to receive raw message
-     */
-    on: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
-    /**
-     * Clear the listener when `$close` is called
-     */
-    off?: (fn: (data: any, ...extras: any[]) => void) => any | Promise<any>;
-    /**
-     * Custom function to serialize data
-     *
-     * by default it passes the data as-is
-     */
-    serialize?: (data: any) => any;
-    /**
-     * Custom function to deserialize data
-     *
-     * by default it passes the data as-is
-     */
-    deserialize?: (data: any) => any;
-    /**
-     * Call the methods with the RPC context or the original functions object
-     */
-    bind?: 'rpc' | 'functions';
-}
-interface EventOptions<Remote> {
-    /**
-     * Names of remote functions that do not need response.
-     */
-    eventNames?: (keyof Remote)[];
-    /**
-     * Maximum timeout for waiting for response, in milliseconds.
-     *
-     * @default 60_000
-     */
-    timeout?: number;
-    /**
-     * Custom resolver to resolve function to be called
-     *
-     * For advanced use cases only
-     */
-    resolver?: BirpcResolver;
-    /**
-     * Custom error handler
-     *
-     * @deprecated use `onFunctionError` and `onGeneralError` instead
-     */
-    onError?: (error: Error, functionName: string, args: any[]) => boolean | void;
-    /**
-     * Custom error handler for errors occurred in local functions being called
-     *
-     * @returns `true` to prevent the error from being thrown
-     */
-    onFunctionError?: (error: Error, functionName: string, args: any[]) => boolean | void;
-    /**
-     * Custom error handler for errors occurred during serialization or messsaging
-     *
-     * @returns `true` to prevent the error from being thrown
-     */
-    onGeneralError?: (error: Error, functionName?: string, args?: any[]) => boolean | void;
-    /**
-     * Custom error handler for timeouts
-     *
-     * @returns `true` to prevent the error from being thrown
-     */
-    onTimeoutError?: (functionName: string, args: any[]) => boolean | void;
-}
-type BirpcOptions<Remote> = EventOptions<Remote> & ChannelOptions;
-type BirpcFn<T> = PromisifyFn<T> & {
-    /**
-     * Send event without asking for response
-     */
-    asEvent: (...args: ArgumentsType<T>) => void;
-};
-type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
-    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
-} & {
-    $functions: LocalFunctions;
-    $close: (error?: Error) => void;
-    $closed: boolean;
-};
-
-interface RuntimeRPC {
-	fetch: (id: string, transformMode: TransformMode) => Promise<{
-		externalize?: string
-		id?: string
-	}>;
-	transform: (id: string, transformMode: TransformMode) => Promise<{
-		code?: string
-	}>;
-	resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
-		external?: boolean | "absolute" | "relative"
-		id: string
-		/** @deprecated */
-		meta?: Record<string, any> | null
-		/** @deprecated */
-		moduleSideEffects?: boolean | "no-treeshake" | null
-		/** @deprecated */
-		syntheticNamedExports?: boolean | string | null
-	} | null>;
-	onUserConsoleLog: (log: UserConsoleLog) => void;
-	onUnhandledError: (err: unknown, type: string) => void;
-	onQueued: (file: File) => void;
-	onCollected: (files: File[]) => Promise<void>;
-	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-	onTaskAnnotate: (testId: string, annotation: TestAnnotation) => Promise<TestAnnotation>;
-	onTaskUpdate: (pack: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
-	onCancel: (reason: CancelReason) => void;
-	getCountOfFailedTests: () => number;
-	snapshotSaved: (snapshot: SnapshotResult) => void;
-	resolveSnapshotPath: (testPath: string) => string;
-}
-interface RunnerRPC {
-	onCancel: (reason: CancelReason) => void;
-}
-
-type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
-interface ContextTestEnvironment {
-	name: string;
-	transformMode?: TransformMode;
-	options: Record<string, any> | null;
-}
-type TestExecutionMethod = "run" | "collect";
-interface ContextRPC {
-	pool: string;
-	worker: string;
-	workerId: number;
-	config: SerializedConfig;
-	projectName: string;
-	files: string[] | FileSpecification[];
-	environment: ContextTestEnvironment;
-	providedContext: Record<string, any>;
-	invalidates?: string[];
-}
-interface WorkerGlobalState {
-	ctx: ContextRPC;
-	config: SerializedConfig;
-	rpc: WorkerRPC;
-	current?: Task;
-	filepath?: string;
-	environment: Environment;
-	environmentTeardownRun?: boolean;
-	onCancel: Promise<CancelReason>;
-	moduleCache: Map<string, any>;
-	moduleExecutionInfo: Map<string, any>;
-	onCleanup: (listener: () => unknown) => void;
-	providedContext: Record<string, any>;
-	durations: {
-		environment: number
-		prepare: number
-	};
-	onFilterStackTrace?: (trace: string) => string;
-}
-
-export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ContextTestEnvironment as c };

package/dist/execute.d.ts

@@ -1,148 +0,0 @@
-import { ViteNodeRunnerOptions } from 'vite-node';
-import { ViteNodeRunner, ModuleExecutionInfo } from 'vite-node/client';
-import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.d.DoNjFAiv.js';
-import vm from 'node:vm';
-import { MockedModule, MockedModuleType } from '@vitest/mocker';
-import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './chunks/mocker.d.BE_2ls6u.js';
-import '@vitest/runner';
-import './chunks/config.d.HJdfX-8k.js';
-import '@vitest/pretty-format';
-import '@vitest/snapshot';
-import '@vitest/utils/diff';
-import './chunks/environment.d.CUq4cUgQ.js';
-
-declare class FileMap {
-	private fsCache;
-	private fsBufferCache;
-	readFileAsync(path: string): Promise<string>;
-	readFile(path: string): string;
-	readBuffer(path: string): Buffer;
-}
-
-// need to copy paste types for vm
-// because they require latest @types/node which we don't bundle
-interface ModuleEvaluateOptions {
-	timeout?: vm.RunningScriptOptions["timeout"] | undefined;
-	breakOnSigint?: vm.RunningScriptOptions["breakOnSigint"] | undefined;
-}
-type ModuleLinker = (specifier: string, referencingModule: VMModule, extra: {
-	assert: object
-}) => VMModule | Promise<VMModule>;
-type ModuleStatus = "unlinked" | "linking" | "linked" | "evaluating" | "evaluated" | "errored";
-declare class VMModule {
-	dependencySpecifiers: readonly string[];
-	error: any;
-	identifier: string;
-	context: vm.Context;
-	namespace: object;
-	status: ModuleStatus;
-	evaluate(options?: ModuleEvaluateOptions): Promise<void>;
-	link(linker: ModuleLinker): Promise<void>;
-}
-
-interface ExternalModulesExecutorOptions {
-	context: vm.Context;
-	fileMap: FileMap;
-	packageCache: Map<string, any>;
-	transform: RuntimeRPC["transform"];
-	interopDefault?: boolean;
-	viteClientModule: Record<string, unknown>;
-}
-// TODO: improve Node.js strict mode support in #2854
-declare class ExternalModulesExecutor {
-	#private;
-	private options;
-	private cjs;
-	private esm;
-	private vite;
-	private context;
-	private fs;
-	private resolvers;
-	constructor(options: ExternalModulesExecutorOptions);
-	import(identifier: string): Promise<object>;
-	require(identifier: string): any;
-	createRequire(identifier: string): NodeJS.Require;
-	// dynamic import can be used in both ESM and CJS, so we have it in the executor
-	importModuleDynamically: (specifier: string, referencer: VMModule) => Promise<VMModule>;
-	resolveModule: (specifier: string, referencer: string) => Promise<VMModule>;
-	resolve(specifier: string, parent: string): string;
-	private findNearestPackageData;
-	private getModuleInformation;
-	private createModule;
-	private get isNetworkSupported();
-}
-
-interface MockContext {
-	/**
-	* When mocking with a factory, this refers to the module that imported the mock.
-	*/
-	callstack: null | string[];
-}
-declare class VitestMocker {
-	executor: VitestExecutor;
-	static pendingIds: PendingSuiteMock[];
-	private spyModule?;
-	private primitives;
-	private filterPublicKeys;
-	private registries;
-	private mockContext;
-	constructor(executor: VitestExecutor);
-	private get root();
-	private get moduleCache();
-	private get moduleDirectories();
-	initializeSpyModule(): Promise<void>;
-	private getMockerRegistry;
-	reset(): void;
-	private deleteCachedItem;
-	private isModuleDirectory;
-	getSuiteFilepath(): string;
-	private createError;
-	private resolvePath;
-	resolveMocks(): Promise<void>;
-	private callFunctionMock;
-	// public method to avoid circular dependency
-	getMockContext(): MockContext;
-	// path used to store mocked dependencies
-	getMockPath(dep: string): string;
-	getDependencyMock(id: string): MockedModule | undefined;
-	normalizePath(path: string): string;
-	resolveMockPath(mockPath: string, external: string | null): string | null;
-	mockObject(object: Record<string | symbol, any>, mockExports?: Record<string | symbol, any>, behavior?: MockedModuleType): Record<string | symbol, any>;
-	unmockPath(path: string): void;
-	mockPath(originalId: string, path: string, external: string | null, mockType: MockedModuleType | undefined, factory: MockFactory | undefined): void;
-	importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
-	importMock(rawId: string, importee: string): Promise<any>;
-	requestWithMock(url: string, callstack: string[]): Promise<any>;
-	queueMock(id: string, importer: string, factoryOrOptions?: MockFactory | MockOptions): void;
-	queueUnmock(id: string, importer: string): void;
-}
-
-interface ExecuteOptions extends ViteNodeRunnerOptions {
-	moduleDirectories?: string[];
-	state: WorkerGlobalState;
-	context?: vm.Context;
-	externalModulesExecutor?: ExternalModulesExecutor;
-}
-declare class VitestExecutor extends ViteNodeRunner {
-	options: ExecuteOptions;
-	mocker: VitestMocker;
-	externalModules?: ExternalModulesExecutor;
-	private primitives;
-	constructor(options: ExecuteOptions);
-	protected getContextPrimitives(): {
-		Object: typeof Object
-		Reflect: typeof Reflect
-		Symbol: typeof Symbol
-	};
-	get state(): WorkerGlobalState;
-	get moduleExecutionInfo(): ModuleExecutionInfo | undefined;
-	shouldResolveId(id: string, _importee?: string | undefined): boolean;
-	originalResolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
-	resolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
-	protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
-	importExternalModule(path: string): Promise<any>;
-	dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
-	prepareContext(context: Record<string, any>): Record<string, any>;
-}
-
-export { VitestExecutor };

package/dist/execute.js

@@ -1,13 +0,0 @@
-export { V as VitestExecutor } from './chunks/execute.B7h3T_Hc.js';
-import 'node:fs';
-import 'node:url';
-import 'node:vm';
-import '@vitest/utils/error';
-import 'pathe';
-import 'vite-node/client';
-import 'vite-node/utils';
-import './path.js';
-import 'node:path';
-import '@vitest/mocker';
-import 'node:module';
-import '@vitest/utils';

package/dist/worker.js

@@ -1,124 +0,0 @@
-import { pathToFileURL } from 'node:url';
-import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
-import { workerId } from 'tinypool';
-import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
-import { readFileSync } from 'node:fs';
-import { resolve, normalize } from 'pathe';
-import { e as environments } from './chunks/index.CmSc2RE5.js';
-import { s as setupInspect } from './chunks/inspector.C914Efll.js';
-import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.CsFtxqeq.js';
-import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.XdZDrNZV.js';
-import { d as disposeInternalListeners } from './chunks/utils.CAioKnHs.js';
-import 'node:console';
-import 'node:module';
-import '@vitest/utils';
-import './chunks/index.B521nVV-.js';
-
-function isBuiltinEnvironment(env) {
-	return env in environments;
-}
-const _loaders = /* @__PURE__ */ new Map();
-async function createEnvironmentLoader(options) {
-	if (!_loaders.has(options.root)) {
-		const loader = new ViteNodeRunner(options);
-		await loader.executeId("/@vite/env");
-		_loaders.set(options.root, loader);
-	}
-	return _loaders.get(options.root);
-}
-async function loadEnvironment(ctx, rpc) {
-	const name = ctx.environment.name;
-	if (isBuiltinEnvironment(name)) return environments[name];
-	const loader = await createEnvironmentLoader({
-		root: ctx.config.root,
-		fetchModule: async (id) => {
-			const result = await rpc.fetch(id, "ssr");
-			if (result.id) return { code: readFileSync(result.id, "utf-8") };
-			return result;
-		},
-		resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
-	});
-	const root = loader.root;
-	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await rpc.resolveId(`vitest-environment-${name}`, void 0, "ssr"))?.id ?? resolve(root, name);
-	const pkg = await loader.executeId(normalize(packageId));
-	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
-	const environment = pkg.default;
-	if (environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web".`);
-	return environment;
-}
-
-const listeners = /* @__PURE__ */ new Set();
-function addCleanupListener(listener) {
-	listeners.add(listener);
-}
-async function cleanup() {
-	const promises = [...listeners].map((l) => l());
-	await Promise.all(promises);
-}
-
-if (isChildProcess()) {
-	setProcessTitle(`vitest ${workerId}`);
-	const isProfiling = process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
-	if (isProfiling)
- // Work-around for nodejs/node#55094
-	process.on("SIGTERM", () => {
-		process.exit();
-	});
-}
-// this is what every pool executes when running tests
-async function execute(method, ctx) {
-	disposeInternalListeners();
-	const prepareStart = performance.now();
-	const inspectorCleanup = setupInspect(ctx);
-	process.env.VITEST_WORKER_ID = String(ctx.workerId);
-	process.env.VITEST_POOL_ID = String(workerId);
-	try {
-		// worker is a filepath or URL to a file that exposes a default export with "getRpcOptions" and "runTests" methods
-		if (ctx.worker[0] === ".") throw new Error(`Path to the test runner cannot be relative, received "${ctx.worker}"`);
-		const file = ctx.worker.startsWith("file:") ? ctx.worker : pathToFileURL(ctx.worker).toString();
-		const testRunnerModule = await import(file);
-		if (!testRunnerModule.default || typeof testRunnerModule.default !== "object") throw new TypeError(`Test worker object should be exposed as a default export. Received "${typeof testRunnerModule.default}"`);
-		const worker = testRunnerModule.default;
-		if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") throw new TypeError(`Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`);
-		// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
-		const { rpc, onCancel } = createRuntimeRpc(worker.getRpcOptions(ctx));
-		const beforeEnvironmentTime = performance.now();
-		const environment = await loadEnvironment(ctx, rpc);
-		if (ctx.environment.transformMode) environment.transformMode = ctx.environment.transformMode;
-		const state = {
-			ctx,
-			moduleCache: new ModuleCacheMap(),
-			moduleExecutionInfo: /* @__PURE__ */ new Map(),
-			config: ctx.config,
-			onCancel,
-			environment,
-			durations: {
-				environment: beforeEnvironmentTime,
-				prepare: prepareStart
-			},
-			rpc,
-			onCleanup: (listener) => addCleanupListener(listener),
-			providedContext: ctx.providedContext,
-			onFilterStackTrace(stack) {
-				return createStackString(parseStacktrace(stack));
-			}
-		};
-		const methodName = method === "collect" ? "collectTests" : "runTests";
-		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
-		await worker[methodName](state);
-	} finally {
-		await rpcDone().catch(() => {});
-		inspectorCleanup();
-	}
-}
-function run(ctx) {
-	return execute("run", ctx);
-}
-function collect(ctx) {
-	return execute("collect", ctx);
-}
-async function teardown() {
-	return cleanup();
-}
-
-export { collect, run, teardown };

package/dist/workers/forks.js

@@ -1,43 +0,0 @@
-import v8 from 'node:v8';
-import { r as runBaseTests } from '../chunks/base.Bj3pWTr1.js';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.CAioKnHs.js';
-import 'vite-node/client';
-import '../chunks/execute.B7h3T_Hc.js';
-import 'node:fs';
-import 'node:url';
-import 'node:vm';
-import '@vitest/utils/error';
-import 'pathe';
-import 'vite-node/utils';
-import '../path.js';
-import 'node:path';
-import '@vitest/mocker';
-import 'node:module';
-import '@vitest/utils';
-import '../chunks/utils.XdZDrNZV.js';
-
-class ForksBaseWorker {
-	getRpcOptions() {
-		return createForksRpcOptions(v8);
-	}
-	async executeTests(method, state) {
-		// TODO: don't rely on reassigning process.exit
-		// https://github.com/vitest-dev/vitest/pull/4441#discussion_r1443771486
-		const exit = process.exit;
-		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
-		try {
-			await runBaseTests(method, state);
-		} finally {
-			process.exit = exit;
-		}
-	}
-	runTests(state) {
-		return this.executeTests("run", state);
-	}
-	collectTests(state) {
-		return this.executeTests("collect", state);
-	}
-}
-const worker = new ForksBaseWorker();
-
-export { worker as default };

package/dist/workers/threads.js

@@ -1,31 +0,0 @@
-import { r as runBaseTests } from '../chunks/base.Bj3pWTr1.js';
-import { a as createThreadsRpcOptions } from '../chunks/utils.CAioKnHs.js';
-import 'vite-node/client';
-import '../chunks/execute.B7h3T_Hc.js';
-import 'node:fs';
-import 'node:url';
-import 'node:vm';
-import '@vitest/utils/error';
-import 'pathe';
-import 'vite-node/utils';
-import '../path.js';
-import 'node:path';
-import '@vitest/mocker';
-import 'node:module';
-import '@vitest/utils';
-import '../chunks/utils.XdZDrNZV.js';
-
-class ThreadsBaseWorker {
-	getRpcOptions(ctx) {
-		return createThreadsRpcOptions(ctx);
-	}
-	runTests(state) {
-		return runBaseTests("run", state);
-	}
-	collectTests(state) {
-		return runBaseTests("collect", state);
-	}
-}
-const worker = new ThreadsBaseWorker();
-
-export { worker as default };

package/dist/workers/vmForks.js

@@ -1,47 +0,0 @@
-import v8 from 'node:v8';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.CAioKnHs.js';
-import { r as runVmTests } from '../chunks/vm.BThCzidc.js';
-import '@vitest/utils';
-import 'node:url';
-import 'node:vm';
-import 'pathe';
-import '../path.js';
-import 'node:path';
-import '../chunks/console.CtFJOzRO.js';
-import 'node:console';
-import 'node:stream';
-import 'tinyrainbow';
-import '../chunks/date.Bq6ZW5rf.js';
-import '../chunks/utils.XdZDrNZV.js';
-import '../chunks/execute.B7h3T_Hc.js';
-import 'node:fs';
-import '@vitest/utils/error';
-import 'vite-node/client';
-import 'vite-node/utils';
-import '@vitest/mocker';
-import 'node:module';
-import 'vite-node/constants';
-
-class ForksVmWorker {
-	getRpcOptions() {
-		return createForksRpcOptions(v8);
-	}
-	async executeTests(method, state) {
-		const exit = process.exit;
-		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
-		try {
-			await runVmTests(method, state);
-		} finally {
-			process.exit = exit;
-		}
-	}
-	runTests(state) {
-		return this.executeTests("run", state);
-	}
-	collectTests(state) {
-		return this.executeTests("collect", state);
-	}
-}
-const worker = new ForksVmWorker();
-
-export { worker as default };

package/dist/workers/vmThreads.js

@@ -1,37 +0,0 @@
-import { a as createThreadsRpcOptions } from '../chunks/utils.CAioKnHs.js';
-import { r as runVmTests } from '../chunks/vm.BThCzidc.js';
-import '@vitest/utils';
-import 'node:url';
-import 'node:vm';
-import 'pathe';
-import '../path.js';
-import 'node:path';
-import '../chunks/console.CtFJOzRO.js';
-import 'node:console';
-import 'node:stream';
-import 'tinyrainbow';
-import '../chunks/date.Bq6ZW5rf.js';
-import '../chunks/utils.XdZDrNZV.js';
-import '../chunks/execute.B7h3T_Hc.js';
-import 'node:fs';
-import '@vitest/utils/error';
-import 'vite-node/client';
-import 'vite-node/utils';
-import '@vitest/mocker';
-import 'node:module';
-import 'vite-node/constants';
-
-class ThreadsVmWorker {
-	getRpcOptions(ctx) {
-		return createThreadsRpcOptions(ctx);
-	}
-	runTests(state) {
-		return runVmTests("run", state);
-	}
-	collectTests(state) {
-		return runVmTests("collect", state);
-	}
-}
-const worker = new ThreadsVmWorker();
-
-export { worker as default };