vitest 3.1.0-beta.1 → 3.1.0

package/dist/worker.js

@@ -4,139 +4,123 @@ 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.K90BXFOx.js';
-import { s as setupInspect } from './chunks/inspector.DKLceBVD.js';
-import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.TVf73xOu.js';
-import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.C8RiOc4B.js';
-import { d as disposeInternalListeners } from './chunks/utils.Cn0zI1t3.js';
+import { e as environments } from './chunks/index.DFXFpH3w.js';
+import { s as setupInspect } from './chunks/inspector.DbDkSkFn.js';
+import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.DGgL5dw7.js';
+import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.CtocqOoE.js';
+import { d as disposeInternalListeners } from './chunks/utils.BfxieIyZ.js';
 import 'node:console';
 import 'node:module';
 import '@vitest/utils';
 import './chunks/index.68735LiX.js';
 
 function isBuiltinEnvironment(env) {
-  return env in environments;
+	return env in environments;
 }
-const _loaders = /* @__PURE__ */ new Map();
+const _loaders = 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);
+	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 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}`, undefined, "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;
 }
 
 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) {
-    process.on("SIGTERM", () => {
-      process.exit();
-    });
-  }
+	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) {
+		process.on("SIGTERM", () => {
+			process.exit();
+		});
+	}
 }
 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 {
-    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}".`
-      );
-    }
-    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,
-      // here we create a new one, workers can reassign this if they need to keep it non-isolated
-      moduleCache: new ModuleCacheMap(),
-      moduleExecutionInfo: /* @__PURE__ */ new Map(),
-      config: ctx.config,
-      onCancel,
-      environment,
-      durations: {
-        environment: beforeEnvironmentTime,
-        prepare: prepareStart
-      },
-      rpc,
-      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();
-  }
+	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 {
+		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}".`);
+		}
+		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: new Map(),
+			config: ctx.config,
+			onCancel,
+			environment,
+			durations: {
+				environment: beforeEnvironmentTime,
+				prepare: prepareStart
+			},
+			rpc,
+			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);
+	return execute("run", ctx);
 }
 function collect(ctx) {
-  return execute("collect", ctx);
+	return execute("collect", ctx);
 }
 
 export { collect, run };

package/dist/workers/forks.js

@@ -1,8 +1,8 @@
 import v8 from 'node:v8';
-import { r as runBaseTests } from '../chunks/base.DV59CbtV.js';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
+import { r as runBaseTests } from '../chunks/base.bV8rwssx.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.BfxieIyZ.js';
 import 'vite-node/client';
-import '../chunks/execute.eDH0aFFd.js';
+import '../chunks/execute.CwmnH2oH.js';
 import 'node:fs';
 import 'node:url';
 import 'node:vm';
@@ -14,27 +14,27 @@ import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
 import '@vitest/utils';
