vitest-auto-spy 3.13.0 → 3.13.1

package/AGENTS.md

@@ -358,6 +358,8 @@ users.getName.calledWith(1).mockReturnValue('Ada');
 users.getName.mustBeCalledWith(1).mockReturnValue('Ada');
 // asymmetric matchers work in both
 users.save.calledWith(expect.objectContaining({ id: 1 })).mockReturnValue(true);
+// re-registering the same arguments replaces the answer — matcher arguments included
+users.save.calledWith(expect.objectContaining({ id: 1 })).mockReturnValue(false);
 
 // promises
 users.load.resolveWith({ id: 1 });
@@ -374,6 +376,13 @@ feed.items$.throwWith('FAKE ERROR');
 const subject = feed.items$.returnSubject(); // ReplaySubject, for anything the helpers miss
 ```
 
+An exact argument list is matched before the asymmetric configs, and those are tried in
+registration order — a narrow config written first keeps its calls. Two matchers count as the same
+argument when they accept the same values (same matcher class, sample and inversion), which is what
+makes a second `calledWith(1, expect.anything())` an override rather than a second config sitting
+behind the first. A hand-rolled `{ asymmetricMatch }` object is compared by identity instead: its
+verdict is a closure, so only re-registering that same instance overrides.
+
 `mock.settledResults` is native on Vitest and polyfilled on Bun / `node:test`, so it is identical on
 all three. Entries are `{ type: 'fulfilled' | 'incomplete' | 'rejected', value }`.
 

package/README.md

@@ -16,7 +16,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 [![npm version](https://img.shields.io/npm/v/vitest-auto-spy?color=brightgreen&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![npm downloads](https://img.shields.io/npm/dm/vitest-auto-spy?color=brightgreen&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-14.6%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-14.8%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -1231,6 +1231,24 @@ Wanted: getName(1)
 Actual: getName(2)
 ```
 
