vitest 0.0.92 → 0.0.96

package/bin/vitest.mjs

@@ -6,6 +6,9 @@ import { ensurePackageInstalled } from '../dist/utils.js'
 
 const argv = process.argv.slice(2)
 
+if (!await ensurePackageInstalled('vite'))
+  process.exit(1)
+
 if (argv.includes('--coverage')) {
   if (!await ensurePackageInstalled('c8'))
     process.exit(1)

package/dist/cli.js

@@ -1,7 +1,7 @@
 import require$$0 from 'readline';
 import { EventEmitter } from 'events';
-import { c, e as ensurePackageInstalled } from './utils-860e5f7e.js';
-import { c as createVitest } from './index-40ecbcb4.js';
+import { c, e as ensurePackageInstalled } from './utils-576876dc.js';
+import { c as createVitest } from './index-ece64e3c.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -13,12 +13,12 @@ import 'util';
 import './constants-9cfa4d7b.js';
 import 'url';
 import 'perf_hooks';
-import './error-4b0c4b4b.js';
+import './error-81292c96.js';
 import 'source-map';
 import './index-5cc247ff.js';
 import 'assert';
 import 'worker_threads';
-import 'piscina';
+import 'tinypool';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -633,7 +633,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.0.92";
+var version = "0.0.96";
 
 const cli = cac("vitest");
 cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-o, --open", "open Vitest UI").option("--api", "listen to port and serve API").option("--threads", "enabled threads", { default: true }).option("--silent", "silent").option("--global", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment", {
@@ -654,16 +654,18 @@ async function run(cliFilters, options) {
   process.env.NODE_ENV = "test";
   if (!options.silent) {
     console.log(c.magenta(c.bold("\nVitest is in closed beta exclusively for Sponsors")));
-    console.log(c.yellow("Learn more at https://vitest.dev\n"));
+    console.log(c.yellow("Learn more at https://vitest.dev"));
   }
   const ctx = await createVitest(options);
-  process.__vitest__ = ctx;
   process.chdir(ctx.config.root);
   registerConsoleShortcuts(ctx);
   if (ctx.config.environment && ctx.config.environment !== "node") {
     if (!await ensurePackageInstalled(ctx.config.environment))
       process.exit(1);
   }
+  ctx.onServerRestarted(() => {
+    ctx.start(cliFilters);
+  });
   try {
     await ctx.start(cliFilters);
   } catch (e) {

package/dist/entry.js

@@ -6,11 +6,12 @@ import chai, { expect, util } from 'chai';
 import Subset from 'chai-subset';
 import path, { basename } from 'path';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, d as hasTests, h as hasFailed } from './utils-860e5f7e.js';
-import { u as unifiedDiff } from './error-4b0c4b4b.js';
+import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, f as hasTests, h as hasFailed } from './utils-576876dc.js';
+import { u as unifiedDiff } from './error-81292c96.js';
 import { performance } from 'perf_hooks';
 import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-b8c6cb53.js';
 import { n as nanoid } from './index-9e71c815.js';
+import { format as format$1 } from 'util';
 import 'tty';
 import 'source-map';
 
@@ -3413,7 +3414,7 @@ const JestChaiExpect = (chai, utils) => {
       const expected = args[0];
       const actual = utils.flag(this, "object");
       if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected, void 0, true), "not match with #{this}", "should not match with #{this}", true);
+        this.assert(equals(actual, expected, void 0, true), "not match with #{act}", "should not match with #{act}", actual, expected);
       } else {
         _super.apply(this, args);
       }
@@ -3424,7 +3425,7 @@ const JestChaiExpect = (chai, utils) => {
       const expected = args[0];
       const actual = utils.flag(this, "object");
       if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected), "not match with #{this}", "should not match with #{this}", true);
+        this.assert(equals(actual, expected), "not match with #{exp}", "should not match with #{exp}", actual, expected);
       } else {
         _super.apply(this, args);
       }