-import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/utils.CtocqOoE.js';
 
 class ForksBaseWorker {
-  getRpcOptions() {
-    return createForksRpcOptions(v8);
-  }
-  async executeTests(method, state) {
-    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);
-  }
+	getRpcOptions() {
+		return createForksRpcOptions(v8);
+	}
+	async executeTests(method, state) {
+		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();
 

package/dist/workers/runVmTests.js

@@ -6,92 +6,87 @@ import util from 'node:util';
 import { startTests, collectTests } from '@vitest/runner';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
 import { installSourcemapsSupport } from 'vite-node/source-map';
-import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.uXkkC4xl.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/setup-common.CPvtqi8q.js';
-import { V as VitestIndex } from '../chunks/index.D7Ny8f_s.js';
-import { c as closeInspector } from '../chunks/inspector.DKLceBVD.js';
-import { g as getWorkerState } from '../chunks/utils.C8RiOc4B.js';
+import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.VfYQ6MXY.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/setup-common.DEGDGBiA.js';
+import { V as VitestIndex } from '../chunks/index.BDobFbcz.js';
+import { c as closeInspector } from '../chunks/inspector.DbDkSkFn.js';
+import { g as getWorkerState } from '../chunks/utils.CtocqOoE.js';
 import 'chai';
 import 'node:path';
 import '../path.js';
 import 'node:url';
-import '../chunks/rpc.TVf73xOu.js';
+import '../chunks/rpc.DGgL5dw7.js';
 import '@vitest/utils';
 import '../chunks/index.68735LiX.js';
-import '../chunks/coverage.A3sS5-Wm.js';
+import '../chunks/coverage.0iPg4Wrz.js';
 import '@vitest/snapshot';
-import '../chunks/run-once.2ogXb3JV.js';
-import '../chunks/vi.nSCvwQ7l.js';
+import '../chunks/run-once.I7PpBOk1.js';
+import '../chunks/vi.B-PuvDzu.js';
 import '@vitest/expect';
 import '@vitest/runner/utils';
 import '../chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
-import '../chunks/date.W2xKR2qe.js';
-import '../chunks/benchmark.DL72EVN-.js';
+import '../chunks/date.CDOsz-HY.js';
+import '../chunks/benchmark.BKUatJGy.js';
 import 'expect-type';
 
 async function run(method, files, config, executor) {
-  const workerState = getWorkerState();
-  await setupCommonEnv(config);
-  Object.defineProperty(globalThis, "__vitest_index__", {
-    value: VitestIndex,
-    enumerable: false
-  });
-  if (workerState.environment.transformMode === "web") {
-    const _require = createRequire(import.meta.url);
-    _require.extensions[".css"] = resolveCss;
-    _require.extensions[".scss"] = resolveCss;
-    _require.extensions[".sass"] = resolveCss;
-    _require.extensions[".less"] = resolveCss;
-    KNOWN_ASSET_TYPES.forEach((type) => {
-      _require.extensions[`.${type}`] = resolveAsset;
-    });
-    process.env.SSR = "";
-  } else {
-    process.env.SSR = "1";
-  }
-  globalThis.__vitest_required__ = {
-    util,
-    timers,
-    timersPromises
-  };
-  installSourcemapsSupport({
-    getSourceMap: (source) => workerState.moduleCache.getSourceMap(source)
-  });
-  await startCoverageInsideWorker(config.coverage, executor, { isolate: false });
-  if (config.chaiConfig) {
-    setupChaiConfig(config.chaiConfig);
-  }
-  const [runner, snapshotEnvironment] = await Promise.all([
-    resolveTestRunner(config, executor),
-    resolveSnapshotEnvironment(config, executor)
-  ]);
-  config.snapshotOptions.snapshotEnvironment = snapshotEnvironment;
-  workerState.onCancel.then((reason) => {
-    closeInspector(config);
-    runner.onCancel?.(reason);
-  });
-  workerState.durations.prepare = performance.now() - workerState.durations.prepare;
-  const { vi } = VitestIndex;
-  for (const file of files) {
-    workerState.filepath = file.filepath;
-    if (method === "run") {
-      await startTests([file], runner);
-    } else {
-      await collectTests([file], runner);
-    }
-    vi.resetConfig();
-    vi.restoreAllMocks();
-  }
-  await stopCoverageInsideWorker(config.coverage, executor, { isolate: false });
+	const workerState = getWorkerState();
+	await setupCommonEnv(config);
+	Object.defineProperty(globalThis, "__vitest_index__", {
+		value: VitestIndex,
+		enumerable: false
+	});
+	if (workerState.environment.transformMode === "web") {
+		const _require = createRequire(import.meta.url);
+		_require.extensions[".css"] = resolveCss;
+		_require.extensions[".scss"] = resolveCss;
+		_require.extensions[".sass"] = resolveCss;
+		_require.extensions[".less"] = resolveCss;
+		KNOWN_ASSET_TYPES.forEach((type) => {
+			_require.extensions[`.${type}`] = resolveAsset;
+		});
+		process.env.SSR = "";
+	} else {
+		process.env.SSR = "1";
+	}
+	globalThis.__vitest_required__ = {
+		util,
+		timers,
+		timersPromises
+	};
+	installSourcemapsSupport({ getSourceMap: (source) => workerState.moduleCache.getSourceMap(source) });
+	await startCoverageInsideWorker(config.coverage, executor, { isolate: false });
+	if (config.chaiConfig) {
+		setupChaiConfig(config.chaiConfig);
+	}
+	const [runner, snapshotEnvironment] = await Promise.all([resolveTestRunner(config, executor), resolveSnapshotEnvironment(config, executor)]);
+	config.snapshotOptions.snapshotEnvironment = snapshotEnvironment;
+	workerState.onCancel.then((reason) => {
+		closeInspector(config);
+		runner.onCancel?.(reason);
+	});
+	workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+	const { vi } = VitestIndex;
+	for (const file of files) {
+		workerState.filepath = file.filepath;
+		if (method === "run") {
+			await startTests([file], runner);
+		} else {
+			await collectTests([file], runner);
+		}
+		vi.resetConfig();
+		vi.restoreAllMocks();
+	}
+	await stopCoverageInsideWorker(config.coverage, executor, { isolate: false });
 }
 function resolveCss(mod) {
-  mod.exports = "";
+	mod.exports = "";
 }
 function resolveAsset(mod, url) {
-  mod.exports = url;
+	mod.exports = url;
 }
 
 export { run };

package/dist/workers/threads.js

@@ -1,7 +1,7 @@
-import { r as runBaseTests } from '../chunks/base.DV59CbtV.js';
-import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
+import { r as runBaseTests } from '../chunks/base.bV8rwssx.js';
+import { a as createThreadsRpcOptions } from '../chunks/utils.BfxieIyZ.js';
 import 'vite-node/client';
-import '../chunks/execute.eDH0aFFd.js';
+import '../chunks/execute.CwmnH2oH.js';
 import 'node:fs';
 import 'node:url';
 import 'node:vm';
@@ -13,18 +13,18 @@ import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
 import '@vitest/utils';
-import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/utils.CtocqOoE.js';
 
 class ThreadsBaseWorker {
-  getRpcOptions(ctx) {
-    return createThreadsRpcOptions(ctx);
-  }
-  runTests(state) {
-    return runBaseTests("run", state);
-  }
-  collectTests(state) {
-    return runBaseTests("collect", state);
-  }
+	getRpcOptions(ctx) {
+		return createThreadsRpcOptions(ctx);
+	}
+	runTests(state) {
+		return runBaseTests("run", state);
+	}
+	collectTests(state) {
+		return runBaseTests("collect", state);
+	}
 }
 const worker = new ThreadsBaseWorker();
 

package/dist/workers/vmForks.js

@@ -1,19 +1,19 @@
 import v8 from 'node:v8';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
-import { r as runVmTests } from '../chunks/vm.jEFQDlX_.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.BfxieIyZ.js';
+import { r as runVmTests } from '../chunks/vm.Lp7mPCVW.js';
 import '@vitest/utils';
 import 'node:url';
 import 'node:vm';
 import 'pathe';
 import '../path.js';
 import 'node:path';
-import '../chunks/console.CN7AiMGV.js';
+import '../chunks/console.D6t261w0.js';
 import 'node:console';
 import 'node:stream';
 import 'tinyrainbow';
-import '../chunks/date.W2xKR2qe.js';
-import '../chunks/utils.C8RiOc4B.js';
-import '../chunks/execute.eDH0aFFd.js';
+import '../chunks/date.CDOsz-HY.js';
+import '../chunks/utils.CtocqOoE.js';
+import '../chunks/execute.CwmnH2oH.js';
 import 'node:fs';
 import '@vitest/utils/error';
 import 'vite-node/client';
@@ -23,24 +23,24 @@ 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);
-  }
+	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();
 

