vitest-auto-spy 5.0.1 → 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
@@ -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;
 }

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

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

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

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

@@ -1,8 +1,14 @@
-import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.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-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 };