vitest 0.0.107 → 0.0.111

package/dist/entry.js

@@ -1,14 +1,15 @@
 import fs, { promises } from 'fs';
-import { w as commonjsRequire, q as commonjsGlobal, x as index, g as getNames, c as c$1, t as toArray, k as basename, y as interpretOnlyMode, z as partitionSuiteChildren, A as hasTests, o as hasFailed, B as clearModuleMocks, b as vi } from './utils-92ec89d1.js';
+import { f as equals, h as iterableEquality, j as subsetEquality, k as isA, J as JestChaiExpect, l as clearContext, m as defaultSuite, n as setHooks, o as getHooks, p as context, s as setState, q as getFn, b as getState, e as vi } from './vi-cb9e4e4e.js';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
 import chai$1, { expect, util } from 'chai';
+import { a as commonjsRequire, c as commonjsGlobal } from './_commonjsHelpers-c9e3b764.js';
+import { l as index, o as getNames, c as c$1, t as toArray, r as relative, p as interpretOnlyMode, q as partitionSuiteChildren, u as hasTests, j as hasFailed } from './utils-cb6b1266.js';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { u as unifiedDiff } from './error-e81aa23d.js';
+import { u as unifiedDiff } from './diff-66d6bb83.js';
 import { performance } from 'perf_hooks';
-import { c as clearContext, b as defaultSuite, e as setHooks, f as getHooks, h as context, j as getFn } from './suite-ff89a82e.js';
-import { n as nanoid } from './index-9e71c815.js';
+import { n as nanoid } from './jest-mock-a57b745c.js';
 import { format as format$1 } from 'util';
 import 'tty';
 import 'path';
@@ -1421,13 +1422,13 @@ var _collections$1 = collections;
 // SENTINEL constants are from https://github.com/facebook/immutable-js
 const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
 const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
-const IS_KEYED_SENTINEL$1 = '@@__IMMUTABLE_KEYED__@@';
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
 const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
-const IS_ORDERED_SENTINEL$1 = '@@__IMMUTABLE_ORDERED__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
 const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
 
 const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
-const IS_SET_SENTINEL$1 = '@@__IMMUTABLE_SET__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
 const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
 
 const getImmutableName = name => 'Immutable.' + name;
@@ -1516,7 +1517,7 @@ const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
     return printAsLeaf(name);
   }
 
-  if (val[IS_KEYED_SENTINEL$1]) {
+  if (val[IS_KEYED_SENTINEL]) {
     return (
       name +
       SPACE +
@@ -1589,7 +1590,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
       depth,
       refs,
       printer,
-      val[IS_ORDERED_SENTINEL$1] ? 'OrderedMap' : 'Map'
+      val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
     );
   }
 
@@ -1605,7 +1606,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
     );
   }
 
