vitest-auto-spy 5.0.1 → 5.2.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`       |
@@ -633,6 +634,31 @@ Also true, and worth not re-deriving:
   mapping = createSpyFromClass(MgwMappingService); // no second type argument here
   ```
 
+  **The symptom that leads here says nothing about overloads**, which is why the option is hard to
+  find from the error. A stub of the real response shape is rejected on the spec's own line —
+  `TS2345: Argument of type 'Page' is not assignable to parameter of type 'HttpEvent<Page>'` — on
+  `nextWith(body)`, `resolveWith(body)`, `calledWith(…).returnValue(body)` or
+  `mockReturnValue(of(body))` against a generated `observe` client. Neither the double nor the stub
+  is wrong; both are being checked against the signature nobody calls. Reach for `overload`, never
+  for `@ts-expect-error`: one migration wrote sixty of those across twenty-five files before anyone
+  found this option, and each one stops checking the response shape that line exists to describe.
+
+  **Name the method rather than the whole double.** `'first'` on the type moves *every* overloaded
+  member, and on a wide type that breaks the ones nobody was fixing — `Spy<Response, { overload:
+  'first' }>` for one method collected five `TS2769`s on `download`. `overload` also takes a map:
+
+  ```ts
+  let perf: Spy<Performance, { overload: { getEntriesByType: 'first' } }>;
+  ```
+
+  A name the type does not have never matches, so a rename leaves a dead entry rather than a red
+  build. The default stays `'last'` because "the useful signature" is not decidable from the type: on
+  a generated `observe` client it is the first, on a four-overload `api-mgw` client the last, and both
+  live in one suite. And **overload order is not always the author's** — `declare global` in a
+  third-party package appends to a global interface (`web-vitals` does exactly this to
+  `Performance.getEntriesByType`), so which signature is last depends on which packages are in the
+  program and can move on a dependency bump.
+
 **A getter that returns a `Signal<T>` goes in `instanceMethodsToSpyOn`**, not in `gettersToSpyOn`.
 `get isKidMode(): Signal<boolean> { return this._isKidMode.asReadonly(); }` is read as a property
 and called as a function, and the accessor route makes you write
@@ -642,6 +668,29 @@ class prototype, so nothing is being shadowed), and
 `service.isKidMode.mockReturnValue(false)` reads like every other member. `mockSignalProp` is the
 other answer when the value has to change during the test.
 
+### The composition belongs to the class — `registerAutoSpyDefaults`
+
+A class is doubled the same way in every file that doubles it, so register that once instead of
+repeating it:
+
+```ts
+// vitest.setup.ts, once
+registerAutoSpyDefaults(Router, { observablePropsToSpyOn: ['events'], gettersToSpyOn: ['url'] });
+
+// every spec, from then on
+provideAutoSpy(Router);
+provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] }); // ADDS to the registration
+```
+
+The call site is **merged** into the registration, not substituted for it: lists unioned
+(registration first, no repeats), `returns` / `overrides` merged key by key with the call site
+winning, scalars decided by the call site when it names the key. The bare-array form counts as
+`{ methodsToSpyOn: [...] }`. Registration is by class identity, so a subclass inherits nothing —
+walking the prototype chain would let one registration change doubles in files nobody was looking at.
+A second registration for the same class replaces the first, because two of them in one suite is the
+drift this removes rather than a merge to perform. `clearAutoSpyDefaults(Class)` drops one,
+`clearAutoSpyDefaults()` the lot.
+
 ### `strict` — a method nobody configured throws instead of answering `undefined`
 
 ```ts
@@ -751,6 +800,23 @@ const config = asSpy<FeatureFlagService>(TestBed.inject(FeatureFlagService)); //
 const config = injectSpy<FeatureFlagService>(FeatureFlagService);             // ✅
 ```
 
