vitest 0.19.1 → 0.20.0

package/dist/chunk-vite-node-client.a247c2c2.mjs

@@ -0,0 +1,320 @@
+import { createRequire } from 'module';
+import { pathToFileURL, fileURLToPath } from 'url';
+import vm from 'vm';
+import { y as resolve, d as dirname, B as isAbsolute, L as extname } from './chunk-mock-date.9160e13b.mjs';
+import { s as slash, n as normalizeRequestId, b as toFilePath, i as isNodeBuiltin, c as isPrimitive, d as normalizeModuleId, m as mergeSlashes } from './chunk-vite-node-utils.9dfd1e3f.mjs';
+import createDebug from 'debug';
+
+const debugExecute = createDebug("vite-node:client:execute");
+const debugNative = createDebug("vite-node:client:native");
+const DEFAULT_REQUEST_STUBS = {
+  "/@vite/client": {
+    injectQuery: (id) => id,
+    createHotContext() {
+      return {
+        accept: () => {
+        },
+        prune: () => {
+        },
+        dispose: () => {
+        },
+        decline: () => {
+        },
+        invalidate: () => {
+        },
+        on: () => {
+        }
+      };
+    },
+    updateStyle(id, css) {
+      if (typeof document === "undefined")
+        return;
+      const element = document.getElementById(id);
+      if (element)
+        element.remove();
+      const head = document.querySelector("head");
+      const style = document.createElement("style");
+      style.setAttribute("type", "text/css");
+      style.id = id;
+      style.innerHTML = css;
+      head == null ? void 0 : head.appendChild(style);
+    }
+  }
+};
+class ModuleCacheMap extends Map {
+  normalizePath(fsPath) {
+    return normalizeModuleId(fsPath);
+  }
+  set(fsPath, mod) {
+    fsPath = this.normalizePath(fsPath);
+    if (!super.has(fsPath))
+      super.set(fsPath, mod);
+    else
+      Object.assign(super.get(fsPath), mod);
+    return this;
+  }
+  get(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.get(fsPath);
+  }
+  delete(fsPath) {
+    fsPath = this.normalizePath(fsPath);
+    return super.delete(fsPath);
+  }
+}
+class ViteNodeRunner {
+  constructor(options) {
+    this.options = options;
+    this.root = options.root ?? process.cwd();
+    this.moduleCache = options.moduleCache ?? new ModuleCacheMap();
+    this.debug = options.debug ?? (typeof process !== "undefined" ? !!process.env.VITE_NODE_DEBUG_RUNNER : false);
+  }
+  async executeFile(file) {
+    return await this.cachedRequest(`/@fs/${slash(resolve(file))}`, []);
+  }
+  async executeId(id) {
+    return await this.cachedRequest(id, []);
+  }
+  async cachedRequest(rawId, callstack) {
+    var _a, _b, _c, _d;
+    const id = normalizeRequestId(rawId, this.options.base);
+    const fsPath = toFilePath(id, this.root);
+    if (callstack.includes(fsPath) && ((_a = this.moduleCache.get(fsPath)) == null ? void 0 : _a.exports))
+      return (_b = this.moduleCache.get(fsPath)) == null ? void 0 : _b.exports;
+    if ((_c = this.moduleCache.get(fsPath)) == null ? void 0 : _c.promise)
+      return (_d = this.moduleCache.get(fsPath)) == null ? void 0 : _d.promise;
+    const promise = this.directRequest(id, fsPath, callstack);
+    this.moduleCache.set(fsPath, { promise });
+    return await promise;
+  }
+  async directRequest(id, fsPath, _callstack) {
+    const callstack = [..._callstack, fsPath];
+    const request = async (dep) => {
+      var _a;
+      const fsPath2 = toFilePath(normalizeRequestId(dep, this.options.base), this.root);
+      const getStack = () => {
+        return `stack:
+${[...callstack, fsPath2].reverse().map((p) => `- ${p}`).join("\n")}`;
+      };
+      let debugTimer;
+      if (this.debug)
+        debugTimer = setTimeout(() => console.warn(() => `module ${fsPath2} takes over 2s to load.
+${getStack()}`), 2e3);
+      try {
+        if (callstack.includes(fsPath2)) {
+          const depExports = (_a = this.moduleCache.get(fsPath2)) == null ? void 0 : _a.exports;
+          if (depExports)
+            return depExports;
+          throw new Error(`[vite-node] Failed to resolve circular dependency, ${getStack()}`);
+        }
+        const mod = await this.cachedRequest(dep, callstack);
+        return mod;
+      } finally {
+        if (debugTimer)
+          clearTimeout(debugTimer);
+      }
+    };
+    Object.defineProperty(request, "callstack", { get: () => callstack });
+    const resolveId = async (dep, callstackPosition = 1) => {
+      if (this.options.resolveId && this.shouldResolveId(dep)) {
+        let importer = callstack[callstack.length - callstackPosition];
+        if (importer && importer.startsWith("mock:"))
+          importer = importer.slice(5);
+        const { id: id2 } = await this.options.resolveId(dep, importer) || {};
+        dep = id2 && isAbsolute(id2) ? mergeSlashes(`/@fs/${id2}`) : id2 || dep;
+      }
+      return dep;
+    };
+    id = await resolveId(id, 2);
+    const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
+    if (id in requestStubs)
+      return requestStubs[id];
+    let { code: transformed, externalize } = await this.options.fetchModule(id);
+    if (externalize) {
+      debugNative(externalize);
+      const mod = await this.interopedImport(externalize);
+      this.moduleCache.set(fsPath, { exports: mod });
+      return mod;
+    }
+    if (transformed == null)
+      throw new Error(`[vite-node] Failed to load ${id}`);
+    const url = pathToFileURL(fsPath).href;
+    const meta = { url };
+    const exports = /* @__PURE__ */ Object.create(null);
+    exports[Symbol.toStringTag] = "Module";
+    this.moduleCache.set(fsPath, { code: transformed, exports });
+    const __filename = fileURLToPath(url);
+    const moduleProxy = {
+      set exports(value) {
+        exportAll(exports, value);
+        exports.default = value;
+      },
+      get exports() {
+        return exports;
+      }
+    };
+    let hotContext;
+    if (this.options.createHotContext) {
+      Object.defineProperty(meta, "hot", {
+        enumerable: true,
+        get: () => {
+          var _a, _b;
+          hotContext || (hotContext = (_b = (_a = this.options).createHotContext) == null ? void 0 : _b.call(_a, this, `/@fs/${fsPath}`));
+          return hotContext;
+        }
+      });
+    }
+    const context = this.prepareContext({
+      __vite_ssr_import__: request,
+      __vite_ssr_dynamic_import__: request,
+      __vite_ssr_exports__: exports,
+      __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+      __vite_ssr_import_meta__: meta,
+      __vitest_resolve_id__: resolveId,
+      require: createRequire(url),
+      exports,
+      module: moduleProxy,
+      __filename,
+      __dirname: dirname(__filename)
+    });
+    debugExecute(__filename);
+    if (transformed[0] === "#")
+      transformed = transformed.replace(/^\#\!.*/, (s) => " ".repeat(s.length));
+    const fn = vm.runInThisContext(`'use strict';async (${Object.keys(context).join(",")})=>{{${transformed}
+}}`, {
+      filename: fsPath,
+      lineOffset: 0
+    });
+    await fn(...Object.values(context));
+    return exports;
+  }
+  prepareContext(context) {
+    return context;
+  }
+  shouldResolveId(dep) {
+    if (isNodeBuiltin(dep) || dep in (this.options.requestStubs || DEFAULT_REQUEST_STUBS) || dep.startsWith("/@vite"))
+      return false;
+    return !isAbsolute(dep) || !extname(dep);
+  }
+  shouldInterop(path, mod) {
+    if (this.options.interopDefault === false)
+      return false;
+    return !path.endsWith(".mjs") && "default" in mod;
+  }
+  async interopedImport(path) {
+    const mod = await import(path);
+    if (this.shouldInterop(path, mod)) {
+      const tryDefault = this.hasNestedDefault(mod);
+      return new Proxy(mod, {
+        get: proxyMethod("get", tryDefault),
+        set: proxyMethod("set", tryDefault),
+        has: proxyMethod("has", tryDefault),
+        deleteProperty: proxyMethod("deleteProperty", tryDefault)
+      });
+    }
+    return mod;
+  }
+  hasNestedDefault(target) {
+    return "__esModule" in target && target.__esModule && "default" in target.default;
+  }
+}
+function proxyMethod(name, tryDefault) {
+  return function(target, key, ...args) {
+    const result = Reflect[name](target, key, ...args);
+    if (isPrimitive(target.default))
+      return result;
+    if (tryDefault && key === "default" || typeof result === "undefined")
+      return Reflect[name](target.default, key, ...args);
+    return result;
+  };
+}
+function exportAll(exports, sourceModule) {
+  if (exports === sourceModule)
+    return;
+  for (const key in sourceModule) {
+    if (key !== "default") {
+      try {
+        Object.defineProperty(exports, key, {
+          enumerable: true,
+          configurable: true,
+          get() {
+            return sourceModule[key];
+          }
+        });
+      } catch (_err) {
+      }
+    }
+  }
+}
+
+const DEFAULT_TIMEOUT = 6e4;
+function createBirpc(functions, options) {
+  const {
+    post,
+    on,
+    eventNames = [],
+    serialize = (i) => i,
+    deserialize = (i) => i,
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  const rpcPromiseMap = /* @__PURE__ */ new Map();
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      const sendEvent = (...args) => {
+        post(serialize({ m: method, a: args, t: "q" }));
+      };
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = (...args) => {
+        return new Promise((resolve, reject) => {
+          const id = nanoid();
+          rpcPromiseMap.set(id, { resolve, reject });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
+          if (timeout >= 0) {
+            setTimeout(() => {
+              reject(new Error(`[birpc] timeout on calling "${method}"`));
+              rpcPromiseMap.delete(id);
+            }, timeout);
+          }
+        });
+      };
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  on(async (data, ...extra) => {
+    const msg = deserialize(data);
+    if (msg.t === "q") {
+      const { m: method, a: args } = msg;
+      let result, error;
+      try {
+        result = await functions[method].apply(rpc, args);
+      } catch (e) {
+        error = e;
+      }
+      if (msg.i)
+        post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = rpcPromiseMap.get(ack);
+      if (error)
+        promise?.reject(error);
+      else
+        promise?.resolve(result);
+      rpcPromiseMap.delete(ack);
+    }
+  });
+  return rpc;
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
+
+export { ModuleCacheMap as M, ViteNodeRunner as V, createBirpc as c };

package/dist/chunk-vite-node-debug.c5887932.mjs

@@ -0,0 +1,76 @@
+import { existsSync, promises } from 'fs';
+import { y as resolve, p as picocolors, j as join } from './chunk-mock-date.9160e13b.mjs';
+import 'path';
+import 'tty';
+import 'local-pkg';
+
+function hashCode(s) {
+  return s.split("").reduce((a, b) => {
+    a = (a << 5) - a + b.charCodeAt(0);
+    return a & a;
+  }, 0);
+}
+class Debugger {
+  constructor(root, options) {
+    this.options = options;
+    this.externalizeMap = /* @__PURE__ */ new Map();
+    if (options.dumpModules)
+      this.dumpDir = resolve(root, options.dumpModules === true ? ".vite-node/dump" : options.dumpModules);
+    if (this.dumpDir) {
+      if (options.loadDumppedModules)
+        console.info(picocolors.exports.gray(`[vite-node] [debug] load modules from ${this.dumpDir}`));
+      else
+        console.info(picocolors.exports.gray(`[vite-node] [debug] dump modules to ${this.dumpDir}`));
+    }
+    this.initPromise = this.clearDump();
+  }
+  async clearDump() {
+    if (!this.dumpDir)
+      return;
+    if (!this.options.loadDumppedModules && existsSync(this.dumpDir))
+      await promises.rm(this.dumpDir, { recursive: true, force: true });
+    await promises.mkdir(this.dumpDir, { recursive: true });
+  }
+  encodeId(id) {
+    return `${id.replace(/[^\w@_-]/g, "_").replace(/_+/g, "_")}-${hashCode(id)}.js`;
+  }
+  async recordExternalize(id, path) {
+    if (!this.dumpDir)
+      return;
+    this.externalizeMap.set(id, path);
+    await this.writeInfo();
+  }
+  async dumpFile(id, result) {
+    if (!result || !this.dumpDir)
+      return;
+    await this.initPromise;
+    const name = this.encodeId(id);
+    return await promises.writeFile(join(this.dumpDir, name), `// ${id.replace(/\0/g, "\\0")}
+${result.code}`, "utf-8");
+  }
+  async loadDump(id) {
+    if (!this.dumpDir)
+      return null;
+    await this.initPromise;
+    const name = this.encodeId(id);
+    const path = join(this.dumpDir, name);
+    if (!existsSync(path))
+      return null;
+    const code = await promises.readFile(path, "utf-8");
+    return {
+      code: code.replace(/^\/\/.*?\n/, ""),
+      map: void 0
+    };
+  }
+  async writeInfo() {
+    if (!this.dumpDir)
+      return;
+    const info = JSON.stringify({
+      time: new Date().toLocaleString(),
+      externalize: Object.fromEntries(this.externalizeMap.entries())
+    }, null, 2);
+    return promises.writeFile(join(this.dumpDir, "info.json"), info, "utf-8");
+  }
+}
+
+export { Debugger };

package/dist/{chunk-vite-node-externalize.e9af6472.mjs → chunk-vite-node-externalize.2e90dadf.mjs}

@@ -1,22 +1,24 @@
-import { j as join, D as basename, d as dirname, C as resolve, E as AggregateErrorPonyfill, p as picocolors, F as isAbsolute, G as relative, c as slash$2, t as isNode, v as relativePath, H as getTests, h as getFullName, B as hasFailed, I as hasFailedSnapshot, J as safeSetInterval, K as safeClearInterval, L as getSuites, s as safeSetTimeout, z as shuffle, u as toArray$1, M as normalize, n as noop$1, k as safeClearTimeout, N as deepMerge, O as toNamespacedPath, b as getCallLastIndex, l as notNullish, P as ensurePackageInstalled, Q as stdout } from './chunk-utils-global.2aa95025.mjs';
-import { p as pLimit, c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage, d as envPackageNames } from './chunk-defaults.ed196a9a.mjs';
+import { j as join, z as basename, d as dirname, y as resolve, A as AggregateErrorPonyfill, p as picocolors, B as isAbsolute, C as relative, s as slash$2, l as isNode, o as relativePath, D as getTests, e as getFullName, x as hasFailed, E as hasFailedSnapshot, F as getSuites, v as shuffle, t as toArray$1, G as normalize, n as noop$1, H as deepMerge, I as toNamespacedPath, g as getCallLastIndex, f as notNullish, J as ensurePackageInstalled, K as stdout } from './chunk-mock-date.9160e13b.mjs';
+import { p as pLimit, c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage, d as envPackageNames } from './chunk-defaults.1c51d585.mjs';
 import { loadConfigFromFile, createServer, mergeConfig } from 'vite';
 import path$a from 'path';
 import _url, { fileURLToPath } from 'url';
 import process$1 from 'process';
 import fs$8, { promises, existsSync, readFileSync } from 'fs';
-import { d as distDir, c as configFiles, a as defaultPort } from './chunk-constants.38b43a44.mjs';
+import { d as distDir, r as rootDir, c as configFiles, a as defaultPort } from './chunk-constants.16825f0c.mjs';
 import require$$0, { cpus, hostname } from 'os';
 import util$2 from 'util';
 import require$$0$1 from 'stream';
 import require$$2 from 'events';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.ad73f2ab.mjs';
+import { c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-client.a247c2c2.mjs';
 import createDebug from 'debug';
+import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap } from './chunk-vite-node-utils.9dfd1e3f.mjs';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
 import { performance } from 'perf_hooks';
-import { c as stripAnsi, d as cliTruncate, p as parseStacktrace, e as stringWidth, h as ansiStyles, i as sliceAnsi, j as interpretSourcePos, s as stringify$5, u as unifiedDiff, b as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.8b066ce2.mjs';
+import { c as stripAnsi, d as cliTruncate, p as parseStacktrace, e as stringWidth, h as ansiStyles, i as sliceAnsi, j as interpretSourcePos, s as stringify$5, u as unifiedDiff, b as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.8198ebd9.mjs';
+import { b as safeSetInterval, c as safeClearInterval, s as safeSetTimeout, a as safeClearTimeout } from './chunk-utils-timers.b48455ed.mjs';
 import { resolveModule } from 'local-pkg';
 import { createHash } from 'crypto';
 import { o as onetime, s as signalExit } from './vendor-index.61438b77.mjs';
@@ -24,7 +26,7 @@ import MagicString from './chunk-magic-string.efe26975.mjs';
 import require$$0$2 from 'readline';
 import { p as prompts } from './vendor-index.de788b6a.mjs';
 
-var version$1 = "0.19.1";
+var version$1 = "0.20.0";
 
 class EndError extends Error {
 	constructor(value) {
@@ -6767,7 +6769,8 @@ function guessCJSversion(id) {
     }
   }
 }
-async function shouldExternalize(id, options, cache = /* @__PURE__ */ new Map()) {
+const _defaultExternalizeCache = /* @__PURE__ */ new Map();
+async function shouldExternalize(id, options, cache = _defaultExternalizeCache) {
   if (!cache.has(id))
     cache.set(id, _shouldExternalize(id, options));
   return cache.get(id);
@@ -6828,6 +6831,7 @@ class ViteNodeServer {
     this.fetchPromiseMap = /* @__PURE__ */ new Map();
     this.transformPromiseMap = /* @__PURE__ */ new Map();
     this.fetchCache = /* @__PURE__ */ new Map();
+    this.externalizeCache = /* @__PURE__ */ new Map();
     var _a, _b;
     const ssrOptions = server.config.ssr;
     if (ssrOptions) {
@@ -6839,9 +6843,17 @@ class ViteNodeServer {
         options.deps.inline.push(...toArray(ssrOptions.noExternal));
       }
     }
+    if (process.env.VITE_NODE_DEBUG_DUMP) {
+      options.debug = Object.assign({
+        dumpModules: !!process.env.VITE_NODE_DEBUG_DUMP,
+        loadDumppedModules: process.env.VITE_NODE_DEBUG_DUMP === "load"
+      }, options.debug ?? {});
+    }
+    if (options.debug)
+      import('./chunk-vite-node-debug.c5887932.mjs').then((r) => this.debugger = new r.Debugger(server.config.root, options.debug));
   }
   shouldExternalize(id) {
-    return shouldExternalize(id, this.options.deps);
+    return shouldExternalize(id, this.options.deps, this.externalizeCache);
   }
   async resolveId(id, importer) {
     if (importer && !importer.startsWith(this.server.config.root))
@@ -6879,6 +6891,7 @@ class ViteNodeServer {
     return "web";
   }
   async _fetchModule(id) {
+    var _a;
     let result;
     const filePath = toFilePath(id, this.server.config.root);
     const module = this.server.moduleGraph.getModuleById(id);
@@ -6889,6 +6902,7 @@ class ViteNodeServer {
     const externalize = await this.shouldExternalize(filePath);
     if (externalize) {
       result = { externalize };
+      (_a = this.debugger) == null ? void 0 : _a.recordExternalize(id, externalize);
     } else {
       const r = await this._transformRequest(id);
       result = { code: r == null ? void 0 : r.code, map: r == null ? void 0 : r.map };
@@ -6900,8 +6914,14 @@ class ViteNodeServer {
     return result;
   }
   async _transformRequest(id) {
+    var _a, _b, _c, _d;
     debugRequest(id);
     let result = null;
+    if ((_a = this.options.debug) == null ? void 0 : _a.loadDumppedModules) {
+      result = await ((_b = this.debugger) == null ? void 0 : _b.loadDump(id)) ?? null;
+      if (result)
+        return result;
+    }
     if (this.getTransformMode(id) === "web") {
       result = await this.server.transformRequest(id);
       if (result)
@@ -6912,6 +6932,8 @@ class ViteNodeServer {
     const sourcemap = this.options.sourcemap ?? "inline";
     if (sourcemap === "inline" && result && !id.includes("node_modules"))
       withInlineSourcemap(result);
+    if ((_c = this.options.debug) == null ? void 0 : _c.dumpModules)
+      await ((_d = this.debugger) == null ? void 0 : _d.dumpFile(id, result));
     return result;
   }
 }
@@ -6979,16 +7001,26 @@ function addSnapshotResult(summary, result) {
 }
 
 const workerPath = _url.pathToFileURL(resolve(distDir, "./worker.mjs")).href;
+const loaderPath = _url.pathToFileURL(resolve(distDir, "./loader.mjs")).href;
+const suppressLoaderWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createPool(ctx) {
-  var _a;
+  var _a, _b;
   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 conditions = (_a = ctx.server.config.resolve.conditions) == null ? void 0 : _a.flatMap((c) => ["-C", c]);
   const options = {
     filename: workerPath,
     useAtomics: false,
     maxThreads,
-    minThreads
+    minThreads,
+    execArgv: [
+      "--require",
+      suppressLoaderWarningsPath,
+      "--experimental-loader",
+      loaderPath,
+      ...conditions || []
+    ]
   };
   if (ctx.config.isolate) {
     options.isolateWorkers = true;
@@ -7000,7 +7032,7 @@ function createPool(ctx) {
     options.minThreads = 1;
   }
   if (ctx.config.coverage.enabled)
-    (_a = process.env).NODE_V8_COVERAGE || (_a.NODE_V8_COVERAGE = ctx.config.coverage.tempDirectory);
+    (_b = process.env).NODE_V8_COVERAGE || (_b.NODE_V8_COVERAGE = ctx.config.coverage.tempDirectory);
   options.env = {
     TEST: "true",
     VITEST: "true",
@@ -7295,7 +7327,8 @@ class BaseReporter {
     this.end = performance.now();
     await this.reportSummary(files);
     if (errors.length) {
-      process.exitCode = 1;
+      if (!this.ctx.config.dangerouslyIgnoreUnhandledErrors)
+        process.exitCode = 1;
       this.ctx.logger.printUnhandledErrors(errors);
     }
   }
@@ -7442,10 +7475,13 @@ ${BADGE}${TRIGGER} ${picocolors.exports.blue(`x${rerun}`)}
       await this.printTaskErrors(failedTests, errorDivider);
     }
     const executionTime = this.end - this.start;
-    const threadTime = files.reduce((acc, test) => {
+    const collectTime = files.reduce((acc, test) => acc + Math.max(0, test.collectDuration || 0), 0);
+    const setupTime = files.reduce((acc, test) => acc + Math.max(0, test.setupDuration || 0), 0);
+    const testsTime = files.reduce((acc, test) => {
       var _a2;
-      return acc + Math.max(0, ((_a2 = test.result) == null ? void 0 : _a2.duration) || 0) + Math.max(0, test.collectDuration || 0);
+      return acc + Math.max(0, ((_a2 = test.result) == null ? void 0 : _a2.duration) || 0);
     }, 0);
+    const threadTime = collectTime + testsTime + setupTime;
     const padTitle = (str) => picocolors.exports.dim(`${str.padStart(10)} `);
     const time = (time2) => {
       if (time2 > 1e3)
@@ -7463,7 +7499,7 @@ ${BADGE}${TRIGGER} ${picocolors.exports.blue(`x${rerun}`)}
     if (this.watchFilters)
       logger.log(padTitle("Time"), time(threadTime));
     else
-      logger.log(padTitle("Time"), time(executionTime) + picocolors.exports.gray(` (in thread ${time(threadTime)}, ${(executionTime / threadTime * 100).toFixed(2)}%)`));
+      logger.log(padTitle("Time"), time(executionTime) + picocolors.exports.gray(` (setup ${time(setupTime)}, collect ${time(collectTime)}, tests ${time(testsTime)})`));
     logger.log();
   }
   async printTaskErrors(tasks, errorDivider) {
@@ -8212,6 +8248,7 @@ class StateManager {
   constructor() {
     this.filesMap = /* @__PURE__ */ new Map();
     this.pathsSet = /* @__PURE__ */ new Set();
+    this.collectingPromise = void 0;
     this.idMap = /* @__PURE__ */ new Map();
     this.taskFileMap = /* @__PURE__ */ new WeakMap();
     this.errorsSet = /* @__PURE__ */ new Set();
@@ -8226,7 +8263,21 @@ class StateManager {
   getUnhandledErrors() {
     return Array.from(this.errorsSet.values());
   }
-  getPaths() {
+  startCollectingPaths() {
+    let _resolve;
+    const promise = new Promise((resolve) => {
+      _resolve = resolve;
+    });
+    this.collectingPromise = { promise, resolve: _resolve };
+  }
+  finishCollectingPaths() {
+    var _a;
+    (_a = this.collectingPromise) == null ? void 0 : _a.resolve();
+    this.collectingPromise = void 0;
+  }
+  async getPaths() {
+    var _a;
+    await ((_a = this.collectingPromise) == null ? void 0 : _a.promise);
     return Array.from(this.pathsSet);
   }
   getFiles(keys) {
@@ -9041,7 +9092,7 @@ createLogUpdate(process$1.stdout);
 
 createLogUpdate(process$1.stderr);
 
-var version = "0.19.1";
+var version = "0.20.0";
 
 function fileFromParsedStack(stack) {
   var _a, _b;
@@ -9408,7 +9459,7 @@ class Vitest {
   }
   async filterTestsBySource(tests) {
     if (this.config.changed && !this.config.related) {
-      const { VitestGit } = await import('./chunk-node-git.9058b82a.mjs');
+      const { VitestGit } = await import('./chunk-node-git.43dbdd42.mjs');
       const vitestGit = new VitestGit(this.config.root);
       const related2 = await vitestGit.findChangedFiles({
         changedSince: this.config.changed
@@ -9440,6 +9491,7 @@ class Vitest {
   }
   async runFiles(paths) {
     await this.runningPromise;
+    this.state.startCollectingPaths();
     this.runningPromise = (async () => {
       if (!this.pool)
         this.pool = createPool(this);
@@ -9461,6 +9513,7 @@ class Vitest {
       await this.cache.results.writeToCache();
     })().finally(() => {
       this.runningPromise = void 0;
+      this.state.finishCollectingPaths();
     });
     return await this.runningPromise;
   }
@@ -9992,7 +10045,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
           await ctx.setServer(options, server);
           haveStarted = true;
           if (options.api && options.watch)
-            (await import('./chunk-api-setup.0cf2c96a.mjs')).setup(ctx);
+            (await import('./chunk-api-setup.7c4c8879.mjs')).setup(ctx);
         } catch (err) {
           ctx.logger.printError(err, true);
           process.exit(1);