+### Matching order, and re-configuring the same arguments
+
+An exact argument list is matched first; the asymmetric configs (`expect.any(Number)`,
+`expect.objectContaining({ … })`, …) are then tried in the order they were registered, so a narrow
+config placed before a wide one keeps its calls. Registering the **same** argument list again
+replaces the answer it gave before — matcher arguments included:
+
+```ts
+myService.getName.calledWith(expect.anything()).mockReturnValue('first');
+myService.getName.calledWith(expect.anything()).mockReturnValue('second');
+expect(myService.getName(1)).toBe('second');
+```
+
+Each `expect.anything()` is a new object, so the two are compared by what they accept rather than by
+identity — same matcher class, same sample, same inversion. A hand-rolled `{ asymmetricMatch }`
+object is the exception: its verdict lives in a closure nothing can read, so two of them are always
+two configs and only the very same instance, re-registered, overrides.
+
 ## Promise-returning methods
 
 ```ts

package/dist/angular.js

@@ -102,6 +102,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }
@@ -172,6 +175,22 @@ function isAsymmetricMatcher(value) {
 function hasAsymmetricMatcher(args) {
   return args.some(isAsymmetricMatcher);
 }
+var ASYMMETRIC_MATCHER_BRAND = /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher");
+function isSameMatcher(configArg, candidateArg) {
+  if (configArg === candidateArg) {
+    return true;
+  }
+  if (!isAsymmetricMatcher(candidateArg) || !isBrandedMatcher(configArg) || !isBrandedMatcher(candidateArg)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(configArg) !== Object.getPrototypeOf(candidateArg)) {
+    return false;
+  }
+  return serializeValue(configArg) === serializeValue(candidateArg);
+}
+function isBrandedMatcher(matcher) {
+  return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
+}
 var ArgsMap = class {
   // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
   // plain own property, never walking or polluting the object prototype chain.
@@ -186,19 +205,7 @@ var ArgsMap = class {
   #arities = /* @__PURE__ */ new Set();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      const serialized = [];
-      const described = [];
-      for (const arg of key) {
-        if (isAsymmetricMatcher(arg)) {
-          serialized.push(void 0);
-          described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
-        } else {
-          const rendered = this.#serialize([arg]);
-          serialized.push(rendered);
-          described.push(rendered.slice(1, -1));
-        }
-      }
-      this.#matcherConfigs.push({ args: key, serialized, described, value });
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
       return;
     }
     if (Array.isArray(key)) {
@@ -228,6 +235,49 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
+  #buildMatcherConfig(key, value) {
+    const serialized = [];
+    const described = [];
+    for (const arg of key) {
+      if (isAsymmetricMatcher(arg)) {
+        serialized.push(void 0);
+        described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
+      } else {
+        const rendered = this.#serialize([arg]);
+        serialized.push(rendered);
+        described.push(rendered.slice(1, -1));
+      }
+    }
+    return { args: key, serialized, described, value };
+  }
+  /**
+   * Register an asymmetric config, replacing an equivalent one in place.
+   *
+   * Re-registering args is how a test overrides an earlier answer, and on the exact map that falls
+   * out for free — the second `set` writes the same key. The matcher list has to do it by hand:
+   * lookup takes the first predicate that matches, so an appended duplicate would sit behind the
+   * config it was meant to replace and never be reached, and a `beforeEach` that reconfigures the
+   * same spy would grow the list on every test. Replacing in place also keeps the registration
+   * order that decides which of two *overlapping* configs wins.
+   */
+  #setMatcherConfig(config) {
+    const index = this.#matcherConfigs.findIndex((existing) => this.#sameConfigArgs(existing, config));
+    if (index === -1) {
+      this.#matcherConfigs.push(config);
+      return;
+    }
+    this.#matcherConfigs[index] = config;
+  }
+  /** Whether two configs were registered for the same argument list, matcher positions included. */
+  #sameConfigArgs(existing, candidate) {
+    if (existing.args.length !== candidate.args.length) {
+      return false;
+    }
+    return existing.args.every(
+      (arg, index) => isAsymmetricMatcher(arg) ? isSameMatcher(arg, candidate.args[index]) : existing.serialized[index] === candidate.serialized[index]
+    );
+  }
   // Keys are always argument arrays; `serializeValue` renders them to a stable,
   // total string (single-quoted strings, bracketed arrays, distinct `undefined`
   // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of

package/dist/bun-angular.js

@@ -1,12 +1,12 @@
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-JV5XRAS4.js';
+import { createSpyForToken } from './chunk-CEVEKNJZ.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass } from './chunk-7YTPHYP7.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-3AWKPZCE.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+import { createSpyFromClass } from './chunk-PCP6A6PD.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-ZY7KPBJJ.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import '@angular/compiler';
 import { NgModule, provideZonelessChangeDetection, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, ApplicationRef, ɵSIGNAL as _SIGNAL } from '@angular/core';

package/dist/bun.js

@@ -1,7 +1,7 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';

package/dist/{chunk-IKH4OTMV.js → chunk-C3IZLTSJ.js}

@@ -1,6 +1,6 @@
-import { mockValueProp, mockReadonlyPropGetter } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, DISPOSE, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-7YTPHYP7.js';
-import { defineHelper, withDocs, DOCS_LINKS, serializeValue, createFunctionSpy, DEEP_CHILDREN } from './chunk-3AWKPZCE.js';
+import { mockValueProp, mockReadonlyPropGetter } from './chunk-WVW4XRL5.js';
+import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, DISPOSE, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-PCP6A6PD.js';
+import { defineHelper, withDocs, DOCS_LINKS, serializeValue, createFunctionSpy, DEEP_CHILDREN } from './chunk-ZY7KPBJJ.js';
 import { getMockAdapter } from './shared-state.js';
 export { describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, getPackageCopies, setEmissionTimeout } from './shared-state.js';
 

package/dist/{chunk-JV5XRAS4.js → chunk-CEVEKNJZ.js}

@@ -1,5 +1,5 @@
-import { createSpyFromClass, createAutoMock } from './chunk-7YTPHYP7.js';
-import { withDocs, DOCS_LINKS } from './chunk-3AWKPZCE.js';
+import { createSpyFromClass, createAutoMock } from './chunk-PCP6A6PD.js';
+import { withDocs, DOCS_LINKS } from './chunk-ZY7KPBJJ.js';
 
 // src/lib/track-injections.ts
 function createSpyForToken(token) {

package/dist/{chunk-7YTPHYP7.js → chunk-PCP6A6PD.js}

@@ -1,4 +1,4 @@
-import { runClearHook, runConfigReset, resolveUnstubbedGuard, withDocs, DOCS_LINKS, AUTO_SPY_MARK, createFunctionSpy, isMarkedMock, readDeepChildren, markAsMock } from './chunk-3AWKPZCE.js';
+import { runClearHook, runConfigReset, resolveUnstubbedGuard, withDocs, DOCS_LINKS, AUTO_SPY_MARK, createFunctionSpy, isMarkedMock, readDeepChildren, markAsMock } from './chunk-ZY7KPBJJ.js';
 import { getMockAdapter, requireObservableSupport } from './shared-state.js';
 
 // src/lib/dispose-symbol.ts

package/dist/{chunk-R4EWAG7Y.js → chunk-WVW4XRL5.js}

@@ -1,4 +1,4 @@
-import { withDocs, DOCS_LINKS } from './chunk-3AWKPZCE.js';
+import { withDocs, DOCS_LINKS } from './chunk-ZY7KPBJJ.js';
 import { getMockAdapter } from './shared-state.js';
 
 // src/lib/redefine-failure.ts

package/dist/{chunk-3AWKPZCE.js → chunk-ZY7KPBJJ.js}

@@ -81,6 +81,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }
@@ -187,6 +190,22 @@ function isAsymmetricMatcher(value) {
 function hasAsymmetricMatcher(args) {
   return args.some(isAsymmetricMatcher);
 }
+var ASYMMETRIC_MATCHER_BRAND = /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher");
+function isSameMatcher(configArg, candidateArg) {
+  if (configArg === candidateArg) {
+    return true;
+  }
+  if (!isAsymmetricMatcher(candidateArg) || !isBrandedMatcher(configArg) || !isBrandedMatcher(candidateArg)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(configArg) !== Object.getPrototypeOf(candidateArg)) {
+    return false;
+  }
+  return serializeValue(configArg) === serializeValue(candidateArg);
+}
+function isBrandedMatcher(matcher) {
+  return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
+}
 var ArgsMap = class {
   // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
   // plain own property, never walking or polluting the object prototype chain.
@@ -201,19 +220,7 @@ var ArgsMap = class {
   #arities = /* @__PURE__ */ new Set();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      const serialized = [];
-      const described = [];
-      for (const arg of key) {
-        if (isAsymmetricMatcher(arg)) {
-          serialized.push(void 0);
-          described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
-        } else {
-          const rendered = this.#serialize([arg]);
-          serialized.push(rendered);
-          described.push(rendered.slice(1, -1));
-        }
-      }
-      this.#matcherConfigs.push({ args: key, serialized, described, value });
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
       return;
     }
     if (Array.isArray(key)) {
@@ -243,6 +250,49 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
+  #buildMatcherConfig(key, value) {
+    const serialized = [];
+    const described = [];
+    for (const arg of key) {
+      if (isAsymmetricMatcher(arg)) {
+        serialized.push(void 0);
+        described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
+      } else {
+        const rendered = this.#serialize([arg]);
+        serialized.push(rendered);
+        described.push(rendered.slice(1, -1));
+      }
+    }
+    return { args: key, serialized, described, value };
+  }
+  /**
+   * Register an asymmetric config, replacing an equivalent one in place.
+   *
+   * Re-registering args is how a test overrides an earlier answer, and on the exact map that falls
+   * out for free — the second `set` writes the same key. The matcher list has to do it by hand:
+   * lookup takes the first predicate that matches, so an appended duplicate would sit behind the
+   * config it was meant to replace and never be reached, and a `beforeEach` that reconfigures the
+   * same spy would grow the list on every test. Replacing in place also keeps the registration
+   * order that decides which of two *overlapping* configs wins.
+   */
+  #setMatcherConfig(config) {
+    const index = this.#matcherConfigs.findIndex((existing) => this.#sameConfigArgs(existing, config));
+    if (index === -1) {
+      this.#matcherConfigs.push(config);
+      return;
+    }
+    this.#matcherConfigs[index] = config;
+  }
+  /** Whether two configs were registered for the same argument list, matcher positions included. */
+  #sameConfigArgs(existing, candidate) {
+    if (existing.args.length !== candidate.args.length) {
+      return false;
+    }
+    return existing.args.every(
+      (arg, index) => isAsymmetricMatcher(arg) ? isSameMatcher(arg, candidate.args[index]) : existing.serialized[index] === candidate.serialized[index]
+    );
+  }
   // Keys are always argument arrays; `serializeValue` renders them to a stable,
   // total string (single-quoted strings, bracketed arrays, distinct `undefined`
   // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of

package/dist/console.js

@@ -1,5 +1,5 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-import { createFunctionSpy } from './chunk-3AWKPZCE.js';
+import { createFunctionSpy } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { hasMockAdapter, registerMockAdapter, getMockAdapter } from './shared-state.js';
 

package/dist/index.js

@@ -164,6 +164,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }
@@ -234,6 +237,22 @@ function isAsymmetricMatcher(value) {
 function hasAsymmetricMatcher(args) {
   return args.some(isAsymmetricMatcher);
 }
+var ASYMMETRIC_MATCHER_BRAND = /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher");
+function isSameMatcher(configArg, candidateArg) {
+  if (configArg === candidateArg) {
+    return true;
+  }
+  if (!isAsymmetricMatcher(candidateArg) || !isBrandedMatcher(configArg) || !isBrandedMatcher(candidateArg)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(configArg) !== Object.getPrototypeOf(candidateArg)) {
+    return false;
+  }
+  return serializeValue(configArg) === serializeValue(candidateArg);
+}
+function isBrandedMatcher(matcher) {
+  return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
+}
 var ArgsMap = class {
   // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
   // plain own property, never walking or polluting the object prototype chain.
@@ -248,19 +267,7 @@ var ArgsMap = class {
   #arities = /* @__PURE__ */ new Set();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      const serialized = [];
-      const described = [];
-      for (const arg of key) {
-        if (isAsymmetricMatcher(arg)) {
-          serialized.push(void 0);
-          described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
-        } else {
-          const rendered = this.#serialize([arg]);
-          serialized.push(rendered);
-          described.push(rendered.slice(1, -1));
-        }
-      }
-      this.#matcherConfigs.push({ args: key, serialized, described, value });
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
       return;
     }
     if (Array.isArray(key)) {
@@ -290,6 +297,49 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
+  #buildMatcherConfig(key, value) {
+    const serialized = [];
+    const described = [];
+    for (const arg of key) {
+      if (isAsymmetricMatcher(arg)) {
+        serialized.push(void 0);
+        described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
+      } else {
+        const rendered = this.#serialize([arg]);
+        serialized.push(rendered);
+        described.push(rendered.slice(1, -1));
+      }
+    }
+    return { args: key, serialized, described, value };
+  }
+  /**
+   * Register an asymmetric config, replacing an equivalent one in place.
+   *
+   * Re-registering args is how a test overrides an earlier answer, and on the exact map that falls
+   * out for free — the second `set` writes the same key. The matcher list has to do it by hand:
+   * lookup takes the first predicate that matches, so an appended duplicate would sit behind the
+   * config it was meant to replace and never be reached, and a `beforeEach` that reconfigures the
+   * same spy would grow the list on every test. Replacing in place also keeps the registration
+   * order that decides which of two *overlapping* configs wins.
+   */
+  #setMatcherConfig(config) {
+    const index = this.#matcherConfigs.findIndex((existing) => this.#sameConfigArgs(existing, config));
+    if (index === -1) {
+      this.#matcherConfigs.push(config);
+      return;
+    }
+    this.#matcherConfigs[index] = config;
+  }
+  /** Whether two configs were registered for the same argument list, matcher positions included. */
+  #sameConfigArgs(existing, candidate) {
+    if (existing.args.length !== candidate.args.length) {
+      return false;
+    }
+    return existing.args.every(
+      (arg, index) => isAsymmetricMatcher(arg) ? isSameMatcher(arg, candidate.args[index]) : existing.serialized[index] === candidate.serialized[index]
+    );
+  }
   // Keys are always argument arrays; `serializeValue` renders them to a stable,
   // total string (single-quoted strings, bracketed arrays, distinct `undefined`
   // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of

package/dist/nestjs.js

@@ -1,7 +1,7 @@
-export { trackInjections } from './chunk-JV5XRAS4.js';
+export { trackInjections } from './chunk-CEVEKNJZ.js';
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-import { createSpyFromClass } from './chunk-7YTPHYP7.js';
-import './chunk-3AWKPZCE.js';
+import { createSpyFromClass } from './chunk-PCP6A6PD.js';
+import './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';
 

package/dist/node.cjs

@@ -322,6 +322,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }
@@ -392,6 +395,22 @@ function isAsymmetricMatcher(value) {
 function hasAsymmetricMatcher(args) {
   return args.some(isAsymmetricMatcher);
 }
+var ASYMMETRIC_MATCHER_BRAND = /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher");
+function isSameMatcher(configArg, candidateArg) {
+  if (configArg === candidateArg) {
+    return true;
+  }
+  if (!isAsymmetricMatcher(candidateArg) || !isBrandedMatcher(configArg) || !isBrandedMatcher(candidateArg)) {
+    return false;
+  }
+  if (Object.getPrototypeOf(configArg) !== Object.getPrototypeOf(candidateArg)) {
+    return false;
+  }
+  return serializeValue(configArg) === serializeValue(candidateArg);
+}
+function isBrandedMatcher(matcher) {
+  return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
+}
 var ArgsMap = class {
   // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
   // plain own property, never walking or polluting the object prototype chain.
@@ -406,19 +425,7 @@ var ArgsMap = class {
   #arities = /* @__PURE__ */ new Set();
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      const serialized = [];
-      const described = [];
-      for (const arg of key) {
-        if (isAsymmetricMatcher(arg)) {
-          serialized.push(void 0);
-          described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
-        } else {
-          const rendered = this.#serialize([arg]);
-          serialized.push(rendered);
-          described.push(rendered.slice(1, -1));
-        }
-      }
-      this.#matcherConfigs.push({ args: key, serialized, described, value });
+      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
       return;
     }
     if (Array.isArray(key)) {
@@ -448,6 +455,49 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
+  #buildMatcherConfig(key, value) {
+    const serialized = [];
+    const described = [];
+    for (const arg of key) {
+      if (isAsymmetricMatcher(arg)) {
+        serialized.push(void 0);
+        described.push(arg.toAsymmetricMatcher?.() ?? String(arg));
+      } else {
+        const rendered = this.#serialize([arg]);
+        serialized.push(rendered);
+        described.push(rendered.slice(1, -1));
+      }
+    }
+    return { args: key, serialized, described, value };
+  }
+  /**
+   * Register an asymmetric config, replacing an equivalent one in place.
+   *
+   * Re-registering args is how a test overrides an earlier answer, and on the exact map that falls
+   * out for free — the second `set` writes the same key. The matcher list has to do it by hand:
+   * lookup takes the first predicate that matches, so an appended duplicate would sit behind the
+   * config it was meant to replace and never be reached, and a `beforeEach` that reconfigures the
+   * same spy would grow the list on every test. Replacing in place also keeps the registration
+   * order that decides which of two *overlapping* configs wins.
+   */
+  #setMatcherConfig(config) {
+    const index = this.#matcherConfigs.findIndex((existing) => this.#sameConfigArgs(existing, config));
+    if (index === -1) {
+      this.#matcherConfigs.push(config);
+      return;
+    }
+    this.#matcherConfigs[index] = config;
+  }
+  /** Whether two configs were registered for the same argument list, matcher positions included. */
+  #sameConfigArgs(existing, candidate) {
+    if (existing.args.length !== candidate.args.length) {
+      return false;
+    }
+    return existing.args.every(
+      (arg, index) => isAsymmetricMatcher(arg) ? isSameMatcher(arg, candidate.args[index]) : existing.serialized[index] === candidate.serialized[index]
+    );
+  }
   // Keys are always argument arrays; `serializeValue` renders them to a stable,
   // total string (single-quoted strings, bracketed arrays, distinct `undefined`
   // / function / symbol / BigInt / Date renderings, circular-ref safe). Arrays of

package/dist/node.js

@@ -1,8 +1,8 @@
 import { createRedefineMockAdapter } from './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { mock } from 'node:test';
 import { registerMockAdapter, guardAccessorSpies } from './shared-state.js';

package/dist/react.js

@@ -1,8 +1,8 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';
 

package/dist/setup.js

@@ -1,6 +1,6 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-import { mockValueProp, countMockedProps, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-import { withDocs, DOCS_LINKS, setDefaultStrictMode } from './chunk-3AWKPZCE.js';
+import { mockValueProp, countMockedProps, restoreMockedProps } from './chunk-WVW4XRL5.js';
+import { withDocs, DOCS_LINKS, setDefaultStrictMode } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter, describeDuplicateCopies } from './shared-state.js';
 export { describeDuplicateCopies, getPackageCopies } from './shared-state.js';

package/dist/shared-state.js

@@ -18,6 +18,9 @@ function serializeShape(value, context) {
   if (value instanceof Date) {
     return `new Date(${value.getTime()})`;
   }
+  if (value instanceof RegExp) {
+    return String(value);
+  }
   if (value instanceof Map) {
     return serializeMap(value, context);
   }

package/dist/svelte.js

@@ -1,8 +1,8 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';
 

package/dist/vue.js

@@ -1,9 +1,9 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass } from './chunk-7YTPHYP7.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
-export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-C3IZLTSJ.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-WVW4XRL5.js';
+import { createSpyFromClass } from './chunk-PCP6A6PD.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-PCP6A6PD.js';
+export { createFunctionSpy, errorHandler } from './chunk-ZY7KPBJJ.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "3.13.0",
+  "version": "3.13.1",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun and node:test, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies.",
   "keywords": [
     "auto-mock",

package/skills/vitest-auto-spy/SKILL.md

@@ -209,6 +209,14 @@ it('loads', async () => {
 - **Never assert a resource with `expect(r.value()).toEqual(...)` alone** — an unresolved resource
   still holds its _default_, so that passes while proving nothing. `toHaveResourceValue(v)` after
   `registerResourceMatchers()` fails unless the resource actually resolved.
+- **`calledWith` matches exact arguments first, then the matcher configs in registration order** —
+  so put the narrow `expect.any(Number)` before the wide `expect.anything()` when both can match.
+  Re-registering the same arguments replaces the previous answer, matcher arguments included: two
+  `calledWith(1, expect.anything())` lines are an override, not two configs.
+- **On Bun (`bun:test`), an asymmetric matcher inside `calledWith` matches nothing** — Bun's
+  `expect.any()` / `expect.objectContaining()` are native objects carrying no `asymmetricMatch`, so
+  the config is kept as an ordinary argument and the call falls through to `undefined` instead of
+  failing. Dispatch on exact arguments there, or use `mockImplementation`.
 - **Never put `captureArg()` in `calledWith`** — it matches every value, so it configures a return
   for every call. It belongs in `toHaveBeenCalledWith`; the types enforce this.
 - **Never `vi.mock('@angular/core')`** (or any relative path) under the Angular unit-test builder —