+**A declared default now reaches the double, and used not to.** `class RemoteConfigService<T =
+RemoteConfigDefaults>` handed to `createSpyFromClass` / `injectSpy` inferred `T` as `unknown`, so
+every member typed against it read as `unknown` on a class that had said exactly what it should be.
+Two shapes caused it, both fixed: the `& { [key: string]: any }` intersection `ClassType<T>` used to
+carry (an index signature makes inference drop the default) and the union in `injectSpy`'s token
+parameter (a union does too — a class now matches a bare construct-signature overload first).
+Spelling the argument out still works and is still the answer when the class has **no** default.
+
+**A generic *method* is a different thing, and it does collapse.** `show<T, U>(component: Type<T>,
+data: U)` on a modal or factory service reaches `Spy<T>` through `Parameters` / `ReturnType`, which
+instantiate the method's own type parameters — so the double types as `show(component: Type<unknown>,
+data: unknown)`. No mapped type in TypeScript can preserve a generic signature, so this is a limit
+rather than a defect, and it is usually harmless: `unknown` accepts every argument and every seeded
+return, so `spy.show.calledWith(MyModal, data).mockReturnValue(ref)` compiles. It bites only where
+the instantiated type appears in a **contravariant** position; there, name the shape on a declaration
+of your own and assign the factory's result to it.
+
 ---
 
 ## 7. Resetting
@@ -1015,6 +1081,12 @@ and a template error about a null profile appeared in a different `describe`. Th
 properties back and warns with the count and the cause. `countMockedProps()` is exported if you
 would rather assert it: `afterEach(() => expect(countMockedProps()).toBe(0))`.
 
+**A `mock*Prop` patch written in a `describe` body or a `beforeAll` is reported**, because the sweep
+undoes it after the test it was applied during and nothing puts it back: the first test passes and
+every one after it reads the real member. `propsOutsideHooks` grades that — `'warn'` (default),
+`'throw'`, `'off'` — and `reportPropsOutsideHooks(reaction)` sets the same dial for a suite that
+wires its own hooks. Move the call into `beforeEach`.
+
 **The one that only bites at scale:** with `isolate: false`, a `setTimeout` or
 `requestAnimationFrame` a component schedules and never clears keeps running after its file is done,
 and fires while the **next** file is mid-test. It is reported against that innocent file, as
@@ -1139,10 +1211,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
@@ -1893,11 +1971,13 @@ enableAngularDiagnostics(); // { ngModuleScopes, deadSchemas, unspiedProviders,
 | `deadSchemas`      | `schemas` sit next to a standalone component (`declarations` empty) — a no-op    |
 | `unspiedProviders` | `injectSpy` got a real instance; a `console.warn` alone, a throw under the group |
 | `pendingRequests`  | the test ended with unflushed `HttpTestingController` requests, named one by one |
+| `shadowedProviders` | a double on the testing module loses to the component's own `providers`         |
 
 Every member defaults to `true`, takes `false` to opt out, and a second call **replaces** the
 selection (safe from anywhere, including inside a test). `disableAngularDiagnostics()` turns the
-group off and leaves the TestBed timing instrumentation alone. `assertNoPendingRequests()` is the
-HTTP check on its own, for use mid-test — reading takes the requests, so the group will not
+group off and leaves the TestBed timing instrumentation alone. `assertNoShadowedProviders(Component, fixture)`
+and `assertNoPendingRequests()` are the same checks on their own, for a spec that renders through a
+helper of its own or wants the HTTP one mid-test — reading takes the requests, so the group will not
 re-report what you inspected.
 
 Nothing here imports `@angular/common/http/testing`: the token is read out of the spec's own
@@ -2273,6 +2353,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 +2462,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`                                                                     |
@@ -2377,17 +2480,21 @@ export default [
 | `no-floating-assertion`           | `error` | —                 | `expect()` in a `.then()` nobody awaits → `expect(await promise)`                                                                         |
 | `no-bare-called-with`             | `error` | —                 | `spy.m.calledWith(1);` as a statement — a stub nobody continued, asserting nothing; chai's `expect(fn).to.have.been.calledWith()` exempt  |
 | `no-overridden-provider`          | `error` | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                 |
-| `no-inject-before-override`       | `error` | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                     |
+| `no-inject-before-override`       | `error` | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                     |
+| `no-private-member-access`        | `error` | —                 | `instance['privateMember']`, `(instance as any).privateMember` (and `as unknown as`, and a decoy type), `vi.spyOn(Object.getPrototypeOf(x), 'm')` → drive the member through the public API. **Type-aware**: silent without `parserOptions.project`, and silent on an index signature |
+| `no-dead-schemas`                 | `error` | —                 | `schemas` on a testing module with no `declarations` — the schema applies to nothing; the file decides, so a `declarations` in another `configureTestingModule` call silences it |
 | `no-import-time-spread`           | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                   |
 | `no-unregistered-inject-spy`      | `error` | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                  |
 | `prefer-render-shallow`           | `error` | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children          |
+| `prefer-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo |
 | `jasmine-namespace-without-entry` | `error` | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compat layer nowhere — option: `{ setupModules: […] }`       |
 | `no-jasmine-globals`              | `error` | —                 | `jasmine.*`, bare `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(`                              |
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                    |
 | `prefer-native-spy-api`           | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim                         |
 
-Nineteen rules, **every one an `error` since 4.0.0**; three fix on their own, seven offer
-suggestions. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
+Twenty-three rules, **every one an `error` since 4.0.0**; three fix on their own, eight offer
+suggestions. Twenty-two are syntactic; `no-private-member-access` is the one that reads types, and it
+reports nothing at all without `parserOptions.project` / `projectService` rather than guessing. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. Three of
 them can report on a _correct_ project, and only one has an option:
 `jasmine-namespace-without-entry` takes `['error', { setupModules: ['./test-setup'] }]`, naming the
@@ -2585,7 +2692,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
@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-15.1%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-15.8%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -76,7 +76,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — twenty rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eight suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
+- 📏 Lint rules and one-line test-run hygiene — twenty-three rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eight suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
 - 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-and-init) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
@@ -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
@@ -1659,6 +1662,27 @@ createSpyFromClass(MyService, {
 });
 ```
 
+### The composition belongs to the class — `registerAutoSpyDefaults`
+
+A spy's composition is a fact about the class rather than about the spec: `Router` needs `events`
+spied as an Observable property and `url` as a getter wherever it is doubled. Register it once and
+every call site starts from it.
+
+```ts
+// vitest-setup.ts, once
+registerAutoSpyDefaults(Router, { observablePropsToSpyOn: ['events'], gettersToSpyOn: ['url'] });
+
+// every spec, from then on
+provideAutoSpy(Router);
+provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] }); // adds, does not replace
+```
+
+The call site is **merged** into the registration rather than replacing it: lists unioned,
+`returns` / `overrides` merged key by key, scalars decided by the call site when it names the key.
+Registration is by class identity — a subclass inherits nothing — and a second registration for one
+class replaces the first, because two of them in one suite is the drift this removes.
+`clearAutoSpyDefaults(Class)` drops one, `clearAutoSpyDefaults()` the lot.
+
 ### Spying instance-assigned callables (`signal()`, arrow props, `signalStore()`)
 
 `createSpyFromClass` discovers methods by walking the **prototype**, so a callable assigned on the
@@ -2831,6 +2855,7 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
 | --------------------- | --------- | ------------------------------------------------------------------------------------- |
 | `duplicateCopies`     | `'throw'` | `'warn'` to report without failing, `'off'` to skip the check                         |
 | `restoreProps`        | `true`    | `restoreMockedProps()` in a global `afterEach`                                        |
+| `propsOutsideHooks`   | `'warn'`  | Name a `mock*Prop` patch made in a `describe` body or `beforeAll` — it survives one test; `'throw'`, `'off'`. `reportPropsOutsideHooks(reaction)` sets the same dial without the setup helper |
 | `restoreMocks`        | `false`   | `vi.restoreAllMocks()` in a global `afterEach` — turn on for `isolate: false`         |
 | `strayTimers`         | `false`   | Cancel timeouts, intervals and frames that outlive their file                         |
 | `onStrayTimers`       | —         | Takes the per-file count the sweep cancelled — see the note on `--detect-async-leaks` |
@@ -3017,6 +3042,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).
@@ -3040,10 +3070,13 @@ export can never be.
 | `no-floating-assertion`           |   `error`   | —                 | `expect()` in a `.then()` nobody awaits → `expect(await promise)`                                                                          |
 | `no-bare-called-with`             |   `error`   | —                 | `spy.m.calledWith(1);` as a statement of its own — a stub nobody continued, asserting nothing                                              |
 | `no-overridden-provider`          |   `error`   | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                  |
-| `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                      |
+| `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                      |
+| `no-private-member-access`        |   `error`   | —                 | `instance['privateMember']`, `(instance as any).privateMember` and `vi.spyOn(Object.getPrototypeOf(x), 'm')` — the three spellings that get past `private`; **type-aware**, and silent without `parserOptions.project` |
+| `no-dead-schemas`                 |   `error`   | —                 | `schemas` on a testing module that declares nothing — a charm protecting nobody, and one that starts working the day `declarations` arrive                                                                            |
 | `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                    |
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                   |
 | `prefer-render-shallow`           |   `error`   | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children           |
+| `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                        |
 | `jasmine-namespace-without-entry` |   `error`   | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compatibility layer nowhere                                   |
 | `no-jasmine-globals`              |   `error`   | —                 | `jasmine.*`, `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(` — none of them exist under Vitest  |
 | `no-save-arguments-by-value`      |   `error`   | —                 | `spy.calls.saveArgumentsByValue()`, which is a no-op here → take the copy at call time                                                     |
@@ -3053,7 +3086,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Three of the twenty fix on their own, eight offer suggestions**, and the split is not about how hard
+**Three of the twenty-three fix on their own, eight offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -3157,7 +3190,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the twenty rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the twenty-three rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3174,7 +3207,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of twenty rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of twenty-three rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -3218,6 +3251,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.
@@ -3264,9 +3298,10 @@ another, and the next one is in that same file.
 | `mockSystemTime` / `withSystemTime` / `mockNow` / `useCountingClock` _(`/setup`)_                                 | Clock control that survives fake timers being re-installed per test                                                                                   |
 | `registerFocusMatchers()` _(`/setup`)_                                                                            | Adds `expect(el).toHaveFocus()`                                                                                                                       |
 | `overrideAutoSpy` / `overrideComponentProvider` / `assertNgModuleScopes` / `assertComponentDefIntact` _(Angular)_ | Override a component-level provider — and verify on the next fixture that the override applied; diagnose an NgModule with an empty runtime scope      |
-| `enableAngularDiagnostics(opts?)` / `disableAngularDiagnostics()` / `assertNoPendingRequests()` _(Angular)_       | Dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests, as failures                                                   |
+| `enableAngularDiagnostics(opts?)` / `disableAngularDiagnostics()` / `assertNoPendingRequests()` / `assertNoShadowedProviders()` _(Angular)_ | `ngModuleScopes`, `deadSchemas`, `unspiedProviders`, `shadowedProviders` and `pendingRequests`: a dead NgModule import, `schemas` that can never apply, an unspied provider, a double the component's own `providers` shadow, and unflushed HTTP requests — each as a failure |
 | `trackInjections(tokens, opts?)` _(Angular, NestJS)_                                                              | Providers that record which collaborators DI constructed, with an auto-spy behind each token                                                          |
 | `setupAutoSpy(opts?)` _(`/setup`)_                                                                                | Property restore + duplicate-copy detection + mock-registry hygiene, in one call                                                                      |
+| `registerAutoSpyDefaults(Class, config)` / `clearAutoSpyDefaults(Class?)`                                         | A class's spy composition registered once, merged into every `createSpyFromClass(X)` / `provideAutoSpy(X)` from then on                               |
 | `setupFakeTimers(config?)` / `advanceTimers(ms?)` _(`/setup`)_                                                    | Paired fake-timer install/restore, and an advance that also settles queued microtasks                                                                 |
 | `describeDuplicateCopies()` / `getPackageCopies()`                                                                | The duplicate-install report, and the copies behind it                                                                                                |
 | `renderShallow(Component, opts?)` _(Angular)_                                                                     | `TestBed` component, minus its children and (by default) its template                                                                                 |

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-BerZbxtu.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-DTi4dIeN.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-D4TuS8yk.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-DmM-rPcG.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-DYtyyKM5.js';
 import '@angular/core/testing';
 
 /**
@@ -245,6 +245,11 @@ interface AngularDiagnosticsOptions {
     unspiedProviders?: boolean;
     /** Fail a test that ends with unflushed `HttpTestingController` requests. */
     pendingRequests?: boolean;
+    /**
+     * Fail when a double registered on the testing module loses to the component's own `providers`,
+     * so the component under test is running against the real service.
+     */
+    shadowedProviders?: boolean;
 }
 /**
  * Fail when the `HttpTestingController` this test configured is still holding requests.
@@ -263,6 +268,23 @@ interface AngularDiagnosticsOptions {
  * ```
  */
 declare function assertNoPendingRequests(): void;
