vitest 1.1.2 → 1.2.0

package/dist/worker.js

@@ -1,100 +1,127 @@
-import { performance } from 'node:perf_hooks';
-import { c as createBirpc } from './vendor/index.cAUulNDf.js';
+import { pathToFileURL } from 'node:url';
 import { workerId } from 'tinypool';
-import { g as getWorkerState } from './vendor/global.L7JRz1qU.js';
-import { l as loadEnvironment } from './vendor/loader.L9CYwKn1.js';
-import { s as startViteNode, m as moduleCache, a as mockMap } from './vendor/execute.cedv4NLQ.js';
-import { s as setupInspect } from './vendor/inspector.lFAeuaAt.js';
-import { r as rpcDone, c as createSafeRpc } from './vendor/rpc.Bl-ysZIr.js';
-import 'pathe';
-import 'vite-node/client';
-import './vendor/environments.QJtma9XQ.js';
+import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
+import { resolve, normalize } from 'pathe';
+import { e as environments } from './vendor/environments.sU0TD7wX.js';
+import { i as isChildProcess, s as setProcessTitle } from './vendor/base.dzu0Y6Hj.js';
+import { createRequire } from 'node:module';
+import { c as createRuntimeRpc, a as rpcDone } from './vendor/rpc.w4v8oCkK.js';
 import 'node:console';
-import 'node:url';
-import 'node:vm';
-import 'vite-node/utils';
-import '@vitest/utils/error';
-import './paths.js';
-import 'node:fs';
 import '@vitest/utils';
-import './vendor/base._79unx2z.js';
-import 'node:path';
-import 'node:module';
-import 'vite-node/constants';
+import './vendor/index.cAUulNDf.js';
+import './vendor/global.CkGT_TMy.js';
 
