vitest-auto-spy 5.0.0 → 5.1.0

package/AGENTS.md

@@ -1,7 +1,7 @@
 # vitest-auto-spy — instructions for AI coding agents
 
 You are looking at the agent-facing reference for **`vitest-auto-spy`**: typed test spies generated
-from a class, a type, or nothing at all, on Vitest / `bun:test` / `node:test`.
+from a class, a type, or nothing at all, on Vitest / `bun:test` / `node:test` / Rstest.
 
 This file is written for an agent **using** the library in someone's test suite. It is shipped
 inside the npm package, so it is readable with no network:
@@ -43,6 +43,7 @@ adapter installed and spies fail at runtime.
 | `bun test`           | `vitest-auto-spy/bun`         |
 | `bun test` + Angular | `vitest-auto-spy/bun-angular` |
 | `node --test`        | `vitest-auto-spy/node`        |
+| `rstest run`         | `vitest-auto-spy/rstest`      |
 | Angular + Vitest     | `vitest-auto-spy/angular`     |
 | NestJS               | `vitest-auto-spy/nestjs`      |
 | React                | `vitest-auto-spy/react`       |
@@ -1139,10 +1140,16 @@ Everything a spec can observe is the same, and the suite pins it by putting the
   Vitest applies through those two functions.
 
 **The one difference.** `mock.invocationCallOrder` counts on this library's own scale, so
-`expect(a).toHaveBeenCalledBefore(b)` is exact between two auto-spies and meaningless between an
-auto-spy and a hand-written `vi.fn()` — the two counters never met. Nothing else in the library or in
-Vitest reads that field. If a suite needs the comparison, switch the whole run back to the runner's
-factory:
+`expect(a).toHaveBeenCalledBefore(b)` is exact between two auto-spies and **wrong** between an
+auto-spy and a hand-written `vi.fn()` — not an error, an answer, computed from two counters that
+never met. `@vitest/spy` keeps its own in a module-private variable it neither exports nor lets
+anything advance, so the scales cannot be reconciled after the fact; they drift apart by however many
+calls of each kind the run has already made. Measured in a converted suite: a double reporting
+`[164, 165, 167, 168, 169]` beside a `vi.fn()` reporting `[28]` for its single call in the same test,
+under an assertion that had been passing — because `jest-auto-spies` built both halves with
+`jest.fn()`, which did share one counter. Three earlier calls of one family are enough to invert the
+verdict. Nothing else in the library or in Vitest reads that field. If a suite needs the comparison,
+compare two doubles of the same family, or switch the whole run back to the runner's factory:
 
 ```ts
 // vitest.setup.ts
@@ -2273,6 +2280,25 @@ and costs +206 B per mock against +65 B for naming at creation, measured over 20
 mock in `node:test`'s reporter output on its own. Full account:
 <https://asdalexey.github.io/vitest-auto-spy/runtimes/node#spy-names>.
 
+### Rstest
+
+`vitest-auto-spy/rstest` drives the same core through `rstest.fn()` / `rstest.spyOn()`. Rstest
+implements the Jest/Vitest mock surface, so **none of the `node:test` differences above apply**:
+`spy.method.mock.calls[0]` is a bare argument array, the `mockReturnValue` family is native, and
+`gettersToSpyOn` / `settersToSpyOn` go through `rstest.spyOn(obj, 'prop', 'get' | 'set')` rather than
+the redefinition fallback. `rstest.clearAllMocks()`, `rstest.resetAllMocks()` and the
+`clearMocks: true` / `resetMocks: true` config keys reach spies built by `createSpyFromClass` — the
+entry plants one sentinel mock for it, and there is nothing to enable.
+
+Two things are not there. `vitest-auto-spy/setup` is wired to Vitest's hooks, so `setupAutoSpy()` and
+the fake-timer helpers are Vitest-only — on Rstest, import `vitest-auto-spy/rstest` once in the setup
+file, which is the part a setup file is for. `trackNodeMocks()` is `node:test`-only and is not needed:
+Rstest drops its mock registry between files, like Vitest and Bun.
+
+Rstest is 0.x. Vitest stays the zero-config default; reach for this entry when the suite already runs
+on Rstest, which is typically an Rspack project reusing its bundler config for tests. Full account:
+<https://asdalexey.github.io/vitest-auto-spy/runtimes/rstest>.
+
 ---
 
 ## 14. `fakeAsync` needs `vitest-auto-spy/zone`
@@ -2363,6 +2389,10 @@ export default [
 ];
 ```
 
