vitest 0.33.0 → 0.34.0

package/dist/{vendor-cli-api.bf4b62a8.js → vendor-node.00226ab1.js}

@@ -1,16 +1,10 @@
-import { resolve as resolve$2, relative, isAbsolute, dirname, basename, normalize, join, extname, toNamespacedPath } from 'pathe';
-import { E as EXIT_CODE_RESTART, c as configFiles, d as defaultPort, a as defaultBrowserPort, w as workspacesFiles, C as CONFIG_NAMES } from './vendor-constants.538d9b49.js';
-import { g as getCoverageProvider, C as CoverageProviderMap } from './vendor-coverage.2e41927a.js';
-import { g as getEnvPackageName } from './vendor-environments.392ddf08.js';
-import url, { fileURLToPath, pathToFileURL } from 'node:url';
-import c from 'picocolors';
-import { isPackageExists, resolveModule } from 'local-pkg';
-import { a as isNode, b as relativePath, c as removeUndefinedValues, d as isWindows } from './vendor-index.23ac4e13.js';
-import { isCI } from 'std-env';
+import { resolve, relative, isAbsolute, dirname, basename, normalize, join, extname, toNamespacedPath } from 'pathe';
 import { loadConfigFromFile, createServer, version as version$2, mergeConfig } from 'vite';
 import path$a from 'node:path';
+import url, { fileURLToPath, pathToFileURL } from 'node:url';
 import process$1 from 'node:process';
 import fs$8, { promises, existsSync, readFileSync } from 'node:fs';
+import { E as EXIT_CODE_RESTART, c as configFiles, d as defaultPort, a as defaultBrowserPort, w as workspacesFiles, C as CONFIG_NAMES } from './vendor-constants.538d9b49.js';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './vendor-_commonjsHelpers.7d1333e8.js';
 import require$$0 from 'os';
 import f$1 from 'path';
@@ -18,20 +12,26 @@ import require$$2 from 'util';
 import require$$0$1 from 'stream';
 import require$$2$1 from 'events';
 import $ from 'fs';