-async function init(ctx) {
-  var _a, _b;
-  const isInitialized = typeof __vitest_worker__ !== "undefined";
-  const isIsolatedThreads = ctx.config.pool === "threads" && (((_b = (_a = ctx.config.poolOptions) == null ? void 0 : _a.threads) == null ? void 0 : _b.isolate) ?? true);
-  if (isInitialized && isIsolatedThreads)
-    throw new Error(`worker for ${ctx.files.join(",")} already initialized by ${getWorkerState().ctx.files.join(",")}. This is probably an internal bug of Vitest.`);
-  const { config, port, workerId: workerId$1, providedContext } = ctx;
-  process.env.VITEST_WORKER_ID = String(workerId$1);
-  process.env.VITEST_POOL_ID = String(workerId);
-  let setCancel = (_reason) => {
-  };
-  const onCancel = new Promise((resolve) => {
-    setCancel = resolve;
-  });
-  const rpc = createSafeRpc(createBirpc(
-    {
-      onCancel: setCancel
-    },
-    {
-      eventNames: ["onUserConsoleLog", "onFinished", "onCollected", "onWorkerExit", "onCancel"],
-      post(v) {
-        port.postMessage(v);
-      },
-      on(fn) {
-        port.addListener("message", fn);
-      }
-    }
-  ));
-  const environment = await loadEnvironment(ctx.environment.name, {
+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) {
+  var _a;
+  const name = ctx.environment.name;
+  if (isBuiltinEnvironment(name))
+    return environments[name];
+  const loader = await createEnvironmentLoader({
     root: ctx.config.root,
     fetchModule: (id) => rpc.fetch(id, "ssr"),
     resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
   });
-  if (ctx.environment.transformMode)
-    environment.transformMode = ctx.environment.transformMode;
-  const state = {
-    ctx,
-    moduleCache,
-    config,
-    mockMap,
-    onCancel,
-    environment,
-    durations: {
-      environment: 0,
-      prepare: performance.now()
-    },
-    rpc,
-    providedContext
-  };
-  Object.defineProperty(globalThis, "__vitest_worker__", {
-    value: state,
-    configurable: true,
-    writable: true,
-    enumerable: false
-  });
-  if (ctx.invalidates) {
-    ctx.invalidates.forEach((fsPath) => {
-      moduleCache.delete(fsPath);
-      moduleCache.delete(`mock:${fsPath}`);
-    });
+  const root = loader.root;
+  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : ((_a = await rpc.resolveId(`vitest-environment-${name}`, void 0, "ssr")) == null ? void 0 : _a.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.`
+    );
   }
-  ctx.files.forEach((i) => moduleCache.delete(i));
-  return state;
+  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 __require = createRequire(import.meta.url);
+let inspector;
+function setupInspect(config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const isEnabled = config.inspect || config.inspectBrk;
+  if (isEnabled) {
+    inspector = __require("node:inspector");
+    const isOpen = inspector.url() !== void 0;
+    if (!isOpen) {
+      inspector.open();
+      if (config.inspectBrk)
+        inspector.waitForDebugger();
+    }
+  }
+  const isIsolatedSingleThread = config.pool === "threads" && ((_b = (_a = config.poolOptions) == null ? void 0 : _a.threads) == null ? void 0 : _b.isolate) === false && ((_d = (_c = config.poolOptions) == null ? void 0 : _c.threads) == null ? void 0 : _d.singleThread);
+  const isIsolatedSingleFork = config.pool === "forks" && ((_f = (_e = config.poolOptions) == null ? void 0 : _e.forks) == null ? void 0 : _f.isolate) === false && ((_h = (_g = config.poolOptions) == null ? void 0 : _g.forks) == null ? void 0 : _h.singleFork);
+  const keepOpen = config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
+  return function cleanup() {
+    if (isEnabled && !keepOpen && inspector)
+      inspector.close();
+  };
 }
+
+if (isChildProcess())
+  setProcessTitle(`vitest ${workerId}`);
 async function run(ctx) {
+  const prepareStart = performance.now();
   const inspectorCleanup = setupInspect(ctx.config);
+  process.env.VITEST_WORKER_ID = String(ctx.workerId);
+  process.env.VITEST_POOL_ID = String(workerId);
+  let state = null;
   try {
-    const state = await init(ctx);
-    const { run: run2, executor } = await startViteNode({ state });
-    await run2(ctx.files, ctx.config, { environment: state.environment, options: ctx.environment.options }, executor);
-    await rpcDone();
+    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;
+    state = {
+      ctx,
+      // here we create a new one, workers can reassign this if they need to keep it non-isolated
+      moduleCache: new ModuleCacheMap(),
+      mockMap: /* @__PURE__ */ new Map(),
+      config: ctx.config,
+      onCancel,
+      environment,
+      durations: {
+        environment: beforeEnvironmentTime,
+        prepare: prepareStart
+      },
+      rpc,
+      providedContext: ctx.providedContext
+    };
+    if (!worker.runTests || typeof worker.runTests !== "function")
+      throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
+    await worker.runTests(state);
   } finally {
+    await rpcDone().catch(() => {
+    });
     inspectorCleanup();
+    if (state) {
+      state.environment = null;
+      state = null;
+    }
   }
 }
 

package/dist/workers/forks.js

@@ -0,0 +1,33 @@
+import v8 from 'node:v8';
+import { c as createForksRpcOptions, u as unwrapForksConfig } from '../vendor/utils.GbToHGHI.js';
+import { r as runBaseTests } from '../vendor/base.8wUUWReP.js';
+import '@vitest/utils';
+import 'vite-node/client';
+import '../vendor/global.CkGT_TMy.js';
+import '../vendor/execute.3_hyGknJ.js';
+import 'node:vm';
+import 'node:url';
+import 'vite-node/utils';
+import 'pathe';
+import '@vitest/utils/error';
+import '../path.js';
+import 'node:fs';
+import '../vendor/base.dzu0Y6Hj.js';
+
+class ForksBaseWorker {
+  getRpcOptions() {
+    return createForksRpcOptions(v8);
+  }
+  async runTests(state) {
+    const exit = process.exit;
+    state.ctx.config = unwrapForksConfig(state.ctx.config);
+    try {
+      await runBaseTests(state);
+    } finally {
+      process.exit = exit;
+    }
+  }
+}
+var forks = new ForksBaseWorker();
+
+export { forks as default };

package/dist/{entry-vm.js → workers/runVmTests.js}

@@ -5,37 +5,39 @@ import timers from 'node:timers';
 import { performance } from 'node:perf_hooks';
 import { startTests } from '@vitest/runner';
 import { setupColors, createColors } from '@vitest/utils';
-import { V as VitestSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './vendor/index.h0j9y5vy.js';
-import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './vendor/coverage.v6aD8iAh.js';
-import { g as getWorkerState } from './vendor/global.L7JRz1qU.js';
-import { i as index } from './vendor/index.IhksUGLR.js';
-import { setupCommonEnv } from './browser.js';
+import { V as VitestSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from '../vendor/index.D-jOsMas.js';
+import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from '../vendor/coverage.E7sG1b3r.js';
+import { g as getWorkerState } from '../vendor/global.CkGT_TMy.js';
+import { V as VitestIndex } from '../vendor/index.3iX2R_Z5.js';
+import { s as setupCommonEnv } from '../vendor/setup-common.j9IXYrbN.js';
 import 'chai';
 import '@vitest/snapshot/environment';
 import 'pathe';
-import './paths.js';
+import '../path.js';
 import 'node:url';
-import './vendor/rpc.Bl-ysZIr.js';
-import './vendor/benchmark.WVm6DARl.js';
+import '../vendor/rpc.w4v8oCkK.js';
+import '../vendor/index.cAUulNDf.js';
+import '../vendor/benchmark.IlKmJkUU.js';
 import '@vitest/runner/utils';
-import './vendor/index.XU72Rmy8.js';
+import '../vendor/index.rJjbcrrp.js';
 import 'std-env';
-import './vendor/run-once.X3E7xx3F.js';
-import './vendor/vi.DTC--YO5.js';
-import './vendor/_commonjsHelpers.jjO7Zipk.js';
+import '../vendor/run-once.Olz_Zkd8.js';
+import '../vendor/vi.smj1Ggd4.js';
+import '../vendor/_commonjsHelpers.jjO7Zipk.js';
 import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './vendor/tasks.IknbGB2n.js';
+import '../vendor/tasks.IknbGB2n.js';
 import '@vitest/utils/source-map';
-import './vendor/date.Ns1pGd_X.js';
+import '../vendor/base.dzu0Y6Hj.js';
+import '../vendor/date.Ns1pGd_X.js';
 import '@vitest/spy';
 
 async function run(files, config, executor) {
   const workerState = getWorkerState();
   await setupCommonEnv(config);
   Object.defineProperty(globalThis, "__vitest_index__", {
-    value: index,
+    value: VitestIndex,
     enumerable: false
   });
   config.snapshotOptions.snapshotEnvironment = new VitestSnapshotEnvironment(workerState.rpc);
@@ -56,10 +58,12 @@ async function run(files, config, executor) {
     setupChaiConfig(config.chaiConfig);
   const runner = await resolveTestRunner(config, executor);
   workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+  const { vi } = VitestIndex;
   for (const file of files) {
     workerState.filepath = file;
     await startTests([file], runner);
-    workerState.filepath = void 0;
+    vi.resetConfig();
+    vi.restoreAllMocks();
   }
   await stopCoverageInsideWorker(config.coverage, executor);
 }

package/dist/workers/threads.js

@@ -0,0 +1,26 @@
+import { r as runBaseTests } from '../vendor/base.8wUUWReP.js';
+import { a as createThreadsRpcOptions } from '../vendor/utils.GbToHGHI.js';
+import 'vite-node/client';
+import '../vendor/global.CkGT_TMy.js';
+import '../vendor/execute.3_hyGknJ.js';
+import 'node:vm';
+import 'node:url';
+import 'vite-node/utils';
+import 'pathe';
+import '@vitest/utils/error';
+import '../path.js';
+import 'node:fs';
+import '@vitest/utils';
+import '../vendor/base.dzu0Y6Hj.js';
+
+class ThreadsBaseWorker {
+  getRpcOptions(ctx) {
+    return createThreadsRpcOptions(ctx);
+  }
+  runTests(state) {
+    return runBaseTests(state);
+  }
+}
+var threads = new ThreadsBaseWorker();
+
+export { threads as default };

package/dist/workers/vmForks.js

@@ -0,0 +1,43 @@
+import v8 from 'node:v8';
+import { c as createForksRpcOptions, u as unwrapForksConfig } from '../vendor/utils.GbToHGHI.js';
+import { r as runVmTests } from '../vendor/vm.vFKXXdo0.js';
+import '@vitest/utils';
+import 'node:vm';
+import 'node:url';
+import 'pathe';
+import '../chunks/runtime-console.hf2msWA9.js';
+import 'node:stream';
+import 'node:console';
+import 'node:path';
+import '../vendor/date.Ns1pGd_X.js';
+import '../vendor/execute.3_hyGknJ.js';
+import 'vite-node/client';
+import 'vite-node/utils';
+import '@vitest/utils/error';
+import '../path.js';
+import 'node:fs';
+import '../vendor/base.dzu0Y6Hj.js';
+import 'node:module';
+import 'vite-node/constants';
+import '../vendor/index.rJjbcrrp.js';
+import 'std-env';
+import '@vitest/runner/utils';
+import '../vendor/global.CkGT_TMy.js';
+
+class ForksVmWorker {
+  getRpcOptions() {
+    return createForksRpcOptions(v8);
+  }
+  async runTests(state) {
+    const exit = process.exit;
+    state.ctx.config = unwrapForksConfig(state.ctx.config);
+    try {
+      await runVmTests(state);
+    } finally {
+      process.exit = exit;
+    }
+  }
+}
+var vmForks = new ForksVmWorker();
+
+export { vmForks as default };

package/dist/workers/vmThreads.js

@@ -0,0 +1,36 @@
+import { a as createThreadsRpcOptions } from '../vendor/utils.GbToHGHI.js';
+import { r as runVmTests } from '../vendor/vm.vFKXXdo0.js';
+import '@vitest/utils';
+import 'node:vm';
+import 'node:url';
+import 'pathe';
+import '../chunks/runtime-console.hf2msWA9.js';
+import 'node:stream';
+import 'node:console';
+import 'node:path';
+import '../vendor/date.Ns1pGd_X.js';
+import '../vendor/execute.3_hyGknJ.js';
+import 'vite-node/client';
+import 'vite-node/utils';
+import '@vitest/utils/error';
+import '../path.js';
+import 'node:fs';
+import '../vendor/base.dzu0Y6Hj.js';
+import 'node:module';
+import 'vite-node/constants';
+import '../vendor/index.rJjbcrrp.js';
+import 'std-env';
+import '@vitest/runner/utils';
+import '../vendor/global.CkGT_TMy.js';
+
+class ThreadsVmWorker {
+  getRpcOptions(ctx) {
+    return createThreadsRpcOptions(ctx);
+  }
+  runTests(state) {
+    return runVmTests(state);
+  }
+}
+var vmThreads = new ThreadsVmWorker();
+
+export { vmThreads as default };

package/dist/workers.d.ts

@@ -0,0 +1,36 @@
+import * as v8 from 'v8';
+import { p as BirpcOptions, h as RuntimeRPC, q as ContextRPC, r as WorkerGlobalState, t as WorkerContext, R as ResolvedConfig } from './reporters-trlZlObr.js';
+import { Awaitable } from '@vitest/utils';
+import 'vite';
+import '@vitest/runner';
+import 'vite-node';
+import '@vitest/snapshot';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import 'tinybench';
+import 'vite-node/client';
+import '@vitest/snapshot/manager';
+import 'vite-node/server';
+import 'node:worker_threads';
+import 'node:fs';
+import 'chai';
+
+type WorkerRpcOptions = Pick<BirpcOptions<RuntimeRPC>, 'on' | 'post' | 'serialize' | 'deserialize'>;
+interface VitestWorker {
+    getRpcOptions(ctx: ContextRPC): WorkerRpcOptions;
+    runTests(state: WorkerGlobalState): Awaitable<unknown>;
+}
+
+declare function createThreadsRpcOptions({ port }: WorkerContext): WorkerRpcOptions;
+declare function createForksRpcOptions(nodeV8: typeof v8): WorkerRpcOptions;
+declare function unwrapForksConfig(config: ResolvedConfig): ResolvedConfig;
+
+declare function provideWorkerState(context: any, state: WorkerGlobalState): WorkerGlobalState;
+
+declare function run(ctx: ContextRPC): Promise<void>;
+
+declare function runVmTests(state: WorkerGlobalState): Promise<void>;
+
+declare function runBaseTests(state: WorkerGlobalState): Promise<void>;
+
+export { type VitestWorker, type WorkerRpcOptions, createForksRpcOptions, createThreadsRpcOptions, provideWorkerState, runBaseTests, run as runVitestWorker, runVmTests, unwrapForksConfig };

package/dist/workers.js

@@ -0,0 +1,30 @@
+export { c as createForksRpcOptions, a as createThreadsRpcOptions, u as unwrapForksConfig } from './vendor/utils.GbToHGHI.js';
+export { p as provideWorkerState } from './vendor/global.CkGT_TMy.js';
+export { run as runVitestWorker } from './worker.js';
+export { r as runVmTests } from './vendor/vm.vFKXXdo0.js';
+export { r as runBaseTests } from './vendor/base.8wUUWReP.js';
+import '@vitest/utils';
+import 'node:url';
+import 'tinypool';
+import 'vite-node/client';
+import 'pathe';
+import './vendor/environments.sU0TD7wX.js';
+import 'node:console';
+import './vendor/base.dzu0Y6Hj.js';
+import 'node:module';
+import './vendor/rpc.w4v8oCkK.js';
+import './vendor/index.cAUulNDf.js';
+import 'node:vm';
+import './chunks/runtime-console.hf2msWA9.js';
+import 'node:stream';
+import 'node:path';
+import './vendor/date.Ns1pGd_X.js';
+import './vendor/execute.3_hyGknJ.js';
+import 'vite-node/utils';
+import '@vitest/utils/error';
+import './path.js';
+import 'node:fs';
+import 'vite-node/constants';
+import './vendor/index.rJjbcrrp.js';
+import 'std-env';
+import '@vitest/runner/utils';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Next generation testing framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -52,6 +52,10 @@
       "types": "./dist/execute.d.ts",
       "default": "./dist/execute.js"
     },
+    "./workers": {
+      "types": "./dist/workers.d.ts",
+      "import": "./dist/workers.js"
+    },
     "./browser": {
       "types": "./dist/browser.d.ts",
       "default": "./dist/browser.js"
@@ -147,12 +151,12 @@
     "tinypool": "^0.8.1",
     "vite": "^5.0.0",
     "why-is-node-running": "^2.2.2",
-    "@vitest/expect": "1.1.2",
-    "@vitest/runner": "1.1.2",
-    "@vitest/spy": "1.1.2",
-    "@vitest/utils": "1.1.2",
-    "@vitest/snapshot": "1.1.2",
-    "vite-node": "1.1.2"
+    "@vitest/expect": "1.2.0",
+    "@vitest/runner": "1.2.0",
+    "@vitest/spy": "1.2.0",
+    "@vitest/snapshot": "1.2.0",
+    "@vitest/utils": "1.2.0",
+    "vite-node": "1.2.0"
   },
   "devDependencies": {
     "@ampproject/remapping": "^2.2.1",

package/workers.d.ts

@@ -0,0 +1 @@
+export * from './dist/workers.js'

package/dist/child.js

@@ -1,125 +0,0 @@
-import { performance } from 'node:perf_hooks';
-import v8 from 'node:v8';
-import { c as createBirpc } from './vendor/index.cAUulNDf.js';
-import { parseRegexp } from '@vitest/utils';
-import { workerId } from 'tinypool';
-import { l as loadEnvironment } from './vendor/loader.L9CYwKn1.js';
-import { s as startViteNode, m as moduleCache, a as mockMap } from './vendor/execute.cedv4NLQ.js';
-import { r as rpcDone, c as createSafeRpc } from './vendor/rpc.Bl-ysZIr.js';
-import { s as setupInspect } from './vendor/inspector.lFAeuaAt.js';
-import 'pathe';
-import 'vite-node/client';
-import './vendor/environments.QJtma9XQ.js';
-import 'node:console';
-import 'node:url';
-import 'node:vm';
-import 'vite-node/utils';
-import '@vitest/utils/error';
-import './paths.js';
-import 'node:fs';
-import './vendor/base._79unx2z.js';
-import 'node:path';
-import 'node:module';
-import 'vite-node/constants';
-import './vendor/global.L7JRz1qU.js';
-
-try {
-  process.title = `node (vitest ${workerId})`;
-} catch {
-}
-async function init(ctx) {
-  const { config, workerId: workerId$1, providedContext } = ctx;
-  process.env.VITEST_WORKER_ID = String(workerId$1);
-  process.env.VITEST_POOL_ID = String(workerId);
-  let setCancel = (_reason) => {
-  };
-  const onCancel = new Promise((resolve) => {
-    setCancel = resolve;
-  });
-  const rpc = createSafeRpc(createBirpc(
-    {
-      onCancel: setCancel
-    },
-    {
-      eventNames: ["onUserConsoleLog", "onFinished", "onCollected", "onWorkerExit", "onCancel"],
-      serialize: v8.serialize,
-      deserialize: (v) => v8.deserialize(Buffer.from(v)),
-      post(v) {
-        var _a;
-        (_a = process.send) == null ? void 0 : _a.call(process, v);
-      },
-      on(fn) {
-        process.on("message", (message, ...extras) => {
-          if (message == null ? void 0 : message.__tinypool_worker_message__)
-            return;
-          return fn(message, ...extras);
-        });
-      }
-    }
-  ));
-  const environment = await loadEnvironment(ctx.environment.name, {
-    root: ctx.config.root,
-    fetchModule: (id) => rpc.fetch(id, "ssr"),
-    resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
-  });
-  if (ctx.environment.transformMode)
-    environment.transformMode = ctx.environment.transformMode;
-  const state = {
-    ctx,
-    moduleCache,
-    config,
-    mockMap,
-    onCancel,
-    environment,
-    durations: {
-      environment: 0,
-      prepare: performance.now()
-    },
-    rpc,
-    providedContext,
-    isChildProcess: true
-  };
-  Object.defineProperty(globalThis, "__vitest_worker__", {
-    value: state,
-    configurable: true,
-    writable: true,
-    enumerable: false
-  });
-  if (ctx.invalidates) {
-    ctx.invalidates.forEach((fsPath) => {
-      moduleCache.delete(fsPath);
-      moduleCache.delete(`mock:${fsPath}`);
-    });
-  }
-  ctx.files.forEach((i) => moduleCache.delete(i));
-  return state;
-}
-function parsePossibleRegexp(str) {
-  const prefix = "$$vitest:";
-  if (typeof str === "string" && str.startsWith(prefix))
-    return parseRegexp(str.slice(prefix.length));
-  return str;
-}
-function unwrapConfig(config) {
-  if (config.testNamePattern)
-    config.testNamePattern = parsePossibleRegexp(config.testNamePattern);
-  return config;
-}
-async function run(ctx) {
-  const exit = process.exit;
-  ctx.config = unwrapConfig(ctx.config);
-  const inspectorCleanup = setupInspect(ctx.config);
-  try {
-    const state = await init(ctx);
-    const { run: run2, executor } = await startViteNode({
-      state
-    });
-    await run2(ctx.files, ctx.config, { environment: state.environment, options: ctx.environment.options }, executor);
-    await rpcDone();
-  } finally {
-    inspectorCleanup();
-    process.exit = exit;
-  }
-}
-
-export { run };