vitest 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/vendor/{vm.Bi3bljci.js → vm.CycSoHnJ.js}

@@ -1,8 +1,8 @@
 import vm, { isContext } from 'node:vm';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
-import { createCustomConsole } from '../chunks/runtime-console.CUES-L8X.js';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.CLLNVNnK.js';
+import { createCustomConsole } from '../chunks/runtime-console.Ckl0vEQr.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.T3gg2ZK6.js';
 import { distDir } from '../path.js';
 import { dirname as dirname$1 } from 'node:path';
 import { statSync, existsSync, promises, readFileSync } from 'node:fs';
@@ -28,7 +28,10 @@ class CommonjsExecutor {
   constructor(options) {
     this.context = options.context;
     this.fs = options.fileMap;
-    const primitives = vm.runInContext("({ Object, Array, Error })", this.context);
+    const primitives = vm.runInContext(
+      "({ Object, Array, Error })",
+      this.context
+    );
     const executor = this;
     this.Module = class Module$1 {
       exports;
@@ -50,14 +53,17 @@ class CommonjsExecutor {
       }
       get require() {
         const require = requiresCache.get(this);
-        if (require)
+        if (require) {
           return require;
+        }
         const _require2 = Module$1.createRequire(this.id);
         requiresCache.set(this, _require2);
         return _require2;
       }
       static register = () => {
-        throw new Error(`[vitest] "register" is not available when running in Vitest.`);
+        throw new Error(
+          `[vitest] "register" is not available when running in Vitest.`
+        );
       };
       _compile(code, filename) {
         const cjsModule = Module$1.wrap(code);
@@ -131,8 +137,9 @@ class CommonjsExecutor {
     const require = (id) => {
       const resolved = _require2.resolve(id);
       const ext = extname(resolved);
-      if (ext === ".node" || isNodeBuiltin(resolved))
+      if (ext === ".node" || isNodeBuiltin(resolved)) {
         return this.requireCoreModule(resolved);
+      }
       const module = new this.Module(resolved);
       return this.loadCommonJSModule(module, resolved);
     };
@@ -166,8 +173,9 @@ class CommonjsExecutor {
   // very naive implementation for Node.js require
   loadCommonJSModule(module, filename) {
     const cached = this.requireCache.get(filename);
-    if (cached)
+    if (cached) {
       return cached.exports;
+    }
     const extension = this.findLongestRegisteredExtension(filename);
     const loader = this.extensions[extension] || this.extensions[".js"];
     loader(module, filename);
@@ -180,25 +188,29 @@ class CommonjsExecutor {
     let startIndex = 0;
     while ((index = name.indexOf(".", startIndex)) !== -1) {
       startIndex = index + 1;
-      if (index === 0)
+      if (index === 0) {
         continue;
+      }
       currentExtension = name.slice(index);
-      if (this.extensions[currentExtension])
+      if (this.extensions[currentExtension]) {
         return currentExtension;
+      }
     }
     return ".js";
   }
   require(identifier) {
     const ext = extname(identifier);
-    if (ext === ".node" || isNodeBuiltin(identifier))
+    if (ext === ".node" || isNodeBuiltin(identifier)) {
       return this.requireCoreModule(identifier);
+    }
     const module = new this.Module(identifier);
     return this.loadCommonJSModule(module, identifier);
   }
   requireCoreModule(identifier) {
     const normalized = identifier.replace(/^node:/, "");
-    if (this.builtinCache[normalized])
+    if (this.builtinCache[normalized]) {
       return this.builtinCache[normalized].exports;
+    }
     const moduleExports = _require(identifier);
     if (identifier === "node:module" || identifier === "module") {
       const module = new this.Module("/module.js");
@@ -268,18 +280,22 @@ class EsmExecutor {
     if (m.status === "unlinked") {
       this.esmLinkMap.set(
         m,
-        m.link((identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier))
+        m.link(
+          (identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier)
+        )
       );
     }
     await this.esmLinkMap.get(m);
-    if (m.status === "linked")
+    if (m.status === "linked") {
       await m.evaluate();
+    }
     return m;
   }
   async createEsModule(fileURL, getCode) {
     const cached = this.moduleCache.get(fileURL);
-    if (cached)
+    if (cached) {
       return cached;
+    }
     const promise = this.loadEsModule(fileURL, getCode);
     this.moduleCache.set(fileURL, promise);
     return promise;
@@ -287,42 +303,40 @@ class EsmExecutor {
   async loadEsModule(fileURL, getCode) {
     const code = await getCode();
     if (fileURL.endsWith(".json")) {
-      const m2 = new SyntheticModule$1(
-        ["default"],
-        () => {
-          const result = JSON.parse(code);
-          m2.setExport("default", result);
-        }
-      );
+      const m2 = new SyntheticModule$1(["default"], () => {
+        const result = JSON.parse(code);
+        m2.setExport("default", result);
+      });
       this.moduleCache.set(fileURL, m2);
       return m2;
     }
-    const m = new SourceTextModule(
-      code,
-      {
-        identifier: fileURL,
-        context: this.context,
-        importModuleDynamically: this.executor.importModuleDynamically,
-        initializeImportMeta: (meta, mod) => {
-          meta.url = mod.identifier;
-          if (mod.identifier.startsWith("file:")) {
-            const filename = fileURLToPath(mod.identifier);
-            meta.filename = filename;
-            meta.dirname = dirname$1(filename);
-          }
-          meta.resolve = (specifier, importer) => {
-            return this.executor.resolve(specifier, importer != null ? importer.toString() : mod.identifier);
-          };
+    const m = new SourceTextModule(code, {
+      identifier: fileURL,
+      context: this.context,
+      importModuleDynamically: this.executor.importModuleDynamically,
+      initializeImportMeta: (meta, mod) => {
+        meta.url = mod.identifier;
+        if (mod.identifier.startsWith("file:")) {
+          const filename = fileURLToPath(mod.identifier);
+          meta.filename = filename;
+          meta.dirname = dirname$1(filename);
         }
+        meta.resolve = (specifier, importer) => {
+          return this.executor.resolve(
+            specifier,
+            importer != null ? importer.toString() : mod.identifier
+          );
+        };
       }
-    );
+    });
     this.moduleCache.set(fileURL, m);
     return m;
   }
   async createWebAssemblyModule(fileUrl, getCode) {
     const cached = this.moduleCache.get(fileUrl);
-    if (cached)
+    if (cached) {
       return cached;
+    }
     const m = this.loadWebAssemblyModule(getCode(), fileUrl);
     this.moduleCache.set(fileUrl, m);
     return m;
@@ -341,8 +355,9 @@ class EsmExecutor {
   }
   async loadWebAssemblyModule(source, identifier) {
     const cached = this.moduleCache.get(identifier);
-    if (cached)
+    if (cached) {
       return cached;
+    }
     const wasmModule = await WebAssembly.compile(source);
     const exports = WebAssembly.Module.exports(wasmModule);
     const imports = WebAssembly.Module.imports(wasmModule);
@@ -360,8 +375,9 @@ class EsmExecutor {
       async () => {
         const importsObject = {};
         for (const { module, name } of imports) {
-          if (!importsObject[module])
+          if (!importsObject[module]) {
             importsObject[module] = {};
+          }
           await this.evaluateModule(moduleLookup[module]);
           importsObject[module][name] = moduleLookup[module].namespace[name];
         }
@@ -369,8 +385,9 @@ class EsmExecutor {
           wasmModule,
           importsObject
         );
-        for (const { name } of exports)
+        for (const { name } of exports) {
           syntheticModule.setExport(name, wasmInstance.exports[name]);
+        }
       },
       { context: this.context, identifier }
     );
@@ -384,18 +401,22 @@ class EsmExecutor {
   }
   async createDataModule(identifier) {
     const cached = this.moduleCache.get(identifier);
-    if (cached)
+    if (cached) {
       return cached;
+    }
     const match = identifier.match(dataURIRegex);
-    if (!match || !match.groups)
+    if (!match || !match.groups) {
       throw new Error("Invalid data URI");
+    }
     const mime = match.groups.mime;
     const encoding = match.groups.encoding;
     if (mime === "application/wasm") {
-      if (!encoding)
+      if (!encoding) {
         throw new Error("Missing data URI encoding");
-      if (encoding !== "base64")
+      }
+      if (encoding !== "base64") {
         throw new Error(`Invalid data URI encoding: ${encoding}`);
+      }
       const module = this.loadWebAssemblyModule(
         Buffer.from(match.groups.code, "base64"),
         identifier
@@ -404,12 +425,13 @@ class EsmExecutor {
       return module;
     }
     let code = match.groups.code;
-    if (!encoding || encoding === "charset=utf-8")
+    if (!encoding || encoding === "charset=utf-8") {
       code = decodeURIComponent(code);
-    else if (encoding === "base64")
+    } else if (encoding === "base64") {
       code = Buffer.from(code, "base64").toString();
-    else
+    } else {
       throw new Error(`Invalid data URI encoding: ${encoding}`);
+    }
     if (mime === "application/json") {
       const module = new SyntheticModule$1(
         ["default"],
@@ -428,8 +450,9 @@ class EsmExecutor {
 _httpIp = new WeakMap();
 function IPnumber(address) {
   const ip = address.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
-  if (ip)
+  if (ip) {
     return (+ip[1] << 24) + (+ip[2] << 16) + (+ip[3] << 8) + +ip[4];
+  }
   throw new Error(`Expected IP address, received ${address}`);
 }
 function IPmask(maskSize) {
@@ -446,8 +469,9 @@ class ViteExecutor {
   esm;
   resolve = (identifier, parent) => {
     if (identifier === CLIENT_ID) {
-      if (this.workerState.environment.transformMode === "web")
+      if (this.workerState.environment.transformMode === "web") {
         return identifier;
+      }
       const packageName = this.getPackageName(parent);
       throw new Error(
         `[vitest] Vitest cannot handle ${CLIENT_ID} imported in ${parent} when running in SSR environment. Add "${packageName}" to "ssr.noExternal" if you are using Vite SSR, or to "server.deps.inline" if you are using Vite Node.`
@@ -460,30 +484,37 @@ class ViteExecutor {
   getPackageName(modulePath) {
     const path = normalize(modulePath);
     let name = path.split("/node_modules/").pop() || "";
-    if (name == null ? void 0 : name.startsWith("@"))
+    if (name == null ? void 0 : name.startsWith("@")) {
       name = name.split("/").slice(0, 2).join("/");
-    else
+    } else {
       name = name.split("/")[0];
+    }
     return name;
   }
   async createViteModule(fileUrl) {
-    if (fileUrl === CLIENT_FILE)
+    if (fileUrl === CLIENT_FILE) {
       return this.createViteClientModule();
+    }
     const cached = this.esm.resolveCachedModule(fileUrl);
-    if (cached)
+    if (cached) {
       return cached;
+    }
     return this.esm.createEsModule(fileUrl, async () => {
       const result = await this.options.transform(fileUrl, "web");
-      if (!result.code)
-        throw new Error(`[vitest] Failed to transform ${fileUrl}. Does the file exist?`);
+      if (!result.code) {
+        throw new Error(
+          `[vitest] Failed to transform ${fileUrl}. Does the file exist?`
+        );
+      }
       return result.code;
     });
   }
   createViteClientModule() {
     const identifier = CLIENT_ID;
     const cached = this.esm.resolveCachedModule(identifier);
-    if (cached)
+    if (cached) {
       return cached;
+    }
     const stub = this.options.viteClientModule;
     const moduleKeys = Object.keys(stub);
     const module = new SyntheticModule$1(
@@ -501,18 +532,25 @@ class ViteExecutor {
   canResolve = (fileUrl) => {
     var _a;
     const transformMode = this.workerState.environment.transformMode;
-    if (transformMode !== "web")
+    if (transformMode !== "web") {
       return false;
-    if (fileUrl === CLIENT_FILE)
+    }
+    if (fileUrl === CLIENT_FILE) {
       return true;
+    }
     const config = ((_a = this.workerState.config.deps) == null ? void 0 : _a.web) || {};
     const [modulePath] = fileUrl.split("?");
-    if (config.transformCss && CSS_LANGS_RE.test(modulePath))
+    if (config.transformCss && CSS_LANGS_RE.test(modulePath)) {
       return true;
-    if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath))
+    }
+    if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath)) {
       return true;
-    if (toArray(config.transformGlobPattern).some((pattern) => pattern.test(modulePath)))
+    }
+    if (toArray(config.transformGlobPattern).some(
+      (pattern) => pattern.test(modulePath)
+    )) {
       return true;
+    }
     return false;
   };
 }
@@ -547,8 +585,9 @@ class ExternalModulesExecutor {
     });
     __publicField(this, "resolveModule", async (specifier, referencer) => {
       let identifier = this.resolve(specifier, referencer);
-      if (identifier instanceof Promise)
+      if (identifier instanceof Promise) {
         identifier = await identifier;
+      }
       return await this.createModule(identifier);
     });
     this.context = options.context;
@@ -583,8 +622,9 @@ class ExternalModulesExecutor {
   resolve(specifier, parent) {
     for (const resolver of this.resolvers) {
       const id = resolver(specifier, parent);
-      if (id)
+      if (id) {
         return id;
+      }
     }
     return nativeResolve(specifier, parent);
   }
@@ -594,21 +634,24 @@ class ExternalModulesExecutor {
     const packageCache = this.options.packageCache;
     while (basedir) {
       const cached = getCachedData(packageCache, basedir, originalBasedir);
-      if (cached)
+      if (cached) {
         return cached;
+      }
       const pkgPath = join(basedir, "package.json");
       try {
         if ((_a = statSync(pkgPath, { throwIfNoEntry: false })) == null ? void 0 : _a.isFile()) {
           const pkgData = JSON.parse(this.fs.readFile(pkgPath));
-          if (packageCache)
+          if (packageCache) {
             setCacheData(packageCache, pkgData, basedir, originalBasedir);
+          }
           return pkgData;
         }
       } catch {
       }
       const nextBasedir = dirname$1(basedir);
-      if (nextBasedir === basedir)
+      if (nextBasedir === basedir) {
         break;
+      }
       basedir = nextBasedir;
     }
     return {};
@@ -618,8 +661,9 @@ class ExternalModulesExecutor {
     const m = new SyntheticModule(
       [...moduleKeys, "default"],
       () => {
-        for (const key of moduleKeys)
+        for (const key of moduleKeys) {
           m.setExport(key, exports[key]);
+        }
         m.setExport("default", exports);
       },
       {
@@ -630,12 +674,16 @@ class ExternalModulesExecutor {
     return m;
   }
   wrapCommonJsSynteticModule(identifier, exports) {
-    const { keys, moduleExports, defaultExport } = interopCommonJsModule(this.options.interopDefault, exports);
+    const { keys, moduleExports, defaultExport } = interopCommonJsModule(
+      this.options.interopDefault,
+      exports
+    );
     const m = new SyntheticModule(
       [...keys, "default"],
       () => {
-        for (const key of keys)
+        for (const key of keys) {
           m.setExport(key, moduleExports[key]);
+        }
         m.setExport("default", defaultExport);
       },
       {
@@ -646,13 +694,16 @@ class ExternalModulesExecutor {
     return m;
   }
   getModuleInformation(identifier) {
-    if (identifier.startsWith("data:"))
+    if (identifier.startsWith("data:")) {
       return { type: "data", url: identifier, path: identifier };
+    }
     const extension = extname(identifier);
-    if (extension === ".node" || isNodeBuiltin(identifier))
+    if (extension === ".node" || isNodeBuiltin(identifier)) {
       return { type: "builtin", url: identifier, path: identifier };
-    if (this.isNetworkSupported && (identifier.startsWith("http:") || identifier.startsWith("https:")))
+    }
+    if (this.isNetworkSupported && (identifier.startsWith("http:") || identifier.startsWith("https:"))) {
       return { type: "network", url: identifier, path: identifier };
+    }
     const isFileUrl = identifier.startsWith("file://");
     const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
     const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
@@ -706,12 +757,13 @@ class ExternalModulesExecutor {
   get isNetworkSupported() {
     var _a;
     if (__privateGet(this, _networkSupported) == null) {
-      if (process.execArgv.includes("--experimental-network-imports"))
+      if (process.execArgv.includes("--experimental-network-imports")) {
         __privateSet(this, _networkSupported, true);
-      else if ((_a = process.env.NODE_OPTIONS) == null ? void 0 : _a.includes("--experimental-network-imports"))
+      } else if ((_a = process.env.NODE_OPTIONS) == null ? void 0 : _a.includes("--experimental-network-imports")) {
         __privateSet(this, _networkSupported, true);
-      else
+      } else {
         __privateSet(this, _networkSupported, false);
+      }
     }
     return __privateGet(this, _networkSupported);
   }
@@ -723,24 +775,27 @@ class FileMap {
   fsBufferCache = /* @__PURE__ */ new Map();
   async readFileAsync(path) {
     const cached = this.fsCache.get(path);
-    if (cached != null)
+    if (cached != null) {
       return cached;
+    }
     const source = await promises.readFile(path, "utf-8");
     this.fsCache.set(path, source);
     return source;
   }
   readFile(path) {
     const cached = this.fsCache.get(path);
-    if (cached != null)
+    if (cached != null) {
       return cached;
+    }
     const source = readFileSync(path, "utf-8");
     this.fsCache.set(path, source);
     return source;
   }
   readBuffer(path) {
     const cached = this.fsBufferCache.get(path);
-    if (cached != null)
+    if (cached != null) {
       return cached;
+    }
     const buffer = readFileSync(path);
     this.fsBufferCache.set(path, buffer);
     return buffer;
@@ -760,14 +815,22 @@ async function runVmTests(state) {
       `Environment "${ctx.environment.name}" is not a valid environment. Path "${packageId}" doesn't support vm environment because it doesn't provide "setupVM" method.`
     );
   }
-  const vm = await environment.setupVM(ctx.environment.options || ctx.config.environmentOptions || {});
+  const vm = await environment.setupVM(
+    ctx.environment.options || ctx.config.environmentOptions || {}
+  );
   state.durations.environment = performance.now() - state.durations.environment;
   process.env.VITEST_VM_POOL = "1";
-  if (!vm.getVmContext)
-    throw new TypeError(`Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`);
+  if (!vm.getVmContext) {
+    throw new TypeError(
+      `Environment ${environment.name} doesn't provide "getVmContext" method. It should return a context created by "vm.createContext" method.`
+    );
+  }
   const context = vm.getVmContext();
-  if (!isContext(context))
-    throw new TypeError(`Environment ${environment.name} doesn't provide a valid context. It should be created by "vm.createContext" method.`);
+  if (!isContext(context)) {
+    throw new TypeError(
+      `Environment ${environment.name} doesn't provide a valid context. It should be created by "vm.createContext" method.`
+    );
+  }
   provideWorkerState(context, state);
   context.process = process;
   context.global = context;
@@ -791,7 +854,9 @@ async function runVmTests(state) {
     requestStubs: stubs
   });
   context.__vitest_mocker__ = executor.mocker;
-  const { run } = await executor.importExternalModule(entryFile);
+  const { run } = await executor.importExternalModule(
+    entryFile
+  );
   try {
     await run(ctx.files, ctx.config, executor);
   } finally {

package/dist/worker.js

@@ -3,10 +3,10 @@ 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 './vendor/index.DeR1hhfY.js';
-import { i as isChildProcess, s as setProcessTitle } from './vendor/base._gnK9Slw.js';
+import { e as environments } from './vendor/index.D4nqnQWz.js';
+import { i as isChildProcess, s as setProcessTitle } from './vendor/base.CTYV4Gnz.js';
 import { s as setupInspect } from './vendor/inspector.hPQncR7V.js';
-import { c as createRuntimeRpc, a as rpcDone } from './vendor/rpc.DRDE9Pu1.js';
+import { c as createRuntimeRpc, a as rpcDone } from './vendor/rpc.BGx7q_k2.js';
 import 'node:console';
 import '@vitest/utils';
 import 'node:module';
@@ -28,14 +28,16 @@ async function createEnvironmentLoader(options) {
 async function loadEnvironment(ctx, rpc) {
   var _a;
   const name = ctx.environment.name;
-  if (isBuiltinEnvironment(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)
+      if (result.id) {
         return { code: readFileSync(result.id, "utf-8") };
+      }
       return result;
     },
     resolveId: (id, importer) => rpc.resolveId(id, importer, "ssr")
@@ -57,28 +59,39 @@ async function loadEnvironment(ctx, rpc) {
   return environment;
 }
 
-if (isChildProcess())
+if (isChildProcess()) {
   setProcessTitle(`vitest ${workerId}`);
+}
 async function run(ctx) {
   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}"`);
+    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}"`);
+    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}".`);
+    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)
+    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
@@ -94,8 +107,11 @@ async function run(ctx) {
       rpc,
       providedContext: ctx.providedContext
     };
-    if (!worker.runTests || typeof worker.runTests !== "function")
-      throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
+    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(() => {

package/dist/workers/forks.js

@@ -1,10 +1,10 @@
 import v8 from 'node:v8';
-import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../vendor/utils.CUjzkRH7.js';
-import { r as runBaseTests } from '../vendor/base.VFkIJ66g.js';
+import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../vendor/utils.DkxLWvS1.js';
+import { r as runBaseTests } from '../vendor/base.C2DbLEfT.js';
 import '@vitest/utils';
 import 'vite-node/client';
 import '../vendor/global.7bFbnyXl.js';
-import '../vendor/execute.CLLNVNnK.js';
+import '../vendor/execute.T3gg2ZK6.js';
 import 'node:vm';
 import 'node:url';
 import 'node:fs';
@@ -12,7 +12,7 @@ import 'vite-node/utils';
 import 'pathe';
 import '@vitest/utils/error';
 import '../path.js';
-import '../vendor/base._gnK9Slw.js';
+import '../vendor/base.CTYV4Gnz.js';
 
 class ForksBaseWorker {
   getRpcOptions() {