vitest 2.0.5 → 2.1.0-beta.2

package/dist/chunks/{cli-api.OKfd3qJ0.js → cli-api.de6RCgV0.js}

@@ -1,29 +1,29 @@
-import fs$8, { existsSync, promises as promises$1, statSync as statSync$1, realpathSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join, resolve, isAbsolute, relative, dirname, normalize, basename, toNamespacedPath } from 'pathe';
+import { existsSync, promises, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { relative, dirname, join, resolve, basename, toNamespacedPath, isAbsolute, normalize } from 'pathe';
 import { g as getCoverageProvider, C as CoverageProviderMap } from './coverage.CqfT4xaf.js';
 import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
 import { f as findUp, p as prompt } from './index.CM5UI-4O.js';
-import { A as API_PATH, e as extraInlineDeps, d as defaultPort, a as defaultBrowserPort, b as defaultInspectPort, w as workspacesFiles, C as CONFIG_NAMES, c as configFiles } from './constants.CaAN7icJ.js';
-import { MessageChannel, isMainThread } from 'node:worker_threads';
+import { A as API_PATH, w as workspacesFiles, C as CONFIG_NAMES, c as configFiles, d as defaultPort } from './constants.CaAN7icJ.js';
+import { isMainThread } from 'node:worker_threads';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'os';
 import p from 'path';
 import require$$0$1 from 'util';
-import { b as braces_1, p as picomatch$1, u as utils$d, m as mm } from './index.BMmMjLIQ.js';
+import { d as braces_1, p as picomatch$1, u as utils$d, V as VitestCache, e as configDefaults, m as mm, a as resolveConfig, i as isBrowserEnabled, f as isPackageExists, h as createPool, r as resolveApiServerConfig, j as coverageConfigDefaults } from './resolveConfig.CGobt8AB.js';
 import require$$0$2 from 'stream';
 import require$$0$4 from 'events';
 import require$$0$3 from 'fs';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.DGgmCKmU.js';
-import { hasFailed, createFileTask, getTasks, getTests, getNames } from '@vitest/runner/utils';
-import { n as noop$1, b as isPrimitive, c as groupBy, A as AggregateErrorPonyfill, a as slash$1, t as toArray, d as deepMerge, e as nanoid, w as wildcardPatternToRegExp, f as stdout } from './base.DSsbfkDg.js';
-import { createDefer, toArray as toArray$1, notNullish } from '@vitest/utils';
-import { b as isWindows } from './env.BU041cs9.js';
-import { rootDir, distDir } from '../path.js';
+import { v as version$1 } from './cac.B6BJeWgz.js';
+import { createFileTask, getTasks, hasFailed, getTests, getNames } from '@vitest/runner/utils';
+import { n as noop$1, c as isPrimitive, t as toArray, d as deepMerge, e as nanoid, w as wildcardPatternToRegExp, a as slash$1, f as stdout } from './base.BH-FAiX7.js';
+import { toArray as toArray$1, notNullish, createDefer } from '@vitest/utils';
+import { i as isWindows } from './env.CmHVDJnw.js';
+import { distDir, rootDir } from '../path.js';
 import { c as createBirpc } from './index.BpSiYbpB.js';
-import { s as stringify, p as parse$3, w as wrapSerializableConfig, j as Typechecker, R as ReportersMap, g as BenchmarkReportsMap, e as TestFile, f as TestSuite, d as TestCase, k as RandomSequencer, h as BaseSequencer, l as findNodeAround, m as generateCodeFrame, n as highlightCode, i as TestProject, L as Logger, o as BlobReporter, r as readBlobs } from './index.JbiJutJ_.js';
+import { s as stringify, p as parse$3, R as ReportersMap, g as BenchmarkReportsMap, e as TestFile, f as TestSuite, d as TestCase, i as generateCodeFrame, j as highlightCode, h as TestProject, L as Logger, k as BlobReporter, r as readBlobs } from './index.YuPJueCg.js';
 import require$$0$5 from 'zlib';
 import require$$0$6 from 'buffer';
 import require$$1 from 'crypto';
@@ -33,27 +33,20 @@ import require$$3 from 'net';
 import require$$4 from 'tls';
 import require$$7 from 'url';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
-import v8 from 'node:v8';
-import * as nodeos from 'node:os';
-import nodeos__default, { tmpdir } from 'node:os';
-import EventEmitter$2 from 'node:events';
-import Tinypool$1, { Tinypool } from 'tinypool';
-import crypto, { createHash as createHash$2 } from 'node:crypto';
-import { mkdir, writeFile, rm } from 'node:fs/promises';
-import path$8, { win32 } from 'node:path';
-import process$1 from 'node:process';
-import { builtinModules, createRequire } from 'node:module';
-import url, { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$2 } from 'node:url';
-import assert from 'node:assert';
-import { format as format$2, inspect } from 'node:util';
-import c from 'tinyrainbow';
-import { isCI, provider as provider$1 } from 'std-env';
+import { tmpdir } from 'node:os';
+import { rm } from 'node:fs/promises';
+import { createHash as createHash$2 } from 'node:crypto';
 import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import MagicString from 'magic-string';
+import { f as findNodeAround } from './RandomSequencer.B4M2ux5b.js';
 import { esmWalker } from '@vitest/utils/ast';
-import { a as removeUndefinedValues } from './index.DYufA6CZ.js';
+import url from 'node:url';
+import { createRequire } from 'node:module';
+import c from 'tinyrainbow';
+import { isCI } from 'std-env';
+import { a as removeUndefinedValues } from './index.CxRxs566.js';
 import readline from 'node:readline';
-import { s as stripAnsi } from './utils.DpP_sDwr.js';
+import { s as stripAnsi } from './utils.DO38lwfj.js';
 
 async function getModuleGraph(ctx, projectName, id, browser = false) {
   const graph = {};
@@ -1446,7 +1439,7 @@ var async$2 = {};
 
 Object.defineProperty(async$2, "__esModule", { value: true });
 async$2.read = void 0;
-function read$4(path, settings, callback) {
+function read$3(path, settings, callback) {
     settings.fs.lstat(path, (lstatError, lstat) => {
         if (lstatError !== null) {
             callFailureCallback$2(callback, lstatError);
@@ -1472,7 +1465,7 @@ function read$4(path, settings, callback) {
         });
     });
 }
-async$2.read = read$4;
+async$2.read = read$3;
 function callFailureCallback$2(callback, error) {
     callback(error);
 }
@@ -1484,7 +1477,7 @@ var sync$7 = {};
 
 Object.defineProperty(sync$7, "__esModule", { value: true });
 sync$7.read = void 0;
-function read$3(path, settings) {
+function read$2(path, settings) {
     const lstat = settings.fs.lstatSync(path);
     if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
         return lstat;
@@ -1503,7 +1496,7 @@ function read$3(path, settings) {
         throw error;
     }
 }
-sync$7.read = read$3;
+sync$7.read = read$2;
 
 var settings$3 = {};
 
@@ -1703,14 +1696,14 @@ const rpl = runParallel_1;
 const constants_1$1 = constants$1;
 const utils$8 = utils$9;
 const common$5 = common$6;
-function read$2(directory, settings, callback) {
+function read$1(directory, settings, callback) {
     if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         readdirWithFileTypes$1(directory, settings, callback);
         return;
     }
     readdir$1(directory, settings, callback);
 }
-async$3.read = read$2;
+async$3.read = read$1;
 function readdirWithFileTypes$1(directory, settings, callback) {
     settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
         if (readdirError !== null) {
@@ -1808,13 +1801,13 @@ const fsStat$4 = out$1;
 const constants_1 = constants$1;
 const utils$7 = utils$9;
 const common$4 = common$6;
-function read$1(directory, settings) {
+function read(directory, settings) {
     if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
         return readdirWithFileTypes(directory, settings);
     }
     return readdir(directory, settings);
 }
-sync$5.read = read$1;
+sync$5.read = read;
 function readdirWithFileTypes(directory, settings) {
     const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
     return dirents.map((dirent) => {
@@ -8050,7 +8043,7 @@ function setup(ctx, _server) {
           if (!ctx.state.filesMap.has(id) || !existsSync(id)) {
             return null;
           }
-          return promises$1.readFile(id, "utf-8");
+          return promises.readFile(id, "utf-8");
         },
         async saveTestFile(id, content) {
           if (!ctx.state.filesMap.has(id) || !existsSync(id)) {
@@ -8058,7 +8051,7 @@ function setup(ctx, _server) {
               `Test file "${id}" was not registered, so it cannot be updated using the API.`
             );
           }
-          return promises$1.writeFile(id, content, "utf-8");
+          return promises.writeFile(id, content, "utf-8");
         },
         async rerun(files) {
           await ctx.rerunFiles(files);
@@ -8071,7 +8064,7 @@ function setup(ctx, _server) {
           const result = browser ? await project.browser.vite.transformRequest(id) : await project.vitenode.transformRequest(id);
           if (result) {
             try {
-              result.source = result.source || await promises$1.readFile(id, "utf-8");
+              result.source = result.source || await promises.readFile(id, "utf-8");
             } catch {
             }
             return result;
@@ -8189,4343 +8182,239 @@ var setup$1 = /*#__PURE__*/Object.freeze({
   setup: setup
 });
 
-const envsOrder = ["node", "jsdom", "happy-dom", "edge-runtime"];
-function getTransformMode(patterns, filename) {
-  if (patterns.web && mm.isMatch(filename, patterns.web)) {
-    return "web";
-  }
-  if (patterns.ssr && mm.isMatch(filename, patterns.ssr)) {
-    return "ssr";
-  }
-  return void 0;
-}
-async function groupFilesByEnv(files) {
-  const filesWithEnv = await Promise.all(
-    files.map(async ([project, file]) => {
-      const code = await promises$1.readFile(file, "utf-8");
-      let env = code.match(/@(?:vitest|jest)-environment\s+([\w-]+)\b/)?.[1];
-      if (!env) {
-        for (const [glob, target] of project.config.environmentMatchGlobs || []) {
-          if (mm.isMatch(file, glob, { cwd: project.config.root })) {
-            env = target;
-            break;
-          }
-        }
-      }
-      env ||= project.config.environment || "node";
-      const transformMode = getTransformMode(
-        project.config.testTransformMode,
-        file
-      );
-      let envOptionsJson = code.match(/@(?:vitest|jest)-environment-options\s+(.+)/)?.[1];
-      if (envOptionsJson?.endsWith("*/")) {
-        envOptionsJson = envOptionsJson.slice(0, -2);
-      }
-      const envOptions = JSON.parse(envOptionsJson || "null");
-      const envKey = env === "happy-dom" ? "happyDOM" : env;
-      const environment = {
-        name: env,
-        transformMode,
-        options: envOptions ? { [envKey]: envOptions } : null
-      };
-      return {
-        file,
-        project,
-        environment
-      };
-    })
-  );
-  return groupBy(filesWithEnv, ({ environment }) => environment.name);
-}
-
-const created = /* @__PURE__ */ new Set();
-const promises = /* @__PURE__ */ new Map();
-function createMethodsRPC(project, options = {}) {
-  const ctx = project.ctx;
-  const cacheFs = options.cacheFs ?? false;
-  return {
-    snapshotSaved(snapshot) {
-      ctx.snapshot.add(snapshot);
-    },
-    resolveSnapshotPath(testPath) {
-      return ctx.snapshot.resolvePath(testPath);
-    },
-    async getSourceMap(id, force) {
-      if (force) {
-        const mod = project.server.moduleGraph.getModuleById(id);
-        if (mod) {
-          project.server.moduleGraph.invalidateModule(mod);
-        }
-      }
-      const r = await project.vitenode.transformRequest(id);
-      return r?.map;
-    },
-    async fetch(id, transformMode) {
-      const result = await project.vitenode.fetchResult(id, transformMode);
-      const code = result.code;
-      if (!cacheFs || result.externalize) {
-        return result;
-      }
-      if ("id" in result && typeof result.id === "string") {
-        return { id: result.id };
-      }
-      if (code == null) {
-        throw new Error(`Failed to fetch module ${id}`);
-      }
-      const dir = join(project.tmpDir, transformMode);
-      const name = createHash$2("sha1").update(id).digest("hex");
-      const tmp = join(dir, name);
-      if (promises.has(tmp)) {
-        await promises.get(tmp);
-        return { id: tmp };
-      }
-      if (!created.has(dir)) {
-        await mkdir(dir, { recursive: true });
-        created.add(dir);
-      }
-      promises.set(
-        tmp,
-        writeFile(tmp, code, "utf-8").finally(() => promises.delete(tmp))
-      );
-      await promises.get(tmp);
-      Object.assign(result, { id: tmp });
-      return { id: tmp };
-    },
-    resolveId(id, importer, transformMode) {
-      return project.vitenode.resolveId(id, importer, transformMode);
-    },
-    transform(id, environment) {
-      return project.vitenode.transformModule(id, environment);
-    },
-    onPathsCollected(paths) {
-      ctx.state.collectPaths(paths);
-      return ctx.report("onPathsCollected", paths);
-    },
-    onCollected(files) {
-      ctx.state.collectFiles(project, files);
-      return ctx.report("onCollected", files);
-    },
-    onAfterSuiteRun(meta) {
-      ctx.coverageProvider?.onAfterSuiteRun(meta);
-    },
-    onTaskUpdate(packs) {
-      ctx.state.updateTasks(packs);
-      return ctx.report("onTaskUpdate", packs);
-    },
-    onUserConsoleLog(log) {
-      ctx.state.updateUserLog(log);
-      ctx.report("onUserConsoleLog", log);
-    },
-    onUnhandledError(err, type) {
-      ctx.state.catchError(err, type);
-    },
-    onFinished(files) {
-      return ctx.report("onFinished", files, ctx.state.getUnhandledErrors());
-    },
-    onCancel(reason) {
-      ctx.cancelCurrentRun(reason);
-    },
-    getCountOfFailedTests() {
-      return ctx.state.getCountOfFailedTests();
-    }
-  };
+async function loadCustomReporterModule(path, runner) {
+  let customReporterModule;
+  try {
+    customReporterModule = await runner.executeId(path);
+  } catch (customReporterModuleError) {
+    throw new Error(`Failed to load custom Reporter from ${path}`, {
+      cause: customReporterModuleError
+    });
+  }
+  if (customReporterModule.default === null || customReporterModule.default === void 0) {
+    throw new Error(
+      `Custom reporter loaded from ${path} was not the default export`
+    );
+  }
+  return customReporterModule.default;
 }
-
-function createChildProcessChannel$1(project) {
-  const emitter = new EventEmitter$2();
-  const cleanup = () => emitter.removeAllListeners();
-  const events = { message: "message", response: "response" };
-  const channel = {
-    onMessage: (callback) => emitter.on(events.message, callback),
-    postMessage: (message) => emitter.emit(events.response, message)
-  };
-  const rpc = createBirpc(createMethodsRPC(project, { cacheFs: true }), {
-    eventNames: ["onCancel"],
-    serialize: v8.serialize,
-    deserialize: (v) => v8.deserialize(Buffer.from(v)),
-    post(v) {
-      emitter.emit(events.message, v);
-    },
-    on(fn) {
-      emitter.on(events.response, fn);
-    },
-    onTimeoutError(functionName) {
-      throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-    }
-  });
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { channel, cleanup };
-}
-function createForksPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.forks ?? {};
-  const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.minForks ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve(ctx.distPath, "workers/forks.js");
-  const options = {
-    runtime: "child_process",
-    filename: resolve(ctx.distPath, "worker.js"),
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1
-  };
-  const isolated = poolOptions.isolate ?? true;
-  if (isolated) {
-    options.isolateWorkers = true;
-  }
-  if (poolOptions.singleFork || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      ctx.state.clearFiles(project, files);
-      const { channel, cleanup } = createChildProcessChannel$1(project);
-      const workerId = ++id;
-      const data = {
-        pool: "forks",
-        worker,
-        config,
-        files,
-        invalidates,
-        environment,
-        workerId,
-        projectName: project.getName(),
-        providedContext: project.getProvidedContext()
-      };
-      try {
-        await pool.run(data, { name, channel });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${files.join(", ")}.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(files, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        cleanup();
-      }
-    }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new Map();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const _config = project.getSerializableConfig();
-        const config = wrapSerializableConfig(_config);
-        configs.set(project, config);
-        return config;
-      };
-      const workspaceMap = /* @__PURE__ */ new Map();
-      for (const [project, file] of specs) {
-        const workspaceFiles = workspaceMap.get(file) ?? [];
-        workspaceFiles.push(project);
-        workspaceMap.set(file, workspaceFiles);
-      }
-      const singleFork = specs.filter(
-        ([project]) => project.config.poolOptions?.forks?.singleFork
-      );
-      const multipleForks = specs.filter(
-        ([project]) => !project.config.poolOptions?.forks?.singleFork
-      );
-      if (multipleForks.length) {
-        const filesByEnv = await groupFilesByEnv(multipleForks);
-        const files = Object.values(filesByEnv).flat();
-        const results = [];
-        if (isolated) {
-          results.push(
-            ...await Promise.allSettled(
-              files.map(
-                ({ file, environment, project }) => runFiles(
-                  project,
-                  getConfig(project),
-                  [file],
-                  environment,
-                  invalidates
-                )
-              )
-            )
+function createReporters(reporterReferences, ctx) {
+  const runner = ctx.runner;
+  const promisedReporters = reporterReferences.map(
+    async (referenceOrInstance) => {
+      if (Array.isArray(referenceOrInstance)) {
+        const [reporterName, reporterOptions] = referenceOrInstance;
+        if (reporterName === "html") {
+          await ctx.packageInstaller.ensureInstalled("@vitest/ui", runner.root);
+          const CustomReporter = await loadCustomReporterModule(
+            "@vitest/ui/reporter",
+            runner
           );
+          return new CustomReporter(reporterOptions);
+        } else if (reporterName in ReportersMap) {
+          const BuiltinReporter = ReportersMap[reporterName];
+          return new BuiltinReporter(reporterOptions);
         } else {
-          const grouped = groupBy(
-            files,
-            ({ project, environment }) => project.getName() + environment.name + JSON.stringify(environment.options)
-          );
-          for (const group of Object.values(grouped)) {
-            results.push(
-              ...await Promise.allSettled(
-                group.map(
-                  ({ file, environment, project }) => runFiles(
-                    project,
-                    getConfig(project),
-                    [file],
-                    environment,
-                    invalidates
-                  )
-                )
-              )
-            );
-            await new Promise(
-              (resolve2) => pool.queueSize === 0 ? resolve2() : pool.once("drain", resolve2)
-            );
-            await pool.recycleWorkers();
-          }
-        }
-        const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-        if (errors.length > 0) {
-          throw new AggregateError(
-            errors,
-            "Errors occurred while running tests. For more information, see serialized error."
-          );
-        }
-      }
-      if (singleFork.length) {
-        const filesByEnv = await groupFilesByEnv(singleFork);
-        const envs = envsOrder.concat(
-          Object.keys(filesByEnv).filter((env2) => !envsOrder.includes(env2))
-        );
-        for (const env2 of envs) {
-          const files = filesByEnv[env2];
-          if (!files?.length) {
-            continue;
-          }
-          const filesByOptions = groupBy(
-            files,
-            ({ project, environment }) => project.getName() + JSON.stringify(environment.options)
-          );
-          for (const files2 of Object.values(filesByOptions)) {
-            await pool.recycleWorkers();
-            const filenames = files2.map((f) => f.file);
-            await runFiles(
-              files2[0].project,
-              getConfig(files2[0].project),
-              filenames,
-              files2[0].environment,
-              invalidates
-            );
-          }
-        }
-      }
-    };
-  };
-  return {
-    name: "forks",
-    runTests: runWithFiles("run"),
-    collectTests: runWithFiles("collect"),
-    close: () => pool.destroy()
-  };
-}
-
-function createWorkerChannel$1(project) {
-  const channel = new MessageChannel();
-  const port = channel.port2;
-  const workerPort = channel.port1;
-  const rpc = createBirpc(createMethodsRPC(project), {
-    eventNames: ["onCancel"],
-    post(v) {
-      port.postMessage(v);
-    },
-    on(fn) {
-      port.on("message", fn);
-    },
-    onTimeoutError(functionName) {
-      throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-    }
-  });
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { workerPort, port };
-}
-function createThreadsPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.threads ?? {};
-  const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve(ctx.distPath, "workers/threads.js");
-  const options = {
-    filename: resolve(ctx.distPath, "worker.js"),
-    // TODO: investigate further
-    // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
-    useAtomics: poolOptions.useAtomics ?? false,
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [...poolOptions.execArgv ?? [], ...execArgv],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1
-  };
-  const isolated = poolOptions.isolate ?? true;
-  if (isolated) {
-    options.isolateWorkers = true;
-  }
-  if (poolOptions.singleThread || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool$1(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      ctx.state.clearFiles(project, files);
-      const { workerPort, port } = createWorkerChannel$1(project);
-      const workerId = ++id;
-      const data = {
-        pool: "threads",
-        worker,
-        port: workerPort,
-        config,
-        files,
-        invalidates,
-        environment,
-        workerId,
-        projectName: project.getName(),
-        providedContext: project.getProvidedContext()
-      };
-      try {
-        await pool.run(data, { transferList: [workerPort], name });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${files.join(
-              ", "
-            )}. 
-See https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`
+          const CustomReporter = await loadCustomReporterModule(
+            reporterName,
+            runner
           );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(files, project);
-        } else {
-          throw error;
+          return new CustomReporter(reporterOptions);
         }
-      } finally {
-        port.close();
-        workerPort.close();
       }
+      return referenceOrInstance;
     }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new Map();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const config = project.getSerializableConfig();
-        configs.set(project, config);
-        return config;
-      };
-      const workspaceMap = /* @__PURE__ */ new Map();
-      for (const [project, file] of specs) {
-        const workspaceFiles = workspaceMap.get(file) ?? [];
-        workspaceFiles.push(project);
-        workspaceMap.set(file, workspaceFiles);
-      }
-      const singleThreads = specs.filter(
-        ([project]) => project.config.poolOptions?.threads?.singleThread
-      );
-      const multipleThreads = specs.filter(
-        ([project]) => !project.config.poolOptions?.threads?.singleThread
-      );
-      if (multipleThreads.length) {
-        const filesByEnv = await groupFilesByEnv(multipleThreads);
-        const files = Object.values(filesByEnv).flat();
-        const results = [];
-        if (isolated) {
-          results.push(
-            ...await Promise.allSettled(
-              files.map(
-                ({ file, environment, project }) => runFiles(
-                  project,
-                  getConfig(project),
-                  [file],
-                  environment,
-                  invalidates
-                )
-              )
-            )
-          );
+  );
+  return Promise.all(promisedReporters);
+}
+function createBenchmarkReporters(reporterReferences, runner) {
+  const promisedReporters = reporterReferences.map(
+    async (referenceOrInstance) => {
+      if (typeof referenceOrInstance === "string") {
+        if (referenceOrInstance in BenchmarkReportsMap) {
+          const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
+          return new BuiltinReporter();
         } else {
-          const grouped = groupBy(
-            files,
-            ({ project, environment }) => project.getName() + environment.name + JSON.stringify(environment.options)
-          );
-          for (const group of Object.values(grouped)) {
-            results.push(
-              ...await Promise.allSettled(
-                group.map(
-                  ({ file, environment, project }) => runFiles(
-                    project,
-                    getConfig(project),
-                    [file],
-                    environment,
-                    invalidates
-                  )
-                )
-              )
-            );
-            await new Promise(
-              (resolve2) => pool.queueSize === 0 ? resolve2() : pool.once("drain", resolve2)
-            );
-            await pool.recycleWorkers();
-          }
-        }
-        const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-        if (errors.length > 0) {
-          throw new AggregateErrorPonyfill(
-            errors,
-            "Errors occurred while running tests. For more information, see serialized error."
-          );
-        }
-      }
-      if (singleThreads.length) {
-        const filesByEnv = await groupFilesByEnv(singleThreads);
-        const envs = envsOrder.concat(
-          Object.keys(filesByEnv).filter((env2) => !envsOrder.includes(env2))
-        );
-        for (const env2 of envs) {
-          const files = filesByEnv[env2];
-          if (!files?.length) {
-            continue;
-          }
-          const filesByOptions = groupBy(
-            files,
-            ({ project, environment }) => project.getName() + JSON.stringify(environment.options)
+          const CustomReporter = await loadCustomReporterModule(
+            referenceOrInstance,
+            runner
           );
-          for (const files2 of Object.values(filesByOptions)) {
-            await pool.recycleWorkers();
-            const filenames = files2.map((f) => f.file);
-            await runFiles(
-              files2[0].project,
-              getConfig(files2[0].project),
-              filenames,
-              files2[0].environment,
-              invalidates
-            );
-          }
+          return new CustomReporter();
         }
       }
-    };
-  };
-  return {
-    name: "threads",
-    runTests: runWithFiles("run"),
-    collectTests: runWithFiles("collect"),
-    close: () => pool.destroy()
-  };
+      return referenceOrInstance;
+    }
+  );
+  return Promise.all(promisedReporters);
 }
 
-function getDefaultThreadsCount(config) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  return config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-}
-function getWorkerMemoryLimit(config) {
-  const memoryLimit = config.poolOptions?.vmThreads?.memoryLimit;
-  if (memoryLimit) {
-    return memoryLimit;
-  }
-  return 1 / (config.poolOptions?.vmThreads?.maxThreads ?? getDefaultThreadsCount(config));
-}
-function stringToBytes(input, percentageReference) {
-  if (input === null || input === void 0) {
-    return input;
-  }
-  if (typeof input === "string") {
-    if (Number.isNaN(Number.parseFloat(input.slice(-1)))) {
-      let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/) || [];
-      if (trailingChars && numericString) {
-        const numericValue = Number.parseFloat(numericString);
-        trailingChars = trailingChars.toLowerCase();
-        switch (trailingChars) {
-          case "%":
-            input = numericValue / 100;
-            break;
-          case "kb":
-          case "k":
-            return numericValue * 1e3;
-          case "kib":
-            return numericValue * 1024;
-          case "mb":
-          case "m":
-            return numericValue * 1e3 * 1e3;
-          case "mib":
-            return numericValue * 1024 * 1024;
-          case "gb":
-          case "g":
-            return numericValue * 1e3 * 1e3 * 1e3;
-          case "gib":
-            return numericValue * 1024 * 1024 * 1024;
-        }
-      }
-    } else {
-      input = Number.parseFloat(input);
-    }
-  }
-  if (typeof input === "number") {
-    if (input <= 1 && input > 0) {
-      if (percentageReference) {
-        return Math.floor(input * percentageReference);
-      } else {
-        throw new Error(
-          "For a percentage based memory limit a percentageReference must be supplied"
-        );
-      }
-    } else if (input > 1) {
-      return Math.floor(input);
-    } else {
-      throw new Error('Unexpected numerical input for "memoryLimit"');
-    }
+function isAggregateError(err) {
+  if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
+    return true;
   }
-  return null;
+  return err instanceof Error && "errors" in err;
 }
-
-const suppressWarningsPath$1 = resolve(rootDir, "./suppress-warnings.cjs");
-function createWorkerChannel(project) {
-  const channel = new MessageChannel();
-  const port = channel.port2;
-  const workerPort = channel.port1;
-  const rpc = createBirpc(createMethodsRPC(project), {
-    eventNames: ["onCancel"],
-    post(v) {
-      port.postMessage(v);
-    },
-    on(fn) {
-      port.on("message", fn);
-    },
-    onTimeoutError(functionName) {
-      throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
+class StateManager {
+  filesMap = /* @__PURE__ */ new Map();
+  pathsSet = /* @__PURE__ */ new Set();
+  idMap = /* @__PURE__ */ new Map();
+  taskFileMap = /* @__PURE__ */ new WeakMap();
+  errorsSet = /* @__PURE__ */ new Set();
+  processTimeoutCauses = /* @__PURE__ */ new Set();
+  reportedTasksMap = /* @__PURE__ */ new WeakMap();
+  catchError(err, type) {
+    if (isAggregateError(err)) {
+      return err.errors.forEach((error) => this.catchError(error, type));
     }
-  });
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { workerPort, port };
-}
-function createVmThreadsPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.vmThreads ?? {};
-  const maxThreads = poolOptions.maxThreads ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.minThreads ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve(ctx.distPath, "workers/vmThreads.js");
-  const options = {
-    filename: resolve(ctx.distPath, "worker.js"),
-    // TODO: investigate further
-    // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
-    useAtomics: poolOptions.useAtomics ?? false,
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [
-      "--experimental-import-meta-resolve",
-      "--experimental-vm-modules",
-      "--require",
-      suppressWarningsPath$1,
-      ...poolOptions.execArgv ?? [],
-      ...execArgv
-    ],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1,
-    maxMemoryLimitBeforeRecycle: getMemoryLimit$1(ctx.config) || void 0
-  };
-  if (poolOptions.singleThread || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool$1(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      ctx.state.clearFiles(project, files);
-      const { workerPort, port } = createWorkerChannel(project);
-      const workerId = ++id;
-      const data = {
-        pool: "vmThreads",
-        worker,
-        port: workerPort,
-        config,
-        files,
-        invalidates,
-        environment,
-        workerId,
-        projectName: project.getName(),
-        providedContext: project.getProvidedContext()
-      };
-      try {
-        await pool.run(data, { transferList: [workerPort], name });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${files.join(
-              ", "
-            )}. 
-See https://vitest.dev/guide/common-errors.html#failed-to-terminate-worker for troubleshooting.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(files, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        port.close();
-        workerPort.close();
-      }
+    if (err === Object(err)) {
+      err.type = type;
+    } else {
+      err = { type, message: err };
     }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new Map();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const config = project.getSerializableConfig();
-        configs.set(project, config);
-        return config;
-      };
-      const filesByEnv = await groupFilesByEnv(specs);
-      const promises = Object.values(filesByEnv).flat();
-      const results = await Promise.allSettled(
-        promises.map(
-          ({ file, environment, project }) => runFiles(
-            project,
-            getConfig(project),
-            [file],
-            environment,
-            invalidates
-          )
-        )
-      );
-      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-      if (errors.length > 0) {
-        throw new AggregateErrorPonyfill(
-          errors,
-          "Errors occurred while running tests. For more information, see serialized error."
-        );
+    const _err = err;
+    if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
+      const task = this.idMap.get(_err.taskId);
+      if (task) {
+        task.mode = "skip";
+        task.result ??= { state: "skip" };
+        task.result.state = "skip";
       }
-    };
-  };
-  return {
-    name: "vmThreads",
-    runTests: runWithFiles("run"),
-    collectTests: runWithFiles("collect"),
-    close: () => pool.destroy()
-  };
-}
-function getMemoryLimit$1(config) {
-  const memory = nodeos.totalmem();
-  const limit = getWorkerMemoryLimit(config);
-  if (typeof memory === "number") {
-    return stringToBytes(limit, config.watch ? memory / 2 : memory);
+      return;
+    }
+    this.errorsSet.add(err);
   }
-  if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
-    return stringToBytes(limit);
+  clearErrors() {
+    this.errorsSet.clear();
   }
-  return null;
-}
-
-function createTypecheckPool(ctx) {
-  const promisesMap = /* @__PURE__ */ new WeakMap();
-  const rerunTriggered = /* @__PURE__ */ new WeakMap();
-  async function onParseEnd(project, { files, sourceErrors }) {
-    const checker = project.typechecker;
-    await ctx.report("onTaskUpdate", checker.getTestPacks());
-    if (!project.config.typecheck.ignoreSourceErrors) {
-      sourceErrors.forEach(
-        (error) => ctx.state.catchError(error, "Unhandled Source Error")
-      );
-    }
-    const processError = !hasFailed(files) && !sourceErrors.length && checker.getExitCode();
-    if (processError) {
-      const error = new Error(checker.getOutput());
-      error.stack = "";
-      ctx.state.catchError(error, "Typecheck Error");
-    }
-    promisesMap.get(project)?.resolve();
-    rerunTriggered.set(project, false);
-    if (ctx.config.watch && !ctx.runningPromise) {
-      await ctx.report("onFinished", files, []);
-      await ctx.report("onWatcherStart", files, [
-        ...project.config.typecheck.ignoreSourceErrors ? [] : sourceErrors,
-        ...ctx.state.getUnhandledErrors()
-      ]);
-    }
-  }
-  async function createWorkspaceTypechecker(project, files) {
-    const checker = project.typechecker ?? new Typechecker(project);
-    if (project.typechecker) {
-      return checker;
-    }
-    project.typechecker = checker;
-    checker.setFiles(files);
-    checker.onParseStart(async () => {
-      ctx.state.collectFiles(project, checker.getTestFiles());
-      await ctx.report("onCollected");
-    });
-    checker.onParseEnd((result) => onParseEnd(project, result));
-    checker.onWatcherRerun(async () => {
-      rerunTriggered.set(project, true);
-      if (!ctx.runningPromise) {
-        ctx.state.clearErrors();
-        await ctx.report(
-          "onWatcherRerun",
-          files,
-          "File change detected. Triggering rerun."
-        );
-      }
-      await checker.collectTests();
-      ctx.state.collectFiles(project, checker.getTestFiles());
-      await ctx.report("onTaskUpdate", checker.getTestPacks());
-      await ctx.report("onCollected");
-    });
-    await checker.prepare();
-    return checker;
-  }
-  async function startTypechecker(project, files) {
-    if (project.typechecker) {
-      return project.typechecker;
-    }
-    const checker = await createWorkspaceTypechecker(project, files);
-    await checker.collectTests();
-    await checker.start();
-  }
-  async function collectTests(specs) {
-    const specsByProject = groupBy(specs, ([project]) => project.getName());
-    for (const name in specsByProject) {
-      const project = specsByProject[name][0][0];
-      const files = specsByProject[name].map(([_, file]) => file);
-      const checker = await createWorkspaceTypechecker(project, files);
-      checker.setFiles(files);
-      await checker.collectTests();
-      ctx.state.collectFiles(project, checker.getTestFiles());
-      await ctx.report("onCollected");
-    }
-  }
-  async function runTests(specs) {
-    const specsByProject = groupBy(specs, ([project]) => project.getName());
-    const promises = [];
-    for (const name in specsByProject) {
-      const project = specsByProject[name][0][0];
-      const files = specsByProject[name].map(([_, file]) => file);
-      const promise = createDefer();
-      const _p = new Promise((resolve) => {
-        const _i = setInterval(() => {
-          if (!project.typechecker || rerunTriggered.get(project)) {
-            resolve(true);
-            clearInterval(_i);
-          }
-        });
-        setTimeout(() => {
-          resolve(false);
-          clearInterval(_i);
-        }, 500).unref();
-      });
-      const triggered = await _p;
-      if (project.typechecker && !triggered) {
-        ctx.state.collectFiles(project, project.typechecker.getTestFiles());
-        await ctx.report("onCollected");
-        await onParseEnd(project, project.typechecker.getResult());
-        continue;
-      }
-      promises.push(promise);
-      promisesMap.set(project, promise);
-      startTypechecker(project, files);
-    }
-    await Promise.all(promises);
+  getUnhandledErrors() {
+    return Array.from(this.errorsSet.values());
   }
-  return {
-    name: "typescript",
-    runTests,
-    collectTests,
-    async close() {
-      const promises = ctx.projects.map(
-        (project) => project.typechecker?.stop()
-      );
-      await Promise.all(promises);
-    }
-  };
-}
-
-const suppressWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
-function createChildProcessChannel(project) {
-  const emitter = new EventEmitter$2();
-  const cleanup = () => emitter.removeAllListeners();
-  const events = { message: "message", response: "response" };
-  const channel = {
-    onMessage: (callback) => emitter.on(events.message, callback),
-    postMessage: (message) => emitter.emit(events.response, message)
-  };
-  const rpc = createBirpc(
-    createMethodsRPC(project, { cacheFs: true }),
-    {
-      eventNames: ["onCancel"],
-      serialize: v8.serialize,
-      deserialize: (v) => v8.deserialize(Buffer.from(v)),
-      post(v) {
-        emitter.emit(events.message, v);
-      },
-      on(fn) {
-        emitter.on(events.response, fn);
-      },
-      onTimeoutError(functionName) {
-        throw new Error(`[vitest-pool]: Timeout calling "${functionName}"`);
-      }
-    }
-  );
-  project.ctx.onCancel((reason) => rpc.onCancel(reason));
-  return { channel, cleanup };
-}
-function createVmForksPool(ctx, { execArgv, env }) {
-  const numCpus = typeof nodeos.availableParallelism === "function" ? nodeos.availableParallelism() : nodeos.cpus().length;
-  const threadsCount = ctx.config.watch ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-  const poolOptions = ctx.config.poolOptions?.vmForks ?? {};
-  const maxThreads = poolOptions.maxForks ?? ctx.config.maxWorkers ?? threadsCount;
-  const minThreads = poolOptions.maxForks ?? ctx.config.minWorkers ?? threadsCount;
-  const worker = resolve(ctx.distPath, "workers/vmForks.js");
-  const options = {
-    runtime: "child_process",
-    filename: resolve(ctx.distPath, "worker.js"),
-    maxThreads,
-    minThreads,
-    env,
-    execArgv: [
-      "--experimental-import-meta-resolve",
-      "--experimental-vm-modules",
-      "--require",
-      suppressWarningsPath,
-      ...poolOptions.execArgv ?? [],
-      ...execArgv
-    ],
-    terminateTimeout: ctx.config.teardownTimeout,
-    concurrentTasksPerWorker: 1,
-    maxMemoryLimitBeforeRecycle: getMemoryLimit(ctx.config) || void 0
-  };
-  if (poolOptions.singleFork || !ctx.config.fileParallelism) {
-    options.maxThreads = 1;
-    options.minThreads = 1;
-  }
-  const pool = new Tinypool$1(options);
-  const runWithFiles = (name) => {
-    let id = 0;
-    async function runFiles(project, config, files, environment, invalidates = []) {
-      ctx.state.clearFiles(project, files);
-      const { channel, cleanup } = createChildProcessChannel(project);
-      const workerId = ++id;
-      const data = {
-        pool: "forks",
-        worker,
-        config,
-        files,
-        invalidates,
-        environment,
-        workerId,
-        projectName: project.getName(),
-        providedContext: project.getProvidedContext()
-      };
-      try {
-        await pool.run(data, { name, channel });
-      } catch (error) {
-        if (error instanceof Error && /Failed to terminate worker/.test(error.message)) {
-          ctx.state.addProcessTimeoutCause(
-            `Failed to terminate worker while running ${files.join(", ")}.`
-          );
-        } else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message)) {
-          ctx.state.cancelFiles(files, project);
-        } else {
-          throw error;
-        }
-      } finally {
-        cleanup();
-      }
-    }
-    return async (specs, invalidates) => {
-      ctx.onCancel(() => pool.cancelPendingTasks());
-      const configs = /* @__PURE__ */ new Map();
-      const getConfig = (project) => {
-        if (configs.has(project)) {
-          return configs.get(project);
-        }
-        const _config = project.getSerializableConfig();
-        const config = wrapSerializableConfig(_config);
-        configs.set(project, config);
-        return config;
-      };
-      const filesByEnv = await groupFilesByEnv(specs);
-      const promises = Object.values(filesByEnv).flat();
-      const results = await Promise.allSettled(
-        promises.map(
-          ({ file, environment, project }) => runFiles(
-            project,
-            getConfig(project),
-            [file],
-            environment,
-            invalidates
-          )
-        )
-      );
-      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-      if (errors.length > 0) {
-        throw new AggregateErrorPonyfill(
-          errors,
-          "Errors occurred while running tests. For more information, see serialized error."
-        );
-      }
-    };
-  };
-  return {
-    name: "vmForks",
-    runTests: runWithFiles("run"),
-    collectTests: runWithFiles("collect"),
-    close: () => pool.destroy()
-  };
-}
-function getMemoryLimit(config) {
-  const memory = nodeos.totalmem();
-  const limit = getWorkerMemoryLimit(config);
-  if (typeof memory === "number") {
-    return stringToBytes(limit, config.watch ? memory / 2 : memory);
-  }
-  if (typeof limit === "number" && limit > 1 || typeof limit === "string" && limit.at(-1) !== "%") {
-    return stringToBytes(limit);
-  }
-  return null;
-}
-
-const builtinPools = [
-  "forks",
-  "threads",
-  "browser",
-  "vmThreads",
-  "vmForks",
-  "typescript"
-];
-function getDefaultPoolName(project, file) {
-  if (project.config.typecheck.enabled) {
-    for (const glob of project.config.typecheck.include) {
-      if (mm.isMatch(file, glob, { cwd: project.config.root })) {
-        return "typescript";
-      }
-    }
-  }
-  if (project.config.browser.enabled) {
-    return "browser";
-  }
-  return project.config.pool;
-}
-function getFilePoolName(project, file) {
-  for (const [glob, pool] of project.config.poolMatchGlobs) {
-    if (pool === "browser") {
-      throw new Error(
-        'Since Vitest 0.31.0 "browser" pool is not supported in "poolMatchGlobs". You can create a workspace to run some of your tests in browser in parallel. Read more: https://vitest.dev/guide/workspace'
-      );
-    }
-    if (mm.isMatch(file, glob, { cwd: project.config.root })) {
-      return pool;
-    }
-  }
-  return getDefaultPoolName(project, file);
-}
-function createPool(ctx) {
-  const pools = {
-    forks: null,
-    threads: null,
-    browser: null,
-    vmThreads: null,
-    vmForks: null,
-    typescript: null
-  };
-  const potentialConditions = /* @__PURE__ */ new Set([
-    "production",
-    "development",
-    ...ctx.server.config.resolve.conditions
-  ]);
-  const conditions = [...potentialConditions].filter((condition) => {
-    if (condition === "production") {
-      return ctx.server.config.isProduction;
-    }
-    if (condition === "development") {
-      return !ctx.server.config.isProduction;
-    }
-    return true;
-  }).flatMap((c) => ["--conditions", c]);
-  const execArgv = process.execArgv.filter(
-    (execArg) => execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")
-  );
-  async function executeTests(method, files, invalidate) {
-    const options = {
-      execArgv: [...execArgv, ...conditions],
-      env: {
-        TEST: "true",
-        VITEST: "true",
-        NODE_ENV: process.env.NODE_ENV || "test",
-        VITEST_MODE: ctx.config.watch ? "WATCH" : "RUN",
-        ...process.env,
-        ...ctx.config.env
-      }
-    };
-    if (isWindows) {
-      for (const name in options.env) {
-        options.env[name.toUpperCase()] = options.env[name];
-      }
-    }
-    const customPools = /* @__PURE__ */ new Map();
-    async function resolveCustomPool(filepath) {
-      if (customPools.has(filepath)) {
-        return customPools.get(filepath);
-      }
-      const pool = await ctx.runner.executeId(filepath);
-      if (typeof pool.default !== "function") {
-        throw new TypeError(
-          `Custom pool "${filepath}" must export a function as default export`
-        );
-      }
-      const poolInstance = await pool.default(ctx, options);
-      if (typeof poolInstance?.name !== "string") {
-        throw new TypeError(
-          `Custom pool "${filepath}" should return an object with "name" property`
-        );
-      }
-      if (typeof poolInstance?.[method] !== "function") {
-        throw new TypeError(
-          `Custom pool "${filepath}" should return an object with "${method}" method`
-        );
-      }
-      customPools.set(filepath, poolInstance);
-      return poolInstance;
-    }
-    const filesByPool = {
-      forks: [],
-      threads: [],
-      // browser: [],
-      vmThreads: [],
-      vmForks: [],
-      typescript: []
-    };
-    const factories = {
-      // browser: () => createBrowserPool(ctx),
-      vmThreads: () => createVmThreadsPool(ctx, options),
-      threads: () => createThreadsPool(ctx, options),
-      forks: () => createForksPool(ctx, options),
-      vmForks: () => createVmForksPool(ctx, options),
-      typescript: () => createTypecheckPool(ctx)
-    };
-    for (const spec of files) {
-      const pool = getFilePoolName(spec[0], spec[1]);
-      filesByPool[pool] ??= [];
-      filesByPool[pool].push(spec);
-    }
-    const Sequencer = ctx.config.sequence.sequencer;
-    const sequencer = new Sequencer(ctx);
-    async function sortSpecs(specs) {
-      if (ctx.config.shard) {
-        specs = await sequencer.shard(specs);
-      }
-      return sequencer.sort(specs);
-    }
-    await Promise.all(
-      Object.entries(filesByPool).map(async (entry) => {
-        const [pool, files2] = entry;
-        if (!files2.length) {
-          return null;
-        }
-        const specs = await sortSpecs(files2);
-        if (pool in factories) {
-          const factory = factories[pool];
-          pools[pool] ??= factory();
-          return pools[pool][method](specs, invalidate);
-        }
-        if (pool === "browser") {
-          pools[pool] ??= await (async () => {
-            const { createBrowserPool } = await import('@vitest/browser');
-            return createBrowserPool(ctx);
-          })();
-          return pools[pool][method](specs, invalidate);
-        }
-        const poolHandler = await resolveCustomPool(pool);
-        pools[poolHandler.name] ??= poolHandler;
-        return poolHandler[method](specs, invalidate);
-      })
-    );
-  }
-  return {
-    name: "default",
-    runTests: (files, invalidates) => executeTests("runTests", files, invalidates),
-    collectTests: (files, invalidates) => executeTests("collectTests", files, invalidates),
-    async close() {
-      await Promise.all(Object.values(pools).map((p) => p?.close?.()));
-    }
-  };
-}
-
-async function loadCustomReporterModule(path, runner) {
-  let customReporterModule;
-  try {
-    customReporterModule = await runner.executeId(path);
-  } catch (customReporterModuleError) {
-    throw new Error(`Failed to load custom Reporter from ${path}`, {
-      cause: customReporterModuleError
-    });
-  }
-  if (customReporterModule.default === null || customReporterModule.default === void 0) {
-    throw new Error(
-      `Custom reporter loaded from ${path} was not the default export`
-    );
-  }
-  return customReporterModule.default;
-}
-function createReporters(reporterReferences, ctx) {
-  const runner = ctx.runner;
-  const promisedReporters = reporterReferences.map(
-    async (referenceOrInstance) => {
-      if (Array.isArray(referenceOrInstance)) {
-        const [reporterName, reporterOptions] = referenceOrInstance;
-        if (reporterName === "html") {
-          await ctx.packageInstaller.ensureInstalled("@vitest/ui", runner.root);
-          const CustomReporter = await loadCustomReporterModule(
-            "@vitest/ui/reporter",
-            runner
-          );
-          return new CustomReporter(reporterOptions);
-        } else if (reporterName in ReportersMap) {
-          const BuiltinReporter = ReportersMap[reporterName];
-          return new BuiltinReporter(reporterOptions);
-        } else {
-          const CustomReporter = await loadCustomReporterModule(
-            reporterName,
-            runner
-          );
-          return new CustomReporter(reporterOptions);
-        }
-      }
-      return referenceOrInstance;
-    }
-  );
-  return Promise.all(promisedReporters);
-}
-function createBenchmarkReporters(reporterReferences, runner) {
-  const promisedReporters = reporterReferences.map(
-    async (referenceOrInstance) => {
-      if (typeof referenceOrInstance === "string") {
-        if (referenceOrInstance in BenchmarkReportsMap) {
-          const BuiltinReporter = BenchmarkReportsMap[referenceOrInstance];
-          return new BuiltinReporter();
-        } else {
-          const CustomReporter = await loadCustomReporterModule(
-            referenceOrInstance,
-            runner
-          );
-          return new CustomReporter();
-        }
-      }
-      return referenceOrInstance;
-    }
-  );
-  return Promise.all(promisedReporters);
-}
-
-function isAggregateError(err) {
-  if (typeof AggregateError !== "undefined" && err instanceof AggregateError) {
-    return true;
-  }
-  return err instanceof Error && "errors" in err;
-}
-class StateManager {
-  filesMap = /* @__PURE__ */ new Map();
-  pathsSet = /* @__PURE__ */ new Set();
-  idMap = /* @__PURE__ */ new Map();
-  taskFileMap = /* @__PURE__ */ new WeakMap();
-  errorsSet = /* @__PURE__ */ new Set();
-  processTimeoutCauses = /* @__PURE__ */ new Set();
-  reportedTasksMap = /* @__PURE__ */ new WeakMap();
-  catchError(err, type) {
-    if (isAggregateError(err)) {
-      return err.errors.forEach((error) => this.catchError(error, type));
-    }
-    if (err === Object(err)) {
-      err.type = type;
-    } else {
-      err = { type, message: err };
-    }
-    const _err = err;
-    if (_err && typeof _err === "object" && _err.code === "VITEST_PENDING") {
-      const task = this.idMap.get(_err.taskId);
-      if (task) {
-        task.mode = "skip";
-        task.result ??= { state: "skip" };
-        task.result.state = "skip";
-      }
-      return;
-    }
-    this.errorsSet.add(err);
-  }
-  clearErrors() {
-    this.errorsSet.clear();
-  }
-  getUnhandledErrors() {
-    return Array.from(this.errorsSet.values());
-  }
-  addProcessTimeoutCause(cause) {
-    this.processTimeoutCauses.add(cause);
-  }
-  getProcessTimeoutCauses() {
-    return Array.from(this.processTimeoutCauses.values());
-  }
-  getPaths() {
-    return Array.from(this.pathsSet);
-  }
-  /**
-   * Return files that were running or collected.
-   */
-  getFiles(keys) {
-    if (keys) {
-      return keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local);
-    }
-    return Array.from(this.filesMap.values()).flat().filter((file) => !file.local);
-  }
-  getFilepaths() {
-    return Array.from(this.filesMap.keys());
-  }
-  getFailedFilepaths() {
-    return this.getFiles().filter((i) => i.result?.state === "fail").map((i) => i.filepath);
-  }
-  collectPaths(paths = []) {
-    paths.forEach((path) => {
-      this.pathsSet.add(path);
-    });
-  }
-  collectFiles(project, files = []) {
-    files.forEach((file) => {
-      const existing = this.filesMap.get(file.filepath) || [];
-      const otherProject = existing.filter(
-        (i) => i.projectName !== file.projectName
-      );
-      const currentFile = existing.find(
-        (i) => i.projectName === file.projectName
-      );
-      if (currentFile) {
-        file.logs = currentFile.logs;
-      }
-      otherProject.push(file);
-      this.filesMap.set(file.filepath, otherProject);
-      this.updateId(file, project);
-    });
-  }
-  clearFiles(project, paths = []) {
-    paths.forEach((path) => {
-      const files = this.filesMap.get(path);
-      const fileTask = createFileTask(
-        path,
-        project.config.root,
-        project.config.name
-      );
-      fileTask.local = true;
-      TestFile.register(fileTask, project);
-      this.idMap.set(fileTask.id, fileTask);
-      if (!files) {
-        this.filesMap.set(path, [fileTask]);
-        return;
-      }
-      const filtered = files.filter(
-        (file) => file.projectName !== project.config.name
-      );
-      if (!filtered.length) {
-        this.filesMap.set(path, [fileTask]);
-      } else {
-        this.filesMap.set(path, [...filtered, fileTask]);
-      }
-    });
-  }
-  updateId(task, project) {
-    if (this.idMap.get(task.id) === task) {
-      return;
-    }
-    if (task.type === "suite" && "filepath" in task) {
-      TestFile.register(task, project);
-    } else if (task.type === "suite") {
-      TestSuite.register(task, project);
-    } else {
-      TestCase.register(task, project);
-    }
-    this.idMap.set(task.id, task);
-    if (task.type === "suite") {
-      task.tasks.forEach((task2) => {
-        this.updateId(task2, project);
-      });
-    }
-  }
-  getReportedEntity(task) {
-    return this.reportedTasksMap.get(task);
-  }
-  updateTasks(packs) {
-    for (const [id, result, meta] of packs) {
-      const task = this.idMap.get(id);
-      if (task) {
-        task.result = result;
-        task.meta = meta;
-        if (result?.state === "skip") {
-          task.mode = "skip";
-        }
-      }
-    }
-  }
-  updateUserLog(log) {
-    const task = log.taskId && this.idMap.get(log.taskId);
-    if (task) {
-      if (!task.logs) {
-        task.logs = [];
-      }
-      task.logs.push(log);
-    }
-  }
-  getCountOfFailedTests() {
-    return Array.from(this.idMap.values()).filter(
-      (t) => t.result?.state === "fail"
-    ).length;
-  }
-  cancelFiles(files, project) {
-    this.collectFiles(
-      project,
-      files.map(
-        (filepath) => createFileTask(filepath, project.config.root, project.config.name)
-      )
-    );
-  }
-}
-
-const JOIN_LEADING_SLASH_RE = /^\.?\//;
-function withTrailingSlash(input = "", respectQueryAndFragment) {
-  {
-    return input.endsWith("/") ? input : input + "/";
-  }
-}
-function isNonEmptyURL(url) {
-  return url && url !== "/";
-}
-function joinURL(base, ...input) {
-  let url = base || "";
-  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
-    if (url) {
-      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
-      url = withTrailingSlash(url) + _segment;
-    } else {
-      url = segment;
-    }
-  }
-  return url;
-}
-
-const BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path) {
-  return path.replace(/\\/g, "/");
-}
-
-/**
- * @typedef ErrnoExceptionFields
- * @property {number | undefined} [errnode]
- * @property {string | undefined} [code]
- * @property {string | undefined} [path]
- * @property {string | undefined} [syscall]
- * @property {string | undefined} [url]
- *
- * @typedef {Error & ErrnoExceptionFields} ErrnoException
- */
-
-
-const own$1 = {}.hasOwnProperty;
-
-const classRegExp = /^([A-Z][a-z\d]*)+$/;
-// Sorted by a rough estimate on most frequently used entries.
-const kTypes = new Set([
-  'string',
-  'function',
-  'number',
-  'object',
-  // Accept 'Function' and 'Object' as alternative to the lower cased version.
-  'Function',
-  'Object',
-  'boolean',
-  'bigint',
-  'symbol'
-]);
-
-const codes = {};
-
-/**
- * Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
- * We cannot use Intl.ListFormat because it's not available in
- * --without-intl builds.
- *
- * @param {Array<string>} array
- *   An array of strings.
- * @param {string} [type]
- *   The list type to be inserted before the last element.
- * @returns {string}
- */
-function formatList(array, type = 'and') {
-  return array.length < 3
-    ? array.join(` ${type} `)
-    : `${array.slice(0, -1).join(', ')}, ${type} ${array[array.length - 1]}`
-}
-
-/** @type {Map<string, MessageFunction | string>} */
-const messages = new Map();
-const nodeInternalPrefix = '__node_internal_';
-/** @type {number} */
-let userStackTraceLimit;
-
-codes.ERR_INVALID_ARG_TYPE = createError(
-  'ERR_INVALID_ARG_TYPE',
-  /**
-   * @param {string} name
-   * @param {Array<string> | string} expected
-   * @param {unknown} actual
-   */
-  (name, expected, actual) => {
-    assert(typeof name === 'string', "'name' must be a string");
-    if (!Array.isArray(expected)) {
-      expected = [expected];
-    }
-
-    let message = 'The ';
-    if (name.endsWith(' argument')) {
-      // For cases like 'first argument'
-      message += `${name} `;
-    } else {
-      const type = name.includes('.') ? 'property' : 'argument';
-      message += `"${name}" ${type} `;
-    }
-
-    message += 'must be ';
-
-    /** @type {Array<string>} */
-    const types = [];
-    /** @type {Array<string>} */
-    const instances = [];
-    /** @type {Array<string>} */
-    const other = [];
-
-    for (const value of expected) {
-      assert(
-        typeof value === 'string',
-        'All expected entries have to be of type string'
-      );
-
-      if (kTypes.has(value)) {
-        types.push(value.toLowerCase());
-      } else if (classRegExp.exec(value) === null) {
-        assert(
-          value !== 'object',
-          'The value "object" should be written as "Object"'
-        );
-        other.push(value);
-      } else {
-        instances.push(value);
-      }
-    }
-
-    // Special handle `object` in case other instances are allowed to outline
-    // the differences between each other.
-    if (instances.length > 0) {
-      const pos = types.indexOf('object');
-      if (pos !== -1) {
-        types.slice(pos, 1);
-        instances.push('Object');
-      }
-    }
-
-    if (types.length > 0) {
-      message += `${types.length > 1 ? 'one of type' : 'of type'} ${formatList(
-        types,
-        'or'
-      )}`;
-      if (instances.length > 0 || other.length > 0) message += ' or ';
-    }
-
-    if (instances.length > 0) {
-      message += `an instance of ${formatList(instances, 'or')}`;
-      if (other.length > 0) message += ' or ';
-    }
-
-    if (other.length > 0) {
-      if (other.length > 1) {
-        message += `one of ${formatList(other, 'or')}`;
-      } else {
-        if (other[0].toLowerCase() !== other[0]) message += 'an ';
-        message += `${other[0]}`;
-      }
-    }
-
-    message += `. Received ${determineSpecificType(actual)}`;
-
-    return message
-  },
-  TypeError
-);
-
-codes.ERR_INVALID_MODULE_SPECIFIER = createError(
-  'ERR_INVALID_MODULE_SPECIFIER',
-  /**
-   * @param {string} request
-   * @param {string} reason
-   * @param {string} [base]
-   */
-  (request, reason, base = undefined) => {
-    return `Invalid module "${request}" ${reason}${
-      base ? ` imported from ${base}` : ''
-    }`
-  },
-  TypeError
-);
-
-codes.ERR_INVALID_PACKAGE_CONFIG = createError(
-  'ERR_INVALID_PACKAGE_CONFIG',
-  /**
-   * @param {string} path
-   * @param {string} [base]
-   * @param {string} [message]
-   */
-  (path, base, message) => {
-    return `Invalid package config ${path}${
-      base ? ` while importing ${base}` : ''
-    }${message ? `. ${message}` : ''}`
-  },
-  Error
-);
-
-codes.ERR_INVALID_PACKAGE_TARGET = createError(
-  'ERR_INVALID_PACKAGE_TARGET',
-  /**
-   * @param {string} packagePath
-   * @param {string} key
-   * @param {unknown} target
-   * @param {boolean} [isImport=false]
-   * @param {string} [base]
-   */
-  (packagePath, key, target, isImport = false, base = undefined) => {
-    const relatedError =
-      typeof target === 'string' &&
-      !isImport &&
-      target.length > 0 &&
-      !target.startsWith('./');
-    if (key === '.') {
-      assert(isImport === false);
-      return (
-        `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
-        `in the package config ${packagePath}package.json${
-          base ? ` imported from ${base}` : ''
-        }${relatedError ? '; targets must start with "./"' : ''}`
-      )
-    }
-
-    return `Invalid "${
-      isImport ? 'imports' : 'exports'
-    }" target ${JSON.stringify(
-      target
-    )} defined for '${key}' in the package config ${packagePath}package.json${
-      base ? ` imported from ${base}` : ''
-    }${relatedError ? '; targets must start with "./"' : ''}`
-  },
-  Error
-);
-
-codes.ERR_MODULE_NOT_FOUND = createError(
-  'ERR_MODULE_NOT_FOUND',
-  /**
-   * @param {string} path
-   * @param {string} base
-   * @param {boolean} [exactUrl]
-   */
-  (path, base, exactUrl = false) => {
-    return `Cannot find ${
-      exactUrl ? 'module' : 'package'
-    } '${path}' imported from ${base}`
-  },
-  Error
-);
-
-codes.ERR_NETWORK_IMPORT_DISALLOWED = createError(
-  'ERR_NETWORK_IMPORT_DISALLOWED',
-  "import of '%s' by %s is not supported: %s",
-  Error
-);
-
-codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
-  'ERR_PACKAGE_IMPORT_NOT_DEFINED',
-  /**
-   * @param {string} specifier
-   * @param {string} packagePath
-   * @param {string} base
-   */
-  (specifier, packagePath, base) => {
-    return `Package import specifier "${specifier}" is not defined${
-      packagePath ? ` in package ${packagePath}package.json` : ''
-    } imported from ${base}`
-  },
-  TypeError
-);
-
-codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
-  'ERR_PACKAGE_PATH_NOT_EXPORTED',
-  /**
-   * @param {string} packagePath
-   * @param {string} subpath
-   * @param {string} [base]
-   */
-  (packagePath, subpath, base = undefined) => {
-    if (subpath === '.')
-      return `No "exports" main defined in ${packagePath}package.json${
-        base ? ` imported from ${base}` : ''
-      }`
-    return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${
-      base ? ` imported from ${base}` : ''
-    }`
-  },
-  Error
-);
-
-codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
-  'ERR_UNSUPPORTED_DIR_IMPORT',
-  "Directory import '%s' is not supported " +
-    'resolving ES modules imported from %s',
-  Error
-);
-
-codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError(
-  'ERR_UNSUPPORTED_RESOLVE_REQUEST',
-  'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.',
-  TypeError
-);
-
-codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
-  'ERR_UNKNOWN_FILE_EXTENSION',
-  /**
-   * @param {string} extension
-   * @param {string} path
-   */
-  (extension, path) => {
-    return `Unknown file extension "${extension}" for ${path}`
-  },
-  TypeError
-);
-
-codes.ERR_INVALID_ARG_VALUE = createError(
-  'ERR_INVALID_ARG_VALUE',
-  /**
-   * @param {string} name
-   * @param {unknown} value
-   * @param {string} [reason='is invalid']
-   */
-  (name, value, reason = 'is invalid') => {
-    let inspected = inspect(value);
-
-    if (inspected.length > 128) {
-      inspected = `${inspected.slice(0, 128)}...`;
-    }
-
-    const type = name.includes('.') ? 'property' : 'argument';
-
-    return `The ${type} '${name}' ${reason}. Received ${inspected}`
-  },
-  TypeError
-  // Note: extra classes have been shaken out.
-  // , RangeError
-);
-
-/**
- * Utility function for registering the error codes. Only used here. Exported
- * *only* to allow for testing.
- * @param {string} sym
- * @param {MessageFunction | string} value
- * @param {ErrorConstructor} constructor
- * @returns {new (...parameters: Array<any>) => Error}
- */
-function createError(sym, value, constructor) {
-  // Special case for SystemError that formats the error message differently
-  // The SystemErrors only have SystemError as their base classes.
-  messages.set(sym, value);
-
-  return makeNodeErrorWithCode(constructor, sym)
-}
-
-/**
- * @param {ErrorConstructor} Base
- * @param {string} key
- * @returns {ErrorConstructor}
- */
-function makeNodeErrorWithCode(Base, key) {
-  // @ts-expect-error It’s a Node error.
-  return NodeError
-  /**
-   * @param {Array<unknown>} parameters
-   */
-  function NodeError(...parameters) {
-    const limit = Error.stackTraceLimit;
-    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
-    const error = new Base();
-    // Reset the limit and setting the name property.
-    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
-    const message = getMessage(key, parameters, error);
-    Object.defineProperties(error, {
-      // Note: no need to implement `kIsNodeError` symbol, would be hard,
-      // probably.
-      message: {
-        value: message,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      },
-      toString: {
-        /** @this {Error} */
-        value() {
-          return `${this.name} [${key}]: ${this.message}`
-        },
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-
-    captureLargerStackTrace(error);
-    // @ts-expect-error It’s a Node error.
-    error.code = key;
-    return error
-  }
-}
-
-/**
- * @returns {boolean}
- */
-function isErrorStackTraceLimitWritable() {
-  // Do no touch Error.stackTraceLimit as V8 would attempt to install
-  // it again during deserialization.
-  try {
-    if (v8.startupSnapshot.isBuildingSnapshot()) {
-      return false
-    }
-  } catch {}
-
-  const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
-  if (desc === undefined) {
-    return Object.isExtensible(Error)
-  }
-
-  return own$1.call(desc, 'writable') && desc.writable !== undefined
-    ? desc.writable
-    : desc.set !== undefined
-}
-
-/**
- * This function removes unnecessary frames from Node.js core errors.
- * @template {(...parameters: unknown[]) => unknown} T
- * @param {T} wrappedFunction
- * @returns {T}
- */
-function hideStackFrames(wrappedFunction) {
-  // We rename the functions that will be hidden to cut off the stacktrace
-  // at the outermost one
-  const hidden = nodeInternalPrefix + wrappedFunction.name;
-  Object.defineProperty(wrappedFunction, 'name', {value: hidden});
-  return wrappedFunction
-}
-
-const captureLargerStackTrace = hideStackFrames(
-  /**
-   * @param {Error} error
-   * @returns {Error}
-   */
-  // @ts-expect-error: fine
-  function (error) {
-    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
-    if (stackTraceLimitIsWritable) {
-      userStackTraceLimit = Error.stackTraceLimit;
-      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-    }
-
-    Error.captureStackTrace(error);
-
-    // Reset the limit
-    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
-
-    return error
-  }
-);
-
-/**
- * @param {string} key
- * @param {Array<unknown>} parameters
- * @param {Error} self
- * @returns {string}
- */
-function getMessage(key, parameters, self) {
-  const message = messages.get(key);
-  assert(message !== undefined, 'expected `message` to be found');
-
-  if (typeof message === 'function') {
-    assert(
-      message.length <= parameters.length, // Default options do not count.
-      `Code: ${key}; The provided arguments length (${parameters.length}) does not ` +
-        `match the required ones (${message.length}).`
-    );
-    return Reflect.apply(message, self, parameters)
-  }
-
-  const regex = /%[dfijoOs]/g;
-  let expectedLength = 0;
-  while (regex.exec(message) !== null) expectedLength++;
-  assert(
-    expectedLength === parameters.length,
-    `Code: ${key}; The provided arguments length (${parameters.length}) does not ` +
-      `match the required ones (${expectedLength}).`
-  );
-  if (parameters.length === 0) return message
-
-  parameters.unshift(message);
-  return Reflect.apply(format$2, null, parameters)
-}
-
-/**
- * Determine the specific type of a value for type-mismatch errors.
- * @param {unknown} value
- * @returns {string}
- */
-function determineSpecificType(value) {
-  if (value === null || value === undefined) {
-    return String(value)
-  }
-
-  if (typeof value === 'function' && value.name) {
-    return `function ${value.name}`
-  }
-
-  if (typeof value === 'object') {
-    if (value.constructor && value.constructor.name) {
-      return `an instance of ${value.constructor.name}`
-    }
-
-    return `${inspect(value, {depth: -1})}`
-  }
-
-  let inspected = inspect(value, {colors: false});
-
-  if (inspected.length > 28) {
-    inspected = `${inspected.slice(0, 25)}...`;
-  }
-
-  return `type ${typeof value} (${inspected})`
-}
-
-// Manually “tree shaken” from:
-// <https://github.com/nodejs/node/blob/7c3dce0/lib/internal/modules/package_json_reader.js>
-// Last checked on: Apr 29, 2023.
-// Removed the native dependency.
-// Also: no need to cache, we do that in resolve already.
-
-
-const hasOwnProperty$1 = {}.hasOwnProperty;
-
-const {ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1} = codes;
-
-/** @type {Map<string, PackageConfig>} */
-const cache = new Map();
-
-/**
- * @param {string} jsonPath
- * @param {{specifier: URL | string, base?: URL}} options
- * @returns {PackageConfig}
- */
-function read(jsonPath, {base, specifier}) {
-  const existing = cache.get(jsonPath);
-
-  if (existing) {
-    return existing
-  }
-
-  /** @type {string | undefined} */
-  let string;
-
-  try {
-    string = fs$8.readFileSync(path$8.toNamespacedPath(jsonPath), 'utf8');
-  } catch (error) {
-    const exception = /** @type {ErrnoException} */ (error);
-
-    if (exception.code !== 'ENOENT') {
-      throw exception
-    }
-  }
-
-  /** @type {PackageConfig} */
-  const result = {
-    exists: false,
-    pjsonPath: jsonPath,
-    main: undefined,
-    name: undefined,
-    type: 'none', // Ignore unknown types for forwards compatibility
-    exports: undefined,
-    imports: undefined
-  };
-
-  if (string !== undefined) {
-    /** @type {Record<string, unknown>} */
-    let parsed;
-
-    try {
-      parsed = JSON.parse(string);
-    } catch (error_) {
-      const cause = /** @type {ErrnoException} */ (error_);
-      const error = new ERR_INVALID_PACKAGE_CONFIG$1(
-        jsonPath,
-        (base ? `"${specifier}" from ` : '') + fileURLToPath$1(base || specifier),
-        cause.message
-      );
-      error.cause = cause;
-      throw error
-    }
-
-    result.exists = true;
-
-    if (
-      hasOwnProperty$1.call(parsed, 'name') &&
-      typeof parsed.name === 'string'
-    ) {
-      result.name = parsed.name;
-    }
-
-    if (
-      hasOwnProperty$1.call(parsed, 'main') &&
-      typeof parsed.main === 'string'
-    ) {
-      result.main = parsed.main;
-    }
-
-    if (hasOwnProperty$1.call(parsed, 'exports')) {
-      // @ts-expect-error: assume valid.
-      result.exports = parsed.exports;
-    }
-
-    if (hasOwnProperty$1.call(parsed, 'imports')) {
-      // @ts-expect-error: assume valid.
-      result.imports = parsed.imports;
-    }
-
-    // Ignore unknown types for forwards compatibility
-    if (
-      hasOwnProperty$1.call(parsed, 'type') &&
-      (parsed.type === 'commonjs' || parsed.type === 'module')
-    ) {
-      result.type = parsed.type;
-    }
-  }
-
-  cache.set(jsonPath, result);
-
-  return result
-}
-
-/**
- * @param {URL | string} resolved
- * @returns {PackageConfig}
- */
-function getPackageScopeConfig(resolved) {
-  // Note: in Node, this is now a native module.
-  let packageJSONUrl = new URL('package.json', resolved);
-
-  while (true) {
-    const packageJSONPath = packageJSONUrl.pathname;
-    if (packageJSONPath.endsWith('node_modules/package.json')) {
-      break
-    }
-
-    const packageConfig = read(fileURLToPath$1(packageJSONUrl), {
-      specifier: resolved
-    });
-
-    if (packageConfig.exists) {
-      return packageConfig
-    }
-
-    const lastPackageJSONUrl = packageJSONUrl;
-    packageJSONUrl = new URL('../package.json', packageJSONUrl);
-
-    // Terminates at root where ../package.json equals ../../package.json
-    // (can't just check "/package.json" for Windows support).
-    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
-      break
-    }
-  }
-
-  const packageJSONPath = fileURLToPath$1(packageJSONUrl);
-  // ^^ Note: in Node, this is now a native module.
-
-  return {
-    pjsonPath: packageJSONPath,
-    exists: false,
-    type: 'none'
-  }
-}
-
-/**
- * Returns the package type for a given URL.
- * @param {URL} url - The URL to get the package type for.
- * @returns {PackageType}
- */
-function getPackageType(url) {
-  // To do @anonrig: Write a C++ function that returns only "type".
-  return getPackageScopeConfig(url).type
-}
-
-// Manually “tree shaken” from:
-// <https://github.com/nodejs/node/blob/7c3dce0/lib/internal/modules/esm/get_format.js>
-// Last checked on: Apr 29, 2023.
-
-
-const {ERR_UNKNOWN_FILE_EXTENSION} = codes;
-
-const hasOwnProperty = {}.hasOwnProperty;
-
-/** @type {Record<string, string>} */
-const extensionFormatMap = {
-  // @ts-expect-error: hush.
-  __proto__: null,
-  '.cjs': 'commonjs',
-  '.js': 'module',
-  '.json': 'json',
-  '.mjs': 'module'
-};
-
-/**
- * @param {string | null} mime
- * @returns {string | null}
- */
-function mimeToFormat(mime) {
-  if (
-    mime &&
-    /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime)
-  )
-    return 'module'
-  if (mime === 'application/json') return 'json'
-  return null
-}
-
-/**
- * @callback ProtocolHandler
- * @param {URL} parsed
- * @param {{parentURL: string, source?: Buffer}} context
- * @param {boolean} ignoreErrors
- * @returns {string | null | void}
- */
-
-/**
- * @type {Record<string, ProtocolHandler>}
- */
-const protocolHandlers = {
-  // @ts-expect-error: hush.
-  __proto__: null,
-  'data:': getDataProtocolModuleFormat,
-  'file:': getFileProtocolModuleFormat,
-  'http:': getHttpProtocolModuleFormat,
-  'https:': getHttpProtocolModuleFormat,
-  'node:'() {
-    return 'builtin'
-  }
-};
-
-/**
- * @param {URL} parsed
- */
-function getDataProtocolModuleFormat(parsed) {
-  const {1: mime} = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
-    parsed.pathname
-  ) || [null, null, null];
-  return mimeToFormat(mime)
-}
-
-/**
- * Returns the file extension from a URL.
- *
- * Should give similar result to
- * `require('node:path').extname(require('node:url').fileURLToPath(url))`
- * when used with a `file:` URL.
- *
- * @param {URL} url
- * @returns {string}
- */
-function extname(url) {
-  const pathname = url.pathname;
-  let index = pathname.length;
-
-  while (index--) {
-    const code = pathname.codePointAt(index);
-
-    if (code === 47 /* `/` */) {
-      return ''
-    }
-
-    if (code === 46 /* `.` */) {
-      return pathname.codePointAt(index - 1) === 47 /* `/` */
-        ? ''
-        : pathname.slice(index)
-    }
-  }
-
-  return ''
-}
-
-/**
- * @type {ProtocolHandler}
- */
-function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
-  const value = extname(url);
-
-  if (value === '.js') {
-    const packageType = getPackageType(url);
-
-    if (packageType !== 'none') {
-      return packageType
-    }
-
-    return 'commonjs'
-  }
-
-  if (value === '') {
-    const packageType = getPackageType(url);
-
-    // Legacy behavior
-    if (packageType === 'none' || packageType === 'commonjs') {
-      return 'commonjs'
-    }
-
-    // Note: we don’t implement WASM, so we don’t need
-    // `getFormatOfExtensionlessFile` from `formats`.
-    return 'module'
-  }
-
-  const format = extensionFormatMap[value];
-  if (format) return format
-
-  // Explicit undefined return indicates load hook should rerun format check
-  if (ignoreErrors) {
-    return undefined
-  }
-
-  const filepath = fileURLToPath$1(url);
-  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath)
-}
-
-function getHttpProtocolModuleFormat() {
-  // To do: HTTPS imports.
-}
-
-/**
- * @param {URL} url
- * @param {{parentURL: string}} context
- * @returns {string | null}
- */
-function defaultGetFormatWithoutErrors(url, context) {
-  const protocol = url.protocol;
-
-  if (!hasOwnProperty.call(protocolHandlers, protocol)) {
-    return null
-  }
-
-  return protocolHandlers[protocol](url, context, true) || null
-}
-
-// Manually “tree shaken” from:
-// <https://github.com/nodejs/node/blob/81a9a97/lib/internal/modules/esm/resolve.js>
-// Last checked on: Apr 29, 2023.
-
-
-const RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
-
-const {
-  ERR_NETWORK_IMPORT_DISALLOWED,
-  ERR_INVALID_MODULE_SPECIFIER,
-  ERR_INVALID_PACKAGE_CONFIG,
-  ERR_INVALID_PACKAGE_TARGET,
-  ERR_MODULE_NOT_FOUND,
-  ERR_PACKAGE_IMPORT_NOT_DEFINED,
-  ERR_PACKAGE_PATH_NOT_EXPORTED,
-  ERR_UNSUPPORTED_DIR_IMPORT,
-  ERR_UNSUPPORTED_RESOLVE_REQUEST
-} = codes;
-
-const own = {}.hasOwnProperty;
-
-const invalidSegmentRegEx =
-  /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
-const deprecatedInvalidSegmentRegEx =
-  /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
-const invalidPackageNameRegEx = /^\.|%|\\/;
-const patternRegEx = /\*/g;
-const encodedSeparatorRegEx = /%2f|%5c/i;
-/** @type {Set<string>} */
-const emittedPackageWarnings = new Set();
-
-const doubleSlashRegEx = /[/\\]{2}/;
-
-/**
- *
- * @param {string} target
- * @param {string} request
- * @param {string} match
- * @param {URL} packageJsonUrl
- * @param {boolean} internal
- * @param {URL} base
- * @param {boolean} isTarget
- */
-function emitInvalidSegmentDeprecation(
-  target,
-  request,
-  match,
-  packageJsonUrl,
-  internal,
-  base,
-  isTarget
-) {
-  // @ts-expect-error: apparently it does exist, TS.
-  if (process$1.noDeprecation) {
-    return
-  }
-
-  const pjsonPath = fileURLToPath$1(packageJsonUrl);
-  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
-  process$1.emitWarning(
-    `Use of deprecated ${
-      double ? 'double slash' : 'leading or trailing slash matching'
-    } resolving "${target}" for module ` +
-      `request "${request}" ${
-        request === match ? '' : `matched to "${match}" `
-      }in the "${
-        internal ? 'imports' : 'exports'
-      }" field module resolution of the package at ${pjsonPath}${
-        base ? ` imported from ${fileURLToPath$1(base)}` : ''
-      }.`,
-    'DeprecationWarning',
-    'DEP0166'
-  );
-}
-
-/**
- * @param {URL} url
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @param {string} [main]
- * @returns {void}
- */
-function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
-  // @ts-expect-error: apparently it does exist, TS.
-  if (process$1.noDeprecation) {
-    return
-  }
-
-  const format = defaultGetFormatWithoutErrors(url, {parentURL: base.href});
-  if (format !== 'module') return
-  const urlPath = fileURLToPath$1(url.href);
-  const packagePath = fileURLToPath$1(new URL$2('.', packageJsonUrl));
-  const basePath = fileURLToPath$1(base);
-  if (!main) {
-    process$1.emitWarning(
-      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
-        packagePath.length
-      )}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`,
-      'DeprecationWarning',
-      'DEP0151'
-    );
-  } else if (path$8.resolve(packagePath, main) !== urlPath) {
-    process$1.emitWarning(
-      `Package ${packagePath} has a "main" field set to "${main}", ` +
-        `excluding the full filename and extension to the resolved file at "${urlPath.slice(
-          packagePath.length
-        )}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is ` +
-        'deprecated for ES modules.',
-      'DeprecationWarning',
-      'DEP0151'
-    );
-  }
-}
-
-/**
- * @param {string} path
- * @returns {Stats | undefined}
- */
-function tryStatSync(path) {
-  // Note: from Node 15 onwards we can use `throwIfNoEntry: false` instead.
-  try {
-    return statSync$1(path)
-  } catch {
-    // Note: in Node code this returns `new Stats`,
-    // but in Node 22 that’s marked as a deprecated internal API.
-    // Which, well, we kinda are, but still to prevent that warning,
-    // just yield `undefined`.
-  }
-}
-
-/**
- * Legacy CommonJS main resolution:
- * 1. let M = pkg_url + (json main field)
- * 2. TRY(M, M.js, M.json, M.node)
- * 3. TRY(M/index.js, M/index.json, M/index.node)
- * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
- * 5. NOT_FOUND
- *
- * @param {URL} url
- * @returns {boolean}
- */
-function fileExists(url) {
-  const stats = statSync$1(url, {throwIfNoEntry: false});
-  const isFile = stats ? stats.isFile() : undefined;
-  return isFile === null || isFile === undefined ? false : isFile
-}
-
-/**
- * @param {URL} packageJsonUrl
- * @param {PackageConfig} packageConfig
- * @param {URL} base
- * @returns {URL}
- */
-function legacyMainResolve(packageJsonUrl, packageConfig, base) {
-  /** @type {URL | undefined} */
-  let guess;
-  if (packageConfig.main !== undefined) {
-    guess = new URL$2(packageConfig.main, packageJsonUrl);
-    // Note: fs check redundances will be handled by Descriptor cache here.
-    if (fileExists(guess)) return guess
-
-    const tries = [
-      `./${packageConfig.main}.js`,
-      `./${packageConfig.main}.json`,
-      `./${packageConfig.main}.node`,
-      `./${packageConfig.main}/index.js`,
-      `./${packageConfig.main}/index.json`,
-      `./${packageConfig.main}/index.node`
-    ];
-    let i = -1;
-
-    while (++i < tries.length) {
-      guess = new URL$2(tries[i], packageJsonUrl);
-      if (fileExists(guess)) break
-      guess = undefined;
-    }
-
-    if (guess) {
-      emitLegacyIndexDeprecation(
-        guess,
-        packageJsonUrl,
-        base,
-        packageConfig.main
-      );
-      return guess
-    }
-    // Fallthrough.
-  }
-
-  const tries = ['./index.js', './index.json', './index.node'];
-  let i = -1;
-
-  while (++i < tries.length) {
-    guess = new URL$2(tries[i], packageJsonUrl);
-    if (fileExists(guess)) break
-    guess = undefined;
-  }
-
-  if (guess) {
-    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
-    return guess
-  }
-
-  // Not found.
-  throw new ERR_MODULE_NOT_FOUND(
-    fileURLToPath$1(new URL$2('.', packageJsonUrl)),
-    fileURLToPath$1(base)
-  )
-}
-
-/**
- * @param {URL} resolved
- * @param {URL} base
- * @param {boolean} [preserveSymlinks]
- * @returns {URL}
- */
-function finalizeResolution(resolved, base, preserveSymlinks) {
-  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
-    throw new ERR_INVALID_MODULE_SPECIFIER(
-      resolved.pathname,
-      'must not include encoded "/" or "\\" characters',
-      fileURLToPath$1(base)
-    )
-  }
-
-  /** @type {string} */
-  let filePath;
-
-  try {
-    filePath = fileURLToPath$1(resolved);
-  } catch (error) {
-    const cause = /** @type {ErrnoException} */ (error);
-    Object.defineProperty(cause, 'input', {value: String(resolved)});
-    Object.defineProperty(cause, 'module', {value: String(base)});
-    throw cause
-  }
-
-  const stats = tryStatSync(
-    filePath.endsWith('/') ? filePath.slice(-1) : filePath
-  );
-
-  if (stats && stats.isDirectory()) {
-    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath$1(base));
-    // @ts-expect-error Add this for `import.meta.resolve`.
-    error.url = String(resolved);
-    throw error
-  }
-
-  if (!stats || !stats.isFile()) {
-    const error = new ERR_MODULE_NOT_FOUND(
-      filePath || resolved.pathname,
-      base && fileURLToPath$1(base),
-      true
-    );
-    // @ts-expect-error Add this for `import.meta.resolve`.
-    error.url = String(resolved);
-    throw error
-  }
-
-  {
-    const real = realpathSync(filePath);
-    const {search, hash} = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path$8.sep) ? '/' : ''));
-    resolved.search = search;
-    resolved.hash = hash;
-  }
-
-  return resolved
-}
-
-/**
- * @param {string} specifier
- * @param {URL | undefined} packageJsonUrl
- * @param {URL} base
- * @returns {Error}
- */
-function importNotDefined(specifier, packageJsonUrl, base) {
-  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
-    specifier,
-    packageJsonUrl && fileURLToPath$1(new URL$2('.', packageJsonUrl)),
-    fileURLToPath$1(base)
-  )
-}
-
-/**
- * @param {string} subpath
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @returns {Error}
- */
-function exportsNotFound(subpath, packageJsonUrl, base) {
-  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    fileURLToPath$1(new URL$2('.', packageJsonUrl)),
-    subpath,
-    base && fileURLToPath$1(base)
-  )
-}
-
-/**
- * @param {string} request
- * @param {string} match
- * @param {URL} packageJsonUrl
- * @param {boolean} internal
- * @param {URL} [base]
- * @returns {never}
- */
-function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
-  const reason = `request is not a valid match in pattern "${match}" for the "${
-    internal ? 'imports' : 'exports'
-  }" resolution of ${fileURLToPath$1(packageJsonUrl)}`;
-  throw new ERR_INVALID_MODULE_SPECIFIER(
-    request,
-    reason,
-    base && fileURLToPath$1(base)
-  )
-}
-
-/**
- * @param {string} subpath
- * @param {unknown} target
- * @param {URL} packageJsonUrl
- * @param {boolean} internal
- * @param {URL} [base]
- * @returns {Error}
- */
-function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
-  target =
-    typeof target === 'object' && target !== null
-      ? JSON.stringify(target, null, '')
-      : `${target}`;
-
-  return new ERR_INVALID_PACKAGE_TARGET(
-    fileURLToPath$1(new URL$2('.', packageJsonUrl)),
-    subpath,
-    target,
-    internal,
-    base && fileURLToPath$1(base)
-  )
-}
-
-/**
- * @param {string} target
- * @param {string} subpath
- * @param {string} match
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @param {boolean} pattern
- * @param {boolean} internal
- * @param {boolean} isPathMap
- * @param {Set<string> | undefined} conditions
- * @returns {URL}
- */
-function resolvePackageTargetString(
-  target,
-  subpath,
-  match,
-  packageJsonUrl,
-  base,
-  pattern,
-  internal,
-  isPathMap,
-  conditions
-) {
-  if (subpath !== '' && !pattern && target[target.length - 1] !== '/')
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
-
-  if (!target.startsWith('./')) {
-    if (internal && !target.startsWith('../') && !target.startsWith('/')) {
-      let isURL = false;
-
-      try {
-        new URL$2(target);
-        isURL = true;
-      } catch {
-        // Continue regardless of error.
-      }
-
-      if (!isURL) {
-        const exportTarget = pattern
-          ? RegExpPrototypeSymbolReplace.call(
-              patternRegEx,
-              target,
-              () => subpath
-            )
-          : target + subpath;
-
-        return packageResolve(exportTarget, packageJsonUrl, conditions)
-      }
-    }
-
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
-  }
-
-  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
-    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
-      if (!isPathMap) {
-        const request = pattern
-          ? match.replace('*', () => subpath)
-          : match + subpath;
-        const resolvedTarget = pattern
-          ? RegExpPrototypeSymbolReplace.call(
-              patternRegEx,
-              target,
-              () => subpath
-            )
-          : target;
-        emitInvalidSegmentDeprecation(
-          resolvedTarget,
-          request,
-          match,
-          packageJsonUrl,
-          internal,
-          base,
-          true
-        );
-      }
-    } else {
-      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
-    }
-  }
-
-  const resolved = new URL$2(target, packageJsonUrl);
-  const resolvedPath = resolved.pathname;
-  const packagePath = new URL$2('.', packageJsonUrl).pathname;
-
-  if (!resolvedPath.startsWith(packagePath))
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base)
-
-  if (subpath === '') return resolved
-
-  if (invalidSegmentRegEx.exec(subpath) !== null) {
-    const request = pattern
-      ? match.replace('*', () => subpath)
-      : match + subpath;
-    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
-      if (!isPathMap) {
-        const resolvedTarget = pattern
-          ? RegExpPrototypeSymbolReplace.call(
-              patternRegEx,
-              target,
-              () => subpath
-            )
-          : target;
-        emitInvalidSegmentDeprecation(
-          resolvedTarget,
-          request,
-          match,
-          packageJsonUrl,
-          internal,
-          base,
-          false
-        );
-      }
-    } else {
-      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
-    }
-  }
-
-  if (pattern) {
-    return new URL$2(
-      RegExpPrototypeSymbolReplace.call(
-        patternRegEx,
-        resolved.href,
-        () => subpath
-      )
-    )
-  }
-
-  return new URL$2(subpath, resolved)
-}
-
-/**
- * @param {string} key
- * @returns {boolean}
- */
-function isArrayIndex(key) {
-  const keyNumber = Number(key);
-  if (`${keyNumber}` !== key) return false
-  return keyNumber >= 0 && keyNumber < 0xff_ff_ff_ff
-}
-
-/**
- * @param {URL} packageJsonUrl
- * @param {unknown} target
- * @param {string} subpath
- * @param {string} packageSubpath
- * @param {URL} base
- * @param {boolean} pattern
- * @param {boolean} internal
- * @param {boolean} isPathMap
- * @param {Set<string> | undefined} conditions
- * @returns {URL | null}
- */
-function resolvePackageTarget(
-  packageJsonUrl,
-  target,
-  subpath,
-  packageSubpath,
-  base,
-  pattern,
-  internal,
-  isPathMap,
-  conditions
-) {
-  if (typeof target === 'string') {
-    return resolvePackageTargetString(
-      target,
-      subpath,
-      packageSubpath,
-      packageJsonUrl,
-      base,
-      pattern,
-      internal,
-      isPathMap,
-      conditions
-    )
-  }
-
-  if (Array.isArray(target)) {
-    /** @type {Array<unknown>} */
-    const targetList = target;
-    if (targetList.length === 0) return null
-
-    /** @type {ErrnoException | null | undefined} */
-    let lastException;
-    let i = -1;
-
-    while (++i < targetList.length) {
-      const targetItem = targetList[i];
-      /** @type {URL | null} */
-      let resolveResult;
-      try {
-        resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          targetItem,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          isPathMap,
-          conditions
-        );
-      } catch (error) {
-        const exception = /** @type {ErrnoException} */ (error);
-        lastException = exception;
-        if (exception.code === 'ERR_INVALID_PACKAGE_TARGET') continue
-        throw error
-      }
-
-      if (resolveResult === undefined) continue
-
-      if (resolveResult === null) {
-        lastException = null;
-        continue
-      }
-
-      return resolveResult
-    }
-
-    if (lastException === undefined || lastException === null) {
-      return null
-    }
-
-    throw lastException
-  }
-
-  if (typeof target === 'object' && target !== null) {
-    const keys = Object.getOwnPropertyNames(target);
-    let i = -1;
-
-    while (++i < keys.length) {
-      const key = keys[i];
-      if (isArrayIndex(key)) {
-        throw new ERR_INVALID_PACKAGE_CONFIG(
-          fileURLToPath$1(packageJsonUrl),
-          base,
-          '"exports" cannot contain numeric property keys.'
-        )
-      }
-    }
-
-    i = -1;
-
-    while (++i < keys.length) {
-      const key = keys[i];
-      if (key === 'default' || (conditions && conditions.has(key))) {
-        // @ts-expect-error: indexable.
-        const conditionalTarget = /** @type {unknown} */ (target[key]);
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          conditionalTarget,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          isPathMap,
-          conditions
-        );
-        if (resolveResult === undefined) continue
-        return resolveResult
-      }
-    }
-
-    return null
-  }
-
-  if (target === null) {
-    return null
-  }
-
-  throw invalidPackageTarget(
-    packageSubpath,
-    target,
-    packageJsonUrl,
-    internal,
-    base
-  )
-}
-
-/**
- * @param {unknown} exports
- * @param {URL} packageJsonUrl
- * @param {URL} base
- * @returns {boolean}
- */
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-  if (typeof exports === 'string' || Array.isArray(exports)) return true
-  if (typeof exports !== 'object' || exports === null) return false
-
-  const keys = Object.getOwnPropertyNames(exports);
-  let isConditionalSugar = false;
-  let i = 0;
-  let keyIndex = -1;
-  while (++keyIndex < keys.length) {
-    const key = keys[keyIndex];
-    const currentIsConditionalSugar = key === '' || key[0] !== '.';
-    if (i++ === 0) {
-      isConditionalSugar = currentIsConditionalSugar;
-    } else if (isConditionalSugar !== currentIsConditionalSugar) {
-      throw new ERR_INVALID_PACKAGE_CONFIG(
-        fileURLToPath$1(packageJsonUrl),
-        base,
-        '"exports" cannot contain some keys starting with \'.\' and some not.' +
-          ' The exports object must either be an object of package subpath keys' +
-          ' or an object of main entry condition name keys only.'
-      )
-    }
-  }
-
-  return isConditionalSugar
-}
-
-/**
- * @param {string} match
- * @param {URL} pjsonUrl
- * @param {URL} base
- */
-function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
-  // @ts-expect-error: apparently it does exist, TS.
-  if (process$1.noDeprecation) {
-    return
-  }
-
-  const pjsonPath = fileURLToPath$1(pjsonUrl);
-  if (emittedPackageWarnings.has(pjsonPath + '|' + match)) return
-  emittedPackageWarnings.add(pjsonPath + '|' + match);
-  process$1.emitWarning(
-    `Use of deprecated trailing slash pattern mapping "${match}" in the ` +
-      `"exports" field module resolution of the package at ${pjsonPath}${
-        base ? ` imported from ${fileURLToPath$1(base)}` : ''
-      }. Mapping specifiers ending in "/" is no longer supported.`,
-    'DeprecationWarning',
-    'DEP0155'
-  );
-}
-
-/**
- * @param {URL} packageJsonUrl
- * @param {string} packageSubpath
- * @param {Record<string, unknown>} packageConfig
- * @param {URL} base
- * @param {Set<string> | undefined} conditions
- * @returns {URL}
- */
-function packageExportsResolve(
-  packageJsonUrl,
-  packageSubpath,
-  packageConfig,
-  base,
-  conditions
-) {
-  let exports = packageConfig.exports;
-
-  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
-    exports = {'.': exports};
-  }
-
-  if (
-    own.call(exports, packageSubpath) &&
-    !packageSubpath.includes('*') &&
-    !packageSubpath.endsWith('/')
-  ) {
-    // @ts-expect-error: indexable.
-    const target = exports[packageSubpath];
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      '',
-      packageSubpath,
-      base,
-      false,
-      false,
-      false,
-      conditions
-    );
-    if (resolveResult === null || resolveResult === undefined) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base)
-    }
-
-    return resolveResult
-  }
-
-  let bestMatch = '';
-  let bestMatchSubpath = '';
-  const keys = Object.getOwnPropertyNames(exports);
-  let i = -1;
-
-  while (++i < keys.length) {
-    const key = keys[i];
-    const patternIndex = key.indexOf('*');
-
-    if (
-      patternIndex !== -1 &&
-      packageSubpath.startsWith(key.slice(0, patternIndex))
-    ) {
-      // When this reaches EOL, this can throw at the top of the whole function:
-      //
-      // if (StringPrototypeEndsWith(packageSubpath, '/'))
-      //   throwInvalidSubpath(packageSubpath)
-      //
-      // To match "imports" and the spec.
-      if (packageSubpath.endsWith('/')) {
-        emitTrailingSlashPatternDeprecation(
-          packageSubpath,
-          packageJsonUrl,
-          base
-        );
-      }
-
-      const patternTrailer = key.slice(patternIndex + 1);
-
-      if (
-        packageSubpath.length >= key.length &&
-        packageSubpath.endsWith(patternTrailer) &&
-        patternKeyCompare(bestMatch, key) === 1 &&
-        key.lastIndexOf('*') === patternIndex
-      ) {
-        bestMatch = key;
-        bestMatchSubpath = packageSubpath.slice(
-          patternIndex,
-          packageSubpath.length - patternTrailer.length
-        );
-      }
-    }
-  }
-
-  if (bestMatch) {
-    // @ts-expect-error: indexable.
-    const target = /** @type {unknown} */ (exports[bestMatch]);
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      bestMatchSubpath,
-      bestMatch,
-      base,
-      true,
-      false,
-      packageSubpath.endsWith('/'),
-      conditions
-    );
-
-    if (resolveResult === null || resolveResult === undefined) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base)
-    }
-
-    return resolveResult
-  }
-
-  throw exportsNotFound(packageSubpath, packageJsonUrl, base)
-}
-
-/**
- * @param {string} a
- * @param {string} b
- */
-function patternKeyCompare(a, b) {
-  const aPatternIndex = a.indexOf('*');
-  const bPatternIndex = b.indexOf('*');
-  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
-  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
-  if (baseLengthA > baseLengthB) return -1
-  if (baseLengthB > baseLengthA) return 1
-  if (aPatternIndex === -1) return 1
-  if (bPatternIndex === -1) return -1
-  if (a.length > b.length) return -1
-  if (b.length > a.length) return 1
-  return 0
-}
-
-/**
- * @param {string} name
- * @param {URL} base
- * @param {Set<string>} [conditions]
- * @returns {URL}
- */
-function packageImportsResolve(name, base, conditions) {
-  if (name === '#' || name.startsWith('#/') || name.endsWith('/')) {
-    const reason = 'is not a valid internal imports specifier name';
-    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath$1(base))
-  }
-
-  /** @type {URL | undefined} */
-  let packageJsonUrl;
-
-  const packageConfig = getPackageScopeConfig(base);
-
-  if (packageConfig.exists) {
-    packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
-    const imports = packageConfig.imports;
-    if (imports) {
-      if (own.call(imports, name) && !name.includes('*')) {
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          imports[name],
-          '',
-          name,
-          base,
-          false,
-          true,
-          false,
-          conditions
-        );
-        if (resolveResult !== null && resolveResult !== undefined) {
-          return resolveResult
-        }
-      } else {
-        let bestMatch = '';
-        let bestMatchSubpath = '';
-        const keys = Object.getOwnPropertyNames(imports);
-        let i = -1;
-
-        while (++i < keys.length) {
-          const key = keys[i];
-          const patternIndex = key.indexOf('*');
-
-          if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
-            const patternTrailer = key.slice(patternIndex + 1);
-            if (
-              name.length >= key.length &&
-              name.endsWith(patternTrailer) &&
-              patternKeyCompare(bestMatch, key) === 1 &&
-              key.lastIndexOf('*') === patternIndex
-            ) {
-              bestMatch = key;
-              bestMatchSubpath = name.slice(
-                patternIndex,
-                name.length - patternTrailer.length
-              );
-            }
-          }
-        }
-
-        if (bestMatch) {
-          const target = imports[bestMatch];
-          const resolveResult = resolvePackageTarget(
-            packageJsonUrl,
-            target,
-            bestMatchSubpath,
-            bestMatch,
-            base,
-            true,
-            true,
-            false,
-            conditions
-          );
-
-          if (resolveResult !== null && resolveResult !== undefined) {
-            return resolveResult
-          }
-        }
-      }
-    }
-  }
-
-  throw importNotDefined(name, packageJsonUrl, base)
-}
-
-/**
- * @param {string} specifier
- * @param {URL} base
- */
-function parsePackageName(specifier, base) {
-  let separatorIndex = specifier.indexOf('/');
-  let validPackageName = true;
-  let isScoped = false;
-  if (specifier[0] === '@') {
-    isScoped = true;
-    if (separatorIndex === -1 || specifier.length === 0) {
-      validPackageName = false;
-    } else {
-      separatorIndex = specifier.indexOf('/', separatorIndex + 1);
-    }
-  }
-
-  const packageName =
-    separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
-
-  // Package name cannot have leading . and cannot have percent-encoding or
-  // \\ separators.
-  if (invalidPackageNameRegEx.exec(packageName) !== null) {
-    validPackageName = false;
-  }
-
-  if (!validPackageName) {
-    throw new ERR_INVALID_MODULE_SPECIFIER(
-      specifier,
-      'is not a valid package name',
-      fileURLToPath$1(base)
-    )
-  }
-
-  const packageSubpath =
-    '.' + (separatorIndex === -1 ? '' : specifier.slice(separatorIndex));
-
-  return {packageName, packageSubpath, isScoped}
-}
-
-/**
- * @param {string} specifier
- * @param {URL} base
- * @param {Set<string> | undefined} conditions
- * @returns {URL}
- */
-function packageResolve(specifier, base, conditions) {
-  if (builtinModules.includes(specifier)) {
-    return new URL$2('node:' + specifier)
-  }
-
-  const {packageName, packageSubpath, isScoped} = parsePackageName(
-    specifier,
-    base
-  );
-
-  // ResolveSelf
-  const packageConfig = getPackageScopeConfig(base);
-
-  // Can’t test.
-  /* c8 ignore next 16 */
-  if (packageConfig.exists) {
-    const packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
-    if (
-      packageConfig.name === packageName &&
-      packageConfig.exports !== undefined &&
-      packageConfig.exports !== null
-    ) {
-      return packageExportsResolve(
-        packageJsonUrl,
-        packageSubpath,
-        packageConfig,
-        base,
-        conditions
-      )
-    }
-  }
-
-  let packageJsonUrl = new URL$2(
-    './node_modules/' + packageName + '/package.json',
-    base
-  );
-  let packageJsonPath = fileURLToPath$1(packageJsonUrl);
-  /** @type {string} */
-  let lastPath;
-  do {
-    const stat = tryStatSync(packageJsonPath.slice(0, -13));
-    if (!stat || !stat.isDirectory()) {
-      lastPath = packageJsonPath;
-      packageJsonUrl = new URL$2(
-        (isScoped ? '../../../../node_modules/' : '../../../node_modules/') +
-          packageName +
-          '/package.json',
-        packageJsonUrl
-      );
-      packageJsonPath = fileURLToPath$1(packageJsonUrl);
-      continue
-    }
-
-    // Package match.
-    const packageConfig = read(packageJsonPath, {base, specifier});
-    if (packageConfig.exports !== undefined && packageConfig.exports !== null) {
-      return packageExportsResolve(
-        packageJsonUrl,
-        packageSubpath,
-        packageConfig,
-        base,
-        conditions
-      )
-    }
-
-    if (packageSubpath === '.') {
-      return legacyMainResolve(packageJsonUrl, packageConfig, base)
-    }
-
-    return new URL$2(packageSubpath, packageJsonUrl)
-    // Cross-platform root check.
-  } while (packageJsonPath.length !== lastPath.length)
-
-  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath$1(base), false)
-}
-
-/**
- * @param {string} specifier
- * @returns {boolean}
- */
-function isRelativeSpecifier(specifier) {
-  if (specifier[0] === '.') {
-    if (specifier.length === 1 || specifier[1] === '/') return true
-    if (
-      specifier[1] === '.' &&
-      (specifier.length === 2 || specifier[2] === '/')
-    ) {
-      return true
-    }
-  }
-
-  return false
-}
-
-/**
- * @param {string} specifier
- * @returns {boolean}
- */
-function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
-  if (specifier === '') return false
-  if (specifier[0] === '/') return true
-  return isRelativeSpecifier(specifier)
-}
-
-/**
- * The “Resolver Algorithm Specification” as detailed in the Node docs (which is
- * sync and slightly lower-level than `resolve`).
- *
- * @param {string} specifier
- *   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
- * @param {URL} base
- *   Full URL (to a file) that `specifier` is resolved relative from.
- * @param {Set<string>} [conditions]
- *   Conditions.
- * @param {boolean} [preserveSymlinks]
- *   Keep symlinks instead of resolving them.
- * @returns {URL}
- *   A URL object to the found thing.
- */
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
-  // Note: The Node code supports `base` as a string (in this internal API) too,
-  // we don’t.
-  const protocol = base.protocol;
-  const isData = protocol === 'data:';
-  const isRemote = isData || protocol === 'http:' || protocol === 'https:';
-  // Order swapped from spec for minor perf gain.
-  // Ok since relative URLs cannot parse as URLs.
-  /** @type {URL | undefined} */
-  let resolved;
-
-  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    try {
-      resolved = new URL$2(specifier, base);
-    } catch (error_) {
-      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-      error.cause = error_;
-      throw error
-    }
-  } else if (protocol === 'file:' && specifier[0] === '#') {
-    resolved = packageImportsResolve(specifier, base, conditions);
-  } else {
-    try {
-      resolved = new URL$2(specifier);
-    } catch (error_) {
-      // Note: actual code uses `canBeRequiredWithoutScheme`.
-      if (isRemote && !builtinModules.includes(specifier)) {
-        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-        error.cause = error_;
-        throw error
-      }
-
-      resolved = packageResolve(specifier, base, conditions);
-    }
-  }
-
-  assert(resolved !== undefined, 'expected to be defined');
-
-  if (resolved.protocol !== 'file:') {
-    return resolved
-  }
-
-  return finalizeResolution(resolved, base)
-}
-
-function fileURLToPath(id) {
-  if (typeof id === "string" && !id.startsWith("file://")) {
-    return normalizeSlash(id);
-  }
-  return normalizeSlash(fileURLToPath$1(id));
-}
-function pathToFileURL(id) {
-  return pathToFileURL$1(fileURLToPath(id)).toString();
-}
-function normalizeid(id) {
-  if (typeof id !== "string") {
-    id = id.toString();
-  }
-  if (/(node|data|http|https|file):/.test(id)) {
-    return id;
-  }
-  if (BUILTIN_MODULES.has(id)) {
-    return "node:" + id;
-  }
-  return "file://" + encodeURI(normalizeSlash(id));
-}
-
-const DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
-const DEFAULT_EXTENSIONS = [".mjs", ".cjs", ".js", ".json"];
-const NOT_FOUND_ERRORS = /* @__PURE__ */ new Set([
-  "ERR_MODULE_NOT_FOUND",
-  "ERR_UNSUPPORTED_DIR_IMPORT",
-  "MODULE_NOT_FOUND",
-  "ERR_PACKAGE_PATH_NOT_EXPORTED"
-]);
-function _tryModuleResolve(id, url, conditions) {
-  try {
-    return moduleResolve(id, url, conditions);
-  } catch (error) {
-    if (!NOT_FOUND_ERRORS.has(error?.code)) {
-      throw error;
-    }
-  }
-}
-function _resolve$1(id, options = {}) {
-  if (typeof id !== "string") {
-    if (id instanceof URL) {
-      id = fileURLToPath(id);
-    } else {
-      throw new TypeError("input must be a `string` or `URL`");
-    }
-  }
-  if (/(node|data|http|https):/.test(id)) {
-    return id;
-  }
-  if (BUILTIN_MODULES.has(id)) {
-    return "node:" + id;
-  }
-  if (id.startsWith("file://")) {
-    id = fileURLToPath(id);
-  }
-  if (isAbsolute(id)) {
-    try {
-      const stat = statSync$1(id);
-      if (stat.isFile()) {
-        return pathToFileURL(id);
-      }
-    } catch (error) {
-      if (error?.code !== "ENOENT") {
-        throw error;
-      }
-    }
-  }
-  const conditionsSet = options.conditions ? new Set(options.conditions) : DEFAULT_CONDITIONS_SET;
-  const _urls = (Array.isArray(options.url) ? options.url : [options.url]).filter(Boolean).map((url) => new URL(normalizeid(url.toString())));
-  if (_urls.length === 0) {
-    _urls.push(new URL(pathToFileURL(process.cwd())));
-  }
-  const urls = [..._urls];
-  for (const url of _urls) {
-    if (url.protocol === "file:") {
-      urls.push(
-        new URL("./", url),
-        // If url is directory
-        new URL(joinURL(url.pathname, "_index.js"), url),
-        // TODO: Remove in next major version?
-        new URL("node_modules", url)
-      );
-    }
-  }
-  let resolved;
-  for (const url of urls) {
-    resolved = _tryModuleResolve(id, url, conditionsSet);
-    if (resolved) {
-      break;
-    }
-    for (const prefix of ["", "/index"]) {
-      for (const extension of options.extensions || DEFAULT_EXTENSIONS) {
-        resolved = _tryModuleResolve(
-          id + prefix + extension,
-          url,
-          conditionsSet
-        );
-        if (resolved) {
-          break;
-        }
-      }
-      if (resolved) {
-        break;
-      }
-    }
-    if (resolved) {
-      break;
-    }
-  }
-  if (!resolved) {
-    const error = new Error(
-      `Cannot find module ${id} imported from ${urls.join(", ")}`
-    );
-    error.code = "ERR_MODULE_NOT_FOUND";
-    throw error;
-  }
-  return pathToFileURL(resolved);
-}
-function resolveSync(id, options) {
-  return _resolve$1(id, options);
-}
-function resolvePathSync(id, options) {
-  return fileURLToPath(resolveSync(id, options));
-}
-
-function _resolve(path, options = {}) {
-  if (options.platform === "auto" || !options.platform)
-    options.platform = process$1.platform === "win32" ? "win32" : "posix";
-  const modulePath = resolvePathSync(path, {
-    url: options.paths
-  });
-  if (options.platform === "win32")
-    return win32.normalize(modulePath);
-  return modulePath;
-}
-function resolveModule(name, options = {}) {
-  try {
-    return _resolve(name, options);
-  } catch (e) {
-    return void 0;
-  }
-}
-function isPackageExists(name, options = {}) {
-  return !!resolvePackage(name, options);
-}
-function resolvePackage(name, options = {}) {
-  try {
-    return _resolve(`${name}/package.json`, options);
-  } catch {
-  }
-  try {
-    return _resolve(name, options);
-  } catch (e) {
-    if (e.code !== "MODULE_NOT_FOUND" && e.code !== "ERR_MODULE_NOT_FOUND")
-      console.error(e);
-    return false;
-  }
-}
-
-const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
-const defaultExclude = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/cypress/**",
-  "**/.{idea,git,cache,output,temp}/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
-];
-const benchmarkConfigDefaults = {
-  include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
-  exclude: defaultExclude,
-  includeSource: [],
-  reporters: ["default"]
-};
-const defaultCoverageExcludes = [
-  "coverage/**",
-  "dist/**",
-  "**/node_modules/**",
-  "**/[.]**",
-  "packages/*/test?(s)/**",
-  "**/*.d.ts",
-  "**/virtual:*",
-  "**/__x00__*",
-  "**/\0*",
-  "cypress/**",
-  "test?(s)/**",
-  "test?(-*).?(c|m)[jt]s?(x)",
-  "**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
-  "**/__tests__/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
-  "**/vitest.{workspace,projects}.[jt]s?(on)",
-  "**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
-];
-const coverageConfigDefaults = {
-  provider: "v8",
-  enabled: false,
-  all: true,
-  clean: true,
-  cleanOnRerun: true,
-  reportsDirectory: "./coverage",
-  exclude: defaultCoverageExcludes,
-  reportOnFailure: false,
-  reporter: [
-    ["text", {}],
-    ["html", {}],
-    ["clover", {}],
-    ["json", {}]
-  ],
-  extension: [
-    ".js",
-    ".cjs",
-    ".mjs",
-    ".ts",
-    ".mts",
-    ".tsx",
-    ".jsx",
-    ".vue",
-    ".svelte",
-    ".marko"
-  ],
-  allowExternal: false,
-  ignoreEmptyLines: true,
-  processingConcurrency: Math.min(
-    20,
-    nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length
-  )
-};
-const fakeTimersDefaults = {
-  loopLimit: 1e4,
-  shouldClearNativeTimers: true,
-  toFake: [
-    "setTimeout",
-    "clearTimeout",
-    "setInterval",
-    "clearInterval",
-    "setImmediate",
-    "clearImmediate",
-    "Date"
-  ]
-};
-const config = {
-  allowOnly: !isCI,
-  isolate: true,
-  watch: !isCI,
-  globals: false,
-  environment: "node",
-  pool: "forks",
-  clearMocks: false,
-  restoreMocks: false,
-  mockReset: false,
-  unstubGlobals: false,
-  unstubEnvs: false,
-  include: defaultInclude,
-  exclude: defaultExclude,
-  teardownTimeout: 1e4,
-  forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
-  update: false,
-  reporters: [],
-  silent: false,
-  hideSkippedTests: false,
-  api: false,
-  ui: false,
-  uiBase: "/__vitest__/",
-  open: !isCI,
-  css: {
-    include: []
-  },
-  coverage: coverageConfigDefaults,
-  fakeTimers: fakeTimersDefaults,
-  maxConcurrency: 5,
-  dangerouslyIgnoreUnhandledErrors: false,
-  typecheck: {
-    checker: "tsc",
-    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
-    exclude: defaultExclude
-  },
-  slowTestThreshold: 300,
-  disableConsoleIntercept: false
-};
-const configDefaults = Object.freeze(config);
-
-function getWorkersCountByPercentage(percent) {
-  const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length;
-  const workersCountByPercentage = Math.round(Number.parseInt(percent) / 100 * maxWorkersCount);
-  return Math.max(1, Math.min(maxWorkersCount, workersCountByPercentage));
-}
-
-class FilesStatsCache {
-  cache = /* @__PURE__ */ new Map();
-  getStats(key) {
-    return this.cache.get(key);
-  }
-  async populateStats(root, specs) {
-    const promises = specs.map((spec) => {
-      const key = `${spec[0].getName()}:${relative(root, spec[1])}`;
-      return this.updateStats(spec[1], key);
-    });
-    await Promise.all(promises);
-  }
-  async updateStats(fsPath, key) {
-    if (!fs$8.existsSync(fsPath)) {
-      return;
-    }
-    const stats = await fs$8.promises.stat(fsPath);
-    this.cache.set(key, { size: stats.size });
-  }
-  removeStats(fsPath) {
-    this.cache.forEach((_, key) => {
-      if (key.endsWith(fsPath)) {
-        this.cache.delete(key);
-      }
-    });
-  }
-}
-
-class ResultsCache {
-  cache = /* @__PURE__ */ new Map();
-  workspacesKeyMap = /* @__PURE__ */ new Map();
-  cachePath = null;
-  version;
-  root = "/";
-  constructor(version) {
-    this.version = version;
-  }
-  getCachePath() {
-    return this.cachePath;
-  }
-  setConfig(root, config) {
-    this.root = root;
-    if (config) {
-      this.cachePath = resolve(config.dir, "results.json");
-    }
-  }
-  getResults(key) {
-    return this.cache.get(key);
-  }
-  async readFromCache() {
-    if (!this.cachePath) {
-      return;
-    }
-    if (!fs$8.existsSync(this.cachePath)) {
-      return;
-    }
-    const resultsCache = await fs$8.promises.readFile(this.cachePath, "utf8");
-    const { results, version } = JSON.parse(resultsCache || "[]");
-    if (Number(version.split(".")[1]) >= 30) {
-      this.cache = new Map(results);
-      this.version = version;
-      results.forEach(([spec]) => {
-        const [projectName, relativePath] = spec.split(":");
-        const keyMap = this.workspacesKeyMap.get(relativePath) || [];
-        keyMap.push(projectName);
-        this.workspacesKeyMap.set(relativePath, keyMap);
-      });
-    }
-  }
-  updateResults(files) {
-    files.forEach((file) => {
-      const result = file.result;
-      if (!result) {
-        return;
-      }
-      const duration = result.duration || 0;
-      const relativePath = relative(this.root, file.filepath);
-      this.cache.set(`${file.projectName || ""}:${relativePath}`, {
-        duration: duration >= 0 ? duration : 0,
-        failed: result.state === "fail"
-      });
-    });
-  }
-  removeFromCache(filepath) {
-    this.cache.forEach((_, key) => {
-      if (key.endsWith(filepath)) {
-        this.cache.delete(key);
-      }
-    });
-  }
-  async writeToCache() {
-    if (!this.cachePath) {
-      return;
-    }
-    const results = Array.from(this.cache.entries());
-    const cacheDirname = dirname(this.cachePath);
-    if (!fs$8.existsSync(cacheDirname)) {
-      await fs$8.promises.mkdir(cacheDirname, { recursive: true });
-    }
-    const cache = JSON.stringify({
-      version: this.version,
-      results
-    });
-    await fs$8.promises.writeFile(this.cachePath, cache);
-  }
-}
-
-class VitestCache {
-  results;
-  stats = new FilesStatsCache();
-  constructor(version) {
-    this.results = new ResultsCache(version);
-  }
-  getFileTestResults(key) {
-    return this.results.getResults(key);
-  }
-  getFileStats(key) {
-    return this.stats.getStats(key);
-  }
-  static resolveCacheDir(root, dir, projectName) {
-    const baseDir = slash$1(dir || "node_modules/.vite/vitest");
-    return projectName ? resolve(
-      root,
-      baseDir,
-      crypto.createHash("md5").update(projectName, "utf-8").digest("hex")
-    ) : resolve(root, baseDir);
-  }
-}
-
-function resolvePath(path, root) {
-  return normalize(
-    /* @__PURE__ */ resolveModule(path, { paths: [root] }) ?? resolve(root, path)
-  );
-}
-function parseInspector(inspect) {
-  if (typeof inspect === "boolean" || inspect === void 0) {
-    return {};
-  }
-  if (typeof inspect === "number") {
-    return { port: inspect };
-  }
-  if (inspect.match(/https?:\//)) {
-    throw new Error(
-      `Inspector host cannot be a URL. Use "host:port" instead of "${inspect}"`
-    );
-  }
-  const [host, port] = inspect.split(":");
-  if (!port) {
-    return { host };
+  addProcessTimeoutCause(cause) {
+    this.processTimeoutCauses.add(cause);
   }
-  return { host, port: Number(port) || defaultInspectPort };
-}
-function resolveApiServerConfig(options, defaultPort2) {
-  let api;
-  if (options.ui && !options.api) {
-    api = { port: defaultPort2 };
-  } else if (options.api === true) {
-    api = { port: defaultPort2 };
-  } else if (typeof options.api === "number") {
-    api = { port: options.api };
+  getProcessTimeoutCauses() {
+    return Array.from(this.processTimeoutCauses.values());
   }
-  if (typeof options.api === "object") {
-    if (api) {
-      if (options.api.port) {
-        api.port = options.api.port;
-      }
-      if (options.api.strictPort) {
-        api.strictPort = options.api.strictPort;
-      }
-      if (options.api.host) {
-        api.host = options.api.host;
-      }
-    } else {
-      api = { ...options.api };
-    }
+  getPaths() {
+    return Array.from(this.pathsSet);
   }
-  if (api) {
-    if (!api.port && !api.middlewareMode) {
-      api.port = defaultPort2;
+  /**
+   * Return files that were running or collected.
+   */
+  getFiles(keys) {
+    if (keys) {
+      return keys.map((key) => this.filesMap.get(key)).flat().filter((file) => file && !file.local);
     }
-  } else {
-    api = { middlewareMode: true };
+    return Array.from(this.filesMap.values()).flat().filter((file) => !file.local);
   }
-  return api;
-}
-function resolveInlineWorkerOption(value) {
-  if (typeof value === "string" && value.trim().endsWith("%")) {
-    return getWorkersCountByPercentage(value);
-  } else {
-    return Number(value);
+  getFilepaths() {
+    return Array.from(this.filesMap.keys());
   }
-}
-function resolveConfig(mode, options, viteConfig, logger) {
-  if (options.dom) {
-    if (viteConfig.test?.environment != null && viteConfig.test.environment !== "happy-dom") {
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(c.yellow(" Vitest "))} Your config.test.environment ("${viteConfig.test.environment}") conflicts with --dom flag ("happy-dom"), ignoring "${viteConfig.test.environment}"`
-        )
-      );
-    }
-    options.environment = "happy-dom";
+  getFailedFilepaths() {
+    return this.getFiles().filter((i) => i.result?.state === "fail").map((i) => i.filepath);
   }
-  const resolved = {
-    ...configDefaults,
-    ...options,
-    root: viteConfig.root,
-    mode
-  };
-  const inspector = resolved.inspect || resolved.inspectBrk;
-  resolved.inspector = {
-    ...resolved.inspector,
-    ...parseInspector(inspector),
-    enabled: !!inspector,
-    waitForDebugger: options.inspector?.waitForDebugger ?? !!resolved.inspectBrk
-  };
-  if (viteConfig.base !== "/") {
-    resolved.base = viteConfig.base;
+  collectPaths(paths = []) {
+    paths.forEach((path) => {
+      this.pathsSet.add(path);
+    });
   }
-  resolved.clearScreen = resolved.clearScreen ?? viteConfig.clearScreen ?? true;
-  if (options.shard) {
-    if (resolved.watch) {
-      throw new Error("You cannot use --shard option with enabled watch");
-    }
-    const [indexString, countString] = options.shard.split("/");
-    const index = Math.abs(Number.parseInt(indexString, 10));
-    const count = Math.abs(Number.parseInt(countString, 10));
-    if (Number.isNaN(count) || count <= 0) {
-      throw new Error("--shard <count> must be a positive number");
-    }
-    if (Number.isNaN(index) || index <= 0 || index > count) {
-      throw new Error(
-        "--shard <index> must be a positive number less then <count>"
+  collectFiles(project, files = []) {
+    files.forEach((file) => {
+      const existing = this.filesMap.get(file.filepath) || [];
+      const otherProject = existing.filter(
+        (i) => i.projectName !== file.projectName
       );
-    }
-    resolved.shard = { index, count };
-  }
-  if (resolved.standalone && !resolved.watch) {
-    throw new Error(`Vitest standalone mode requires --watch`);
-  }
-  if (resolved.mergeReports && resolved.watch) {
-    throw new Error(`Cannot merge reports with --watch enabled`);
-  }
-  if (resolved.maxWorkers) {
-    resolved.maxWorkers = resolveInlineWorkerOption(resolved.maxWorkers);
-  }
-  if (resolved.minWorkers) {
-    resolved.minWorkers = resolveInlineWorkerOption(resolved.minWorkers);
-  }
-  resolved.browser ??= {};
-  resolved.fileParallelism ??= mode !== "benchmark";
-  if (!resolved.fileParallelism) {
-    resolved.maxWorkers = 1;
-    resolved.minWorkers = 1;
-  }
-  if (resolved.inspect || resolved.inspectBrk) {
-    const isSingleThread = resolved.pool === "threads" && resolved.poolOptions?.threads?.singleThread;
-    const isSingleFork = resolved.pool === "forks" && resolved.poolOptions?.forks?.singleFork;
-    if (resolved.fileParallelism && !isSingleThread && !isSingleFork) {
-      const inspectOption = `--inspect${resolved.inspectBrk ? "-brk" : ""}`;
-      throw new Error(
-        `You cannot use ${inspectOption} without "--no-file-parallelism", "poolOptions.threads.singleThread" or "poolOptions.forks.singleFork"`
+      const currentFile = existing.find(
+        (i) => i.projectName === file.projectName
       );
-    }
-  }
-  if (resolved.coverage.provider === "v8" && resolved.coverage.enabled && isBrowserEnabled(resolved)) {
-    throw new Error(
-      "@vitest/coverage-v8 does not work with --browser. Use @vitest/coverage-istanbul instead"
-    );
+      if (currentFile) {
+        file.logs = currentFile.logs;
+      }
+      otherProject.push(file);
+      this.filesMap.set(file.filepath, otherProject);
+      this.updateId(file, project);
+    });
   }
-  if (resolved.coverage.enabled && resolved.coverage.reportsDirectory) {
-    const reportsDirectory = resolve(
-      resolved.root,
-      resolved.coverage.reportsDirectory
-    );
-    if (reportsDirectory === resolved.root || reportsDirectory === process.cwd()) {
-      throw new Error(
-        `You cannot set "coverage.reportsDirectory" as ${reportsDirectory}. Vitest needs to be able to remove this directory before test run`
+  clearFiles(project, paths = []) {
+    paths.forEach((path) => {
+      const files = this.filesMap.get(path);
+      const fileTask = createFileTask(
+        path,
+        project.config.root,
+        project.config.name
       );
-    }
-  }
-  if (resolved.coverage.enabled && resolved.coverage.provider === "custom" && resolved.coverage.customProviderModule) {
-    resolved.coverage.customProviderModule = resolvePath(
-      resolved.coverage.customProviderModule,
-      resolved.root
-    );
-  }
-  resolved.expect ??= {};
-  resolved.deps ??= {};
-  resolved.deps.moduleDirectories ??= [];
-  resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map(
-    (dir) => {
-      if (!dir.startsWith("/")) {
-        dir = `/${dir}`;
-      }
-      if (!dir.endsWith("/")) {
-        dir += "/";
+      fileTask.local = true;
+      TestFile.register(fileTask, project);
+      this.idMap.set(fileTask.id, fileTask);
+      if (!files) {
+        this.filesMap.set(path, [fileTask]);
+        return;
       }
-      return normalize(dir);
-    }
-  );
-  if (!resolved.deps.moduleDirectories.includes("/node_modules/")) {
-    resolved.deps.moduleDirectories.push("/node_modules/");
-  }
-  resolved.deps.optimizer ??= {};
-  resolved.deps.optimizer.ssr ??= {};
-  resolved.deps.optimizer.ssr.enabled ??= true;
-  resolved.deps.optimizer.web ??= {};
-  resolved.deps.optimizer.web.enabled ??= true;
-  resolved.deps.web ??= {};
-  resolved.deps.web.transformAssets ??= true;
-  resolved.deps.web.transformCss ??= true;
-  resolved.deps.web.transformGlobPattern ??= [];
-  resolved.server ??= {};
-  resolved.server.deps ??= {};
-  const deprecatedDepsOptions = ["inline", "external", "fallbackCJS"];
-  deprecatedDepsOptions.forEach((option) => {
-    if (resolved.deps[option] === void 0) {
-      return;
-    }
-    if (option === "fallbackCJS") {
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(
-            c.yellow(" Vitest ")
-          )} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`
-        )
-      );
-    } else {
-      const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(
-            c.yellow(" Vitest ")
-          )} "deps.${option}" is deprecated. If you rely on vite-node directly, use "server.deps.${option}" instead. Otherwise, consider using "deps.optimizer.${transformMode}.${option === "external" ? "exclude" : "include"}"`
-        )
+      const filtered = files.filter(
+        (file) => file.projectName !== project.config.name
       );
-    }
-    if (resolved.server.deps[option] === void 0) {
-      resolved.server.deps[option] = resolved.deps[option];
-    }
-  });
-  if (resolved.cliExclude) {
-    resolved.exclude.push(...resolved.cliExclude);
-  }
-  if (resolved.server.deps.inline !== true) {
-    const ssrOptions = viteConfig.ssr;
-    if (ssrOptions?.noExternal === true && resolved.server.deps.inline == null) {
-      resolved.server.deps.inline = true;
-    } else {
-      resolved.server.deps.inline ??= [];
-      resolved.server.deps.inline.push(...extraInlineDeps);
-    }
-  }
-  resolved.server.deps.moduleDirectories ??= [];
-  resolved.server.deps.moduleDirectories.push(
-    ...resolved.deps.moduleDirectories
-  );
-  if (resolved.runner) {
-    resolved.runner = resolvePath(resolved.runner, resolved.root);
-  }
-  if (resolved.snapshotEnvironment) {
-    resolved.snapshotEnvironment = resolvePath(
-      resolved.snapshotEnvironment,
-      resolved.root
-    );
-  }
-  resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
-  if (resolved.snapshotFormat && "plugins" in resolved.snapshotFormat) {
-    resolved.snapshotFormat.plugins = [];
-  }
-  const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
-  resolved.snapshotOptions = {
-    expand: resolved.expandSnapshotDiff ?? false,
-    snapshotFormat: resolved.snapshotFormat || {},
-    updateSnapshot: isCI && !UPDATE_SNAPSHOT ? "none" : UPDATE_SNAPSHOT ? "all" : "new",
-    resolveSnapshotPath: options.resolveSnapshotPath,
-    // resolved inside the worker
-    snapshotEnvironment: null
-  };
-  resolved.snapshotSerializers ??= [];
-  resolved.snapshotSerializers = resolved.snapshotSerializers.map(
-    (file) => resolvePath(file, resolved.root)
-  );
-  resolved.forceRerunTriggers.push(...resolved.snapshotSerializers);
-  if (options.resolveSnapshotPath) {
-    delete resolved.resolveSnapshotPath;
-  }
-  resolved.pool ??= "threads";
-  if (process.env.VITEST_MAX_THREADS) {
-    resolved.poolOptions = {
-      ...resolved.poolOptions,
-      threads: {
-        ...resolved.poolOptions?.threads,
-        maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
-      },
-      vmThreads: {
-        ...resolved.poolOptions?.vmThreads,
-        maxThreads: Number.parseInt(process.env.VITEST_MAX_THREADS)
-      }
-    };
-  }
-  if (process.env.VITEST_MIN_THREADS) {
-    resolved.poolOptions = {
-      ...resolved.poolOptions,
-      threads: {
-        ...resolved.poolOptions?.threads,
-        minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-      },
-      vmThreads: {
-        ...resolved.poolOptions?.vmThreads,
-        minThreads: Number.parseInt(process.env.VITEST_MIN_THREADS)
-      }
-    };
-  }
-  if (process.env.VITEST_MAX_FORKS) {
-    resolved.poolOptions = {
-      ...resolved.poolOptions,
-      forks: {
-        ...resolved.poolOptions?.forks,
-        maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
-      },
-      vmForks: {
-        ...resolved.poolOptions?.vmForks,
-        maxForks: Number.parseInt(process.env.VITEST_MAX_FORKS)
-      }
-    };
-  }
-  if (process.env.VITEST_MIN_FORKS) {
-    resolved.poolOptions = {
-      ...resolved.poolOptions,
-      forks: {
-        ...resolved.poolOptions?.forks,
-        minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
-      },
-      vmForks: {
-        ...resolved.poolOptions?.vmForks,
-        minForks: Number.parseInt(process.env.VITEST_MIN_FORKS)
+      if (!filtered.length) {
+        this.filesMap.set(path, [fileTask]);
+      } else {
+        this.filesMap.set(path, [...filtered, fileTask]);
       }
-    };
-  }
-  const poolThreadsOptions = [
-    ["threads", "minThreads"],
-    ["threads", "maxThreads"],
-    ["vmThreads", "minThreads"],
-    ["vmThreads", "maxThreads"]
-  ];
-  for (const [poolOptionKey, workerOptionKey] of poolThreadsOptions) {
-    if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) {
-      resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-    }
-  }
-  const poolForksOptions = [
-    ["forks", "minForks"],
-    ["forks", "maxForks"],
-    ["vmForks", "minForks"],
-    ["vmForks", "maxForks"]
-  ];
-  for (const [poolOptionKey, workerOptionKey] of poolForksOptions) {
-    if (resolved.poolOptions?.[poolOptionKey]?.[workerOptionKey]) {
-      resolved.poolOptions[poolOptionKey][workerOptionKey] = resolveInlineWorkerOption(resolved.poolOptions[poolOptionKey][workerOptionKey]);
-    }
-  }
-  if (resolved.workspace) {
-    resolved.workspace = options.workspace && options.workspace[0] === "." ? resolve(process.cwd(), options.workspace) : resolvePath(resolved.workspace, resolved.root);
-  }
-  if (!builtinPools.includes(resolved.pool)) {
-    resolved.pool = resolvePath(resolved.pool, resolved.root);
+    });
   }
-  resolved.poolMatchGlobs = (resolved.poolMatchGlobs || []).map(
-    ([glob, pool]) => {
-      if (!builtinPools.includes(pool)) {
-        pool = resolvePath(pool, resolved.root);
-      }
-      return [glob, pool];
+  updateId(task, project) {
+    if (this.idMap.get(task.id) === task) {
+      return;
     }
-  );
-  if (mode === "benchmark") {
-    resolved.benchmark = {
-      ...benchmarkConfigDefaults,
-      ...resolved.benchmark
-    };
-    resolved.coverage.enabled = false;
-    resolved.include = resolved.benchmark.include;
-    resolved.exclude = resolved.benchmark.exclude;
-    resolved.includeSource = resolved.benchmark.includeSource;
-    const reporters = Array.from(
-      /* @__PURE__ */ new Set([
-        ...toArray(resolved.benchmark.reporters),
-        // @ts-expect-error reporter is CLI flag
-        ...toArray(options.reporter)
-      ])
-    ).filter(Boolean);
-    if (reporters.length) {
-      resolved.benchmark.reporters = reporters;
+    if (task.type === "suite" && "filepath" in task) {
+      TestFile.register(task, project);
+    } else if (task.type === "suite") {
+      TestSuite.register(task, project);
     } else {
-      resolved.benchmark.reporters = ["default"];
-    }
-    if (options.outputFile) {
-      resolved.benchmark.outputFile = options.outputFile;
-    }
-    if (options.compare) {
-      resolved.benchmark.compare = options.compare;
+      TestCase.register(task, project);
     }
-    if (options.outputJson) {
-      resolved.benchmark.outputJson = options.outputJson;
+    this.idMap.set(task.id, task);
+    if (task.type === "suite") {
+      task.tasks.forEach((task2) => {
+        this.updateId(task2, project);
+      });
     }
   }
-  resolved.setupFiles = toArray(resolved.setupFiles || []).map(
-    (file) => resolvePath(file, resolved.root)
-  );
-  resolved.globalSetup = toArray(resolved.globalSetup || []).map(
-    (file) => resolvePath(file, resolved.root)
-  );
-  resolved.coverage.exclude.push(
-    ...resolved.setupFiles.map(
-      (file) => `${resolved.coverage.allowExternal ? "**/" : ""}${relative(
-        resolved.root,
-        file
-      )}`
-    )
-  );
-  resolved.forceRerunTriggers = [
-    ...resolved.forceRerunTriggers,
-    ...resolved.setupFiles
-  ];
-  if (resolved.diff) {
-    resolved.diff = resolvePath(resolved.diff, resolved.root);
-    resolved.forceRerunTriggers.push(resolved.diff);
-  }
-  resolved.api = resolveApiServerConfig(options, defaultPort);
-  if (options.related) {
-    resolved.related = toArray(options.related).map(
-      (file) => resolve(resolved.root, file)
-    );
+  getReportedEntity(task) {
+    return this.reportedTasksMap.get(task);
   }
-  if (options.reporters) {
-    if (!Array.isArray(options.reporters)) {
-      if (typeof options.reporters === "string") {
-        resolved.reporters = [[options.reporters, {}]];
-      } else {
-        resolved.reporters = [options.reporters];
-      }
-    } else {
-      resolved.reporters = [];
-      for (const reporter of options.reporters) {
-        if (Array.isArray(reporter)) {
-          resolved.reporters.push([reporter[0], reporter[1] || {}]);
-        } else if (typeof reporter === "string") {
-          resolved.reporters.push([reporter, {}]);
-        } else {
-          resolved.reporters.push(reporter);
+  updateTasks(packs) {
+    for (const [id, result, meta] of packs) {
+      const task = this.idMap.get(id);
+      if (task) {
+        task.result = result;
+        task.meta = meta;
+        if (result?.state === "skip") {
+          task.mode = "skip";
         }
       }
     }
   }
-  if (mode !== "benchmark") {
-    const reportersFromCLI = resolved.reporter;
-    const cliReporters = toArray(reportersFromCLI || []).map(
-      (reporter) => {
-        if (/^\.\.?\//.test(reporter)) {
-          return resolve(process.cwd(), reporter);
-        }
-        return reporter;
+  updateUserLog(log) {
+    const task = log.taskId && this.idMap.get(log.taskId);
+    if (task) {
+      if (!task.logs) {
+        task.logs = [];
       }
-    );
-    if (cliReporters.length) {
-      resolved.reporters = Array.from(new Set(toArray(cliReporters))).filter(Boolean).map((reporter) => [reporter, {}]);
-    }
-  }
-  if (!resolved.reporters.length) {
-    resolved.reporters.push(["default", {}]);
-    if (process.env.GITHUB_ACTIONS === "true") {
-      resolved.reporters.push(["github-actions", {}]);
-    }
-  }
-  if (resolved.changed) {
-    resolved.passWithNoTests ??= true;
-  }
-  resolved.css ??= {};
-  if (typeof resolved.css === "object") {
-    resolved.css.modules ??= {};
-    resolved.css.modules.classNameStrategy ??= "stable";
-  }
-  if (resolved.cache !== false) {
-    let cacheDir = VitestCache.resolveCacheDir(
-      "",
-      resolve(viteConfig.cacheDir, "vitest"),
-      resolved.name
-    );
-    if (resolved.cache && resolved.cache.dir) {
-      logger.console.warn(
-        c.yellow(
-          `${c.inverse(
-            c.yellow(" Vitest ")
-          )} "cache.dir" is deprecated, use Vite's "cacheDir" instead if you want to change the cache director. Note caches will be written to "cacheDir/vitest"`
-        )
-      );
-      cacheDir = VitestCache.resolveCacheDir(
-        resolved.root,
-        resolved.cache.dir,
-        resolved.name
-      );
+      task.logs.push(log);
     }
-    resolved.cache = { dir: cacheDir };
-  }
-  resolved.sequence ??= {};
-  if (resolved.sequence.shuffle && typeof resolved.sequence.shuffle === "object") {
-    const { files, tests } = resolved.sequence.shuffle;
-    resolved.sequence.sequencer ??= files ? RandomSequencer : BaseSequencer;
-    resolved.sequence.shuffle = tests;
-  }
-  if (!resolved.sequence?.sequencer) {
-    resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
   }
-  resolved.sequence.hooks ??= "stack";
-  if (resolved.sequence.sequencer === RandomSequencer) {
-    resolved.sequence.seed ??= Date.now();
+  getCountOfFailedTests() {
+    return Array.from(this.idMap.values()).filter(
+      (t) => t.result?.state === "fail"
+    ).length;
   }
-  resolved.typecheck = {
-    ...configDefaults.typecheck,
-    ...resolved.typecheck
-  };
-  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map(
-    (i) => [resolve(resolved.root, i[0]), i[1]]
-  );
-  resolved.typecheck ??= {};
-  resolved.typecheck.enabled ??= false;
-  if (resolved.typecheck.enabled) {
-    logger.console.warn(
-      c.yellow(
-        "Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow SemVer, please pin Vitest's version when using it."
+  cancelFiles(files, project) {
+    this.collectFiles(
+      project,
+      files.map(
+        (filepath) => createFileTask(filepath, project.config.root, project.config.name)
       )
     );
   }
-  resolved.browser ??= {};
-  resolved.browser.enabled ??= false;
-  resolved.browser.headless ??= isCI;
-  resolved.browser.isolate ??= true;
-  resolved.browser.fileParallelism ??= options.fileParallelism ?? mode !== "benchmark";
-  resolved.browser.ui ??= resolved.browser.headless === true ? false : !isCI;
-  if (resolved.browser.screenshotDirectory) {
-    resolved.browser.screenshotDirectory = resolve(
-      resolved.root,
-      resolved.browser.screenshotDirectory
-    );
-  }
-  const isPreview = resolved.browser.provider === "preview";
-  if (isPreview && resolved.browser.screenshotFailures === true) {
-    console.warn(c.yellow(
-      [
-        `Browser provider "preview" doesn't support screenshots, `,
-        `so "browser.screenshotFailures" option is forcefully disabled. `,
-        `Set "browser.screenshotFailures" to false or remove it from the config to suppress this warning.`
-      ].join("")
-    ));
-    resolved.browser.screenshotFailures = false;
-  } else {
-    resolved.browser.screenshotFailures ??= !isPreview && !resolved.browser.ui;
-  }
-  resolved.browser.viewport ??= {};
-  resolved.browser.viewport.width ??= 414;
-  resolved.browser.viewport.height ??= 896;
-  if (resolved.browser.enabled && provider$1 === "stackblitz") {
-    resolved.browser.provider = "preview";
-  }
-  resolved.browser.api = resolveApiServerConfig(
-    resolved.browser,
-    defaultBrowserPort
-  ) || {
-    port: defaultBrowserPort
-  };
-  if (resolved.browser.enabled) {
-    if (resolved.browser.ui) {
-      resolved.includeTaskLocation ??= true;
-    }
-  } else if (resolved.ui) {
-    resolved.includeTaskLocation ??= true;
-  }
-  const htmlReporter = toArray(resolved.reporters).some((reporter) => {
-    if (Array.isArray(reporter)) {
-      return reporter[0] === "html";
-    }
-    return false;
-  });
-  if (htmlReporter) {
-    resolved.includeTaskLocation ??= true;
-  }
-  resolved.testTransformMode ??= {};
-  resolved.testTimeout ??= resolved.browser.enabled ? 15e3 : 5e3;
-  resolved.hookTimeout ??= resolved.browser.enabled ? 3e4 : 1e4;
-  return resolved;
-}
-function isBrowserEnabled(config) {
-  return Boolean(config.browser?.enabled);
 }
 
 function generateCssFilenameHash(filepath) {
@@ -14046,7 +9935,10 @@ function serializeConfig(config, coreConfig, viteConfig) {
         fileParallelism: browser.fileParallelism,
         ui: browser.ui,
         viewport: browser.viewport,
-        screenshotFailures: browser.screenshotFailures
+        screenshotFailures: browser.screenshotFailures,
+        locators: {
+          testIdAttribute: browser.locators.testIdAttribute
+        }
       };
     })(config.browser),
     standalone: config.standalone,
@@ -14195,7 +10087,7 @@ class WorkspaceProject {
       await Promise.all(
         files.map(async (file) => {
           try {
-            const code = await promises$1.readFile(file, "utf-8");
+            const code = await promises.readFile(file, "utf-8");
             if (this.isInSourceTestFile(code)) {
               testFiles.push(file);
             }
@@ -14229,7 +10121,7 @@ class WorkspaceProject {
       return true;
     }
     if (this.config.includeSource?.length && mm.isMatch(relativeId, this.config.includeSource)) {
-      source = source || await promises$1.readFile(id, "utf-8");
+      source = source || await promises.readFile(id, "utf-8");
       return this.isInSourceTestFile(source);
     }
     return false;
@@ -14560,7 +10452,7 @@ class Vitest {
       return this.config.workspace;
     }
     const configDir = this.server.config.configFile ? dirname(this.server.config.configFile) : this.config.root;
-    const rootFiles = await promises$1.readdir(configDir);
+    const rootFiles = await promises.readdir(configDir);
     const workspaceConfigName = workspacesFiles.find((configFile) => {
       return rootFiles.includes(configFile);
     });
@@ -14614,7 +10506,7 @@ class Vitest {
       return CONFIG_NAMES.some((configName) => filename.startsWith(configName));
     }).map(async (filepath) => {
       if (filepath.endsWith("/")) {
-        const filesInside = await promises$1.readdir(filepath);
+        const filesInside = await promises.readdir(filepath);
         const configFile = configFiles.find((config) => filesInside.includes(config));
         return configFile ? join(filepath, configFile) : filepath;
       }
@@ -16028,4 +11920,4 @@ var cliApi = /*#__PURE__*/Object.freeze({
   startVitest: startVitest
 });
 
-export { FilesNotFoundError as F, GitNotFoundError as G, VitestPlugin as V, createMethodsRPC as a, VitestPackageInstaller as b, createVitest as c, resolveFsAllow as d, resolveApiServerConfig as e, resolveConfig as f, getFilePoolName as g, cliApi as h, registerConsoleShortcuts as r, startVitest as s };
+export { FilesNotFoundError as F, GitNotFoundError as G, VitestPlugin as V, VitestPackageInstaller as a, resolveFsAllow as b, createVitest as c, cliApi as d, registerConsoleShortcuts as r, startVitest as s };