-  if (val[IS_SET_SENTINEL$1]) {
+  if (val[IS_SET_SENTINEL]) {
     return printImmutableValues(
       val,
       config,
@@ -1613,7 +1614,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
       depth,
       refs,
       printer,
-      val[IS_ORDERED_SENTINEL$1] ? 'OrderedSet' : 'Set'
+      val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
     );
   }
 
@@ -2186,7 +2187,7 @@ function _interopRequireDefault(obj) {
  */
 
 /* eslint-disable local/ban-types-eventually */
-const toString$1 = Object.prototype.toString;
+const toString = Object.prototype.toString;
 const toISOString = Date.prototype.toISOString;
 const errorToString = Error.prototype.toString;
 const regExpToString = RegExp.prototype.toString;
@@ -2298,7 +2299,7 @@ function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
     return printSymbol(val);
   }
 
-  const toStringed = toString$1.call(val);
+  const toStringed = toString.call(val);
 
   if (toStringed === '[object WeakMap]') {
     return 'WeakMap {}';
@@ -2374,7 +2375,7 @@ function printComplexValue(
     return printer(val.toJSON(), config, indentation, depth, refs, true);
   }
 
-  const toStringed = toString$1.call(val);
+  const toStringed = toString.call(val);
 
   if (toStringed === '[object Arguments]') {
     return hitMaxDepth
@@ -3168,14 +3169,12 @@ const stringify = (object, maxDepth = 10) => {
   try {
     result = format_1(object, {
       maxDepth,
-      min: true,
       plugins: PLUGINS
     });
   } catch {
     result = format_1(object, {
       callToJSON: false,
       maxDepth,
-      min: true,
       plugins: PLUGINS
     });
   }
@@ -3201,238 +3200,6 @@ var matcherUtils = /*#__PURE__*/Object.freeze({
   diff: diff
 });
 
-const isObject = (val) => toString.call(val) === "[object Object]";
-function equals(a, b, customTesters, strictCheck) {
-  customTesters = customTesters || [];
-  return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
-}
-function isAsymmetric(obj) {
-  return !!obj && isA("Function", obj.asymmetricMatch);
-}
-function hasAsymmetric(obj, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(obj))
-    return false;
-  seen.add(obj);
-  if (isAsymmetric(obj))
-    return true;
-  if (Array.isArray(obj))
-    return obj.some((i) => hasAsymmetric(i, seen));
-  if (obj instanceof Set)
-    return Array.from(obj).some((i) => hasAsymmetric(i, seen));
-  if (isObject(obj))
-    return Object.values(obj).some((v) => hasAsymmetric(v, seen));
-  return false;
-}
-function asymmetricMatch(a, b) {
-  const asymmetricA = isAsymmetric(a);
-  const asymmetricB = isAsymmetric(b);
-  if (asymmetricA && asymmetricB)
-    return void 0;
-  if (asymmetricA)
-    return a.asymmetricMatch(b);
-  if (asymmetricB)
-    return b.asymmetricMatch(a);
-}
-function eq(a, b, aStack, bStack, customTesters, hasKey2) {
-  let result = true;
-  const asymmetricResult = asymmetricMatch(a, b);
-  if (asymmetricResult !== void 0)
-    return asymmetricResult;
-  for (let i = 0; i < customTesters.length; i++) {
-    const customTesterResult = customTesters[i](a, b);
-    if (customTesterResult !== void 0)
-      return customTesterResult;
-  }
-  if (a instanceof Error && b instanceof Error)
-    return a.message === b.message;
-  if (Object.is(a, b))
-    return true;
-  if (a === null || b === null)
-    return a === b;
-  const className = Object.prototype.toString.call(a);
-  if (className !== Object.prototype.toString.call(b))
-    return false;
-  switch (className) {
-    case "[object Boolean]":
-    case "[object String]":
-    case "[object Number]":
-      if (typeof a !== typeof b) {
-        return false;
-      } else if (typeof a !== "object" && typeof b !== "object") {
-        return Object.is(a, b);
-      } else {
-        return Object.is(a.valueOf(), b.valueOf());
-      }
-    case "[object Date]":
-      return +a === +b;
-    case "[object RegExp]":
-      return a.source === b.source && a.flags === b.flags;
-  }
-  if (typeof a !== "object" || typeof b !== "object")
-    return false;
-  if (isDomNode(a) && isDomNode(b))
-    return a.isEqualNode(b);
-  let length = aStack.length;
-  while (length--) {
-    if (aStack[length] === a)
-      return bStack[length] === b;
-    else if (bStack[length] === b)
-      return false;
-  }
-  aStack.push(a);
-  bStack.push(b);
-  if (className === "[object Array]" && a.length !== b.length)
-    return false;
-  const aKeys = keys(a, hasKey2);
-  let key;
-  let size = aKeys.length;
-  if (keys(b, hasKey2).length !== size)
-    return false;
-  while (size--) {
-    key = aKeys[size];
-    result = hasKey2(b, key) && eq(a[key], b[key], aStack, bStack, customTesters, hasKey2);
-    if (!result)
-      return false;
-  }
-  aStack.pop();
-  bStack.pop();
-  return result;
-}
-function keys(obj, hasKey2) {
-  const keys2 = [];
-  for (const key in obj) {
-    if (hasKey2(obj, key))
-      keys2.push(key);
-  }
-  return keys2.concat(Object.getOwnPropertySymbols(obj).filter((symbol) => Object.getOwnPropertyDescriptor(obj, symbol).enumerable));
-}
-function hasDefinedKey(obj, key) {
-  return hasKey(obj, key) && obj[key] !== void 0;
-}
-function hasKey(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-function isA(typeName, value) {
-  return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
-}
-function isDomNode(obj) {
-  return obj !== null && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string" && typeof obj.isEqualNode === "function";
-}
-const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
-const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
-const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
-function isImmutableUnorderedKeyed(maybeKeyed) {
-  return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL] && !maybeKeyed[IS_ORDERED_SENTINEL]);
-}
-function isImmutableUnorderedSet(maybeSet) {
-  return !!(maybeSet && maybeSet[IS_SET_SENTINEL] && !maybeSet[IS_ORDERED_SENTINEL]);
-}
-const IteratorSymbol = Symbol.iterator;
-const hasIterator = (object) => !!(object != null && object[IteratorSymbol]);
-const iterableEquality = (a, b, aStack = [], bStack = []) => {
-  if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b))
-    return void 0;
-  if (a.constructor !== b.constructor)
-    return false;
-  let length = aStack.length;
-  while (length--) {
-    if (aStack[length] === a)
-      return bStack[length] === b;
-  }
-  aStack.push(a);
-  bStack.push(b);
-  const iterableEqualityWithStack = (a2, b2) => iterableEquality(a2, b2, [...aStack], [...bStack]);
-  if (a.size !== void 0) {
-    if (a.size !== b.size) {
-      return false;
-    } else if (isA("Set", a) || isImmutableUnorderedSet(a)) {
-      let allFound = true;
-      for (const aValue of a) {
-        if (!b.has(aValue)) {
-          let has = false;
-          for (const bValue of b) {
-            const isEqual = equals(aValue, bValue, [iterableEqualityWithStack]);
-            if (isEqual === true)
-              has = true;
-          }
-          if (has === false) {
-            allFound = false;
-            break;
-          }
-        }
-      }
-      aStack.pop();
-      bStack.pop();
-      return allFound;
-    } else if (isA("Map", a) || isImmutableUnorderedKeyed(a)) {
-      let allFound = true;
-      for (const aEntry of a) {
-        if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), [iterableEqualityWithStack])) {
-          let has = false;
-          for (const bEntry of b) {
-            const matchedKey = equals(aEntry[0], bEntry[0], [
-              iterableEqualityWithStack
-            ]);
-            let matchedValue = false;
-            if (matchedKey === true) {
-              matchedValue = equals(aEntry[1], bEntry[1], [
-                iterableEqualityWithStack
-              ]);
-            }
-            if (matchedValue === true)
-              has = true;
-          }
-          if (has === false) {
-            allFound = false;
-            break;
-          }
-        }
-      }
-      aStack.pop();
-      bStack.pop();
-      return allFound;
-    }
-  }
-  const bIterator = b[IteratorSymbol]();
-  for (const aValue of a) {
-    const nextB = bIterator.next();
-    if (nextB.done || !equals(aValue, nextB.value, [iterableEqualityWithStack]))
-      return false;
-  }
-  if (!bIterator.next().done)
-    return false;
-  aStack.pop();
-  bStack.pop();
-  return true;
-};
-const hasPropertyInObject = (object, key) => {
-  const shouldTerminate = !object || typeof object !== "object" || object === Object.prototype;
-  if (shouldTerminate)
-    return false;
-  return Object.prototype.hasOwnProperty.call(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
-};
-const isObjectWithKeys = (a) => isObject(a) && !(a instanceof Error) && !(a instanceof Array) && !(a instanceof Date);
-const subsetEquality = (object, subset) => {
-  const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object2, subset2) => {
-    if (!isObjectWithKeys(subset2))
-      return void 0;
-    return Object.keys(subset2).every((key) => {
-      if (isObjectWithKeys(subset2[key])) {
-        if (seenReferences.has(subset2[key]))
-          return equals(object2[key], subset2[key], [iterableEquality]);
-        seenReferences.set(subset2[key], true);
-      }
-      const result = object2 != null && hasPropertyInObject(object2, key) && equals(object2[key], subset2[key], [
-        iterableEquality,
-        subsetEqualityWithContext(seenReferences)
-      ]);
-      seenReferences.delete(subset2[key]);
-      return result;
-    });
-  };
-  return subsetEqualityWithContext()(object, subset);
-};
-
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -3500,213 +3267,11 @@ const JestExtend = (chai2, utils) => {
   });
 };
 
