@venos-inc/venos 0.1.5 → 0.1.6

package/etc/mcp-server/node_modules/vitest/dist/worker.js

@@ -4,138 +4,121 @@ 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.70d6emsh.js';
-import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.C3q9uwRX.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.CmSc2RE5.js';
+import { s as setupInspect } from './chunks/inspector.C914Efll.js';
+import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.-pEldfrD.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.68735LiX.js';
+import './chunks/index.B521nVV-.js';
 
 function isBuiltinEnvironment(env) {
-  return env in environments;
+	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);
+	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}`, 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) {
-    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)
+ // 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 {
-    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(),
-      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 {
+		// 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);
+	return execute("run", ctx);
 }
 function collect(ctx) {
-  return execute("collect", ctx);
+	return execute("collect", ctx);
+}
+async function teardown() {
+	return cleanup();
 }
 
-export { collect, run };
+export { collect, run, teardown };

package/etc/mcp-server/node_modules/vitest/dist/workers/forks.js

@@ -1,8 +1,8 @@
 import v8 from 'node:v8';
-import { r as runBaseTests } from '../chunks/base.BZZh4cSm.js';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
+import { r as runBaseTests } from '../chunks/base.DfmxU-tU.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.CAioKnHs.js';
 import 'vite-node/client';
-import '../chunks/execute.2pr0rHgK.js';
+import '../chunks/execute.B7h3T_Hc.js';
 import 'node:fs';
 import 'node:url';
 import 'node:vm';
@@ -14,28 +14,30 @@ import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
 import '@vitest/utils';
-import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/utils.XdZDrNZV.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) {
+		// 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);
+	}
 }
-var forks = new ForksBaseWorker();
+const worker = new ForksBaseWorker();
 
-export { forks as default };
+export { worker as default };

package/etc/mcp-server/node_modules/vitest/dist/workers/runVmTests.js

@@ -1,95 +1,90 @@
 import { createRequire } from 'node:module';
 import { performance } from 'node:perf_hooks';
 import timers from 'node:timers';
+import timersPromises from 'node:timers/promises';
 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.nEwtF0bu.js';
-import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/coverage.BoMDb1ip.js';
-import { V as VitestIndex } from '../chunks/index.ckWaX2gY.js';
-import { c as closeInspector } from '../chunks/inspector.70d6emsh.js';
-import { s as setupCommonEnv } from '../chunks/setup-common.Dj6BZI3u.js';
-import { g as getWorkerState } from '../chunks/utils.C8RiOc4B.js';
+import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.CwejwG0H.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/setup-common.Dd054P77.js';
+import { V as VitestIndex } from '../chunks/index.CdQS2e2Q.js';
+import { c as closeInspector } from '../chunks/inspector.C914Efll.js';
+import { g as getWorkerState } from '../chunks/utils.XdZDrNZV.js';
 import 'chai';
 import 'node:path';
 import '../path.js';
 import 'node:url';
-import '../chunks/rpc.C3q9uwRX.js';
+import '../chunks/rpc.-pEldfrD.js';
 import '@vitest/utils';
-import '../chunks/index.68735LiX.js';
-import '../chunks/vi.DgezovHB.js';
+import '../chunks/index.B521nVV-.js';
+import '../chunks/coverage.DVF1vEu8.js';
+import '@vitest/snapshot';
+import '../chunks/vi.bdSIJ99Y.js';
 import '@vitest/expect';
 import '@vitest/runner/utils';
 import '../chunks/_commonjsHelpers.BFTU3MAI.js';
-import '@vitest/snapshot';
 import '@vitest/utils/error';
-import '@vitest/utils/source-map';
-import '../chunks/date.W2xKR2qe.js';
 import '@vitest/spy';
-import '../chunks/run-once.2ogXb3JV.js';
-import '../chunks/benchmark.Cdu9hjj4.js';
+import '@vitest/utils/source-map';
+import '../chunks/date.Bq6ZW5rf.js';
+import '../chunks/benchmark.CYdenmiT.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
-  };
-  installSourcemapsSupport({
-    getSourceMap: (source) => workerState.moduleCache.getSourceMap(source)
-  });
-  await startCoverageInsideWorker(config.coverage, executor);
-  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;
-    if (method === "run") {
-      await startTests([file], runner);
-    } else {
-      await collectTests([file], runner);
-    }
-    vi.resetConfig();
-    vi.restoreAllMocks();
-  }
-  await stopCoverageInsideWorker(config.coverage, 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);
+		// always mock "required" `css` files, because we cannot process them
+		_require.extensions[".css"] = resolveCss;
+		_require.extensions[".scss"] = resolveCss;
+		_require.extensions[".sass"] = resolveCss;
+		_require.extensions[".less"] = resolveCss;
+		// since we are using Vite, we can assume how these will be resolved
+		KNOWN_ASSET_TYPES.forEach((type) => {
+			_require.extensions[`.${type}`] = resolveAsset;
+		});
+		process.env.SSR = "";
+	} else process.env.SSR = "1";
+	// @ts-expect-error not typed global for patched timers
+	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;
+	runner.getWorkerContext = void 0;
+	workerState.onCancel.then((reason) => {
+		closeInspector(config);
+		runner.cancel?.(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);
+		// reset after tests, because user might call `vi.setConfig` in setupFile
+		vi.resetConfig();
+		// mocks should not affect different files
+		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/etc/mcp-server/node_modules/vitest/dist/workers/threads.js

@@ -1,7 +1,7 @@
-import { r as runBaseTests } from '../chunks/base.BZZh4cSm.js';
-import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
+import { r as runBaseTests } from '../chunks/base.DfmxU-tU.js';
+import { a as createThreadsRpcOptions } from '../chunks/utils.CAioKnHs.js';
 import 'vite-node/client';
-import '../chunks/execute.2pr0rHgK.js';
+import '../chunks/execute.B7h3T_Hc.js';
 import 'node:fs';
 import 'node:url';
 import 'node:vm';
@@ -13,19 +13,19 @@ import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
 import '@vitest/utils';
-import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/utils.XdZDrNZV.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);
+	}
 }
-var threads = new ThreadsBaseWorker();
+const worker = new ThreadsBaseWorker();
 
-export { threads as default };
+export { worker as default };

package/etc/mcp-server/node_modules/vitest/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.Zr4qWzDJ.js';
+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.BYGVloWk.js';
+import '../chunks/console.CtFJOzRO.js';
 import 'node:console';
 import 'node:stream';
 import 'tinyrainbow';
-import '../chunks/date.W2xKR2qe.js';
-import '../chunks/utils.C8RiOc4B.js';
-import '../chunks/execute.2pr0rHgK.js';
+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';
@@ -23,25 +23,25 @@ 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);
+	}
 }
-var vmForks = new ForksVmWorker();
+const worker = new ForksVmWorker();
 
-export { vmForks as default };
+export { worker as default };

package/etc/mcp-server/node_modules/vitest/dist/workers/vmThreads.js

@@ -1,18 +1,18 @@
-import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
-import { r as runVmTests } from '../chunks/vm.Zr4qWzDJ.js';
+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.BYGVloWk.js';
+import '../chunks/console.CtFJOzRO.js';
 import 'node:console';
 import 'node:stream';
 import 'tinyrainbow';
-import '../chunks/date.W2xKR2qe.js';
-import '../chunks/utils.C8RiOc4B.js';
-import '../chunks/execute.2pr0rHgK.js';
+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';
@@ -22,16 +22,16 @@ 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);
+	}
 }
-var vmThreads = new ThreadsVmWorker();
+const worker = new ThreadsVmWorker();
 
-export { vmThreads as default };
+export { worker as default };