+`autoSpy.configs.typeErrors` is a second flat config holding the subset whose findings are compile
+errors — `prefer-as-spy` (`TS2352`) and `no-mocked-for-spy` (`TS2322`). Spread its `rules` after a
+blanket downgrade so those keep their severity; do not copy the two names into a consumer's config.
+
 | Rule                              | Level   | Fix               | Flags                                                                                                                                     |
 | --------------------------------- | ------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
 | `no-expect-in-subscribe`          | `error` | suggest           | `expect()` inside `subscribe()` → `expectEmission` / `firstValueFrom`                                                                     |
@@ -2585,7 +2615,8 @@ packages, which a subpath export can never be.
 | `TS2540: Cannot assign to 'X' because it is a read-only property`                                        | a `readonly` field of an object under test                                                                                                           | `mockValueProp(obj, 'X', value)` — on a class **getter**, `mockReadonlyProp`                                                            |
 | `TypeError: Cannot read properties of undefined (reading 'mockReturnValue')`                             | the member is an **instance field**, not on the prototype — `Router.currentNavigation` since Angular 20                                              | `provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] })` (§5)                                                        |
 | `throwWith` reaching the success branch first, with the previous test's value                            | the spy's `ReplaySubject(1)` outlived the test that filled it                                                                                        | upgrade; and `resetAutoSpy(spy)` in `beforeEach` when the TestBed is built in `beforeAll`                                               |
-| `TS2540` on a `Spy<T>` / `createAutoMock` member, which the runtime writes fine                          | `Spy<T>` is homomorphic, so it keeps the `readonly` of an abstract getter                                                                            | `Mutable<Spy<T>>` for direct assignment, or `mockValueProp` for a patch that is undone                                                  |
+| `TS2540` on a `Spy<T>` / `createAutoMock` member, which the runtime writes fine                          | `Spy<T>` is homomorphic and keeps the `readonly` of the source member — deliberately: on a member replaced by a **spied accessor** the assignment reaches the setter spy and the getter still answers `undefined`, so the type error is the loud version of a silent no-op | `mockValueProp(spy, 'X', value)` — it defines rather than assigns, so it works in both cases; `Mutable<Spy<T>>` is the opt-in for plain data members, and `Reflect.set` is **not** a way round it |
+| `TS2345` from `mockReturnValue` / `mockImplementation` / `mockResolvedValue` on a double that used to compile | the mock surface is `MockInstance<Method>`, so the stub is now checked against the method's own return type                                          | stub with what the method returns; if the double is meant to answer something else, the method's type or the spec's expectation is wrong |
 | `delete mock.optionalMethod` leaving the member present and truthy                                       | the Proxy had no `deleteProperty` trap before 3.5.0                                                                                                  | upgrade; before that, `mock.optionalMethod = undefined`                                                                                 |
 | half a double's methods reaching the real implementation after `Object.assign`                           | `ownKeys` on a type-driven Proxy lists only the keys already read                                                                                    | `createSpyFromClass(X)` — a real object, with enumerable method keys                                                                    |
 | `let s: MockInstance<() => unknown>` not matching anything                                               | `MockInstance<F>` is invariant in `F`; Jest's `SpyInstance` was not                                                                                  | `MockInstance<T['method']>`, or better `injectSpy(X).method`                                                                            |

package/README.md

@@ -8,7 +8,7 @@ The only auto-spy library that reads a **class** and gives a **fully-typed** spy
 with **return-type-aware** helpers — `resolveWith` / `rejectWith` for `Promise`s, `nextWith` /
 `throwWith` for RxJS `Observable`s, and `calledWith` / `mustBeCalledWith` for argument matching. Or
 skip the class entirely and mock straight from a **type or interface** with `createAutoMock<T>()` and