@@ -3437,7 +3438,7 @@ const JestChaiExpect = (chai, utils) => {
     return this.chaiEqual(expected);
   });
   def("toBe", function(expected) {
-    return this.chaiEqual(expected);
+    return this.equal(expected);
   });
   def("toMatchObject", function(expected) {
     return this.containSubset(expected);
@@ -3534,7 +3535,7 @@ const JestChaiExpect = (chai, utils) => {
   def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
     const spy = getSpy(this);
     const pass = spy.calls.some((callArg) => equals(callArg, args));
-    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
+    return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args, spy.calls);
   });
   const ordinalOf = (i) => {
     const j = i % 10;
@@ -3629,7 +3630,7 @@ class StringContaining extends AsymmetricMatcher {
 }
 class Anything extends AsymmetricMatcher {
   asymmetricMatch(other) {
-    return other !== void 0 && other !== null;
+    return other != null;
   }
   toString() {
     return "Anything";
@@ -3638,11 +3639,127 @@ class Anything extends AsymmetricMatcher {
     return "Anything";
   }
 }
+class ObjectContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+  getPrototype(obj) {
+    if (Object.getPrototypeOf)
+      return Object.getPrototypeOf(obj);
+    if (obj.constructor.prototype === obj)
+      return null;
+    return obj.constructor.prototype;
+  }
+  hasProperty(obj, property) {
+    if (!obj)
+      return false;
+    if (Object.prototype.hasOwnProperty.call(obj, property))
+      return true;
+    return this.hasProperty(this.getPrototype(obj), property);
+  }
+  asymmetricMatch(other) {
+    if (typeof this.sample !== "object") {
+      throw new TypeError(`You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`);
+    }
+    let result = true;
+    for (const property in this.sample) {
+      if (!this.hasProperty(other, property) || !equals(this.sample[property], other[property])) {
+        result = false;
+        break;
+      }
+    }
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `Object${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "object";
+  }
+}
+class ArrayContaining extends AsymmetricMatcher {
+  constructor(sample, inverse = false) {
+    super(sample, inverse);
+  }
+  asymmetricMatch(other) {
+    if (!Array.isArray(this.sample)) {
+      throw new TypeError(`You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`);
+    }
+    const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every((item) => other.some((another) => equals(item, another)));
+    return this.inverse ? !result : result;
+  }
+  toString() {
+    return `Array${this.inverse ? "Not" : ""}Containing`;
+  }
+  getExpectedType() {
+    return "array";
+  }
+}
+class Any extends AsymmetricMatcher {
+  constructor(sample) {
+    if (typeof sample === "undefined") {
+      throw new TypeError("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.");
+    }
+    super(sample);
+  }
+  fnNameFor(func) {
+    if (func.name)
+      return func.name;
+    const functionToString = Function.prototype.toString;
+    const matches = functionToString.call(func).match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
+    return matches ? matches[1] : "<anonymous>";
+  }
+  asymmetricMatch(other) {
+    if (this.sample === String)
+      return typeof other == "string" || other instanceof String;
+    if (this.sample === Number)
+      return typeof other == "number" || other instanceof Number;
+    if (this.sample === Function)
+      return typeof other == "function" || other instanceof Function;
+    if (this.sample === Boolean)
+      return typeof other == "boolean" || other instanceof Boolean;
+    if (this.sample === BigInt)
+      return typeof other == "bigint" || other instanceof BigInt;
+    if (this.sample === Symbol)
+      return typeof other == "symbol" || other instanceof Symbol;
+    if (this.sample === Object)
+      return typeof other == "object";
+    return other instanceof this.sample;
+  }
+  toString() {
+    return "Any";
+  }
+  getExpectedType() {
+    if (this.sample === String)
+      return "string";
+    if (this.sample === Number)
+      return "number";
+    if (this.sample === Function)
+      return "function";
+    if (this.sample === Object)
+      return "object";
+    if (this.sample === Boolean)
+      return "boolean";
+    return this.fnNameFor(this.sample);
+  }
+  toAsymmetricMatcher() {
+    return `Any<${this.fnNameFor(this.sample)}>`;
+  }
+}
 const JestAsymmetricMatchers = (chai, utils) => {
   utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
   utils.addMethod(chai.expect, "anything", () => {
     return new Anything();
   });
+  utils.addMethod(chai.expect, "objectContaining", (expected) => {
+    return new ObjectContaining(expected);
+  });
+  utils.addMethod(chai.expect, "any", (expected) => {
+    return new Any(expected);
+  });
+  utils.addMethod(chai.expect, "arrayContaining", (expected) => {
+    return new ArrayContaining(expected);
+  });
 };
 
 let installed = false;
@@ -3665,7 +3782,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-c40aeb86.js')).registerApiGlobally();
+    (await import('./global-473089f7.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3725,6 +3842,8 @@ function serializeError(val) {
     return "Promise";
   if (typeof Element !== "undefined" && val instanceof Element)
     return val.tagName;
+  if (typeof val.asymmetricMatch === "function")
+    return `${val.toString()} ${format$1(val.sample)}`;
   Object.keys(val).forEach((key) => {
     val[key] = serializeError(val[key]);
   });

package/dist/{error-4b0c4b4b.js → error-81292c96.js}

@@ -1,6 +1,7 @@
 import { existsSync, promises } from 'fs';
 import { relative } from 'path';
-import { n as notNullish, c } from './utils-860e5f7e.js';
+import { format } from 'util';
+import { d as notNullish, c } from './utils-576876dc.js';
 import { SourceMapConsumer } from 'source-map';
 
 function Diff() {}
@@ -1338,7 +1339,7 @@ function generateCodeFrame(source, indent = 0, start = 0, end, range = 2) {
   return res.join("\n");
 }
 function stringify(obj) {
-  return String(obj);
+  return format(obj);
 }
 const stackFnCallRE = /at (.*) \((.+):(\d+):(\d+)\)$/;
 const stackBarePathRE = /at ?(.*) (.+):(\d+):(\d+)$/;
@@ -1373,35 +1374,34 @@ function unifiedDiff(actual, expected) {
       if (expectedLinesCount >= diffLimit)
         return;
       expectedLinesCount++;
+      line = line[0] + " " + line.slice(1);
       const isLastLine = expectedLinesCount === diffLimit;
-      return indent + c.green(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
+      return indent + c.red(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
     }
     if (line[0] === "-") {
       if (actualLinesCount >= diffLimit)
         return;
       actualLinesCount++;
+      line = line[0] + " " + line.slice(1);
       const isLastLine = actualLinesCount === diffLimit;
-      return indent + c.red(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
+      return indent + c.green(`${formatLine(line)} ${isLastLine ? renderTruncateMessage(indent) : ""}`);
     }
     if (line.match(/@@/))
       return "--";
     if (line.match(/\\ No newline/))
       return null;
-    return indent + line;
+    return indent + " " + line;
   }
   const msg = createPatch("string", actual, expected);
   const lines = msg.split("\n").splice(5);
   return `
-${indent}${c.red("- actual")}
-${indent}${c.green("+ expected")}
+${indent}${c.green("- expected")}
+${indent}${c.red("+ actual")}
 
 ${lines.map(cleanUp).filter(notBlank).join("\n")}`;
 }
 function formatLine(line) {
-  const lineLimitLength = 50;
-  if (line.length > lineLimitLength)
-    return `${line.slice(0, lineLimitLength)} ${c.dim("[...truncated]")}`;
-  return line;
+  return cliTruncate(line, (process.stdout.columns || 40) - 1);
 }
 function renderTruncateMessage(indent) {
   return `

package/dist/{global-c40aeb86.js → global-473089f7.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants-9cfa4d7b.js';
-import { i as index } from './index-708135df.js';
+import { i as index } from './index-368448f4.js';
 import 'path';
 import 'url';
 import './suite-b8c6cb53.js';

package/dist/{index-708135df.js → index-368448f4.js}

@@ -1,7 +1,7 @@
 import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-b8c6cb53.js';
 import chai, { util, assert, should, expect } from 'chai';
 import * as tinyspy from 'tinyspy';
-import { spy, spyOn as spyOn$1 } from 'tinyspy';
+import { spies } from 'tinyspy';
 
 const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
@@ -136,7 +136,8 @@ class FakeTimers {
     const spyFactory = (spyType, resultBuilder) => {
       return (cb, ms = 0) => {
         const id = ++this._spyid;
-        const nestedMs = ms + (this._nestedTime[this._scopeId] ?? 0);
+        const nestedTo = Object.entries(this._nestedTime).filter(([key]) => Number(key) <= this._scopeId);
+        const nestedMs = nestedTo.reduce((total, [, ms2]) => total + ms2, ms);
         const call = { id, cb, ms, nestedMs, scopeId: this._scopeId };
         const task = { type: spyType, call, nested: this._isNested };
         this.pushTask(task);
@@ -306,6 +307,24 @@ class VitestUtils {
   getTimerCount() {
     return this._timers.getTimerCount();
   }
+  isMockFunction(fn2) {
+    return typeof fn2 === "function" && "__isSpy" in fn2 && fn2.__isSpy;
+  }
+  clearAllMocks() {
+    spies.forEach((spy) => {
+      spy.reset();
+    });
+  }
+  resetAllMocks() {
+    spies.forEach((spy) => {
+      spy.reset();
+    });
+  }
+  restoreAllMocks() {
+    spies.forEach((spy) => {
+      spy.restore();
+    });
+  }
 }
 const vitest = new VitestUtils();
 const vi = vitest;
@@ -324,10 +343,10 @@ var index = /*#__PURE__*/Object.freeze({
   should: should,
   expect: expect,
   chai: chai,
-  spy: spy,
-  spyOn: spyOn$1,
+  spyOn: spyOn,
+  fn: fn,
   vitest: vitest,
   vi: vi
 });
 
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, vi as e, index as i, vitest as v };
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, vi as e, fn as f, index as i, spyOn as s, vitest as v };

package/dist/{index-40ecbcb4.js → index-ece64e3c.js}

@@ -5,13 +5,13 @@ import { promises } from 'fs';
 import fg from 'fast-glob';
 import require$$0 from 'util';
 import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-9cfa4d7b.js';
-import { c, g as getNames, s as slash, a as getTests, b as getSuites, t as toArray, h as hasFailed } from './utils-860e5f7e.js';
+import { c, g as getNames, s as slash, a as getTests, b as getSuites, n as noop, t as toArray, h as hasFailed } from './utils-576876dc.js';
 import { performance } from 'perf_hooks';
-import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-4b0c4b4b.js';
+import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-81292c96.js';
 import { o as onetime, s as signalExit } from './index-5cc247ff.js';
 import { MessageChannel } from 'worker_threads';
 import { pathToFileURL } from 'url';
-import Piscina from 'piscina';
+import { Tinypool } from 'tinypool';
 
 /*
 How it works:
@@ -4971,7 +4971,8 @@ class ConsoleReporter {
     this.console = globalThis.console;
     this.isFirstWatchRun = true;
     const mode = ctx.config.watch ? c.yellow(" DEV ") : c.cyan(" RUN ");
-    this.log(`${c.inverse(c.bold(mode))} ${c.gray(this.ctx.config.root)}
+    this.log(`
+${c.inverse(c.bold(mode))} ${c.gray(this.ctx.config.root)}
 `);
     this.start = performance.now();
   }
@@ -5110,7 +5111,6 @@ ${c.bold(c.inverse(c.green(" PASS ")))}${c.green(" Waiting for file changes...")
 `);
   }
   onServerRestart() {
-    this.console.clear();
     this.log(c.cyan("Restarted due to config changes..."));
   }
 }
@@ -5263,7 +5263,7 @@ function createWorkerPool(ctx) {
     options.maxThreads = ctx.config.maxThreads;
   if (ctx.config.minThreads != null)
     options.minThreads = ctx.config.minThreads;
-  const piscina = new Piscina(options);
+  const pool = new Tinypool(options);
   const runWithFiles = (name) => {
     return async (files, invalidates) => {
       await Promise.all(files.map(async (file) => {
@@ -5274,7 +5274,7 @@ function createWorkerPool(ctx) {
           files: [file],
           invalidates
         };
-        await piscina.run(data, { transferList: [workerPort], name });
+        await pool.run(data, { transferList: [workerPort], name });
         port.close();
         workerPort.close();
       }));
@@ -5283,7 +5283,7 @@ function createWorkerPool(ctx) {
   return {
     runTests: runWithFiles("run"),
     collectTests: runWithFiles("collect"),
-    close: () => piscina.destroy()
+    close: () => pool.destroy()
   };
 }
 function createChannel(ctx) {
@@ -5343,11 +5343,17 @@ class Vitest {
     this.invalidates = /* @__PURE__ */ new Set();
     this.changedTests = /* @__PURE__ */ new Set();
     this.isFirstRun = true;
+    this.restartsCount = 0;
+    this._onRestartListeners = [];
+    this.unregisterWatcher = noop;
     this.console = globalThis.console;
   }
   setServer(options, server) {
-    var _a;
-    (_a = this.pool) == null ? void 0 : _a.close();
+    var _a, _b;
+    (_a = this.unregisterWatcher) == null ? void 0 : _a.call(this);
+    clearTimeout(this._rerunTimer);
+    this.restartsCount += 1;
+    (_b = this.pool) == null ? void 0 : _b.close();
     this.pool = void 0;
     const resolved = resolveConfig(options, server.config);
     this.server = server;
@@ -5360,6 +5366,7 @@ class Vitest {
     if (this.config.watch)
       this.registerWatcher();
     this.runningPromise = void 0;
+    this._onRestartListeners.forEach((fn) => fn());
   }
   async start(filters) {
     const files = await this.globTestFiles(filters);
@@ -5368,11 +5375,8 @@ class Vitest {
       process.exitCode = 1;
     }
     await this.runFiles(files);
-    if (this.config.watch) {
+    if (this.config.watch)
       await this.report("onWatcherStart");
-      await new Promise(() => {
-      });
-    }
   }
   async runFiles(files) {
     await this.runningPromise;
@@ -5390,44 +5394,59 @@ class Vitest {
     });
     return await this.runningPromise;
   }
+  async scheduleRerun(triggerId) {
+    const currentCount = this.restartsCount;
+    clearTimeout(this._rerunTimer);
+    await this.runningPromise;
+    clearTimeout(this._rerunTimer);
+    if (this.restartsCount !== currentCount)
+      return;
+    this._rerunTimer = setTimeout(async () => {
+      if (this.changedTests.size === 0) {
+        this.invalidates.clear();
+        return;
+      }
+      if (this.restartsCount !== currentCount)
+        return;
+      this.isFirstRun = false;
+      const files = Array.from(this.changedTests);
+      await this.report("onWatcherRerun", files, triggerId);
+      await this.runFiles(files);
+      await this.report("onWatcherStart");
+    }, WATCHER_DEBOUNCE);
+  }
   registerWatcher() {
-    let timer;
-    const scheduleRerun = async (id) => {
-      await this.runningPromise;
-      clearTimeout(timer);
-      timer = setTimeout(async () => {
-        if (this.changedTests.size === 0) {
-          this.invalidates.clear();
-          return;
-        }
-        this.isFirstRun = false;
-        const files = Array.from(this.changedTests);
-        await this.report("onWatcherRerun", files, id);
-        await this.runFiles(files);
-        await this.report("onWatcherStart");
-      }, WATCHER_DEBOUNCE);
-    };
-    this.server.watcher.on("change", (id) => {
+    const onChange = (id) => {
       id = slash(id);
       this.handleFileChanged(id);
       if (this.changedTests.size)
-        scheduleRerun(id);
-    });
-    this.server.watcher.on("unlink", (id) => {
+        this.scheduleRerun(id);
+    };
+    const onUnlink = (id) => {
       id = slash(id);
       this.invalidates.add(id);
       if (id in this.state.filesMap) {
         delete this.state.filesMap[id];
         this.changedTests.delete(id);
       }
-    });
-    this.server.watcher.on("add", async (id) => {
+    };
+    const onAdd = (id) => {
       id = slash(id);
       if (this.isTargetFile(id)) {
         this.changedTests.add(id);
-        scheduleRerun(id);
+        this.scheduleRerun(id);
       }
-    });
+    };
+    const watcher = this.server.watcher;
+    watcher.on("change", onChange);
+    watcher.on("unlink", onUnlink);
+    watcher.on("add", onAdd);
+    this.unregisterWatcher = () => {
+      watcher.off("change", onChange);
+      watcher.off("unlink", onUnlink);
+      watcher.off("add", onAdd);
+      this.unregisterWatcher = noop;
+    };
   }
   handleFileChanged(id) {
     if (this.changedTests.has(id) || this.invalidates.has(id) || id.includes("/node_modules/") || id.includes("/vitest/dist/"))
@@ -5471,6 +5490,9 @@ class Vitest {
       return false;
     return micromatch_1.isMatch(id, this.config.include);
   }
+  onServerRestarted(fn) {
+    this._onRestartListeners.push(fn);
+  }
 }
 async function createVitest(options, viteOverrides = {}) {
   const ctx = new Vitest();
@@ -5491,7 +5513,7 @@ async function createVitest(options, viteOverrides = {}) {
           ctx.setServer(options, server2);
           haveStarted = true;
           if (options.api)
-            server2.middlewares.use((await import('./middleware-b1884a99.js')).default());
+            server2.middlewares.use((await import('./middleware-bf0f818d.js')).default(ctx));
         }
       }
     ],
@@ -5507,6 +5529,8 @@ async function createVitest(options, viteOverrides = {}) {
   };
   const server = await createServer(mergeConfig(config, viteOverrides));
   await server.pluginContainer.buildStart({});
+  if (options.api === true)
+    options.api = defaultPort;
   if (typeof options.api === "number")
     await server.listen(options.api);
   return ctx;