+import c from 'picocolors';
 import { slash as slash$2, normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
+import { a as isNode, r as relativePath, b as removeUndefinedValues, c as isWindows } from './vendor-index.087d1af7.js';
+import { g as getCoverageProvider, C as CoverageProviderMap } from './vendor-coverage.78040316.js';
 import { d as distDir, r as rootDir } from './vendor-paths.84fc7a99.js';
 import v8 from 'node:v8';
 import { fork } from 'node:child_process';
-import { a as groupBy, b as getEnvironmentTransformMode, c as createBirpc, A as AggregateErrorPonyfill, s as slash$1, t as toArray, i as isPrimitive, d as deepMerge, n as noop$1, e as stdout } from './vendor-index.cc463d9e.js';
+import { c as createBirpc } from './vendor-index.b271ebe4.js';
+import { g as groupBy, A as AggregateErrorPonyfill, s as slash$1, t as toArray, i as isPrimitive, d as deepMerge, n as noop$1, a as stdout } from './vendor-base.9c08bbd0.js';
 import { MessageChannel } from 'node:worker_threads';
-import { cpus, hostname } from 'node:os';
+import { cpus, hostname, totalmem } from 'node:os';
 import Tinypool from 'tinypool';
-import { createDefer, getSafeTimers, notNullish, parseErrorStacktrace, shuffle, stringify as stringify$5, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { createDefer, getSafeTimers, notNullish, shuffle, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { isPackageExists, resolveModule } from 'local-pkg';
+import { isCI } from 'std-env';
 import { performance } from 'node:perf_hooks';
-import { g as getFullName, h as hasFailedSnapshot } from './vendor-tasks.f9d75aed.js';
+import { g as getFullName, h as hasFailedSnapshot, p as parseErrorStacktrace, T as TraceMap, b as generatedPositionFor } from './vendor-source-map.e6c1997b.js';
 import { getTests, hasFailed, getSuites, generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, getTasks } from '@vitest/runner/utils';
 import { createRequire, builtinModules } from 'node:module';
 import { createHash } from 'node:crypto';
@@ -42,6 +42,7 @@ import { parse as parse$4 } from 'acorn';
 import { ancestor, simple, findNodeAround } from 'acorn-walk';
 import MagicString from 'magic-string';
 import { stripLiteral } from 'strip-literal';
+import { g as getEnvPackageName } from './vendor-environments.443ecd82.js';
 import readline from 'node:readline';
 import require$$0$2 from 'readline';
 
@@ -60,15 +61,13 @@ function _mergeNamespaces(n, m) {
   return Object.freeze(n);
 }
 
-var version$1 = "0.33.0";
+var version$1 = "0.34.0";
 
 const __dirname$1 = url.fileURLToPath(new URL(".", import.meta.url));
-async function ensurePackageInstalled(dependency, root, errorMessage) {
+async function ensurePackageInstalled(dependency, root) {
   if (isPackageExists(dependency, { paths: [root, __dirname$1] }))
     return true;
   const promptInstall = !isCI && process.stdout.isTTY;
-  if (errorMessage)
-    process.stderr.write(c.red(errorMessage));
   process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEP "))} Can not find dependency '${dependency}'
 
 `));
@@ -81,7 +80,7 @@ async function ensurePackageInstalled(dependency, root, errorMessage) {
     message: c.reset(`Do you want to install ${c.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.23da664c.js')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.dd70081b.js')).installPackage(dependency, { dev: true });
     process.stderr.write(c.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -527,7 +526,7 @@ var isExtglob$1 = function isExtglob(str) {
  */
 
 var isExtglob = isExtglob$1;
-var chars$1 = { '{': '}', '(': ')', '[': ']'};
+var chars = { '{': '}', '(': ')', '[': ']'};
 var strictCheck = function(str) {
   if (str[0] === '!') {
     return true;
@@ -600,7 +599,7 @@ var strictCheck = function(str) {
     if (str[index] === '\\') {
       var open = str[index + 1];
       index += 2;
-      var close = chars$1[open];
+      var close = chars[open];
 
       if (close) {
         var n = str.indexOf(close, index);
@@ -632,7 +631,7 @@ var relaxedCheck = function(str) {
     if (str[index] === '\\') {
       var open = str[index + 1];
       index += 2;
-      var close = chars$1[open];
+      var close = chars[open];
 
       if (close) {
         var n = str.indexOf(close, index);
@@ -7063,6 +7062,13 @@ const envsOrder = [
   "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]) => {
     var _a, _b;
@@ -7077,12 +7083,14 @@ async function groupFilesByEnv(files) {
       }
     }
     env || (env = project.config.environment || "node");
+    const transformMode = getTransformMode(project.config.testTransformMode, file);
     const envOptions = JSON.parse(((_b = code.match(/@(?:vitest|jest)-environment-options\s+?(.+)/)) == null ? void 0 : _b[1]) || "null");
     return {
       file,
       project,
       environment: {
         name: env,
+        transformMode,
         options: envOptions ? { [env]: envOptions } : null
       }
     };
@@ -7094,7 +7102,7 @@ function createMethodsRPC(project) {
   const ctx = project.ctx;
   return {
     async onWorkerExit(error, code) {
-      await ctx.logger.printError(error, false, "Unexpected Exit");
+      await ctx.logger.printError(error, { type: "Unexpected Exit" });
       process.exit(code || 1);
     },
     snapshotSaved(snapshot) {
@@ -7112,12 +7120,10 @@ function createMethodsRPC(project) {
       const r = await project.vitenode.transformRequest(id);
       return r == null ? void 0 : r.map;
     },
-    fetch(id, environment) {
-      const transformMode = getEnvironmentTransformMode(project.config, environment);
+    fetch(id, transformMode) {
       return project.vitenode.fetchModule(id, transformMode);
     },
-    resolveId(id, importer, environment) {
-      const transformMode = getEnvironmentTransformMode(project.config, environment);
+    resolveId(id, importer, transformMode) {
       return project.vitenode.resolveId(id, importer, transformMode);
     },
     onPathsCollected(paths) {
@@ -7155,7 +7161,7 @@ function createMethodsRPC(project) {
   };
 }
 
-const childPath = fileURLToPath(pathToFileURL(resolve$2(distDir, "./child.js")).href);
+const childPath = fileURLToPath(pathToFileURL(resolve(distDir, "./child.js")).href);
 function setupChildProcessChannel(project, fork2) {
   const rpc = createBirpc(
     createMethodsRPC(project),
@@ -7202,6 +7208,8 @@ function createChildProcessPool(ctx, { execArgv, env }) {
     const child = fork(childPath, [], {
       execArgv,
       env
+      // TODO: investigate
+      // serialization: 'advanced',
     });
     children.add(child);
     setupChildProcessChannel(project, child);
@@ -7232,7 +7240,7 @@ function createChildProcessPool(ctx, { execArgv, env }) {
       const files = filesByEnv[env2];
       if (!(files == null ? void 0 : files.length))
         continue;
-      const filesByOptions = groupBy(files, ({ project, environment }) => project.getName() + JSON.stringify(environment.options));
+      const filesByOptions = groupBy(files, ({ project, environment }) => project.getName() + JSON.stringify(environment.options) + environment.transformMode);
       for (const option in filesByOptions) {
         const files2 = filesByOptions[option];
         if (files2 == null ? void 0 : files2.length) {
@@ -7254,8 +7262,8 @@ function createChildProcessPool(ctx, { execArgv, env }) {
   };
 }
 
-const workerPath = pathToFileURL(resolve$2(distDir, "./worker.js")).href;
-function createWorkerChannel(project) {
+const workerPath$1 = pathToFileURL(resolve(distDir, "./worker.js")).href;
+function createWorkerChannel$1(project) {
   const channel = new MessageChannel();
   const port = channel.port2;
   const workerPort = channel.port1;
@@ -7279,7 +7287,7 @@ function createThreadsPool(ctx, { execArgv, env }) {
   const maxThreads = ctx.config.maxThreads ?? threadsCount;
   const minThreads = ctx.config.minThreads ?? threadsCount;
   const options = {
-    filename: workerPath,
+    filename: workerPath$1,
     // TODO: investigate further
     // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
     useAtomics: ctx.config.useAtomics ?? false,
@@ -7303,7 +7311,7 @@ function createThreadsPool(ctx, { execArgv, env }) {
     let id = 0;
     async function runFiles(project, config, files, environment, invalidates = []) {
       ctx.state.clearFiles(project, files);
-      const { workerPort, port } = createWorkerChannel(project);
+      const { workerPort, port } = createWorkerChannel$1(project);
       const workerId = ++id;
       const data = {
         port: workerPort,
@@ -7353,8 +7361,18 @@ function createThreadsPool(ctx, { execArgv, env }) {
       const multipleThreads = specs.filter(([project]) => !project.config.singleThread);
       if (multipleThreads.length) {
         const filesByEnv = await groupFilesByEnv(multipleThreads);
-        const promises = Object.values(filesByEnv).flat();
-        const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
+        const files = Object.values(filesByEnv).flat();
+        const results = [];
+        if (ctx.config.isolate) {
+          results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+        } 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.");
@@ -7369,11 +7387,11 @@ function createThreadsPool(ctx, { execArgv, env }) {
           if (!(files == null ? void 0 : files.length))
             continue;
           const filesByOptions = groupBy(files, ({ project, environment }) => project.getName() + JSON.stringify(environment.options));
-          const promises = Object.values(filesByOptions).map(async (files2) => {
+          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);
-          });
-          await Promise.all(promises);
+          }
         }
       }
     };
@@ -7460,17 +7478,130 @@ function createBrowserPool(ctx) {
   };
 }
 
-const loaderPath = pathToFileURL(resolve$2(distDir, "./loader.js")).href;
-const suppressLoaderWarningsPath = resolve$2(rootDir, "./suppress-warnings.cjs");
+const workerPath = pathToFileURL(resolve(distDir, "./vm.js")).href;
+const suppressLoaderWarningsPath$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);
+      }
+    }
+  );
+  project.ctx.onCancel((reason) => rpc.onCancel(reason));
+  return { workerPort, port };
+}
+function createVmThreadsPool(ctx, { execArgv, env }) {
+  const threadsCount = ctx.config.watch ? Math.max(Math.floor(cpus().length / 2), 1) : Math.max(cpus().length - 1, 1);
+  const maxThreads = ctx.config.maxThreads ?? threadsCount;
+  const minThreads = ctx.config.minThreads ?? threadsCount;
+  const options = {
+    filename: workerPath,
+    // TODO: investigate further
+    // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
+    useAtomics: ctx.config.useAtomics ?? false,
+    maxThreads,
+    minThreads,
+    env,
+    execArgv: [
+      "--experimental-import-meta-resolve",
+      "--experimental-vm-modules",
+      "--require",
+      suppressLoaderWarningsPath$1,
+      ...execArgv
+    ],
+    terminateTimeout: ctx.config.teardownTimeout
+  };
+  if (ctx.config.singleThread) {
+    options.concurrentTasksPerWorker = 1;
+    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 { workerPort, port } = createWorkerChannel(project);
+      const workerId = ++id;
+      const data = {
+        port: workerPort,
+        config,
+        files,
+        invalidates,
+        environment,
+        workerId
+      };
+      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(", ")}.`);
+        else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message))
+          ctx.state.cancelFiles(files, ctx.config.root);
+        else
+          throw error;
+      } finally {
+        port.close();
+        workerPort.close();
+      }
+    }
+    const Sequencer = ctx.config.sequence.sequencer;
+    const sequencer = new Sequencer(ctx);
+    return async (specs, invalidates) => {
+      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 { shard } = ctx.config;
+      if (shard)
+        specs = await sequencer.shard(specs);
+      specs = await sequencer.sort(specs);
+      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 {
+    runTests: runWithFiles("run"),
+    close: async () => {
+      var _a;
+      const nodeVersion = Number((_a = process.version.match(/v(\d+)\.(\d+)/)) == null ? void 0 : _a[0].slice(1));
+      if (nodeVersion >= 16.17)
+        await pool.destroy();
+    }
+  };
+}
+
+const loaderPath = pathToFileURL(resolve(distDir, "./loader.js")).href;
+const suppressLoaderWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createPool(ctx) {
   const pools = {
     child_process: null,
     threads: null,
-    browser: null
+    browser: null,
+    experimentalVmThreads: null
   };
   function getDefaultPoolName(project) {
     if (project.config.browser.enabled)
       return "browser";
+    if (project.config.experimentalVmThreads)
+      return "experimentalVmThreads";
     if (project.config.threads)
       return "threads";
     return "child_process";
@@ -7496,7 +7627,8 @@ function createPool(ctx) {
         "--require",
         suppressLoaderWarningsPath,
         "--experimental-loader",
-        loaderPath
+        loaderPath,
+        ...conditions
       ] : [
         ...execArgv,
         ...conditions
@@ -7513,10 +7645,13 @@ function createPool(ctx) {
     const filesByPool = {
       child_process: [],
       threads: [],
-      browser: []
+      browser: [],
+      experimentalVmThreads: []
     };
     for (const spec of files) {
       const pool = getPoolName(spec);
+      if (!(pool in filesByPool))
+        throw new Error(`Unknown pool name "${pool}" for ${spec[1]}. Available pools: ${Object.keys(filesByPool).join(", ")}`);
       filesByPool[pool].push(spec);
     }
     await Promise.all(Object.entries(filesByPool).map(([pool, files2]) => {
@@ -7526,6 +7661,10 @@ function createPool(ctx) {
         pools.browser ?? (pools.browser = createBrowserPool(ctx));
         return pools.browser.runTests(files2, invalidate);
       }
+      if (pool === "experimentalVmThreads") {
+        pools.experimentalVmThreads ?? (pools.experimentalVmThreads = createVmThreadsPool(ctx, options));
+        return pools.experimentalVmThreads.runTests(files2, invalidate);
+      }
       if (pool === "threads") {
         pools.threads ?? (pools.threads = createThreadsPool(ctx, options));
         return pools.threads.runTests(files2, invalidate);
@@ -8037,8 +8176,13 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
     for (const task of tasks) {
       (_b = (_a2 = task.result) == null ? void 0 : _a2.errors) == null ? void 0 : _b.forEach((error) => {
         const errorItem = (error == null ? void 0 : error.stackStr) && errorsQueue.find((i) => {
-          var _a3;
-          return ((_a3 = i[0]) == null ? void 0 : _a3.stackStr) === error.stackStr;
+          var _a3, _b2, _c2, _d;
+          const hasStr = ((_a3 = i[0]) == null ? void 0 : _a3.stackStr) === error.stackStr;
+          if (!hasStr)
+            return false;
+          const currentProjectName = (task == null ? void 0 : task.projectName) || ((_b2 = task.file) == null ? void 0 : _b2.projectName);
+          const projectName = ((_c2 = i[1][0]) == null ? void 0 : _c2.projectName) || ((_d = i[1][0].file) == null ? void 0 : _d.projectName);
+          return projectName === currentProjectName;
         });
         if (errorItem)
           errorItem[1].push(task);
@@ -8055,7 +8199,8 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
           name = `${name} ${c.dim(`[ ${this.relative(filepath)} ]`)}`;
         this.ctx.logger.error(`${c.red(c.bold(c.inverse(" FAIL ")))} ${formatProjectName(projectName)}${name}`);
       }
-      await this.ctx.logger.printError(error);
+      const project = this.ctx.getProjectByTaskId(tasks2[0].id);
+      await this.ctx.logger.printError(error, { project });
       errorDivider();
       await Promise.resolve();
     }
@@ -8063,7 +8208,7 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
   registerUnhandledRejection() {
     process.on("unhandledRejection", async (err) => {
       process.exitCode = 1;
-      await this.ctx.logger.printError(err, true, "Unhandled Rejection");
+      await this.ctx.logger.printError(err, { fullStack: true, type: "Unhandled Rejection" });
       this.ctx.logger.error("\n\n");
       process.exit(1);
     });
@@ -9415,7 +9560,7 @@ let JsonReporter$1 = class JsonReporter {
   async writeReport(report) {
     const outputFile = getOutputFile(this.ctx.config, "json");
     if (outputFile) {
-      const reportFile = resolve$2(this.ctx.config.root, outputFile);
+      const reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(reportFile);
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
@@ -9430,7 +9575,10 @@ let JsonReporter$1 = class JsonReporter {
     const error = (_b = (_a = test.result) == null ? void 0 : _a.errors) == null ? void 0 : _b[0];
     if (!error)
       return;
-    const stack = parseErrorStacktrace(error);
+    const project = this.ctx.getProjectByTaskId(test.id);
+    const stack = parseErrorStacktrace(error, {
+      getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+    });
     const frame = stack[0];
     if (!frame)
       return;
@@ -9529,10 +9677,13 @@ class TapReporter {
         this.logger.log("}");
       } else {
         this.logger.log(`${ok} ${id} - ${tapString(task.name)}${comment}`);
+        const project = this.ctx.getProjectByTaskId(task.id);
         if (((_b = task.result) == null ? void 0 : _b.state) === "fail" && task.result.errors) {
           this.logger.indent();
           task.result.errors.forEach((error) => {
-            const stacks = parseErrorStacktrace(error);
+            const stacks = parseErrorStacktrace(error, {
+              getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+            });
             const stack = stacks[0];
             this.logger.log("---");
             this.logger.log("error:");
@@ -9606,7 +9757,7 @@ class JUnitReporter {
     this.ctx = ctx;
     const outputFile = getOutputFile(this.ctx.config, "junit");
     if (outputFile) {
-      this.reportFile = resolve$2(this.ctx.config.root, outputFile);
+      this.reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(this.reportFile);
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
@@ -9638,11 +9789,14 @@ class JUnitReporter {
     this.logger.unindent();
     await this.logger.log(`</${name}>`);
   }
-  async writeErrorDetails(error) {
+  async writeErrorDetails(task, error) {
     const errorName = error.name ?? error.nameStr ?? "Unknown Error";
     const errorDetails = `${errorName}: ${error.message}`;
     await this.baseLog(escapeXML(errorDetails));
-    const stack = parseErrorStacktrace(error);
+    const project = this.ctx.getProjectByTaskId(task.id);
+    const stack = parseErrorStacktrace(error, {
+      getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+    });
     for (const frame of stack) {
       const path = relative(this.ctx.config.root, frame.file);
       await this.baseLog(escapeXML(` ${F_POINTER} ${[frame.method, `${path}:${frame.line}:${frame.column}`].filter(Boolean).join(" ")}`));
@@ -9665,7 +9819,7 @@ class JUnitReporter {
   async writeTasks(tasks, filename) {
     for (const task of tasks) {
       await this.writeElement("testcase", {
-        classname: filename,
+        classname: process.env.VITEST_JUNIT_CLASSNAME ?? filename,
         name: task.name,
         time: getDuration(task)
       }, async () => {
@@ -9683,7 +9837,7 @@ class JUnitReporter {
             }, async () => {
               if (!error)
                 return;
-              await this.writeErrorDetails(error);
+              await this.writeErrorDetails(task, error);
             });
           }
         }
@@ -9835,7 +9989,7 @@ class JsonReporter {
   async writeReport(report) {
     const outputFile = getOutputFile(this.ctx.config.benchmark, "json");
     if (outputFile) {
-      const reportFile = resolve$2(this.ctx.config.root, outputFile);
+      const reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(reportFile);
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
@@ -10134,7 +10288,6 @@ function isAggregateError(err) {
 class StateManager {
   filesMap = /* @__PURE__ */ new Map();
   pathsSet = /* @__PURE__ */ new Set();
-  collectingPromise = void 0;
   browserTestPromises = /* @__PURE__ */ new Map();
   idMap = /* @__PURE__ */ new Map();
   taskFileMap = /* @__PURE__ */ new WeakMap();
@@ -10192,7 +10345,9 @@ class StateManager {
       this.updateId(file);
     });
   }
-  clearFiles(project, paths = []) {
+  // this file is reused by ws-client, and shoult not rely on heavy dependencies like workspace
+  clearFiles(_project, paths = []) {
+    const project = _project;
     paths.forEach((path) => {
       const files = this.filesMap.get(path);
       if (!files)
@@ -10267,6 +10422,9 @@ const defaultCoverageExcludes = [
   "dist/**",
   "packages/*/test?(s)/**",
   "**/*.d.ts",
+  "**/virtual:*",
+  "**/__x00__*",
+  "**/\0*",
   "cypress/**",
   "test?(s)/**",
   "test?(-*).?(c|m)[jt]s?(x)",
@@ -10282,10 +10440,8 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reportOnFailure: true,
+  reportOnFailure: false,
   reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
-  // default extensions used by c8, plus '.vue' and '.svelte'
-  // see https://github.com/istanbuljs/schema/blob/master/default-extension.js
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {
@@ -10345,6 +10501,66 @@ const config = {
 };
 const configDefaults = Object.freeze(config);
 
+function getDefaultThreadsCount(config) {
+  return config.watch ? Math.max(Math.floor(cpus().length / 2), 1) : Math.max(cpus().length - 1, 1);
+}
+function getWorkerMemoryLimit(config) {
+  if (config.experimentalVmWorkerMemoryLimit)
+    return config.experimentalVmWorkerMemoryLimit;
+  return 1 / (config.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.-]+)$/i) || [];
+      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 "experimentalVmWorkerMemoryLimit"');
+    }
+  }
+  return null;
+}
+
 class FilesStatsCache {
   cache = /* @__PURE__ */ new Map();
   getStats(key) {
@@ -10383,7 +10599,7 @@ class ResultsCache {
   setConfig(root, config) {
     this.root = root;
     if (config)
-      this.cachePath = resolve$2(config.dir, "results.json");
+      this.cachePath = resolve(config.dir, "results.json");
   }
   getResults(key) {
     return this.cache.get(key);
@@ -10450,12 +10666,12 @@ class VitestCache {
     return this.stats.getStats(key);
   }
   static resolveCacheDir(root, dir) {
-    return resolve$2(root, slash$1(dir || "node_modules/.vitest"));
+    return resolve(root, slash$1(dir || "node_modules/.vitest"));
   }
   static async clearCache(options) {
     var _a, _b;
-    const root = resolve$2(options.root || process.cwd());
-    const configPath = options.config === false ? false : options.config ? resolve$2(root, options.config) : await findUp(configFiles, { cwd: root });
+    const root = resolve(options.root || process.cwd());
+    const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
     const config = configPath ? (_a = await loadConfigFromFile({ command: "serve", mode: "test" }, configPath)) == null ? void 0 : _a.config : void 0;
     const cache = (_b = config == null ? void 0 : config.test) == null ? void 0 : _b.cache;
     if (cache === false)
@@ -10483,7 +10699,7 @@ class BaseSequencer {
     const shardStart = shardSize * (index - 1);
     const shardEnd = shardSize * index;
     return [...files].map((spec) => {
-      const fullPath = resolve$2(slash$2(config.root), slash$2(spec[1]));
+      const fullPath = resolve(slash$2(config.root), slash$2(spec[1]));
       const specPath = fullPath == null ? void 0 : fullPath.slice(config.root.length);
       return {
         spec,
@@ -10557,7 +10773,7 @@ function resolveApiServerConfig(options) {
   return api;
 }
 function resolveConfig(mode, options, viteConfig) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
   if (options.dom) {
     if (((_a = viteConfig.test) == null ? void 0 : _a.environment) != null && viteConfig.test.environment !== "happy-dom") {
       console.warn(
@@ -10597,21 +10813,12 @@ function resolveConfig(mode, options, viteConfig) {
       throw new Error(`You cannot use ${inspectOption} without "threads: false" or "singleThread: true"`);
     }
   }
-  if (resolved.coverage.provider === "c8" && resolved.coverage.enabled && isBrowserEnabled(resolved))
-    throw new Error("@vitest/coverage-c8 does not work with --browser. Use @vitest/coverage-istanbul instead");
+  if (resolved.coverage.provider === "c8")
+    throw new Error('"coverage.provider: c8" is not supported anymore. Use "coverage.provider: v8" instead');
   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");
-  resolved.deps = resolved.deps || {};
-  if (resolved.deps.inline !== true) {
-    const ssrOptions = viteConfig.ssr;
-    if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.deps.inline == null) {
-      resolved.deps.inline = true;
-    } else {
-      (_b = resolved.deps).inline ?? (_b.inline = []);
-      resolved.deps.inline.push(...extraInlineDeps);
-    }
-  }
-  (_c = resolved.deps).moduleDirectories ?? (_c.moduleDirectories = ["/node_modules/"]);
+  resolved.deps ?? (resolved.deps = {});
+  (_b = resolved.deps).moduleDirectories ?? (_b.moduleDirectories = []);
   resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
     if (!dir.startsWith("/"))
       dir = `/${dir}`;
@@ -10619,10 +10826,49 @@ function resolveConfig(mode, options, viteConfig) {
       dir += "/";
     return normalize(dir);
   });
+  if (!resolved.deps.moduleDirectories.includes("/node_modules/"))
+    resolved.deps.moduleDirectories.push("/node_modules/");
+  resolved.server ?? (resolved.server = {});
+  (_c = resolved.server).deps ?? (_c.deps = {});
+  const deprecatedDepsOptions = ["inline", "external", "fallbackCJS"];
+  deprecatedDepsOptions.forEach((option) => {
+    if (resolved.deps[option] === void 0)
+      return;
+    if (option === "fallbackCJS") {
+      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";
+      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"}"`
+        )
+      );
+    }
+    if (resolved.server.deps[option] === void 0)
+      resolved.server.deps[option] = resolved.deps[option];
+  });
+  if (resolved.server.deps.inline !== true) {
+    const ssrOptions = viteConfig.ssr;
+    if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.server.deps.inline == null) {
+      resolved.server.deps.inline = true;
+    } else {
+      (_d = resolved.server.deps).inline ?? (_d.inline = []);
+      resolved.server.deps.inline.push(...extraInlineDeps);
+    }
+  }
+  (_e = resolved.server.deps).moduleDirectories ?? (_e.moduleDirectories = []);
+  resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
   if (resolved.runner) {
-    resolved.runner = resolveModule(resolved.runner, { paths: [resolved.root] }) ?? resolve$2(resolved.root, resolved.runner);
+    resolved.runner = resolveModule(resolved.runner, { paths: [resolved.root] }) ?? resolve(resolved.root, resolved.runner);
+  }
+  if (resolved.deps.registerNodeLoader) {
+    const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
+    console.warn(
+      c.yellow(
+        `${c.inverse(c.yellow(" Vitest "))} "deps.registerNodeLoader" is deprecated.If you rely on aliases inside external packages, use "deps.optimizer.${transformMode}.include" instead.`
+      )
+    );
   }
-  (_d = resolved.deps).registerNodeLoader ?? (_d.registerNodeLoader = false);
   resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
   const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
   resolved.snapshotOptions = {
@@ -10632,6 +10878,10 @@ function resolveConfig(mode, options, viteConfig) {
     // resolved inside the worker
     snapshotEnvironment: null
   };
+  resolved.experimentalVmWorkerMemoryLimit = stringToBytes(
+    getWorkerMemoryLimit(resolved),
+    totalmem()
+  );
   if (options.resolveSnapshotPath)
     delete resolved.resolveSnapshotPath;
   if (process.env.VITEST_MAX_THREADS)
@@ -10661,7 +10911,7 @@ function resolveConfig(mode, options, viteConfig) {
   }
   resolved.setupFiles = toArray(resolved.setupFiles || []).map(
     (file) => normalize(
-      resolveModule(file, { paths: [resolved.root] }) ?? resolve$2(resolved.root, file)
+      resolveModule(file, { paths: [resolved.root] }) ?? resolve(resolved.root, file)
     )
   );
   resolved.coverage.exclude.push(...resolved.setupFiles.map((file) => relative(resolved.root, file)));
@@ -10671,11 +10921,11 @@ function resolveConfig(mode, options, viteConfig) {
   ];
   resolved.api = resolveApiServerConfig(options);
   if (options.related)
-    resolved.related = toArray(options.related).map((file) => resolve$2(resolved.root, file));
+    resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
   if (mode !== "benchmark") {
     const cliReporters = toArray(resolved.reporter || []).map((reporter) => {
       if (/^\.\.?\//.test(reporter))
-        return resolve$2(process.cwd(), reporter);
+        return resolve(process.cwd(), reporter);
       return reporter;
     });
     const reporters = cliReporters.length ? cliReporters : resolved.reporters;
@@ -10687,35 +10937,36 @@ function resolveConfig(mode, options, viteConfig) {
     resolved.passWithNoTests ?? (resolved.passWithNoTests = true);
   resolved.css ?? (resolved.css = {});
   if (typeof resolved.css === "object") {
-    (_e = resolved.css).modules ?? (_e.modules = {});
-    (_f = resolved.css.modules).classNameStrategy ?? (_f.classNameStrategy = "stable");
+    (_f = resolved.css).modules ?? (_f.modules = {});
+    (_g = resolved.css.modules).classNameStrategy ?? (_g.classNameStrategy = "stable");
   }
   resolved.cache ?? (resolved.cache = { dir: "" });
   if (resolved.cache)
     resolved.cache.dir = VitestCache.resolveCacheDir(resolved.root, resolved.cache.dir);
   resolved.sequence ?? (resolved.sequence = {});
-  if (!((_g = resolved.sequence) == null ? void 0 : _g.sequencer)) {
+  if (!((_h = resolved.sequence) == null ? void 0 : _h.sequencer)) {
     resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
   }
-  (_h = resolved.sequence).hooks ?? (_h.hooks = "parallel");
+  (_i = resolved.sequence).hooks ?? (_i.hooks = "parallel");
   if (resolved.sequence.sequencer === RandomSequencer)
-    (_i = resolved.sequence).seed ?? (_i.seed = Date.now());
+    (_j = resolved.sequence).seed ?? (_j.seed = Date.now());
   resolved.typecheck = {
     ...configDefaults.typecheck,
     ...resolved.typecheck
   };
-  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve$2(resolved.root, i[0]), i[1]]);
+  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve(resolved.root, i[0]), i[1]]);
   if (mode === "typecheck") {
     resolved.include = resolved.typecheck.include;
     resolved.exclude = resolved.typecheck.exclude;
   }
   resolved.browser ?? (resolved.browser = {});
-  (_j = resolved.browser).enabled ?? (_j.enabled = false);
-  (_k = resolved.browser).headless ?? (_k.headless = isCI);
-  (_l = resolved.browser).slowHijackESM ?? (_l.slowHijackESM = true);
+  (_k = resolved.browser).enabled ?? (_k.enabled = false);
+  (_l = resolved.browser).headless ?? (_l.headless = isCI);
+  (_m = resolved.browser).slowHijackESM ?? (_m.slowHijackESM = true);
   resolved.browser.api = resolveApiServerConfig(resolved.browser) || {
     port: defaultBrowserPort
   };
+  resolved.testTransformMode ?? (resolved.testTransformMode = {});
   return resolved;
 }
 function isBrowserEnabled(config) {
@@ -10725,7 +10976,7 @@ function isBrowserEnabled(config) {
   return ((_b = config.poolMatchGlobs) == null ? void 0 : _b.length) && config.poolMatchGlobs.some(([, pool]) => pool === "browser");
 }
 
-const ESC = '\u001B[';
+const ESC$1 = '\u001B[';
 const OSC = '\u001B]';
 const BEL = '\u0007';
 const SEP = ';';
@@ -10739,10 +10990,10 @@ ansiEscapes.cursorTo = (x, y) => {
 	}
 
 	if (typeof y !== 'number') {
-		return ESC + (x + 1) + 'G';
+		return ESC$1 + (x + 1) + 'G';
 	}
 
-	return ESC + (y + 1) + ';' + (x + 1) + 'H';
+	return ESC$1 + (y + 1) + ';' + (x + 1) + 'H';
 };
 
 ansiEscapes.cursorMove = (x, y) => {
@@ -10753,33 +11004,33 @@ ansiEscapes.cursorMove = (x, y) => {
 	let returnValue = '';
 
 	if (x < 0) {
-		returnValue += ESC + (-x) + 'D';
+		returnValue += ESC$1 + (-x) + 'D';
 	} else if (x > 0) {
-		returnValue += ESC + x + 'C';
+		returnValue += ESC$1 + x + 'C';
 	}
 
 	if (y < 0) {
-		returnValue += ESC + (-y) + 'A';
+		returnValue += ESC$1 + (-y) + 'A';
 	} else if (y > 0) {
-		returnValue += ESC + y + 'B';
+		returnValue += ESC$1 + y + 'B';
 	}
 
 	return returnValue;
 };
 
-ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
-ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
-ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
-ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
+ansiEscapes.cursorUp = (count = 1) => ESC$1 + count + 'A';
+ansiEscapes.cursorDown = (count = 1) => ESC$1 + count + 'B';
+ansiEscapes.cursorForward = (count = 1) => ESC$1 + count + 'C';
+ansiEscapes.cursorBackward = (count = 1) => ESC$1 + count + 'D';
 
-ansiEscapes.cursorLeft = ESC + 'G';
-ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
-ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
-ansiEscapes.cursorGetPosition = ESC + '6n';
-ansiEscapes.cursorNextLine = ESC + 'E';
-ansiEscapes.cursorPrevLine = ESC + 'F';
-ansiEscapes.cursorHide = ESC + '?25l';
-ansiEscapes.cursorShow = ESC + '?25h';
+ansiEscapes.cursorLeft = ESC$1 + 'G';
+ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC$1 + 's';
+ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC$1 + 'u';
+ansiEscapes.cursorGetPosition = ESC$1 + '6n';
+ansiEscapes.cursorNextLine = ESC$1 + 'E';
+ansiEscapes.cursorPrevLine = ESC$1 + 'F';
+ansiEscapes.cursorHide = ESC$1 + '?25l';
+ansiEscapes.cursorShow = ESC$1 + '?25h';
 
 ansiEscapes.eraseLines = count => {
 	let clear = '';
@@ -10795,24 +11046,24 @@ ansiEscapes.eraseLines = count => {
 	return clear;
 };
 
-ansiEscapes.eraseEndLine = ESC + 'K';
-ansiEscapes.eraseStartLine = ESC + '1K';
-ansiEscapes.eraseLine = ESC + '2K';
-ansiEscapes.eraseDown = ESC + 'J';
-ansiEscapes.eraseUp = ESC + '1J';
-ansiEscapes.eraseScreen = ESC + '2J';
-ansiEscapes.scrollUp = ESC + 'S';
-ansiEscapes.scrollDown = ESC + 'T';
+ansiEscapes.eraseEndLine = ESC$1 + 'K';
+ansiEscapes.eraseStartLine = ESC$1 + '1K';
+ansiEscapes.eraseLine = ESC$1 + '2K';
+ansiEscapes.eraseDown = ESC$1 + 'J';
+ansiEscapes.eraseUp = ESC$1 + '1J';
+ansiEscapes.eraseScreen = ESC$1 + '2J';
+ansiEscapes.scrollUp = ESC$1 + 'S';
+ansiEscapes.scrollDown = ESC$1 + 'T';
 
 ansiEscapes.clearScreen = '\u001Bc';
 
 ansiEscapes.clearTerminal = process.platform === 'win32' ?
-	`${ansiEscapes.eraseScreen}${ESC}0f` :
+	`${ansiEscapes.eraseScreen}${ESC$1}0f` :
 	// 1. Erases the screen (Only done in case `2` is not supported)
 	// 2. Erases the whole screen including scrollback buffer
 	// 3. Moves cursor to the top-left position
 	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
-	`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
+	`${ansiEscapes.eraseScreen}${ESC$1}3J${ESC$1}H`;
 
 ansiEscapes.beep = BEL;
 
@@ -11276,633 +11527,7 @@ createLogUpdate(process$1.stdout);
 
 createLogUpdate(process$1.stderr);
 
-var version = "0.33.0";
-
-const comma = ','.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars.length; i++) {
-    const c = chars.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
-}
-function decode(mappings) {
-    const state = new Int32Array(5);
-    const decoded = [];
-    let index = 0;
-    do {
-        const semi = indexOf(mappings, index);
-        const line = [];
-        let sorted = true;
-        let lastCol = 0;
-        state[0] = 0;
-        for (let i = index; i < semi; i++) {
-            let seg;
-            i = decodeInteger(mappings, i, state, 0); // genColumn
-            const col = state[0];
-            if (col < lastCol)
-                sorted = false;
-            lastCol = col;
-            if (hasMoreVlq(mappings, i, semi)) {
-                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
-                i = decodeInteger(mappings, i, state, 2); // sourceLine
-                i = decodeInteger(mappings, i, state, 3); // sourceColumn
-                if (hasMoreVlq(mappings, i, semi)) {
-                    i = decodeInteger(mappings, i, state, 4); // namesIndex
-                    seg = [col, state[1], state[2], state[3], state[4]];
-                }
-                else {
-                    seg = [col, state[1], state[2], state[3]];
-                }
-            }
-            else {
-                seg = [col];
-            }
-            line.push(seg);
-        }
-        if (!sorted)
-            sort(line);
-        decoded.push(line);
-        index = semi + 1;
-    } while (index <= mappings.length);
-    return decoded;
-}
-function indexOf(mappings, index) {
-    const idx = mappings.indexOf(';', index);
-    return idx === -1 ? mappings.length : idx;
-}
-function decodeInteger(mappings, pos, state, j) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = mappings.charCodeAt(pos++);
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -0x80000000 | -value;
-    }
-    state[j] += value;
-    return pos;
-}
-function hasMoreVlq(mappings, i, length) {
-    if (i >= length)
-        return false;
-    return mappings.charCodeAt(i) !== comma;
-}
-function sort(line) {
-    line.sort(sortComparator$1);
-}
-function sortComparator$1(a, b) {
-    return a[0] - b[0];
-}
-
-// Matches the scheme of a URL, eg "http://"
-const schemeRegex = /^[\w+.-]+:\/\//;
-/**
- * Matches the parts of a URL:
- * 1. Scheme, including ":", guaranteed.
- * 2. User/password, including "@", optional.
- * 3. Host, guaranteed.
- * 4. Port, including ":", optional.
- * 5. Path, including "/", optional.
- * 6. Query, including "?", optional.
- * 7. Hash, including "#", optional.
- */
-const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
-/**
- * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
- * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
- *
- * 1. Host, optional.
- * 2. Path, which may include "/", guaranteed.
- * 3. Query, including "?", optional.
- * 4. Hash, including "#", optional.
- */
-const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-var UrlType;
-(function (UrlType) {
-    UrlType[UrlType["Empty"] = 1] = "Empty";
-    UrlType[UrlType["Hash"] = 2] = "Hash";
-    UrlType[UrlType["Query"] = 3] = "Query";
-    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
-    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
-    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
-    UrlType[UrlType["Absolute"] = 7] = "Absolute";
-})(UrlType || (UrlType = {}));
-function isAbsoluteUrl(input) {
-    return schemeRegex.test(input);
-}
-function isSchemeRelativeUrl(input) {
-    return input.startsWith('//');
-}
-function isAbsolutePath(input) {
-    return input.startsWith('/');
-}
-function isFileUrl(input) {
-    return input.startsWith('file:');
-}
-function isRelative(input) {
-    return /^[.?#]/.test(input);
-}
-function parseAbsoluteUrl(input) {
-    const match = urlRegex.exec(input);
-    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
-}
-function parseFileUrl(input) {
-    const match = fileRegex.exec(input);
-    const path = match[2];
-    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
-}
-function makeUrl(scheme, user, host, port, path, query, hash) {
-    return {
-        scheme,
-        user,
-        host,
-        port,
-        path,
-        query,
-        hash,
-        type: UrlType.Absolute,
-    };
-}
-function parseUrl(input) {
-    if (isSchemeRelativeUrl(input)) {
-        const url = parseAbsoluteUrl('http:' + input);
-        url.scheme = '';
-        url.type = UrlType.SchemeRelative;
-        return url;
-    }
-    if (isAbsolutePath(input)) {
-        const url = parseAbsoluteUrl('http://foo.com' + input);
-        url.scheme = '';
-        url.host = '';
-        url.type = UrlType.AbsolutePath;
-        return url;
-    }
-    if (isFileUrl(input))
-        return parseFileUrl(input);
-    if (isAbsoluteUrl(input))
-        return parseAbsoluteUrl(input);
-    const url = parseAbsoluteUrl('http://foo.com/' + input);
-    url.scheme = '';
-    url.host = '';
-    url.type = input
-        ? input.startsWith('?')
-            ? UrlType.Query
-            : input.startsWith('#')
-                ? UrlType.Hash
-                : UrlType.RelativePath
-        : UrlType.Empty;
-    return url;
-}
-function stripPathFilename(path) {
-    // If a path ends with a parent directory "..", then it's a relative path with excess parent
-    // paths. It's not a file, so we can't strip it.
-    if (path.endsWith('/..'))
-        return path;
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-function mergePaths(url, base) {
-    normalizePath(base, base.type);
-    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
-    // path).
-    if (url.path === '/') {
-        url.path = base.path;
-    }
-    else {
-        // Resolution happens relative to the base path's directory, not the file.
-        url.path = stripPathFilename(base.path) + url.path;
-    }
-}
-/**
- * The path can have empty directories "//", unneeded parents "foo/..", or current directory
- * "foo/.". We need to normalize to a standard representation.
- */
-function normalizePath(url, type) {
-    const rel = type <= UrlType.RelativePath;
-    const pieces = url.path.split('/');
-    // We need to preserve the first piece always, so that we output a leading slash. The item at
-    // pieces[0] is an empty string.
-    let pointer = 1;
-    // Positive is the number of real directories we've output, used for popping a parent directory.
-    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
-    let positive = 0;
-    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
-    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
-    // real directory, we won't need to append, unless the other conditions happen again.
-    let addTrailingSlash = false;
-    for (let i = 1; i < pieces.length; i++) {
-        const piece = pieces[i];
-        // An empty directory, could be a trailing slash, or just a double "//" in the path.
-        if (!piece) {
-            addTrailingSlash = true;
-            continue;
-        }
-        // If we encounter a real directory, then we don't need to append anymore.
-        addTrailingSlash = false;
-        // A current directory, which we can always drop.
-        if (piece === '.')
-            continue;
-        // A parent directory, we need to see if there are any real directories we can pop. Else, we
-        // have an excess of parents, and we'll need to keep the "..".
-        if (piece === '..') {
-            if (positive) {
-                addTrailingSlash = true;
-                positive--;
-                pointer--;
-            }
-            else if (rel) {
-                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
-                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
-                pieces[pointer++] = piece;
-            }
-            continue;
-        }
-        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
-        // any popped or dropped directories.
-        pieces[pointer++] = piece;
-        positive++;
-    }
-    let path = '';
-    for (let i = 1; i < pointer; i++) {
-        path += '/' + pieces[i];
-    }
-    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
-        path += '/';
-    }
-    url.path = path;
-}
-/**
- * Attempts to resolve `input` URL/path relative to `base`.
- */
-function resolve$1(input, base) {
-    if (!input && !base)
-        return '';
-    const url = parseUrl(input);
-    let inputType = url.type;
-    if (base && inputType !== UrlType.Absolute) {
-        const baseUrl = parseUrl(base);
-        const baseType = baseUrl.type;
-        switch (inputType) {
-            case UrlType.Empty:
-                url.hash = baseUrl.hash;
-            // fall through
-            case UrlType.Hash:
-                url.query = baseUrl.query;
-            // fall through
-            case UrlType.Query:
-            case UrlType.RelativePath:
-                mergePaths(url, baseUrl);
-            // fall through
-            case UrlType.AbsolutePath:
-                // The host, user, and port are joined, you can't copy one without the others.
-                url.user = baseUrl.user;
-                url.host = baseUrl.host;
-                url.port = baseUrl.port;
-            // fall through
-            case UrlType.SchemeRelative:
-                // The input doesn't have a schema at least, so we need to copy at least that over.
-                url.scheme = baseUrl.scheme;
-        }
-        if (baseType > inputType)
-            inputType = baseType;
-    }
-    normalizePath(url, inputType);
-    const queryHash = url.query + url.hash;
-    switch (inputType) {
-        // This is impossible, because of the empty checks at the start of the function.
-        // case UrlType.Empty:
-        case UrlType.Hash:
-        case UrlType.Query:
-            return queryHash;
-        case UrlType.RelativePath: {
-            // The first char is always a "/", and we need it to be relative.
-            const path = url.path.slice(1);
-            if (!path)
-                return queryHash || '.';
-            if (isRelative(base || input) && !isRelative(path)) {
-                // If base started with a leading ".", or there is no base and input started with a ".",
-                // then we need to ensure that the relative path starts with a ".". We don't know if
-                // relative starts with a "..", though, so check before prepending.
-                return './' + path + queryHash;
-            }
-            return path + queryHash;
-        }
-        case UrlType.AbsolutePath:
-            return url.path + queryHash;
-        default:
-            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
-    }
-}
-
-function resolve(input, base) {
-    // The base is always treated as a directory, if it's not empty.
-    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-    if (base && !base.endsWith('/'))
-        base += '/';
-    return resolve$1(input, base);
-}
-
-/**
- * Removes everything after the last "/", but leaves the slash.
- */
-function stripFilename(path) {
-    if (!path)
-        return '';
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-
-const COLUMN = 0;
-const SOURCES_INDEX = 1;
-const SOURCE_LINE = 2;
-const SOURCE_COLUMN = 3;
-const REV_GENERATED_LINE = 1;
-const REV_GENERATED_COLUMN = 2;
-
-function maybeSort(mappings, owned) {
-    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
-    if (unsortedIndex === mappings.length)
-        return mappings;
-    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
-    // not, we do not want to modify the consumer's input array.
-    if (!owned)
-        mappings = mappings.slice();
-    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
-        mappings[i] = sortSegments(mappings[i], owned);
-    }
-    return mappings;
-}
-function nextUnsortedSegmentLine(mappings, start) {
-    for (let i = start; i < mappings.length; i++) {
-        if (!isSorted(mappings[i]))
-            return i;
-    }
-    return mappings.length;
-}
-function isSorted(line) {
-    for (let j = 1; j < line.length; j++) {
-        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
-            return false;
-        }
-    }
-    return true;
-}
-function sortSegments(line, owned) {
-    if (!owned)
-        line = line.slice();
-    return line.sort(sortComparator);
-}
-function sortComparator(a, b) {
-    return a[COLUMN] - b[COLUMN];
-}
-
-let found = false;
-/**
- * A binary search implementation that returns the index if a match is found.
- * If no match is found, then the left-index (the index associated with the item that comes just
- * before the desired index) is returned. To maintain proper sort order, a splice would happen at
- * the next index:
- *
- * ```js
- * const array = [1, 3];
- * const needle = 2;
- * const index = binarySearch(array, needle, (item, needle) => item - needle);
- *
- * assert.equal(index, 0);
- * array.splice(index + 1, 0, needle);
- * assert.deepEqual(array, [1, 2, 3]);
- * ```
- */
-function binarySearch(haystack, needle, low, high) {
-    while (low <= high) {
-        const mid = low + ((high - low) >> 1);
-        const cmp = haystack[mid][COLUMN] - needle;
-        if (cmp === 0) {
-            found = true;
-            return mid;
-        }
-        if (cmp < 0) {
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    found = false;
-    return low - 1;
-}
-function upperBound(haystack, needle, index) {
-    for (let i = index + 1; i < haystack.length; index = i++) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
-}
-function lowerBound(haystack, needle, index) {
-    for (let i = index - 1; i >= 0; index = i--) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
-}
-function memoizedState() {
-    return {
-        lastKey: -1,
-        lastNeedle: -1,
-        lastIndex: -1,
-    };
-}
-/**
- * This overly complicated beast is just to record the last tested line/column and the resulting
- * index, allowing us to skip a few tests if mappings are monotonically increasing.
- */
-function memoizedBinarySearch(haystack, needle, state, key) {
-    const { lastKey, lastNeedle, lastIndex } = state;
-    let low = 0;
-    let high = haystack.length - 1;
-    if (key === lastKey) {
-        if (needle === lastNeedle) {
-            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
-            return lastIndex;
-        }
-        if (needle >= lastNeedle) {
-            // lastIndex may be -1 if the previous needle was not found.
-            low = lastIndex === -1 ? 0 : lastIndex;
-        }
-        else {
-            high = lastIndex;
-        }
-    }
-    state.lastKey = key;
-    state.lastNeedle = needle;
-    return (state.lastIndex = binarySearch(haystack, needle, low, high));
-}
-
-// Rebuilds the original source files, with mappings that are ordered by source line/column instead
-// of generated line/column.
-function buildBySources(decoded, memos) {
-    const sources = memos.map(buildNullArray);
-    for (let i = 0; i < decoded.length; i++) {
-        const line = decoded[i];
-        for (let j = 0; j < line.length; j++) {
-            const seg = line[j];
-            if (seg.length === 1)
-                continue;
-            const sourceIndex = seg[SOURCES_INDEX];
-            const sourceLine = seg[SOURCE_LINE];
-            const sourceColumn = seg[SOURCE_COLUMN];
-            const originalSource = sources[sourceIndex];
-            const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
-            const memo = memos[sourceIndex];
-            // The binary search either found a match, or it found the left-index just before where the
-            // segment should go. Either way, we want to insert after that. And there may be multiple
-            // generated segments associated with an original location, so there may need to move several
-            // indexes before we find where we need to insert.
-            const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
-            insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
-        }
-    }
-    return sources;
-}
-function insert(array, index, value) {
-    for (let i = array.length; i > index; i--) {
-        array[i] = array[i - 1];
-    }
-    array[index] = value;
-}
-// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
-// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
-// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
-// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
-// order when iterating with for-in.
-function buildNullArray() {
-    return { __proto__: null };
-}
-
-const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
-const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
-const LEAST_UPPER_BOUND = -1;
-const GREATEST_LOWER_BOUND = 1;
-/**
- * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
- */
-let decodedMappings;
-/**
- * Finds the generated line/column position of the provided source/line/column source position.
- */
-let generatedPositionFor;
-class TraceMap {
-    constructor(map, mapUrl) {
-        const isString = typeof map === 'string';
-        if (!isString && map._decodedMemo)
-            return map;
-        const parsed = (isString ? JSON.parse(map) : map);
-        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
-        this.version = version;
-        this.file = file;
-        this.names = names;
-        this.sourceRoot = sourceRoot;
-        this.sources = sources;
-        this.sourcesContent = sourcesContent;
-        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-        this.resolvedSources = sources.map((s) => resolve(s || '', from));
-        const { mappings } = parsed;
-        if (typeof mappings === 'string') {
-            this._encoded = mappings;
-            this._decoded = undefined;
-        }
-        else {
-            this._encoded = undefined;
-            this._decoded = maybeSort(mappings, isString);
-        }
-        this._decodedMemo = memoizedState();
-        this._bySources = undefined;
-        this._bySourceMemos = undefined;
-    }
-}
-(() => {
-    decodedMappings = (map) => {
-        return (map._decoded || (map._decoded = decode(map._encoded)));
-    };
-    generatedPositionFor = (map, { source, line, column, bias }) => {
-        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
-    };
-    function generatedPosition(map, source, line, column, bias, all) {
-        line--;
-        if (line < 0)
-            throw new Error(LINE_GTR_ZERO);
-        if (column < 0)
-            throw new Error(COL_GTR_EQ_ZERO);
-        const { sources, resolvedSources } = map;
-        let sourceIndex = sources.indexOf(source);
-        if (sourceIndex === -1)
-            sourceIndex = resolvedSources.indexOf(source);
-        if (sourceIndex === -1)
-            return all ? [] : GMapping(null, null);
-        const generated = (map._bySources || (map._bySources = buildBySources(decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
-        const segments = generated[sourceIndex][line];
-        if (segments == null)
-            return all ? [] : GMapping(null, null);
-        const memo = map._bySourceMemos[sourceIndex];
-        if (all)
-            return sliceGeneratedPositions(segments, memo, line, column, bias);
-        const index = traceSegmentInternal(segments, memo, line, column, bias);
-        if (index === -1)
-            return GMapping(null, null);
-        const segment = segments[index];
-        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
-    }
-})();
-function GMapping(line, column) {
-    return { line, column };
-}
-function traceSegmentInternal(segments, memo, line, column, bias) {
-    let index = memoizedBinarySearch(segments, column, memo, line);
-    if (found) {
-        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
-    }
-    else if (bias === LEAST_UPPER_BOUND)
-        index++;
-    if (index === -1 || index === segments.length)
-        return -1;
-    return index;
-}
-function sliceGeneratedPositions(segments, memo, line, column, bias) {
-    let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
-    // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
-    // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
-    // still need to call `lowerBound()` to find the first segment, which is slower than just looking
-    // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
-    // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
-    // match LEAST_UPPER_BOUND.
-    if (!found && bias === LEAST_UPPER_BOUND)
-        min++;
-    if (min === -1 || min === segments.length)
-        return [];
-    // We may have found the segment that started at an earlier column. If this is the case, then we
-    // need to slice all generated segments that match _that_ column, because all such segments span
-    // to our desired column.
-    const matchedColumn = found ? column : segments[min][COLUMN];
-    // The binary search is not guaranteed to find the lower bound when a match wasn't found.
-    if (!found)
-        min = lowerBound(segments, matchedColumn, min);
-    const max = upperBound(segments, matchedColumn, min);
-    const result = [];
-    for (; min <= max; min++) {
-        const segment = segments[min];
-        result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
-    }
-    return result;
-}
+var version = "0.34.0";
 
 const A=r=>r!==null&&typeof r=="object",a=(r,t)=>Object.assign(new Error(`[${r}]: ${t}`),{code:r}),_$1="ERR_INVALID_PACKAGE_CONFIG",E="ERR_INVALID_PACKAGE_TARGET",I="ERR_PACKAGE_PATH_NOT_EXPORTED",R$1=/^\d+$/,O=/^(\.{1,2}|node_modules)$/i,w=/\/|\\/;var h=(r=>(r.Export="exports",r.Import="imports",r))(h||{});const f=(r,t,e,o,c)=>{if(t==null)return [];if(typeof t=="string"){const[n,...i]=t.split(w);if(n===".."||i.some(l=>O.test(l)))throw a(E,`Invalid "${r}" target "${t}" defined in the package config`);return [c?t.replace(/\*/g,c):t]}if(Array.isArray(t))return t.flatMap(n=>f(r,n,e,o,c));if(A(t)){for(const n of Object.keys(t)){if(R$1.test(n))throw a(_$1,"Cannot contain numeric property keys");if(n==="default"||o.includes(n))return f(r,t[n],e,o,c)}return []}throw a(E,`Invalid "${r}" target "${t}"`)},s="*",m=(r,t)=>{const e=r.indexOf(s),o=t.indexOf(s);return e===o?t.length>r.length:o>e};function d$1(r,t){if(!t.includes(s)&&r.hasOwnProperty(t))return [t];let e,o;for(const c of Object.keys(r))if(c.includes(s)){const[n,i,l]=c.split(s);if(l===void 0&&t.startsWith(n)&&t.endsWith(i)){const g=t.slice(n.length,-i.length||void 0);g&&(!e||m(e,c))&&(e=c,o=g);}}return [e,o]}const p=r=>Object.keys(r).reduce((t,e)=>{const o=e===""||e[0]!==".";if(t===void 0||t===o)return o;throw a(_$1,'"exports" cannot contain some keys starting with "." and some not')},void 0),u=/^\w+:/,v=(r,t,e)=>{if(!r)throw new Error('"exports" is required');t=t===""?".":`./${t}`,(typeof r=="string"||Array.isArray(r)||A(r)&&p(r))&&(r={".":r});const[o,c]=d$1(r,t),n=f(h.Export,r[o],t,e,c);if(n.length===0)throw a(I,t==="."?'No "exports" main defined':`Package subpath '${t}' is not defined by "exports"`);for(const i of n)if(!i.startsWith("./")&&!u.test(i))throw a(E,`Invalid "exports" target "${i}" defined in the package config`);return n};
 
@@ -11947,7 +11572,7 @@ async function makeTscErrorInfo(errInfo) {
 }
 async function getTsconfig(root, config) {
   const configName = config.tsconfig ? basename(config.tsconfig) : void 0;
-  const configSearchPath = config.tsconfig ? dirname(resolve$2(root, config.tsconfig)) : root;
+  const configSearchPath = config.tsconfig ? dirname(resolve(root, config.tsconfig)) : root;
   const tsconfig = Te(configSearchPath, configName);
   if (!tsconfig)
     throw new Error("no tsconfig.json found");
@@ -12270,7 +11895,7 @@ class Typechecker {
     const errorsMap = await getRawErrsMapFromTsCompile(output);
     const typesErrors = /* @__PURE__ */ new Map();
     errorsMap.forEach((errors, path) => {
-      const filepath = resolve$2(this.ctx.config.root, path);
+      const filepath = resolve(this.ctx.config.root, path);
       const suiteErrors = errors.map((info) => {
         const limit = Error.stackTraceLimit;
         Error.stackTraceLimit = 0;
@@ -12379,8 +12004,9 @@ class Typechecker {
   }
 }
 
-async function printError(error, ctx, options = {}) {
+async function printError(error, project, options) {
   const { showCodeFrame = true, fullStack = false, type } = options;
+  const logger = options.logger;
   let e = error;
   if (isPrimitive(e)) {
     e = {
@@ -12395,25 +12021,31 @@ async function printError(error, ctx, options = {}) {
       stack: error2.stack
     };
   }
-  if (!ctx.config)
-    return printErrorMessage(e, ctx.logger);
-  const stacks = parseErrorStacktrace(e, fullStack ? [] : void 0);
+  if (!project)
+    return printErrorMessage(e, logger);
+  const parserOptions = {
+    // only browser stack traces require remapping
+    getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+  };
+  if (fullStack)
+    parserOptions.ignoreStackEntries = [];
+  const stacks = parseErrorStacktrace(e, parserOptions);
   const nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find(
-    (stack) => ctx.getModuleProjects(stack.file).length && existsSync(stack.file)
+    (stack) => project.getModuleById(stack.file) && existsSync(stack.file)
   );
   const errorProperties = getErrorProperties(e);
   if (type)
-    printErrorType(type, ctx);
-  printErrorMessage(e, ctx.logger);
+    printErrorType(type, project.ctx);
+  printErrorMessage(e, logger);
   if (e.diff)
-    displayDiff(e.diff, ctx.logger.console);
+    displayDiff(e.diff, logger.console);
   if (e.frame) {
-    ctx.logger.error(c.yellow(e.frame));
+    logger.error(c.yellow(e.frame));
   } else {
-    printStack(ctx, stacks, nearest, errorProperties, (s) => {
+    printStack(project, stacks, nearest, errorProperties, (s) => {
       if (showCodeFrame && s === nearest && nearest) {
         const sourceCode = readFileSync(nearest.file, "utf-8");
-        ctx.logger.error(generateCodeFrame(sourceCode, 4, s.line, s.column));
+        logger.error(generateCodeFrame(sourceCode, 4, s.line, s.column));
       }
     });
   }
@@ -12421,20 +12053,20 @@ async function printError(error, ctx, options = {}) {
   const testName = e.VITEST_TEST_NAME;
   const afterEnvTeardown = e.VITEST_AFTER_ENV_TEARDOWN;
   if (testPath)
-    ctx.logger.error(c.red(`This error originated in "${c.bold(testPath)}" test file. It doesn't mean the error was thrown inside the file itself, but while it was running.`));
+    logger.error(c.red(`This error originated in "${c.bold(testPath)}" test file. It doesn't mean the error was thrown inside the file itself, but while it was running.`));
   if (testName) {
-    ctx.logger.error(c.red(`The latest test that might've caused the error is "${c.bold(testName)}". It might mean one of the following:
+    logger.error(c.red(`The latest test that might've caused the error is "${c.bold(testName)}". It might mean one of the following:
 - The error was thrown, while Vitest was running this test.
 - This was the last recorded test before the error was thrown, if error originated after test finished its execution.`));
   }
   if (afterEnvTeardown) {
-    ctx.logger.error(c.red("This error was caught after test environment was torn down. Make sure to cancel any running tasks before test finishes:\n- cancel timeouts using clearTimeout and clearInterval\n- wait for promises to resolve using the await keyword"));
+    logger.error(c.red("This error was caught after test environment was torn down. Make sure to cancel any running tasks before test finishes:\n- cancel timeouts using clearTimeout and clearInterval\n- wait for promises to resolve using the await keyword"));
   }
   if (typeof e.cause === "object" && e.cause && "name" in e.cause) {
     e.cause.name = `Caused by: ${e.cause.name}`;
-    await printError(e.cause, ctx, { fullStack, showCodeFrame: false });
+    await printError(e.cause, project, { fullStack, showCodeFrame: false, logger: options.logger });
   }
-  handleImportOutsideModuleError(e.stack || e.stackStr || "", ctx);
+  handleImportOutsideModuleError(e.stack || e.stackStr || "", logger);
 }
 function printErrorType(type, ctx) {
   ctx.logger.error(`
@@ -12471,7 +12103,7 @@ const esmErrors = [
   "Cannot use import statement outside a module",
   "Unexpected token 'export'"
 ];
-function handleImportOutsideModuleError(stack, ctx) {
+function handleImportOutsideModuleError(stack, logger) {
   if (!esmErrors.some((e) => stack.includes(e)))
     return;
   const path = normalize(stack.split("\n")[0].trim());
@@ -12481,9 +12113,9 @@ function handleImportOutsideModuleError(stack, ctx) {
   else
     name = name.split("/")[0];
   if (name)
-    printModuleWarningForPackage(ctx.logger, path, name);
+    printModuleWarningForPackage(logger, path, name);
   else
-    printModuleWarningForSourceCode(ctx.logger, path);
+    printModuleWarningForSourceCode(logger, path);
 }
 function printModuleWarningForPackage(logger, path, name) {
   logger.error(c.yellow(
@@ -12516,17 +12148,21 @@ ${diff}
 }
 function printErrorMessage(error, logger) {
   const errorName = error.name || error.nameStr || "Unknown Error";
+  if (!error.message) {
+    logger.error(error);
+    return;
+  }
   if (error.message.length > 5e3) {
     logger.error(`${c.red(c.bold(errorName))}: ${error.message}`);
   } else {
     logger.error(c.red(`${c.bold(errorName)}: ${error.message}`));
   }
 }
-function printStack(ctx, stack, highlight, errorProperties, onStack) {
-  const logger = ctx.logger;
+function printStack(project, stack, highlight, errorProperties, onStack) {
+  const logger = project.ctx.logger;
   for (const frame of stack) {
     const color = frame === highlight ? c.cyan : c.gray;
-    const path = relative(ctx.config.root, frame.file);
+    const path = relative(project.config.root, frame.file);
     logger.error(color(` ${c.dim(F_POINTER)} ${[frame.method, `${path}:${c.dim(`${frame.line}:${frame.column}`)}`].filter(Boolean).join(" ")}`));
     onStack == null ? void 0 : onStack(frame);
   }
@@ -12535,7 +12171,7 @@ function printStack(ctx, stack, highlight, errorProperties, onStack) {
   const hasProperties = Object.keys(errorProperties).length > 0;
   if (hasProperties) {
     logger.error(c.red(c.dim(divider())));
-    const propertiesString = stringify$5(errorProperties, 10, { printBasicPrototype: false });
+    const propertiesString = inspect(errorProperties);
     logger.error(c.red(c.bold("Serialized Error:")), c.gray(propertiesString));
   }
 }
@@ -12580,6 +12216,11 @@ function generateCodeFrame(source, indent = 0, lineNumber, columnNumber, range =
   return res.join("\n");
 }
 
+const ESC = "\x1B[";
+const ERASE_DOWN = `${ESC}J`;
+const ERASE_SCROLLBACK = `${ESC}3J`;
+const CURSOR_TO_START = `${ESC}1;1H`;
+const CLEAR_SCREEN = "\x1Bc";
 class Logger {
   constructor(ctx, console = globalThis.console) {
     this.ctx = ctx;
@@ -12606,7 +12247,7 @@ class Logger {
       this.console.log(message);
       return;
     }
-    this.console.log(`\x1Bc${message}`);
+    this.console.log(`${ERASE_SCROLLBACK}${CLEAR_SCREEN}${message}`);
   }
   clearScreen(message, force = false) {
     if (this.ctx.server.config.clearScreen === false) {
@@ -12622,16 +12263,20 @@ class Logger {
       return;
     const log = this._clearScreenPending;
     this._clearScreenPending = void 0;
-    this.console.log(`\x1B[1;1H\x1B[J${log}`);
+    this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
   }
-  printError(err, fullStack = false, type) {
-    return printError(err, this.ctx, {
+  printError(err, options = {}) {
+    const { fullStack = false, type } = options;
+    const project = options.project ?? this.ctx.getCoreWorkspaceProject() ?? this.ctx.projects[0];
+    return printError(err, project, {
       fullStack,
       type,
-      showCodeFrame: true
+      showCodeFrame: true,
+      logger: this
     });
   }
   printNoTestFound(filters) {
+    var _a;
     const config = this.ctx.config;
     const comma = c.dim(", ");
     if (filters == null ? void 0 : filters.length)
@@ -12642,12 +12287,17 @@ class Logger {
       this.console.error(c.dim("exclude:  ") + c.yellow(config.exclude.join(comma)));
     if (config.watchExclude)
       this.console.error(c.dim("watch exclude:  ") + c.yellow(config.watchExclude.join(comma)));
-    if (config.passWithNoTests)
-      this.log(`No ${config.mode} files found, exiting with code 0
+    if (config.watch && (config.changed || ((_a = config.related) == null ? void 0 : _a.length))) {
+      this.log(`No affected ${config.mode} files found
 `);
-    else
-      this.error(c.red(`
+    } else {
+      if (config.passWithNoTests)
+        this.log(`No ${config.mode} files found, exiting with code 0
+`);
+      else
+        this.error(c.red(`
 No ${config.mode} files found, exiting with code 1`));
+    }
   }
   printBanner() {
     var _a, _b;
@@ -12682,7 +12332,7 @@ This might cause false positive tests. Resolve unhandled errors to make sure you
     this.log(c.red(divider(c.bold(c.inverse(" Unhandled Errors ")))));
     this.log(errorMessage);
     await Promise.all(errors.map(async (err) => {
-      await this.printError(err, true, err.type || "Unhandled Error");
+      await this.printError(err, { fullStack: true, type: err.type || "Unhandled Error" });
     }));
     this.log(c.red(divider()));
   }
@@ -12694,7 +12344,7 @@ Vitest found ${errors.length} error${errors.length > 1 ? "s" : ""} not related t
     this.log(c.red(divider(c.bold(c.inverse(" Source Errors ")))));
     this.log(errorMessage);
     await Promise.all(errors.map(async (err) => {
-      await this.printError(err, true);
+      await this.printError(err, { fullStack: true });
     }));
     this.log(c.red(divider()));
   }
@@ -12853,7 +12503,7 @@ function MocksPlugin() {
 async function createBrowserServer(project, options) {
   const root = project.config.root;
   await ensurePackageInstalled("@vitest/browser", root);
-  const configPath = options.config === false ? false : options.config ? resolve$2(root, options.config) : await findUp(configFiles, { cwd: root });
+  const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
   const server = await createServer({
     logLevel: "error",
     mode: project.config.mode,
@@ -12891,7 +12541,7 @@ async function createBrowserServer(project, options) {
   });
   await server.listen();
   await server.watcher.close();
-  (await import('./chunk-api-setup.8f785c4a.js')).setup(project, server);
+  (await import('./chunk-api-setup.644415c3.js')).setup(project, server);
   return server;
 }
 
@@ -13094,21 +12744,29 @@ function CSSEnablerPlugin(ctx) {
   ];
 }
 
-function EnvReplacerPlugin() {
+function SsrReplacerPlugin() {
   return {
     name: "vitest:env-replacer",
     enforce: "pre",
     transform(code, id) {
-      if (!/\bimport\.meta\.env\b/g.test(code))
+      if (!/\bimport\.meta\.env\b/.test(code) && !/\bimport\.meta\.url\b/.test(code))
         return null;
       let s = null;
-      const envs = stripLiteral(code).matchAll(/\bimport\.meta\.env\b/g);
+      const cleanCode = stripLiteral(code);
+      const envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
       for (const env of envs) {
         s || (s = new MagicString(code));
         const startIndex = env.index;
         const endIndex = startIndex + env[0].length;
         s.overwrite(startIndex, endIndex, "process.env");
       }
+      const urls = cleanCode.matchAll(/\bimport\.meta\.url\b/g);
+      for (const env of urls) {
+        s || (s = new MagicString(code));
+        const startIndex = env.index;
+        const endIndex = startIndex + env[0].length;
+        s.overwrite(startIndex, endIndex, "__vite_ssr_import_meta__.url");
+      }
       if (s) {
         return {
           code: s.toString(),
@@ -13192,14 +12850,17 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
   };
 }
 
-function resolveOptimizerConfig(testOptionc, viteOptions, testConfig) {
+function resolveOptimizerConfig(_testOptions, viteOptions, testConfig) {
   var _a;
+  const testOptions = _testOptions || {};
   const newConfig = {};
   const [major, minor] = version$2.split(".").map(Number);
   const allowed = major >= 5 || major === 4 && minor >= 3;
-  if (!allowed && (testOptionc == null ? void 0 : testOptionc.enabled) === true)
+  if (!allowed && (testOptions == null ? void 0 : testOptions.enabled) === true)
     console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.0, current Vite version: ${version$2}`);
-  if (!allowed || (testOptionc == null ? void 0 : testOptionc.enabled) !== true) {
+  else
+    testOptions.enabled ?? (testOptions.enabled = true);
+  if (!allowed || (testOptions == null ? void 0 : testOptions.enabled) !== true) {
     newConfig.cacheDir = void 0;
     newConfig.optimizeDeps = {
       // experimental in Vite >2.9.2, entries remains to help with older versions
@@ -13211,12 +12872,12 @@ function resolveOptimizerConfig(testOptionc, viteOptions, testConfig) {
     newConfig.cacheDir = cacheDir ?? "node_modules/.vitest";
     newConfig.optimizeDeps = {
       ...viteOptions,
-      ...testOptionc,
+      ...testOptions,
       noDiscovery: true,
       disabled: false,
       entries: [],
-      exclude: ["vitest", ...builtinModules, ...testOptionc.exclude || (viteOptions == null ? void 0 : viteOptions.exclude) || []],
-      include: (testOptionc.include || (viteOptions == null ? void 0 : viteOptions.include) || []).filter((n) => n !== "vitest")
+      exclude: ["vitest", ...builtinModules, ...testOptions.exclude || (viteOptions == null ? void 0 : viteOptions.exclude) || []],
+      include: (testOptions.include || (viteOptions == null ? void 0 : viteOptions.include) || []).filter((n) => n !== "vitest")
     };
   }
   return newConfig;
@@ -13334,8 +12995,8 @@ function WorkspaceVitestPlugin(project, options) {
             };
           }
         }
-        const webOptimizer = resolveOptimizerConfig((_e = (_d = testConfig.deps) == null ? void 0 : _d.experimentalOptimizer) == null ? void 0 : _e.web, viteConfig.optimizeDeps, testConfig);
-        const ssrOptimizer = resolveOptimizerConfig((_g = (_f = testConfig.deps) == null ? void 0 : _f.experimentalOptimizer) == null ? void 0 : _g.ssr, (_h = viteConfig.ssr) == null ? void 0 : _h.optimizeDeps, testConfig);
+        const webOptimizer = resolveOptimizerConfig((_e = (_d = testConfig.deps) == null ? void 0 : _d.optimizer) == null ? void 0 : _e.web, viteConfig.optimizeDeps, testConfig);
+        const ssrOptimizer = resolveOptimizerConfig((_g = (_f = testConfig.deps) == null ? void 0 : _f.optimizer) == null ? void 0 : _g.ssr, (_h = viteConfig.ssr) == null ? void 0 : _h.optimizeDeps, testConfig);
         config.cacheDir = webOptimizer.cacheDir || ssrOptimizer.cacheDir || config.cacheDir;
         config.optimizeDeps = webOptimizer.optimizeDeps;
         config.ssr = {
@@ -13352,13 +13013,13 @@ function WorkspaceVitestPlugin(project, options) {
           );
           await project.setServer(options2, server);
         } catch (err) {
-          await project.ctx.logger.printError(err, true);
+          await project.ctx.logger.printError(err, { fullStack: true });
           process.exit(1);
         }
         await server.watcher.close();
       }
     },
-    EnvReplacerPlugin(),
+    SsrReplacerPlugin(),
     ...CSSEnablerPlugin(project),
     CoverageTransform(project.ctx),
     GlobalSetupPlugin(project, project.ctx.logger),
@@ -13370,7 +13031,7 @@ function WorkspaceVitestPlugin(project, options) {
 async function initializeProject(workspacePath, ctx, options) {
   var _a, _b, _c, _d, _e, _f, _g;
   const project = new WorkspaceProject(workspacePath, ctx);
-  const configFile = options.extends ? resolve$2(dirname(options.workspaceConfigPath), options.extends) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
+  const configFile = options.extends ? resolve(dirname(options.workspaceConfigPath), options.extends) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
   const root = options.root || (typeof workspacePath === "number" ? void 0 : dirname(workspacePath));
   const config = {
     ...options,
@@ -13385,7 +13046,7 @@ async function initializeProject(workspacePath, ctx, options) {
     ]
   };
   const server = await createServer(config);
-  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = project.config.deps) == null ? void 0 : _b.experimentalOptimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = project.config.deps) == null ? void 0 : _e.experimentalOptimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
+  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = project.config.deps) == null ? void 0 : _b.optimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = project.config.deps) == null ? void 0 : _e.optimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
     await server.listen();
   else
     await server.pluginContainer.buildStart({});
@@ -13401,16 +13062,30 @@ class WorkspaceProject {
   server;
   vitenode;
   runner;
-  browser = void 0;
+  browser;
   typechecker;
   closingPromise;
   browserProvider;
+  testFilesList = [];
   getName() {
     return this.config.name || "";
   }
   isCore() {
     return this.ctx.getCoreWorkspaceProject() === this;
   }
+  getModuleById(id) {
+    var _a;
+    return this.server.moduleGraph.getModuleById(id) || ((_a = this.browser) == null ? void 0 : _a.moduleGraph.getModuleById(id));
+  }
+  getSourceMapModuleById(id) {
+    var _a, _b;
+    const mod = this.server.moduleGraph.getModuleById(id);
+    return ((_a = mod == null ? void 0 : mod.ssrTransformResult) == null ? void 0 : _a.map) || ((_b = mod == null ? void 0 : mod.transformResult) == null ? void 0 : _b.map);
+  }
+  getBrowserSourceMapModuleById(id) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.browser) == null ? void 0 : _a.moduleGraph.getModuleById(id)) == null ? void 0 : _b.transformResult) == null ? void 0 : _c.map;
+  }
   get reporters() {
     return this.ctx.reporters;
   }
@@ -13434,8 +13109,12 @@ class WorkspaceProject {
         }
       }));
     }
+    this.testFilesList = testFiles;
     return testFiles;
   }
+  isTestFile(id) {
+    return this.testFilesList.includes(id);
+  }
   async globFiles(include, exclude, cwd) {
     const globOptions = {
       absolute: true,
@@ -13572,10 +13251,10 @@ class WorkspaceProject {
           ...this.config.deps,
           optimizer: {
             web: {
-              enabled: ((_c = (_b = (_a = this.config.deps) == null ? void 0 : _a.experimentalOptimizer) == null ? void 0 : _b.web) == null ? void 0 : _c.enabled) ?? false
+              enabled: ((_c = (_b = (_a = this.config.deps) == null ? void 0 : _a.optimizer) == null ? void 0 : _b.web) == null ? void 0 : _c.enabled) ?? false
             },
             ssr: {
-              enabled: ((_f = (_e = (_d = this.config.deps) == null ? void 0 : _d.experimentalOptimizer) == null ? void 0 : _e.ssr) == null ? void 0 : _f.enabled) ?? false
+              enabled: ((_f = (_e = (_d = this.config.deps) == null ? void 0 : _d.optimizer) == null ? void 0 : _e.ssr) == null ? void 0 : _f.enabled) ?? false
             }
           }
         },
@@ -13677,7 +13356,7 @@ class Vitest {
     this.snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
     if (this.config.watch && this.mode !== "typecheck")
       this.registerWatcher();
-    this.vitenode = new ViteNodeServer(server, this.config);
+    this.vitenode = new ViteNodeServer(server, this.config.server);
     const node = this.vitenode;
     this.runner = new ViteNodeRunner({
       root: server.config.root,
@@ -13727,6 +13406,12 @@ class Vitest {
   getCoreWorkspaceProject() {
     return this.coreWorkspace || null;
   }
+  getProjectByTaskId(taskId) {
+    var _a;
+    const task = this.state.idMap.get(taskId);
+    const projectName = task.projectName || ((_a = task == null ? void 0 : task.file) == null ? void 0 : _a.projectName);
+    return this.projects.find((p) => p.getName() === projectName) || this.getCoreWorkspaceProject() || this.projects[0];
+  }
   async resolveWorkspace(options, cliOptions) {
     const configDir = this.server.config.configFile ? dirname(this.server.config.configFile) : this.config.root;
     const rootFiles = await promises.readdir(configDir);
@@ -13826,7 +13511,7 @@ class Vitest {
     return Promise.all(this.projects.map((project) => project.typecheck(filters)));
   }
   async start(filters) {
-    var _a;
+    var _a, _b;
     if (this.mode === "typecheck") {
       await this.typecheck(filters);
       return;
@@ -13842,32 +13527,40 @@ class Vitest {
       await this.globTestFiles(filters)
     );
     if (!files.length) {
-      const exitCode = this.config.passWithNoTests ? 0 : 1;
       await this.reportCoverage(true);
       this.logger.printNoTestFound(filters);
-      process.exit(exitCode);
+      if (!this.config.watch || !(this.config.changed || ((_b = this.config.related) == null ? void 0 : _b.length))) {
+        const exitCode = this.config.passWithNoTests ? 0 : 1;
+        process.exit(exitCode);
+      }
+    }
+    this.config.changed = false;
+    this.config.related = void 0;
+    if (files.length) {
+      await this.cache.stats.populateStats(this.config.root, files);
+      await this.runFiles(files);
     }
-    await this.cache.stats.populateStats(this.config.root, files);
-    await this.runFiles(files);
     await this.reportCoverage(true);
     if (this.config.watch)
       await this.report("onWatcherStart");
   }
-  async getTestDependencies(filepath) {
-    const deps = /* @__PURE__ */ new Set();
+  async getTestDependencies(filepath, deps = /* @__PURE__ */ new Set()) {
     const addImports = async ([project, filepath2]) => {
-      const transformed = await project.vitenode.transformRequest(filepath2);
+      if (deps.has(filepath2))
+        return;
+      const mod = project.server.moduleGraph.getModuleById(filepath2);
+      const transformed = (mod == null ? void 0 : mod.ssrTransformResult) || await project.vitenode.transformRequest(filepath2);
       if (!transformed)
         return;
       const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
-      for (const dep of dependencies) {
+      await Promise.all(dependencies.map(async (dep) => {
         const path = await this.server.pluginContainer.resolveId(dep, filepath2, { ssr: true });
         const fsPath = path && !path.external && path.id.split("?")[0];
         if (fsPath && !fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) {
           deps.add(fsPath);
           await addImports([project, fsPath]);
         }
-      }
+      }));
     };
     await addImports(filepath);
     return deps;
@@ -13891,7 +13584,7 @@ class Vitest {
     const forceRerunTriggers = this.config.forceRerunTriggers;
     if (forceRerunTriggers.length && mm(related, forceRerunTriggers).length)
       return specs;
-    if (!related.length)
+    if (!this.config.watch && !related.length)
       return [];
     const testGraphs = await Promise.all(
       specs.map(async (spec) => {
@@ -14027,8 +13720,7 @@ class Vitest {
   }
   getModuleProjects(id) {
     return this.projects.filter((project) => {
-      var _a, _b, _c;
-      return project.server.moduleGraph.getModuleById(id) || ((_a = project.browser) == null ? void 0 : _a.moduleGraph.getModuleById(id)) || ((_c = (_b = project.browser) == null ? void 0 : _b.moduleGraph.getModulesByFile(id)) == null ? void 0 : _c.size);
+      return project.getModuleById(id);
     });
   }
   unregisterWatcher = noop$1;
@@ -14095,13 +13787,14 @@ class Vitest {
       return [];
     if (mm.isMatch(id, this.config.forceRerunTriggers)) {
       this.state.getFilepaths().forEach((file) => this.changedTests.add(file));
-      return [];
+      return [id];
     }
     const projects = this.getModuleProjects(id);
     if (!projects.length)
       return [];
     const files = [];
-    for (const { server, browser } of projects) {
+    for (const project of projects) {
+      const { server, browser } = project;
       const mod = server.moduleGraph.getModuleById(id) || (browser == null ? void 0 : browser.moduleGraph.getModuleById(id));
       if (!mod) {
         const mods = browser == null ? void 0 : browser.moduleGraph.getModulesByFile(id);
@@ -14118,7 +13811,7 @@ class Vitest {
       }
       id = normalizeRequestId(id, server.config.base);
       this.invalidates.add(id);
-      if (this.state.filesMap.has(id)) {
+      if (this.state.filesMap.has(id) || project.isTestFile(id)) {
         this.changedTests.add(id);
         files.push(id);
         continue;
@@ -14283,6 +13976,10 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             preTransformRequests: false
           }
         };
+        if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) {
+          config.server.watch.useFsEvents = false;
+          config.server.watch.usePolling = false;
+        }
         const classNameStrategy = typeof testConfig.css !== "boolean" && ((_c = (_b = testConfig.css) == null ? void 0 : _b.modules) == null ? void 0 : _c.classNameStrategy) || "stable";
         if (classNameStrategy !== "scoped") {
           config.css ?? (config.css = {});
@@ -14294,8 +13991,8 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             };
           }
         }
-        const webOptimizer = resolveOptimizerConfig((_f = (_e = testConfig.deps) == null ? void 0 : _e.experimentalOptimizer) == null ? void 0 : _f.web, viteConfig.optimizeDeps, testConfig);
-        const ssrOptimizer = resolveOptimizerConfig((_h = (_g = testConfig.deps) == null ? void 0 : _g.experimentalOptimizer) == null ? void 0 : _h.ssr, (_i = viteConfig.ssr) == null ? void 0 : _i.optimizeDeps, testConfig);
+        const webOptimizer = resolveOptimizerConfig((_f = (_e = testConfig.deps) == null ? void 0 : _e.optimizer) == null ? void 0 : _f.web, viteConfig.optimizeDeps, testConfig);
+        const ssrOptimizer = resolveOptimizerConfig((_h = (_g = testConfig.deps) == null ? void 0 : _g.optimizer) == null ? void 0 : _h.ssr, (_i = viteConfig.ssr) == null ? void 0 : _i.optimizeDeps, testConfig);
         config.cacheDir = webOptimizer.cacheDir || ssrOptimizer.cacheDir || config.cacheDir;
         config.optimizeDeps = webOptimizer.optimizeDeps;
         config.ssr = {
@@ -14332,19 +14029,24 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
         }
       },
       async configureServer(server) {
+        if (options.watch && process.env.VITE_TEST_WATCHER_DEBUG) {
+          server.watcher.on("ready", () => {
+            console.log("[debug] watcher is ready");
+          });
+        }
         try {
           await ctx.setServer(options, server, userConfig);
           if (options.api && options.watch)
-            (await import('./chunk-api-setup.8f785c4a.js')).setup(ctx);
+            (await import('./chunk-api-setup.644415c3.js')).setup(ctx);
         } catch (err) {
-          await ctx.logger.printError(err, true);
+          await ctx.logger.printError(err, { fullStack: true });
           process.exit(1);
         }
         if (!options.watch)
           await server.watcher.close();
       }
     },
-    EnvReplacerPlugin(),
+    SsrReplacerPlugin(),
     GlobalSetupPlugin(ctx, ctx.logger),
     ...CSSEnablerPlugin(ctx),
     CoverageTransform(ctx),
@@ -14357,8 +14059,8 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
 async function createVitest(mode, options, viteOverrides = {}) {
   var _a, _b, _c, _d, _e, _f, _g;
   const ctx = new Vitest(mode);
-  const root = resolve$2(options.root || process.cwd());
-  const configPath = options.config === false ? false : options.config ? resolve$2(root, options.config) : await findUp(configFiles, { cwd: root });
+  const root = resolve(options.root || process.cwd());
+  const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
   const config = {
     logLevel: "error",
     configFile: configPath,
@@ -14367,7 +14069,7 @@ async function createVitest(mode, options, viteOverrides = {}) {
     plugins: await VitestPlugin(options, ctx)
   };
   const server = await createServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
-  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = ctx.config.deps) == null ? void 0 : _b.experimentalOptimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = ctx.config.deps) == null ? void 0 : _e.experimentalOptimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
+  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = ctx.config.deps) == null ? void 0 : _b.optimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = ctx.config.deps) == null ? void 0 : _e.optimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
     await server.listen();
   else
     await server.pluginContainer.buildStart({});
@@ -20761,13 +20463,13 @@ function registerConsoleShortcuts(ctx) {
 }
 
 async function startVitest(mode, cliFilters = [], options = {}, viteOverrides) {
-  var _a, _b, _c, _d;
+  var _a;
   process.env.TEST = "true";
   process.env.VITEST = "true";
   (_a = process.env).NODE_ENV ?? (_a.NODE_ENV = options.mode || "test");
   if (options.run)
     options.watch = false;
-  const root = resolve$2(options.root || process.cwd());
+  const root = resolve(options.root || process.cwd());
   if (!await ensurePackageInstalled("vite", root)) {
     process.exitCode = 1;
     return;
@@ -20780,14 +20482,14 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides) {
     options.browser = { enabled: true, name: options.browser };
   if (typeof options.browser === "object" && !("enabled" in options.browser))
     options.browser.enabled = true;
+  if ("threads" in options && options.experimentalVmThreads)
+    throw new Error('Cannot use both "threads" (or "no-threads") and "experimentalVmThreads" at the same time.');
   const ctx = await createVitest(mode, options, viteOverrides);
   if (mode === "test" && ctx.config.coverage.enabled) {
     const provider = ctx.config.coverage.provider || "v8";
     const requiredPackages = CoverageProviderMap[provider];
     if (requiredPackages) {
-      const defaultProviderInfo = 'Default coverage provider has changed from "c8" to "v8". New package is required to be installed. To use the old deprecated coverage provider use "--coverage.provider c8" option.\nSee https://github.com/vitest-dev/vitest/pull/3339 for more information.\n\n';
-      const isUsingDefaultProvider = ((_c = (_b = ctx.server.config.test) == null ? void 0 : _b.coverage) == null ? void 0 : _c.provider) === void 0 && ((_d = options.coverage) == null ? void 0 : _d.provider) === void 0;
-      if (!await ensurePackageInstalled(requiredPackages, root, isUsingDefaultProvider ? defaultProviderInfo : void 0)) {
+      if (!await ensurePackageInstalled(requiredPackages, root)) {
         process.exitCode = 1;
         return ctx;
       }
@@ -20813,7 +20515,7 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides) {
     await ctx.start(cliFilters);
   } catch (e) {
     process.exitCode = 1;
-    await ctx.logger.printError(e, true, "Unhandled Error");
+    await ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });
     ctx.logger.error("\n\n");
     return ctx;
   }