package/dist/workers/vmThreads.js

@@ -1,18 +1,18 @@
-import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
-import { r as runVmTests } from '../chunks/vm.jEFQDlX_.js';
+import { a as createThreadsRpcOptions } from '../chunks/utils.BfxieIyZ.js';
+import { r as runVmTests } from '../chunks/vm.Lp7mPCVW.js';
 import '@vitest/utils';
 import 'node:url';
 import 'node:vm';
 import 'pathe';
 import '../path.js';
 import 'node:path';
-import '../chunks/console.CN7AiMGV.js';
+import '../chunks/console.D6t261w0.js';
 import 'node:console';
 import 'node:stream';
 import 'tinyrainbow';
-import '../chunks/date.W2xKR2qe.js';
-import '../chunks/utils.C8RiOc4B.js';
-import '../chunks/execute.eDH0aFFd.js';
+import '../chunks/date.CDOsz-HY.js';
+import '../chunks/utils.CtocqOoE.js';
+import '../chunks/execute.CwmnH2oH.js';
 import 'node:fs';
 import '@vitest/utils/error';
 import 'vite-node/client';
@@ -22,15 +22,15 @@ 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);
-  }
+	getRpcOptions(ctx) {
+		return createThreadsRpcOptions(ctx);
+	}
+	runTests(state) {
+		return runVmTests("run", state);
+	}
+	collectTests(state) {
+		return runVmTests("collect", state);
+	}
 }
 const worker = new ThreadsVmWorker();
 

package/dist/workers.d.ts

@@ -35,4 +35,5 @@ declare function unwrapSerializableConfig(config: SerializedConfig): SerializedC
 
 declare function runVmTests(method: "run" | "collect", state: WorkerGlobalState): Promise<void>;
 
-export { type VitestWorker, type WorkerRpcOptions, collect as collectVitestWorkerTests, createForksRpcOptions, createThreadsRpcOptions, provideWorkerState, runBaseTests, run as runVitestWorker, runVmTests, unwrapSerializableConfig };
+export { collect as collectVitestWorkerTests, createForksRpcOptions, createThreadsRpcOptions, provideWorkerState, runBaseTests, run as runVitestWorker, runVmTests, unwrapSerializableConfig };
+export type { VitestWorker, WorkerRpcOptions };