+/**
+ * Fail when a double this test registered on the testing module never reached `component`.
+ *
+ * `shadowedProviders` calls this on every fixture; it is exported for the same reason
+ * {@link assertNoPendingRequests} is — a spec that builds its component through a helper of its own
+ * can ask directly, and a check that can only be reached through one code path is a check that
+ * stops running the day that path changes.
+ *
+ * A no-op when the fixture never rendered `component`, and when everything it resolved is a double.
+ *
+ * @example
+ * ```ts
+ * const fixture = renderThroughOurHelper(CartComponent);
+ * assertNoShadowedProviders(CartComponent, fixture); // the doubles really are the ones in play
+ * ```
+ */
+declare function assertNoShadowedProviders(component: unknown, fixture: unknown): void;
 /**
  * Turn the group on. Every member defaults to `true`; pass `false` to leave one out.
  *
@@ -709,4 +731,4 @@ declare function reportSpecTiming(timing: SpecTiming): void;
  */
 declare function enableTestBedDiagnostics(options?: TestBedDiagnosticsOptions): void;
 
-export { type AngularDiagnosticsOptions, type AngularTestEnvMode, type AngularTestEnvOptions, type AutoSpyFixture, type AutoSpyOverride, type DirectiveHostOptions, type ExtendWithAutoSpiesOptions, type MockedResource, type ResourceDouble, type ResourceDoubleStatus, type ResourceLike, type SignalLike, type SpecTiming, type SpiedFixtures, type TestBedDiagnosticsOptions, assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, createDirectiveHost, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, extendWithAutoSpies, formatSpecTiming, getTestBedTiming, instrumentTestBed, mockResourceProp, mockSignalProp, overrideAutoSpy, overrideComponentProvider, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, reportSpecTiming, setupAngularTestEnv };
+export { type AngularDiagnosticsOptions, type AngularTestEnvMode, type AngularTestEnvOptions, type AutoSpyFixture, type AutoSpyOverride, type DirectiveHostOptions, type ExtendWithAutoSpiesOptions, type MockedResource, type ResourceDouble, type ResourceDoubleStatus, type ResourceLike, type SignalLike, type SpecTiming, type SpiedFixtures, type TestBedDiagnosticsOptions, assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, assertNoShadowedProviders, createDirectiveHost, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, extendWithAutoSpies, formatSpecTiming, getTestBedTiming, instrumentTestBed, mockResourceProp, mockSignalProp, overrideAutoSpy, overrideComponentProvider, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, reportSpecTiming, setupAngularTestEnv };