vitest-auto-spy 5.0.0 → 5.0.1

package/README.md

@@ -86,7 +86,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🤖 Built for AI agents too — one `npx vitest-auto-spy init` writes the pointer into the files your agents actually read and specialises it for this repository, backed by an offline [`AGENTS.md`](#using-this-library-with-an-ai-agent) inside the package, a [per-agent map](#which-file-your-agent-reads) for **Claude Code**, **OpenAI Codex**, **GLM/z.ai**, **Cursor**, **Copilot**, **Gemini CLI** and the rest, `llms.txt` on the docs site, a Claude Code skill, and errors that name their own fix
 - 🟢 100% test coverage, **zero runtime dependencies** (in-tree arg serializer, no `javascript-stringify`)
 
-## New in 5.0
+## New in 5
 
 A major that changes **no helper, no option and no runtime behaviour**. What it changes is what the
 package claims to run on, because both old peer ranges were claims the code could not keep — the
@@ -103,7 +103,7 @@ full list, with what to do about each, is in
 For almost everyone the whole upgrade is a version number: every Angular still supported by Angular
 satisfies the new floor, and only a project pinning `rxjs@7.0` or `7.1` on purpose has to move.
 
-## New in 4.0
+## New in 4
 
 A major with **one job**: take out of your project the weight this library was making it carry.
 Nothing was removed or renamed and no runtime behaviour changed — the whole cost is two import

package/dist/angular.js

@@ -564,33 +564,43 @@ function isSameMatcher(configArg, candidateArg) {
 function isBrandedMatcher(matcher) {
   return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
 }
+var ARGS_MAP_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.args-map");
+var _a;
+_a = ARGS_MAP_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.
-  #map = /* @__PURE__ */ Object.create(null);
-  #matcherConfigs = [];
-  // Argument counts present in the exact map. A call with a count nobody configured cannot be in
-  // that map — two arg lists of different lengths never serialize to the same string — so the
-  // serialization can be skipped outright. That matters because the map is consulted on *every*
-  // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
-  // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
-  // build a key that provably cannot match, and throws it away one line later.
-  #arities = /* @__PURE__ */ new Set();
-  /**
-   * The configs of exactly one primitive argument, keyed by the argument itself.
-   *
-   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
-   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
-   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
-   * do on the value with no allocation at all. The configs live in both maps: the string map still
-   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
-   * changes.
-   *
-   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
-   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
-   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
-   */
-  #exactSinglePrimitive = /* @__PURE__ */ new Map();
+  constructor() {
+    this[_a] = true;
+    // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
+    // plain own property, never walking or polluting the object prototype chain.
+    this.#map = /* @__PURE__ */ Object.create(null);
+    this.#matcherConfigs = [];
+    // Argument counts present in the exact map. A call with a count nobody configured cannot be in
+    // that map — two arg lists of different lengths never serialize to the same string — so the
+    // serialization can be skipped outright. That matters because the map is consulted on *every*
+    // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
+    // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
+    // build a key that provably cannot match, and throws it away one line later.
+    this.#arities = /* @__PURE__ */ new Set();
+    /**
+     * The configs of exactly one primitive argument, keyed by the argument itself.
+     *
+     * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+     * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+     * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+     * do on the value with no allocation at all. The configs live in both maps: the string map still
+     * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+     * changes.
+     *
+     * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+     * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+     * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+     */
+    this.#exactSinglePrimitive = /* @__PURE__ */ new Map();
+  }
+  #map;
+  #matcherConfigs;
+  #arities;
+  #exactSinglePrimitive;
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
       this.#setMatcherConfig(this.#buildMatcherConfig(key, value));

package/dist/bun-angular.js

@@ -1,13 +1,13 @@
 import { flushEffects } from './chunk-ALFMIDWW.js';
 export { flushEffects, stable } from './chunk-ALFMIDWW.js';
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-5UF3IVFC.js';
+import { createSpyForToken } from './chunk-CWHCYCCQ.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-KJREOXX6.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-YZOB2KRF.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-import { createSpyFromClass } from './chunk-GNBP7CNT.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GNBP7CNT.js';
-export { createFunctionSpy, errorHandler } from './chunk-E7HYS4K4.js';
+import { createSpyFromClass } from './chunk-VX5DDHAS.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-VX5DDHAS.js';
+export { createFunctionSpy, errorHandler } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import { isAutoSpyLike } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';

package/dist/bun.d.ts

@@ -384,8 +384,19 @@ interface ConfiguredEntry {
     /** Whether an actual call's arguments hit this config. */
     matches(actualArgs: unknown[]): boolean;
 }
+/**
+ * Identity that survives being bundled twice.
+ *
+ * tsup inlines a copy of this class into every entry point that reaches it, so a double built by
+ * `vitest-auto-spy` and read by `vitest-auto-spy/diagnostics` carries two different `ArgsMap`
+ * constructors and `instanceof` answers false. That is how `explainSpy` reported `nothing
+ * configured` for every configured double in the published package while every source-level spec
+ * passed: the specs import one copy. A registry symbol is the same value in both.
+ */
+declare const ARGS_MAP_BRAND: unique symbol;
 declare class ArgsMap {
     #private;
+    readonly [ARGS_MAP_BRAND] = true;
     set(key: unknown, value: unknown): void;
     get(key: unknown): unknown;
     /**

package/dist/bun.js

@@ -1,9 +1,9 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-KJREOXX6.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-YZOB2KRF.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GNBP7CNT.js';
-export { createFunctionSpy, errorHandler } from './chunk-E7HYS4K4.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-VX5DDHAS.js';
+export { createFunctionSpy, errorHandler } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/{chunk-7U6CKTXA.js → chunk-5LLY42R7.js}

@@ -1,4 +1,4 @@
-import { vitestMockAdapter } from './chunk-VZP5MG5N.js';
+import { vitestMockAdapter } from './chunk-NTJDMRHP.js';
 import { registerMockAdapter } from './shared-state.js';
 
 function useVitestAdapter() {

package/dist/{chunk-5UF3IVFC.js → chunk-CWHCYCCQ.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-GNBP7CNT.js';
+import { createSpyFromClass, createAutoMock } from './chunk-VX5DDHAS.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';
 
 // src/lib/track-injections.ts

package/dist/{chunk-VZP5MG5N.js → chunk-NTJDMRHP.js}

@@ -1,5 +1,5 @@
 import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
-import { FAST_SPY_BRAND, isThenable } from './chunk-E7HYS4K4.js';
+import { FAST_SPY_BRAND, isThenable } from './chunk-Q74KQJWG.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
 import { vi } from 'vitest';
 import { guardAccessorSpies } from './shared-state.js';

package/dist/{chunk-E7HYS4K4.js → chunk-Q74KQJWG.js}

@@ -181,33 +181,43 @@ function isSameMatcher(configArg, candidateArg) {
 function isBrandedMatcher(matcher) {
   return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
 }
+var ARGS_MAP_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.args-map");
+var _a;
+_a = ARGS_MAP_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.
-  #map = /* @__PURE__ */ Object.create(null);
-  #matcherConfigs = [];
-  // Argument counts present in the exact map. A call with a count nobody configured cannot be in
-  // that map — two arg lists of different lengths never serialize to the same string — so the
-  // serialization can be skipped outright. That matters because the map is consulted on *every*
-  // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
-  // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
-  // build a key that provably cannot match, and throws it away one line later.
-  #arities = /* @__PURE__ */ new Set();
-  /**
-   * The configs of exactly one primitive argument, keyed by the argument itself.
-   *
-   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
-   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
-   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
-   * do on the value with no allocation at all. The configs live in both maps: the string map still
-   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
-   * changes.
-   *
-   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
-   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
-   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
-   */
-  #exactSinglePrimitive = /* @__PURE__ */ new Map();
+  constructor() {
+    this[_a] = true;
+    // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
+    // plain own property, never walking or polluting the object prototype chain.
+    this.#map = /* @__PURE__ */ Object.create(null);
+    this.#matcherConfigs = [];
+    // Argument counts present in the exact map. A call with a count nobody configured cannot be in
+    // that map — two arg lists of different lengths never serialize to the same string — so the
+    // serialization can be skipped outright. That matters because the map is consulted on *every*
+    // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
+    // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
+    // build a key that provably cannot match, and throws it away one line later.
+    this.#arities = /* @__PURE__ */ new Set();
+    /**
+     * The configs of exactly one primitive argument, keyed by the argument itself.
+     *
+     * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+     * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+     * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+     * do on the value with no allocation at all. The configs live in both maps: the string map still
+     * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+     * changes.
+     *
+     * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+     * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+     * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+     */
+    this.#exactSinglePrimitive = /* @__PURE__ */ new Map();
+  }
+  #map;
+  #matcherConfigs;
+  #arities;
+  #exactSinglePrimitive;
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
       this.#setMatcherConfig(this.#buildMatcherConfig(key, value));

package/dist/{chunk-GNBP7CNT.js → chunk-VX5DDHAS.js}

@@ -1,4 +1,4 @@
-import { resolveUnstubbedGuard, createFunctionSpy } from './chunk-E7HYS4K4.js';
+import { resolveUnstubbedGuard, createFunctionSpy } from './chunk-Q74KQJWG.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
 import { runClearHook, runConfigReset, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';

package/dist/{chunk-KJREOXX6.js → chunk-YZOB2KRF.js}

@@ -1,6 +1,6 @@
 import { redefineFailure, mockValueProp, mockAccessorsProp } from './chunk-ZLF2YBXV.js';
-import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-GNBP7CNT.js';
-import { defineHelper, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-E7HYS4K4.js';
+import { resolveConfiguration, mergeMethodNames, getCallableMemberNames, applyReturns, createSpyFromClass, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-VX5DDHAS.js';
+import { defineHelper, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-Q74KQJWG.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
 import { DEEP_CHILDREN } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';

package/dist/cli.js

@@ -2411,7 +2411,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.0.0";
+var EXPORT_MAP_VERSION = "5.0.1";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular-http vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 11 14 15 16",

package/dist/console.js

@@ -1,6 +1,6 @@
-import { vitestMockAdapter } from './chunk-VZP5MG5N.js';
+import { vitestMockAdapter } from './chunk-NTJDMRHP.js';
 import './chunk-YHDBRBGU.js';
-import { createFunctionSpy } from './chunk-E7HYS4K4.js';
+import { createFunctionSpy } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/diagnostics.js

@@ -125,9 +125,6 @@ function serializePrimitive(value) {
   }
   return String(value);
 }
-function isDeepValue(value) {
-  return typeof value === "object" && value !== null;
-}
 function serializeInContext(value, context) {
   if (typeof value === "object" && value !== null) {
     return serializeObject(value, context);
@@ -203,213 +200,10 @@ function diffByField(actual, expected) {
   const lines = differences.map((difference) => describeField(difference, actual.length));
   return [`${affected.size} of ${actual.length} elements differ.`, ...lines].join("\n");
 }
-
-// src/lib/args-map.ts
-function isSinglePrimitiveArgs(args) {
-  if (args.length !== 1) {
-    return false;
-  }
-  const [argument] = args;
-  const kind = typeof argument;
-  if (kind === "object" || kind === "function" || kind === "symbol") {
-    return argument === null;
-  }
-  return !Object.is(argument, -0);
-}
-function isAsymmetricMatcher(value) {
-  return typeof value === "object" && value !== null && "asymmetricMatch" in value && typeof value.asymmetricMatch === "function";
-}
-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.
-  #map = /* @__PURE__ */ Object.create(null);
-  #matcherConfigs = [];
-  // Argument counts present in the exact map. A call with a count nobody configured cannot be in
-  // that map — two arg lists of different lengths never serialize to the same string — so the
-  // serialization can be skipped outright. That matters because the map is consulted on *every*
-  // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
-  // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
-  // build a key that provably cannot match, and throws it away one line later.
-  #arities = /* @__PURE__ */ new Set();
-  /**
-   * The configs of exactly one primitive argument, keyed by the argument itself.
-   *
-   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
-   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
-   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
-   * do on the value with no allocation at all. The configs live in both maps: the string map still
-   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
-   * changes.
-   *
-   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
-   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
-   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
-   */
-  #exactSinglePrimitive = /* @__PURE__ */ new Map();
-  set(key, value) {
-    if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
-      this.#setMatcherConfig(this.#buildMatcherConfig(key, value));
-      return;
-    }
-    if (Array.isArray(key)) {
-      this.#arities.add(key.length);
-      if (isSinglePrimitiveArgs(key)) {
-        this.#exactSinglePrimitive.set(key[0], value);
-      }
-    }
-    this.#map[this.#serialize(key)] = value;
-  }
-  get(key) {
-    if (Array.isArray(key) && !this.#arities.has(key.length)) {
-      return this.#findByMatcher(key);
-    }
-    if (Array.isArray(key) && isSinglePrimitiveArgs(key)) {
-      const hit = this.#exactSinglePrimitive.get(key[0]);
-      return hit === void 0 ? this.#findByMatcher(key) : hit;
-    }
-    const serialized = this.#serialize(key);
-    if (serialized in this.#map) {
-      return this.#map[serialized];
-    }
-    return this.#findByMatcher(key);
-  }
-  /**
-   * Every configured argument list, rendered the way a lookup key is — the *wanted* half of a
-   * `mustBeCalledWith` failure.
-   *
-   * Nothing is rendered here: the exact configs are keyed by their own serialization, and an
-   * asymmetric config carries the description built when it was registered. A failure message is
-   * assembling text it already has.
-   */
-  configured() {
-    const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
-    return [...Object.keys(this.#map), ...asymmetric];
-  }
-  /**
-   * Every configured argument list as a {@link ConfiguredEntry} — the same lists {@link configured}
-   * returns, each carrying its own position and its own predicate.
-   *
-   * The order is the order a lookup consults them (exact configs first, then the asymmetric ones in
-   * registration order), so the first entry whose `matches` holds is the config `get` would have
-   * answered from. That is what lets a reader be told "call 3 hit config 2" instead of a list of
-   * configs and a list of calls with nothing joining them.
-   */
-  configuredEntries() {
-    const exact = Object.keys(this.#map).map((key, position) => ({
-      index: position + 1,
-      args: key,
-      matches: (actualArgs) => this.#serialize(actualArgs) === key
-    }));
-    const asymmetric = this.#matcherConfigs.map((config, position) => ({
-      index: exact.length + position + 1,
-      args: `[${config.described.join(",")}]`,
-      matches: (actualArgs) => this.#argsMatch(config, actualArgs)
-    }));
-    return [...exact, ...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
-  // only primitive args take a fast path that skips the circular-ref bookkeeping.
-  #serialize(key) {
-    if (Array.isArray(key) && !key.some(isDeepValue)) {
-      return `[${key.map((arg) => serializePrimitive(arg)).join(",")}]`;
-    }
-    return serializeValue(key);
-  }
-  /** Return the value of the first asymmetric config whose predicate matches the actual args. */
-  #findByMatcher(actualArgs) {
-    if (!Array.isArray(actualArgs)) {
-      return void 0;
-    }
-    const match = this.#matcherConfigs.find((config) => this.#argsMatch(config, actualArgs));
-    return match?.value;
-  }
-  /** Whether every configured arg matches the actual arg at the same position (same length). */
-  #argsMatch(config, actualArgs) {
-    if (config.args.length !== actualArgs.length) {
-      return false;
-    }
-    return config.args.every((configArg, index) => this.#valueMatches(configArg, config.serialized[index], actualArgs[index]));
-  }
-  /**
-   * Match a single arg: asymmetric matchers delegate to `asymmetricMatch`, others compare the
-   * config arg's serialization — rendered once at `set()` time — against the actual arg's.
-   *
-   * The branch is taken on `configArg` rather than on `serializedConfigArg === undefined`, even
-   * though the two are the same test by construction: the type guard is what narrows `configArg`
-   * to something with `asymmetricMatch` on it, and the alternative needs an assertion to say the
-   * same thing less safely.
-   */
-  #valueMatches(configArg, serializedConfigArg, actualArg) {
-    if (isAsymmetricMatcher(configArg)) {
-      return configArg.asymmetricMatch(actualArg);
-    }
-    return serializedConfigArg === this.#serialize([actualArg]);
-  }
-};
+var ARGS_MAP_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.args-map");
+function isArgsMap(value) {
+  return typeof value === "object" && value !== null && Reflect.get(value, ARGS_MAP_BRAND) === true;
+}
 
 // src/lib/spy-mark.ts
 var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
@@ -447,7 +241,7 @@ function chainsOf(mock) {
   for (const name of CHAIN_NAMES) {
     const chain = Reflect.get(state, name);
     const map = isObject(chain) ? Reflect.get(chain, "argsToValuesMap") : void 0;
-    if (map instanceof ArgsMap) {
+    if (isArgsMap(map)) {
       chains.push({ name, map });
     }
   }

package/dist/index.js

@@ -613,33 +613,43 @@ function isSameMatcher(configArg, candidateArg) {
 function isBrandedMatcher(matcher) {
   return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
 }
+var ARGS_MAP_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.args-map");
+var _a;
+_a = ARGS_MAP_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.
-  #map = /* @__PURE__ */ Object.create(null);
-  #matcherConfigs = [];
-  // Argument counts present in the exact map. A call with a count nobody configured cannot be in
-  // that map — two arg lists of different lengths never serialize to the same string — so the
-  // serialization can be skipped outright. That matters because the map is consulted on *every*
-  // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
-  // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
-  // build a key that provably cannot match, and throws it away one line later.
-  #arities = /* @__PURE__ */ new Set();
-  /**
-   * The configs of exactly one primitive argument, keyed by the argument itself.
-   *
-   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
-   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
-   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
-   * do on the value with no allocation at all. The configs live in both maps: the string map still
-   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
-   * changes.
-   *
-   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
-   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
-   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
-   */
-  #exactSinglePrimitive = /* @__PURE__ */ new Map();
+  constructor() {
+    this[_a] = true;
+    // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
+    // plain own property, never walking or polluting the object prototype chain.
+    this.#map = /* @__PURE__ */ Object.create(null);
+    this.#matcherConfigs = [];
+    // Argument counts present in the exact map. A call with a count nobody configured cannot be in
+    // that map — two arg lists of different lengths never serialize to the same string — so the
+    // serialization can be skipped outright. That matters because the map is consulted on *every*
+    // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
+    // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
+    // build a key that provably cannot match, and throws it away one line later.
+    this.#arities = /* @__PURE__ */ new Set();
+    /**
+     * The configs of exactly one primitive argument, keyed by the argument itself.
+     *
+     * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+     * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+     * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+     * do on the value with no allocation at all. The configs live in both maps: the string map still
+     * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+     * changes.
+     *
+     * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+     * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+     * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+     */
+    this.#exactSinglePrimitive = /* @__PURE__ */ new Map();
+  }
+  #map;
+  #matcherConfigs;
+  #arities;
+  #exactSinglePrimitive;
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
       this.#setMatcherConfig(this.#buildMatcherConfig(key, value));

package/dist/jasmine.js

@@ -1,10 +1,10 @@
-import { useVitestAdapter } from './chunk-7U6CKTXA.js';
+import { useVitestAdapter } from './chunk-5LLY42R7.js';
 import { enableJasmineCompat } from './chunk-MAKQSO2R.js';
 export { enableJasmineCompat } from './chunk-MAKQSO2R.js';
-import './chunk-VZP5MG5N.js';
+import './chunk-NTJDMRHP.js';
 import './chunk-YHDBRBGU.js';
-import { createSpyFromClass } from './chunk-GNBP7CNT.js';
-import { createFunctionSpy } from './chunk-E7HYS4K4.js';
+import { createSpyFromClass } from './chunk-VX5DDHAS.js';
+import { createFunctionSpy } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/nestjs.js

@@ -1,9 +1,9 @@
-import { createSpyForToken } from './chunk-5UF3IVFC.js';
-export { trackInjections } from './chunk-5UF3IVFC.js';
-import { vitestMockAdapter } from './chunk-VZP5MG5N.js';
+import { createSpyForToken } from './chunk-CWHCYCCQ.js';
+export { trackInjections } from './chunk-CWHCYCCQ.js';
+import { vitestMockAdapter } from './chunk-NTJDMRHP.js';
 import './chunk-YHDBRBGU.js';
-import { createSpyFromClass } from './chunk-GNBP7CNT.js';
-import './chunk-E7HYS4K4.js';
+import { createSpyFromClass } from './chunk-VX5DDHAS.js';
+import './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';

package/dist/node.cjs

@@ -513,33 +513,43 @@ function isSameMatcher(configArg, candidateArg) {
 function isBrandedMatcher(matcher) {
   return matcher.$$typeof === ASYMMETRIC_MATCHER_BRAND;
 }
+var ARGS_MAP_BRAND = /* @__PURE__ */ Symbol.for("vitest-auto-spy.args-map");
+var _a;
+_a = ARGS_MAP_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.
-  #map = /* @__PURE__ */ Object.create(null);
-  #matcherConfigs = [];
-  // Argument counts present in the exact map. A call with a count nobody configured cannot be in
-  // that map — two arg lists of different lengths never serialize to the same string — so the
-  // serialization can be skipped outright. That matters because the map is consulted on *every*
-  // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
-  // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
-  // build a key that provably cannot match, and throws it away one line later.
-  #arities = /* @__PURE__ */ new Set();
-  /**
-   * The configs of exactly one primitive argument, keyed by the argument itself.
-   *
-   * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
-   * **every call** of that spy. Through the string map that costs a rendered key per call — an array
-   * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
-   * do on the value with no allocation at all. The configs live in both maps: the string map still
-   * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
-   * changes.
-   *
-   * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
-   * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
-   * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
-   */
-  #exactSinglePrimitive = /* @__PURE__ */ new Map();
+  constructor() {
+    this[_a] = true;
+    // Prototype-less so a `'__proto__'` (or `'constructor'`) serialized key is a
+    // plain own property, never walking or polluting the object prototype chain.
+    this.#map = /* @__PURE__ */ Object.create(null);
+    this.#matcherConfigs = [];
+    // Argument counts present in the exact map. A call with a count nobody configured cannot be in
+    // that map — two arg lists of different lengths never serialize to the same string — so the
+    // serialization can be skipped outright. That matters because the map is consulted on *every*
+    // invocation of a spy that has any `calledWith` config: without this, `service.load(component)`
+    // on a spy configured with `calledWith(1)` walks and stringifies the whole component graph to
+    // build a key that provably cannot match, and throws it away one line later.
+    this.#arities = /* @__PURE__ */ new Set();
+    /**
+     * The configs of exactly one primitive argument, keyed by the argument itself.
+     *
+     * `calledWith(1)` / `calledWith('id')` is what nearly every spec writes, and it is looked up on
+     * **every call** of that spy. Through the string map that costs a rendered key per call — an array
+     * from `map`, a string per argument, a joined string, then a hash — for a lookup that a `Map` can
+     * do on the value with no allocation at all. The configs live in both maps: the string map still
+     * owns `configured()` and the arity set, so nothing about the failure messages or the miss check
+     * changes.
+     *
+     * Only shapes where the two agree go in here. A symbol renders by description, so two distinct
+     * symbols that share one are the same key in the string map and different keys in a `Map`; `-0`
+     * renders apart from `0` and is the same key under `SameValueZero`. Both stay on the string path.
+     */
+    this.#exactSinglePrimitive = /* @__PURE__ */ new Map();
+  }
+  #map;
+  #matcherConfigs;
+  #arities;
+  #exactSinglePrimitive;
   set(key, value) {
     if (Array.isArray(key) && hasAsymmetricMatcher(key)) {
       this.#setMatcherConfig(this.#buildMatcherConfig(key, value));

package/dist/node.js

@@ -1,8 +1,8 @@
 import { createRedefineMockAdapter } from './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-KJREOXX6.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-YZOB2KRF.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GNBP7CNT.js';
-export { createFunctionSpy, errorHandler } from './chunk-E7HYS4K4.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-VX5DDHAS.js';
+export { createFunctionSpy, errorHandler } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/react.js

@@ -1,9 +1,9 @@
-import { vitestMockAdapter } from './chunk-VZP5MG5N.js';
+import { vitestMockAdapter } from './chunk-NTJDMRHP.js';
 import './chunk-YHDBRBGU.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-KJREOXX6.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-YZOB2KRF.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GNBP7CNT.js';
-export { createFunctionSpy, errorHandler } from './chunk-E7HYS4K4.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-VX5DDHAS.js';
+export { createFunctionSpy, errorHandler } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/setup.js

@@ -1,8 +1,8 @@
-import { useVitestAdapter } from './chunk-7U6CKTXA.js';
-export { getSpyEngine, setSpyEngine } from './chunk-VZP5MG5N.js';
+import { useVitestAdapter } from './chunk-5LLY42R7.js';
+export { getSpyEngine, setSpyEngine } from './chunk-NTJDMRHP.js';
 import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
 import { mockValueProp, countMockedProps, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-import { defineHelper, setDefaultStrictMode } from './chunk-E7HYS4K4.js';
+import { defineHelper, setDefaultStrictMode } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';

package/dist/svelte.js

@@ -1,9 +1,9 @@
-import { vitestMockAdapter } from './chunk-VZP5MG5N.js';
+import { vitestMockAdapter } from './chunk-NTJDMRHP.js';
 import './chunk-YHDBRBGU.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-KJREOXX6.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-YZOB2KRF.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GNBP7CNT.js';
-export { createFunctionSpy, errorHandler } from './chunk-E7HYS4K4.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-VX5DDHAS.js';
+export { createFunctionSpy, errorHandler } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/vue.js

@@ -1,10 +1,10 @@
-import { vitestMockAdapter } from './chunk-VZP5MG5N.js';
+import { vitestMockAdapter } from './chunk-NTJDMRHP.js';
 import './chunk-YHDBRBGU.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-KJREOXX6.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-YZOB2KRF.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-ZLF2YBXV.js';
-import { createSpyFromClass } from './chunk-GNBP7CNT.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GNBP7CNT.js';
-export { createFunctionSpy, errorHandler } from './chunk-E7HYS4K4.js';
+import { createSpyFromClass } from './chunk-VX5DDHAS.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-VX5DDHAS.js';
+export { createFunctionSpy, errorHandler } from './chunk-Q74KQJWG.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.0.0",
+  "version": "5.0.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 and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",
@@ -223,6 +223,7 @@
     "size:entries": "node scripts/size-entries.mjs",
     "size:entries:check": "node scripts/size-entries.mjs --check",
     "size:entries:update": "node scripts/size-entries.mjs --update",
+    "smoke:dist": "node scripts/smoke-dist.mjs",
     "cold-import": "node scripts/cold-import.mjs",
     "cold-import:check": "node scripts/cold-import.mjs --check",
     "cold-import:update": "node scripts/cold-import.mjs --update",
@@ -319,6 +320,7 @@
     "@types/node": "^24.13.3",
     "@typescript-eslint/eslint-plugin": "^8.69.0",
     "@typescript-eslint/parser": "^8.69.0",
+    "@vitest/coverage-istanbul": "^5.0.0",
     "@vitest/coverage-v8": "^5.0.0",
     "eslint": "^10.10.0",
     "eslint-plugin-import-x": "^4.17.1",