-recursive `mockDeep<T>()`. Runs on **Vitest**, **Bun** (`bun:test`) and **`node:test`** behind one
+recursive `mockDeep<T>()`. Runs on **Vitest**, **Bun** (`bun:test`), **`node:test`** and **Rstest** behind one
 identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia / Svelte** recipes
 ([availability](#availability)). A drop-in replacement for
 [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spies) — same API, and roughly 1.5x
@@ -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
@@ -719,7 +719,7 @@ the time. It works in any client that _is_ Claude Code — the z.ai and Kimi set
 
 ## Availability
 
-> **All entry points are published.** The **Vitest / Bun / `node:test`** runtimes, the **RxJS** layer,
+> **All entry points are published.** The **Vitest / Bun / `node:test` / Rstest** runtimes, the **RxJS** layer,
 > and the **Angular / NestJS / React / Vue·Pinia / Svelte** recipes all ship as importable entry points —
 > one identical API across every runner and framework.
 
@@ -727,6 +727,7 @@ the time. It works in any client that _is_ Claude Code — the z.ai and Kimi set
 | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `vitest-auto-spy` · `vitest-auto-spy/rxjs` · `vitest-auto-spy/angular`             | ✅ **Published**                                                                                                                                                                                |
 | `vitest-auto-spy/bun` · `vitest-auto-spy/bun-angular` · `vitest-auto-spy/node`     | ✅ **Published**                                                                                                                                                                                |
+| `vitest-auto-spy/rstest`                                                           | ✅ **Published**                                                                                                                                                                                |
 | `vitest-auto-spy/nestjs` · `/react` · `/vue` · `/svelte` · `/console`              | `provideAutoSpy`, `injectSpy` for `Test.createTestingModule`; `createNestUnit` builds the unit from its DI metadata with every unprovided token auto-spied, `expose` for sociable collaborators |
 | `vitest-auto-spy/setup` · `vitest-auto-spy/zone` · `vitest-auto-spy/eslint-plugin` | ✅ **Published**                                                                                                                                                                                |
 | `vitest-auto-spy/jasmine` · `/jasmine-compat` · `/observer-spy`                    | ✅ **Published**                                                                                                                                                                                |
@@ -1154,6 +1155,7 @@ Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runti
 | `vitest-auto-spy/bun`            | the same core, driven by Bun's `bun:test` mocks                                                                                                                                                                | `bun:test`                                               |   ✅   |
 | `vitest-auto-spy/bun-angular`    | Angular's `TestBed` under `bun test` — DOM, JIT `templateUrl` resolution and a zoneless environment, from one preload                                                                                          | `bun:test`, `@angular/core`, `@angular/platform-browser` |   ✅   |
 | `vitest-auto-spy/node`           | the same core, driven by `node:test`'s `mock.fn()`, plus `trackNodeMocks()` — a private `MockTracker` so dropped spies are actually freed                                                                      | `node:test`                                              |   ✅   |
+| `vitest-auto-spy/rstest`         | the same core, driven by Rstest's `rstest.fn()` / `rstest.spyOn()`                                                                                                                                             | `@rstest/core`                                           |   ✅   |
 | `vitest-auto-spy/nestjs`         | `provideAutoSpy`, `injectSpy` for `Test.createTestingModule`                                                                                                                                                   | — (your `@nestjs/*`)                                     |   ✅   |
 | `vitest-auto-spy/react`          | the core, with a natural import for React Testing Library suites                                                                                                                                               | — (your `react`)                                         |   ✅   |
 | `vitest-auto-spy/vue`            | `provideAutoSpy` for `global.provide` + Pinia store spying                                                                                                                                                     | — (your `vue`/`pinia`)                                   |   ✅   |
@@ -1202,18 +1204,19 @@ import 'vitest-auto-spy/rxjs';
 
 The core is runner-agnostic behind a `MockAdapter`: pick the entry that matches your test
 runner — the public API (`createSpyFromClass`, `calledWith`, `resolveWith`, `nextWith`, …) is
-identical across all three.
+identical across all four.
 
 ```ts
 import { createSpyFromClass } from 'vitest-auto-spy'; // Vitest (default, zero-config)
 import { createSpyFromClass } from 'vitest-auto-spy/bun'; // Bun — bun:test
 import { createSpyFromClass } from 'vitest-auto-spy/node'; // node:test
+import { createSpyFromClass } from 'vitest-auto-spy/rstest'; // Rstest
 ```
 
 Angular's `TestBed` runs on Bun too — see [Angular on Bun](#angular-on-bun-buntest) below.
 
 > Only the auto-spy helpers are normalised across runtimes; **native** mock methods stay the
-> runner's own — `mockReturnValue` on Vitest/Bun, `spy.method.mock.mockImplementation` on
+> runner's own — `mockReturnValue` on Vitest/Bun/Rstest, `spy.method.mock.mockImplementation` on
 > `node:test`. Each entry registers its adapter on import, so import the one matching your runner.
 
 > Using an observable spy (`observablePropsToSpyOn`, `nextWith`, …) without importing
@@ -3017,6 +3020,11 @@ export default [
 ];
 ```
 
+A second config, `autoSpy.configs.typeErrors`, holds the subset whose findings are compile errors
+(`prefer-as-spy` is `TS2352`, `no-mocked-for-spy` is `TS2322`). Spread it **after** a blanket
+downgrade so those keep their severity — the recipe is a spread rather than rule names copied into
+your config, where they would go stale silently.
+
 The full dial — landing it on a large existing suite without a red CI, the three rules that can
 report on correct code, and `setupModules` — is on the docs site:
 [ESLint plugin → Tuning it for your project](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-plugin#tuning-it-for-your-project).
@@ -3218,6 +3226,7 @@ names are unfindable from these messages otherwise — no `TS2739` text contains
 | `TS2322: Type 'Spy<X>' is not assignable to type 'Mocked<X>' …`                   | the variable was declared `Mocked<T>`                                                                               | declare it `Spy<T>`                                |
 | `'AddPromiseSpyMethods<unknown>' is missing … from type 'WithMockReturnValue<…>'` | a generic class inferred as `Service<any>`                                                                          | `asSpy<Service>(…)` / `injectSpy<Service>(…)`      |
 | `TS2345` / `TS2554` **on a call to a spied method** (wrong arguments)             | the arguments the real method rejects — the double's call signature is the method's own; it used to accept anything | fix the call; don't re-widen the spy               |
+| `TS2345` **inside `mockReturnValue` / `mockImplementation` / `mockResolvedValue`** | the stub is not what the method returns — the mock surface is `MockInstance<Method>`, so it is checked                | fix the stub; a deliberate mismatch is a type bug  |
 | `TS2739 … 'Spy<X>' is missing …` **on a line with `injectSpy`**                   | the provider handed back the real object                                                                            | `provideAutoSpy(X)`, or an honest `TestBed.inject` |
 
 Two notes that cost real time when they are missing.

package/dist/angular.d.ts

@@ -1,10 +1,10 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-BFq3ve6Q.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-C9ruGqto.js';
 import { InjectionToken, Provider, Type, Signal, WritableSignal } from '@angular/core';
 import { TestAPI } from 'vitest';
-import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-CQLPjw8z.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CAqxzlhV.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-Dp2ZMFqj.js';
-export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-Dy5CvsF2.js';
+import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-CroX5c53.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CiYfR36E.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DkSaUWiQ.js';
+export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-BfCKHEzi.js';
 import '@angular/core/testing';
 
 /**

package/dist/angular.js

@@ -374,6 +374,8 @@ function createFastSpy(implementation, name) {
   spy[STATE] = void 0;
   return spy;
 }
+
+// src/lib/vitest-adapter.ts
 function asVitestMock(mock) {
   return mock;
 }
@@ -564,33 +566,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.d.ts

@@ -1,9 +1,9 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, S as Spy, t as SpyDisposable, u as SpyOptions, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, y as UnstubbedCallHandler, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, S as Spy, t as SpyDisposable, u as SpyOptions, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, y as UnstubbedCallHandler, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CroX5c53.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-Dy5CvsF2.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-Dp2ZMFqj.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-BfCKHEzi.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DkSaUWiQ.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-BFq3ve6Q.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-C9ruGqto.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

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

@@ -1,7 +1,7 @@
-import { u as SpyOptions, C as ClassType, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, S as Spy, m as DeepPartial, D as DeepMockProxy, F as Func, y as UnstubbedCallHandler, g as AddSpyMethodsByReturnTypes } from './types-CQLPjw8z.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, l as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, t as SpyDisposable, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-Dy5CvsF2.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-Dp2ZMFqj.js';
+import { u as SpyOptions, C as ClassType, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, S as Spy, m as DeepPartial, D as DeepMockProxy, F as Func, y as UnstubbedCallHandler, g as AddSpyMethodsByReturnTypes } from './types-CroX5c53.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, l as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, t as SpyDisposable, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CroX5c53.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-BfCKHEzi.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DkSaUWiQ.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import { Mock } from 'vitest';
 
@@ -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-5WEFPNUG.js}

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

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

@@ -1,8 +1,14 @@
-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';
+
+// src/lib/spy-engine.ts
+var engine = "auto-spy";
+function setSpyEngine(next) {
+  engine = next;
+}
+function getSpyEngine() {
+  return engine;
+}
 
 // src/lib/fast-spy.ts
 var clearEpoch = 0;
@@ -343,56 +349,5 @@ function createFastSpy(implementation, name) {
   spy[STATE] = void 0;
   return spy;
 }
-function asVitestMock(mock) {
-  return mock;
-}
-var sweepSentinel = vi.fn();
-Object.defineProperty(sweepSentinel, SWEEP_SENTINEL, { value: true, enumerable: false, configurable: true });
-sweepSentinel.mockClear = function clearAllMocksSweep() {
-  clearAllFastSpies();
-  return sweepSentinel;
-};
-sweepSentinel.mockReset = function resetAllMocksSweep() {
-  resetAllFastSpies();
-  return sweepSentinel;
-};
-sweepSentinel();
-var engine = "auto-spy";
-function setSpyEngine(next) {
-  engine = next;
-}
-function getSpyEngine() {
-  return engine;
-}
-function createRunnerMockFn(implementation, name) {
-  const mock = implementation ? vi.fn(implementation) : vi.fn();
-  if (name !== void 0) {
-    mock.mockName(name);
-  }
-  return mock;
-}
-var vitestMockAdapter = guardAccessorSpies({
-  createMockFn(implementation, name) {
-    return engine === "auto-spy" ? createFastSpy(implementation, name) : createRunnerMockFn(implementation, name);
-  },
-  spyOnGetter(target, property) {
-    return vi.spyOn(target, property, "get");
-  },
-  spyOnSetter(target, property) {
-    return vi.spyOn(target, property, "set");
-  },
-  getCalls(mock) {
-    return asVitestMock(mock).mock.calls;
-  },
-  reset(mock) {
-    asVitestMock(mock).mockReset();
-  },
-  clear(mock) {
-    asVitestMock(mock).mockClear();
-  },
-  restoreImplementation(mock, implementation) {
-    asVitestMock(mock).mockImplementation(implementation);
-  }
-});
 
-export { getSpyEngine, setSpyEngine, vitestMockAdapter };
+export { clearAllFastSpies, createFastSpy, getSpyEngine, resetAllFastSpies, setSpyEngine };

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-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-RQGMLVRO.js

@@ -0,0 +1,51 @@
+import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-CUVQUISO.js';
+import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
+import { vi } from 'vitest';
+import { guardAccessorSpies } from './shared-state.js';
+
+function asVitestMock(mock) {
+  return mock;
+}
+var sweepSentinel = vi.fn();
+Object.defineProperty(sweepSentinel, SWEEP_SENTINEL, { value: true, enumerable: false, configurable: true });
+sweepSentinel.mockClear = function clearAllMocksSweep() {
+  clearAllFastSpies();
+  return sweepSentinel;
+};
+sweepSentinel.mockReset = function resetAllMocksSweep() {
+  resetAllFastSpies();
+  return sweepSentinel;
+};
+sweepSentinel();
+function createRunnerMockFn(implementation, name) {
+  const mock = implementation ? vi.fn(implementation) : vi.fn();
+  if (name !== void 0) {
+    mock.mockName(name);
+  }
+  return mock;
+}
+var vitestMockAdapter = guardAccessorSpies({
+  createMockFn(implementation, name) {
+    return getSpyEngine() === "auto-spy" ? createFastSpy(implementation, name) : createRunnerMockFn(implementation, name);
+  },
+  spyOnGetter(target, property) {
+    return vi.spyOn(target, property, "get");
+  },
+  spyOnSetter(target, property) {
+    return vi.spyOn(target, property, "set");
+  },
+  getCalls(mock) {
+    return asVitestMock(mock).mock.calls;
+  },
+  reset(mock) {
+    asVitestMock(mock).mockReset();
+  },
+  clear(mock) {
+    asVitestMock(mock).mockClear();
+  },
+  restoreImplementation(mock, implementation) {
+    asVitestMock(mock).mockImplementation(implementation);
+  }
+});
+
+export { vitestMockAdapter };

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';