-const JestChaiExpect = (chai, utils) => {
-  function def(name, fn) {
-    const addMethod = (n) => {
-      utils.addMethod(chai.Assertion.prototype, n, fn);
-    };
-    if (Array.isArray(name))
-      name.forEach((n) => addMethod(n));
-    else
-      addMethod(name);
-  }
-  const chaiEqual = chai.Assertion.prototype.equal;
-  def("chaiEqual", function(...args) {
-    return chaiEqual.apply(this, args);
-  });
-  utils.overwriteMethod(chai.Assertion.prototype, "equal", (_super) => {
-    return function(...args) {
-      const expected = args[0];
-      const actual = utils.flag(this, "object");
-      if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected, void 0, true), "not match with #{act}", "should not match with #{act}", actual, expected);
-      } else {
-        _super.apply(this, args);
-      }
-    };
-  });
-  utils.overwriteMethod(chai.Assertion.prototype, "eql", (_super) => {
-    return function(...args) {
-      const expected = args[0];
-      const actual = utils.flag(this, "object");
-      if (hasAsymmetric(expected)) {
-        this.assert(equals(actual, expected), "not match with #{exp}", "should not match with #{exp}", actual, expected);
-      } else {
-        _super.apply(this, args);
-      }
-    };
-  });
-  def("toEqual", function(expected) {
-    return this.eql(expected);
-  });
-  def("toStrictEqual", function(expected) {
-    return this.chaiEqual(expected);
-  });
-  def("toBe", function(expected) {
-    return this.equal(expected);
-  });
-  def("toMatchObject", function(expected) {
-    return this.containSubset(expected);
-  });
-  def("toMatch", function(expected) {
-    if (typeof expected === "string")
-      return this.include(expected);
-    else
-      return this.match(expected);
-  });
-  def("toContain", function(item) {
-    return this.contain(item);
-  });
-  def("toContainEqual", function(expected) {
-    const obj = utils.flag(this, "object");
-    const index = Array.from(obj).findIndex((item) => {
-      try {
-        chai.assert.deepEqual(item, expected);
-      } catch {
-        return false;
-      }
-      return true;
-    });
-    this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
-  });
-  def("toBeTruthy", function() {
-    const obj = utils.flag(this, "object");
-    this.assert(Boolean(obj), "expected #{this} to be truthy", "expected #{this} to not be truthy", obj);
-  });
-  def("toBeFalsy", function() {
-    const obj = utils.flag(this, "object");
-    this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
-  });
-  def("toBeGreaterThan", function(expected) {
-    return this.to.greaterThan(expected);
-  });
-  def("toBeGreaterThanOrEqual", function(expected) {
-    return this.to.greaterThanOrEqual(expected);
-  });
-  def("toBeLessThan", function(expected) {
-    return this.to.lessThan(expected);
-  });
-  def("toBeLessThanOrEqual", function(expected) {
-    return this.to.lessThanOrEqual(expected);
-  });
-  def("toBeNaN", function() {
-    return this.be.NaN;
-  });
-  def("toBeUndefined", function() {
-    return this.be.undefined;
-  });
-  def("toBeNull", function() {
-    return this.be.null;
-  });
-  def("toBeDefined", function() {
-    return this.not.be.undefined;
-  });
-  def("toBeInstanceOf", function(obj) {
-    return this.instanceOf(obj);
-  });
-  def("toHaveLength", function(length) {
-    return this.have.length(length);
-  });
-  def("toHaveProperty", function(...args) {
-    return this.have.deep.nested.property(...args);
-  });
-  def("toBeCloseTo", function(number, numDigits = 2) {
-    utils.expectTypes(this, ["number"]);
-    return this.closeTo(number, numDigits);
-  });
-  function isSpy(putativeSpy) {
-    return typeof putativeSpy === "function" && "__isSpy" in putativeSpy && putativeSpy.__isSpy;
-  }
-  const assertIsMock = (assertion) => {
-    if (!isSpy(assertion._obj))
-      throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
-  };
-  const getSpy = (assertion) => {
-    assertIsMock(assertion);
-    return assertion._obj;
-  };
-  def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
-    const spy = getSpy(this);
-    return this.assert(spy.callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number, spy.callCount);
-  });
-  def("toHaveBeenCalledOnce", function() {
-    const spy = getSpy(this);
-    return this.assert(spy.callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1, spy.callCount);
-  });
-  def(["toHaveBeenCalled", "toBeCalled"], function() {
-    const spy = getSpy(this);
-    return this.assert(spy.called, "expected spy to be called at least once", "expected spy to not be called at all", true, spy.called);
-  });
-  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, spy.calls);
-  });
-  const ordinalOf = (i) => {
-    const j = i % 10;
-    const k = i % 100;
-    if (j === 1 && k !== 11)
-      return `${i}st`;
-    if (j === 2 && k !== 12)
-      return `${i}nd`;
-    if (j === 3 && k !== 13)
-      return `${i}rd`;
-    return `${i}th`;
-  };
-  def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-    const spy = getSpy(this);
-    const nthCall = spy.calls[times - 1];
-    this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
-  });
-  def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-    const spy = getSpy(this);
-    const lastCall = spy.calls[spy.calls.length - 1];
-    this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
-  });
-  def(["toThrow", "toThrowError"], function(expected) {
-    const negate = utils.flag(this, "negate");
-    if (negate)
-      this.not.to.throw(expected);
-    else
-      this.to.throw(expected);
-  });
-  def(["toHaveReturned", "toReturn"], function() {
-    const spy = getSpy(this);
-    const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
-    this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
-  });
-  def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-    const spy = getSpy(this);
-    const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
-    this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `received number of returns: ${successfullReturns}`);
-  });
-  def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-    const spy = getSpy(this);
-    const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
-    this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
-  });
-  def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-    const spy = getSpy(this);
-    const lastResult = spy.returns[spy.returns.length - 1];
-    const pass = equals(lastResult, value);
-    this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
-  });
-  def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-    const spy = getSpy(this);
-    const isNot = utils.flag(this, "negate");
-    const [callType, callResult] = spy.results[nthCall - 1];
-    const ordinalCall = `${ordinalOf(nthCall)} call`;
-    if (!isNot && callType === "error")
-      chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-    const nthCallReturn = equals(callResult, value);
-    this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
-  });
-};
-
 class AsymmetricMatcher {
   constructor(sample, inverse = false) {
     this.sample = sample;
     this.inverse = inverse;
+    this.$$typeof = Symbol.for("jest.asymmetricMatcher");
   }
   getMatcherContext() {
     return {
@@ -3907,7 +3472,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-0f4da031.js')).registerApiGlobally();
+    (await import('./global-201fd559.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3932,13 +3497,12 @@ function setupConsoleLogSpy() {
       callback();
     }
   });
-  const newConsole = new Console({
+  globalThis.console = new Console({
     stdout,
     stderr,
     colorMode: true,
     groupIndentation: 2
   });
-  globalThis.console = newConsole;
 }
 async function withEnv(name, fn) {
   const env = await environments[name].setup(globalThis);
@@ -3957,7 +3521,7 @@ async function runSetupFiles(config) {
 }
 
 function serializeError(val) {
-  if (!val)
+  if (!val || typeof val === "string")
     return val;
   if (typeof val === "function")
     return `Function<${val.name}>`;
@@ -3981,6 +3545,10 @@ function processError(err) {
     err.stackStr = String(err.stack);
   if (err.name)
     err.nameStr = String(err.name);
+  if (typeof err.expected !== "string")
+    err.expected = stringify(err.expected);
+  if (typeof err.actual !== "string")
+    err.actual = stringify(err.actual);
   return serializeError(err);
 }
 
@@ -3989,7 +3557,7 @@ async function collectTests(paths, config) {
   for (const filepath of paths) {
     const file = {
       id: nanoid(),
-      name: basename(filepath),
+      name: relative(config.root, filepath),
       type: "suite",
       mode: "run",
       computeMode: "serial",
@@ -4051,7 +3619,11 @@ async function runTest(test) {
   process.__vitest_worker__.current = test;
   try {
     await callSuiteHook(test.suite, "beforeEach", [test, test.suite]);
+    setState({ assertionCalls: 0, expectedAssertionsNumber: null, expectedAssertionsNumberError: null });
     await getFn(test)();
+    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberError } = getState();
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
+      throw expectedAssertionsNumberError;
     test.result.state = "pass";
   } catch (e) {
     test.result.state = "fail";
@@ -4135,6 +3707,15 @@ async function startTests(paths, config) {
   await runSuites(files);
   await getSnapshotClient().saveSnap();
 }
+function clearModuleMocks() {
+  const { clearMocks, mockReset, restoreMocks } = process.__vitest_worker__.config;
+  if (restoreMocks)
+    vi.restoreAllMocks();
+  else if (mockReset)
+    vi.resetAllMocks();
+  else if (clearMocks)
+    vi.clearAllMocks();
+}
 
 async function run(files, config) {
   var _a;

package/dist/global-201fd559.js

@@ -0,0 +1,20 @@
+import { g as globalApis } from './constants-2b0310b7.js';
+import { i as index } from './index-2bb9fd4d.js';
+import 'url';
+import './utils-cb6b1266.js';
+import 'tty';
+import 'local-pkg';
+import 'path';
+import './vi-cb9e4e4e.js';
+import './jest-mock-a57b745c.js';
+import 'chai';
+import 'tinyspy';
+import './_commonjsHelpers-c9e3b764.js';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };