vitest-auto-spy 5.7.0 → 5.9.0

package/AGENTS.md

@@ -52,17 +52,19 @@ adapter installed and spies fail at runtime.
 
 Add-ons, orthogonal to the runner:
 
-| Add-on            | Import                          | Needed for                                                                                                                                                                                                                      |
-| ----------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Observable spies  | `import 'vitest-auto-spy/rxjs'` | `nextWith` & friends. **Side-effect import, once**, and in a file the `tsconfig` includes (§4)                                                                                                                                  |
-| observer-spy shim | `vitest-auto-spy/observer-spy`  | `subscribeSpyTo` — the `@hirez_io/observer-spy` surface (§20). Its own entry so `/rxjs` does not carry it                                                                                                                       |
-| Console spies     | `vitest-auto-spy/console`       | silent typed spies over the global `console` — `installConsoleSpies()` per test, `restoreConsole()` after                                                                                                                                                                                    |
-| DOM stubs         | `vitest-auto-spy/dom-stubs`     | `stubIntersectionObserver` / `stubResizeObserver` / `stubMutationObserver` / `stubObserver`, `stubMediaElement`, `stubAbortController`, `intersectionEntry` / `resizeEntry` / `mutationRecord`. **Moved off the root in 4.0.0** |
-| Run diagnostics   | `vitest-auto-spy/diagnostics`   | `compareTestRuns`, `summarizeTestRun`, `formatTestRunComparison`, `diffByField`. **Moved off the root in 4.0.0**                                                                                                                |
-| Angular HTTP      | `vitest-auto-spy/angular-http`  | `provideHttpTesting`, `expectRequest` — `httpResource()` / `HttpClient` (§13). Optional `@angular/common` peer, this entry only                                                                                                 |
-| Setup helpers     | `vitest-auto-spy/setup`         | `setupAutoSpy()`, `setupFakeTimers()`                                                                                                                                                                                           |
-| Zone patch        | `import 'vitest-auto-spy/zone'` | `fakeAsync` / `waitForAsync` on Vitest (§14)                                                                                                                                                                                    |
-| jasmine compat    | `vitest-auto-spy/jasmine`       | `.and` / `.calls` / `.withArgs`, the `jasmine` namespace (§20)                                                                                                                                                                  |
+| Add-on            | Import                           | Needed for                                                                                                                                                                                                                                                                      |
+| ----------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Observable spies  | `import 'vitest-auto-spy/rxjs'`  | `nextWith` & friends. **Side-effect import, once**, and in a file the `tsconfig` includes (§4)                                                                                                                                                                                  |
+| observer-spy shim | `vitest-auto-spy/observer-spy`   | `subscribeSpyTo` — the `@hirez_io/observer-spy` surface (§20). Its own entry so `/rxjs` does not carry it                                                                                                                                                                       |
+| Console spies     | `vitest-auto-spy/console`        | silent typed spies over the global `console` — `installConsoleSpies()` per test, `restoreConsole()` after                                                                                                                                                                       |
+| DOM stubs         | `vitest-auto-spy/dom-stubs`      | `stubIntersectionObserver` / `stubResizeObserver` / `stubMutationObserver` / `stubObserver`, `stubMediaElement`, `stubAbortController`, `stubWebStorage` (§12), `intersectionEntry` / `resizeEntry` / `mutationRecord`. **Moved off the root in 4.0.0**                         |
+| Run diagnostics   | `vitest-auto-spy/diagnostics`    | `compareTestRuns`, `summarizeTestRun`, `formatTestRunComparison`, `diffByField`. **Moved off the root in 4.0.0**                                                                                                                                                                |
+| Angular HTTP      | `vitest-auto-spy/angular-http`   | `provideHttpTesting`, `expectRequest` — `httpResource()` / `HttpClient` (§13). Optional `@angular/common` peer, this entry only                                                                                                                                                 |
+| Angular router    | `vitest-auto-spy/angular-router` | `provideActivatedRoute`, `injectActivatedRoute` — an `ActivatedRoute` whose streams and snapshot share one record; `provideRouterDouble`, `injectRouterDouble` — a `Router` whose URL, `routerState` and `events` agree (§13). Optional `@angular/router` peer, this entry only |
+| Signal forms      | `vitest-auto-spy/signal-forms`   | `createForm`, `registerFormMatchers` — a signal form built where `form()` can inject, and `toHaveFieldErrors` over what it produced (§13). Optional `@angular/forms` peer, this entry only; Angular 22+                                                                         |
+| Setup helpers     | `vitest-auto-spy/setup`          | `setupAutoSpy()`, `setupFakeTimers()`                                                                                                                                                                                                                                           |
+| Zone patch        | `import 'vitest-auto-spy/zone'`  | `fakeAsync` / `waitForAsync` on Vitest (§14)                                                                                                                                                                                                                                    |
+| jasmine compat    | `vitest-auto-spy/jasmine`        | `.and` / `.calls` / `.withArgs`, the `jasmine` namespace (§20)                                                                                                                                                                                                                  |
 
 `vitest-auto-spy/jasmine` is Vitest-only, because it registers the Vitest adapter. On `bun test` and
 `node --test` call `enableJasmineCompat()` from `vitest-auto-spy/jasmine-compat` instead.
@@ -73,8 +75,8 @@ so the specifier moved to the root `rxjs` entry — which is where rxjs re-expor
 the floor moved with it. Any Angular project already satisfies it: Angular 16 through 22 all peer on
 `^6.5.3 || ^7.4.0`.
 
-The Angular entries need **Angular >= 20** — `@angular/core`, `@angular/common` and
-`@angular/platform-browser`, all optional peers on the same range. Below 20 the failure is a link
+The Angular entries need **Angular >= 20** — `@angular/core`, `@angular/common`,
+`@angular/platform-browser` and `@angular/router`, all optional peers on the same range. Below 20 the failure is a link
 error, not a missing helper: `/angular` imports `ɵSIGNAL` (Angular 18+) as a value on the first line
 of its bundle, so on 16 and 17 the whole entry fails to load, and `/bun-angular` imports
 `provideZonelessChangeDetection` (Angular 20+; called `provideExperimentalZonelessChangeDetection`
@@ -173,8 +175,8 @@ out, and the one that costs an afternoon otherwise. `mock.repo.user.find()` chai
 but the last is a _read_. A node that is **called** returns what it was configured to return, and by
 default that is `undefined`, so `mockDeep<AppLogger>().channel('app').info('x')` is a `TypeError` at
 the second call — while `DeepMockProxy<AppLogger>` types it perfectly, so nothing warns. Pass
-`{ selfReturning: true }` for a fluent API, or use `createAutoMock<T>()` with
-`channel.mockReturnThis()` when only one method chains:
+`{ selfReturning: true }` for a fluent API, or use
+`createAutoMock<T>(undefined, { selfReturning: ['channel'] })` when only one method chains:
 
 ```ts
 const logger = mockDeep<AppLogger>({}, { selfReturning: true });
@@ -557,6 +559,7 @@ createSpyFromClass(MyService, {
   autoSpyAccessors: true, // discover every accessor on the prototype chain
   lazySpies: true, // build each method spy on first access ('proxy' for very wide classes)
   returns: { getProducts: of([]) }, // what a spied METHOD answers
+  selfReturning: ['where'], // a method that answers the double itself, for a chained call
   overrides: { products$: subject }, // a member that is not a method result
 });
 ```
@@ -570,6 +573,7 @@ createSpyFromClass(MyService, {
 | `lazySpies`              | Behaviour-identical; only changes _when_ each spy is built. `'proxy'` also changes _what holds the name_. |
 | `strict`                 | Throw on a method nobody configured, instead of answering `undefined` (below).                            |
 | `onUnstubbedCall`        | The general form of `strict`; its return value becomes the call's return value.                           |
+| `selfReturning`          | The named methods answer the double itself — a default like `returns`; a name in both answers `returns`.  |
 
 **`instanceMethodsToSpyOn` is not an edge case — it is a top-5 option** (103 of ~370 spec files in
 the reference suite). Method discovery walks the _prototype chain_; a callable assigned to an
@@ -603,7 +607,9 @@ would then take the wrong branch, silently, which is the exact failure mode the
 in §2 exists to remove. A loud `TypeError` on the spec's own line is the better of the two.
 
 For an ngrx `signalStore()`, prefer `createAutoMock<T>()` over listing every member: it mocks from
-the type, needs no prototype, and the list cannot fall behind the store.
+the type, needs no prototype, and the list cannot fall behind the store. Its **signal** members want
+`mockSignalProp`, not a method spy — a store's state is read during the first render, so a method spy
+there answers `undefined` to the template.
 
 The symptom of getting this wrong is **a spy that is never called and no warning at all**: the
 additive lists exist precisely to name things the prototype does not have, so a typo in one cannot
@@ -707,6 +713,33 @@ registerAutoSpyDefaults([
 A later row for a class an earlier row already named replaces it, exactly as a second call would.
 `AutoSpyDefaultEntry<T>` is the row type, for a row built outside the literal.
 
+**An `InjectionToken` is a key too — import `registerAutoSpyDefaults` from `vitest-auto-spy/angular`
+for it.** Same registry, same merge; the core export takes a class only, because the core entry may
+not mention Angular's types. `provideAutoSpyForToken(TOKEN)` reads the registration exactly as
+`provideAutoSpy(Class)` reads a class's — both of its arguments are merged over it, and a registered
+`returns` stays a default a later `calledWith` / `resolveWith` wins over:
+
+```ts
+import { registerAutoSpyDefaults } from 'vitest-auto-spy/angular';
+
+registerAutoSpyDefaults(LOGGER, { returns: { info: undefined, err: undefined }, selfReturning: ['channel'] });
+registerAutoSpyDefaults(NAVIGATION, { overrides: { activeRow$: of({}) }, returns: { setFocus: undefined } });
+
+providers: [provideAutoSpyForToken(LOGGER), provideAutoSpyForToken(NAVIGATION, { activeRow$: rows$ })];
+```
+
+A token row holds `AutoSpyTokenDefaults<T>`: what `createAutoMock` takes (`returns`, `selfReturning`,
+`observablePropsToSpyOn`, `strict`, `name`) plus `overrides`, the seeds `provideAutoSpyForToken` takes
+second. Keys are checked against the token's `T`; a table may mix class rows and token rows;
+`clearAutoSpyDefaults(TOKEN)` from the same entry drops one. Handing a token to the **core**
+`registerAutoSpyDefaults` fails with `TS2345 … 'InjectionToken<X>' is not assignable to parameter of
+type 'ClassType<unknown>'` — the fix is the import, not a cast.
+
+**`selfReturning` names the methods that answer the double itself.** `returns` cannot say it — the
+double does not exist when the literal is written — and without it a chained call dies on
+`undefined`. It works on every factory and in a registration; a registered chain takes a link back out
+through the call site's `returns`, since lists only ever union.
+
 ### `strict` — a method nobody configured throws instead of answering `undefined`
 
 ```ts
@@ -733,6 +766,7 @@ Precedence, first one set wins: the double's `onUnstubbedCall` → the double's
 - **`returns:` is a default in the spy's own container**: a `calledWith` / `resolveWith` / `failWith`
   configured later wins for its arguments or supersedes it, every other call still gets it, and
   `undefined` counts as configured. `returns: { save: undefined }` is how a `void` call is expected.
+  `selfReturning: ['channel']` is the same kind of default, and counts as configured too.
 - **`mockReturnValue` / `mockImplementation` replace the dispatch**, so they never reach the guard —
   and a `calledWith` configured after them is never consulted. After the last `mockReturnValueOnce`
   the queue empties back onto the library dispatch and the next call **is** reported as unstubbed —
@@ -745,6 +779,17 @@ Precedence, first one set wins: the double's `onUnstubbedCall` → the double's
 - **It does not reach** accessor spies, observable-property spies, `mockDeep` nodes, `console-spy`,
   `mockResourceProp`'s `reload` or a standalone `createFunctionSpy`. A strict double still answers
   `undefined` for an unconfigured getter or `items$`. `fillMissing` members **are** covered.
+- **The getter and the stream are reported after the test instead** — a read cannot throw, because a
+  failure diff that prints the double reads it. `setupAutoSpy({ unconfiguredReads: 'warn' | 'throw' })`
+  (default `'off'`, not in the preset) reports a strict double's getter read that reached no
+  configuration and a subscription to a stream nothing fed **by the end of the test** — subscribe in
+  `beforeEach`, `nextWith` in the test is fine. Counted from setup's `beforeEach` to its `afterEach`,
+  so the spec's own hooks count. Configured means `accessorSpies.getters.x.mockReturnValue(…)` /
+  `mockImplementation`, `overrides: { x }` (call site or registration — a registered _list_ alone is
+  not), `mockReadonlyProp`; for a stream any of `nextWith` / `throwWith` / `complete` /
+  `returnSubject`. `undefined` meant: `mockReturnValue(undefined)`. `onUnstubbedRead({ className,
+member, kind, count })` — suite-wide or per double, same precedence as `onUnstubbedCall` — takes the
+  findings instead of the report, from every double not `strict: false`: survey with it first.
 - **Angular lifecycle hooks are exempt.** `ngOnDestroy`, `ngOnInit`, `ngOnChanges`, `ngDoCheck` and the
   `ngAfter…` hooks answer `undefined` on a strict double: Angular calls `ngOnDestroy` itself on every
   provided value at teardown (a `createAutoMock` / `provideAutoSpyForToken` double always has one), and
@@ -832,6 +877,16 @@ const config = asSpy<FeatureFlagService>(TestBed.inject(FeatureFlagService)); //
 const config = injectSpy<FeatureFlagService>(FeatureFlagService);             // ✅
 ```
 
+It applies to `createSpyFromClass` with a configuration too, in one combination: an accessor list
+(or `overrides`) **and** `returns` on a generic class. TypeScript checks a generic class argument
+after the configuration, reads `T` back from `gettersToSpyOn: ['remoteConfig']` as
+`{ remoteConfig: any }`, and fails with `'isKeyEnabled' does not exist in type
+'MethodReturns<{ remoteConfig: any; }>'`. Spell it out — `createSpyFromClass<RemoteConfigService>(…)`.
+`provideAutoSpy`, `overrideAutoSpy`, `overrideComponentProvider` and the class overload of
+`registerAutoSpyDefaults` (`/angular`) take `T` from the class alone, so there the inferred form
+compiles; the core `registerAutoSpyDefaults` needs the argument spelled out like
+`createSpyFromClass`. A token key needs nothing: `T` comes from the `InjectionToken<T>` itself.
+
 **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.
@@ -1610,7 +1665,8 @@ setupAutoSpy({ preset: 'strict' });
 Sets `duplicateCopies`, `propsOutsideHooks`, `guardGlobals`, `prototypePollution`, `strayConsole` and
 `misconfiguration` to `'throw'`, turns `strayTimers` on, and `strayRejections` on when zone.js is
 loaded. An option passed alongside still wins. **Not** included: `strict` (strict doubles change what
-an unconfigured call returns — a semantic switch, not a grade; the name was taken, hence `preset`),
+an unconfigured call returns — a semantic switch, not a grade; the name was taken, hence `preset`) and
+`unconfiguredReads`, its read side (survey with `onUnstubbedRead` before turning it on),
 `blockNetwork` (changes the code under test), `restoreMocks` (drops `beforeAll` spies), failing on
 stray-timer counts (the sweep fails the file from `afterAll`, and a callback scheduled after the
 previous file's sweep is charged to the next — opt in with
@@ -1675,7 +1731,7 @@ never holds fails naming the `label` rather than hanging until the runner's time
 
 **Not for an Angular `resource()` / `httpResource()`.** Those need a change-detection _tick_, and
 this helper only takes event-loop turns — a resource awaited through it finishes the whole budget
-having issued zero requests. `settleResource(resource, { turns, label })` from
+having issued zero requests. `settleResource(resource, { turns, label, allowIdle })` from
 `vitest-auto-spy/angular` is that wait.
 
 `flushEventLoop(turns?)` takes real event-loop turns even while the timers are faked, without
@@ -1750,6 +1806,34 @@ State is per element, so an ad and the content report different durations.
 the record and fires `timeupdate` too — `media.set()` is not the only way in, and the component's own
 handler runs where it used to stay unrun while the assertion read the new value.
 
+### `localStorage` and `sessionStorage`
+
+Do not write a `TestingStorage` class per project. `stubWebStorage()` installs an in-memory `Storage`
+for this test — `getItem` / `setItem` / `removeItem` / `clear` / `key` / `length`, string coercion
+as the platform does it — and `snapshot()` is the plain record to assert on:
+
+```ts
+import { type WebStorageStub, stubWebStorage } from 'vitest-auto-spy/dom-stubs';
+
+let local: WebStorageStub;
+
+beforeEach(() => {
+  local = stubWebStorage('localStorage', { items: { token: 'abc' } }); // or 'sessionStorage'
+});
+
+it('forgets the token on logout', () => {
+  session.logout();
+  expect(local.snapshot()).toEqual({});
+});
+```
+
+It goes through `mockValueProp`, so `restoreMockedProps()` (and `setupAutoSpy()` between tests) puts
+the previous storage back; install it in `beforeEach`. It also lands on `document.defaultView` when
+that is a separate object. It is not `restoreWebStorage()`: that one repairs a broken environment
+once and leaves a working storage alone; this one replaces whatever is there, for one test, and
+installs even in a `node` environment because the spec asked for it. Named-property access
+(`localStorage.token`, `Object.keys(localStorage)`) does not see the items — read through the API.
+
 ### A module mock that did nothing
 
 `vi.mock()` is the one thing in a ported suite that fails **silently**. Under a bundler
@@ -1858,6 +1942,12 @@ statement is not brevity: the shortcut people take instead is an exported `const
 the values, and under `isolate: false` that is one set of spies shared by every file that imports
 it.
 
+**A member named in both wins as the seed**, whatever the seed is — a value, a plain function, a
+`vi.fn()`. `returns` and `selfReturning` skip such a member rather than configuring it, which is the
+precedence the merge already applies between a registration and a call site: a spec seeding `channel`
+over `registerAutoSpyDefaults(LOGGER, { selfReturning: ['channel'] })` gets its own function back, not
+the registered link.
+
 **`observablePropsToSpyOn` works on a token too**, and matters more there than on a class. A class
 tells the factory which members are methods; a type does not, so _every_ unnamed key of a
 token-driven double is a function spy — including an `Observable` property, which the code under
@@ -1919,6 +2009,25 @@ selected.set(true); // every computed reading it updates
 Use it whenever the value has to change during the test. `mockReadonlyProp` stays right when the
 value is fixed for the whole test and you never need the handle.
 
+A `linkedSignal()` is a writable signal like any other, so `mockSignalProp` covers it and there is
+no separate helper to go looking for.
+
+**It patches as little as it can, and the order rule follows from that.** A member that is already
+writable — `signal()`, `model()`, `linkedSignal()` — is **written through**, not replaced: Angular
+links a consumer to the signal it read, not to the property it read it through, so replacing one
+that anything has already read strands every `computed()`, `effect()` and template binding on the
+old signal, silently and for the rest of the test. Writing through keeps all of them, keeps a
+`model()`'s output half alive, and leaves nothing for `restoreMockedProps()` to undo — the value
+stays where the spec left it.
+
+Two shapes are still swapped: a `computed()` the class declares, and a member the spy does not have
+yet. **Patch those before anything reads them** — before the first `detectChanges()` /
+`stable(fixture)`. A read-only signal a live consumer has already read is refused by name rather
+than replaced where nothing would notice it, and an `input()` is refused outright: Angular sets an
+input through the input node rather than the property, so a replaced one breaks the host's next
+write. Drive an input with `fixture.componentRef.setInput(name, value)`, or with
+`renderShallow(Component, { inputs: { … } })` for the value it starts at.
+
 ### Observers the component constructs itself
 
 Do not assign `globalThis.IntersectionObserver` by hand: it stays assigned, and under
@@ -2160,8 +2269,9 @@ and the next line reads the settled value.
 
 Three things to know before reaching for it:
 
-- **It does not re-export the core.** The one subpath that does not: it is a companion to
-  `vitest-auto-spy/angular`, which stays the import for spies, `TestBed` helpers and `settleResource`.
+- **It does not re-export the core** — nor does `/angular-router`; every other subpath does. It is a
+  companion to `vitest-auto-spy/angular`, which stays the import for spies, `TestBed` helpers and
+  `settleResource`.
   Staying narrow is what keeps `@angular/common` — an **optional** peer — out of every other entry.
 - **`settleResource` is unchanged and still the answer** whenever the wait is not tied to one
   request: a `resource()` with an async loader, an `rxResource`, a reload, anything not HTTP.
@@ -2170,6 +2280,286 @@ Three things to know before reaching for it:
   suite using `provideHttpTesting()` everywhere the diagnostic is redundant; keep it on while any
   file still configures HTTP testing by hand.
 
+### `ActivatedRoute` from one record — `vitest-auto-spy/angular-router`
+
+```ts
+import { injectActivatedRoute, provideActivatedRoute } from 'vitest-auto-spy/angular-router';
+
+TestBed.configureTestingModule({
+  providers: [provideActivatedRoute({ params: { id: '7' }, queryParams: { tab: 'reviews' } })],
+});
+
+const fixture = TestBed.createComponent(ProductPage);
+
+injectActivatedRoute().setParams({ id: '8' }); // params + paramMap emit; snapshot.params already agrees
+fixture.detectChanges();
+```
+
+**Do not hand-write an `ActivatedRoute` double, and do not `provideAutoSpy(ActivatedRoute)`.** Its
+streams and its snapshot are instance fields: the spy has neither, and a `useValue` has whichever half
+its author thought of — `route.paramMap.pipe(…)` throws on the `{ snapshot }` one, `route.snapshot`
+is `undefined` on the `{ params: of(…) }` one, and a spec that updates one half by hand tests a route
+no navigation produces. `provideActivatedRoute(init)` provides **Angular's own `ActivatedRoute`**
+built over one record, so every stream, both `ParamMap`s and `snapshot` read the same values.
+
+| Call                              | Does                                                                                                                                               |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `provideActivatedRoute(init?)`    | a `FactoryProvider` — a fresh route per injector; `init`: `params`, `queryParams`, `data`, `fragment`, `url`, `outlet`, `component`, `routeConfig` |
+| `injectActivatedRoute(injector?)` | the handle: `.route`, `setParams`, `setQueryParams`, `setData`, `setFragment`, `setUrl`, `set({ … })`                                              |
+| `createActivatedRoute(init?)`     | the same handle without a `TestBed` — for `new Page(route)`, or a guard given `route.snapshot`                                                     |
+
+A setter behaves like the router after a navigation: it **replaces** (not merges) that part, builds
+a new snapshot first, then emits only the streams whose value changed (router equality: same keys,
+arrays as sorted sets), in the order `queryParams`, `fragment`, `params`, `url`, `data`. Setting
+an equal value emits nothing; a string `url` is split on `/`.
+
+Four things to know:
+
+- **List it after `provideRouter()`** — the later provider of `ActivatedRoute` wins, and
+  `injectActivatedRoute()` throws naming the one that did. With the real router present, the double
+  still works as `relativeTo` for `router.createUrlTree`.
+- **One node, no tree.** `root` is the route itself, `parent` / `firstChild` are `null`. For
+  `route.parent.params` patch that member with `mockReadonlyProp`, or use `RouterTestingHarness`.
+- **No `title`, no navigation, no input binding** — `title` emits `undefined`, `Router.navigate`
+  does not move it (the setters do), and `withComponentInputBinding()` is the outlet's job
+  (`fixture.componentRef.setInput`).
+- **Its own entry, like `/angular-http`.** It does not re-export the core, imports no runner, and is
+  the only file that reaches `@angular/router` — an optional peer.
+
+### `Router` from one URL — `vitest-auto-spy/angular-router`
+
+```ts
+import { injectRouterDouble, provideRouterDouble } from 'vitest-auto-spy/angular-router';
+
+TestBed.configureTestingModule({ providers: [provideRouterDouble({ url: '/products/7' })] });
+
+const router = injectRouterDouble();
+
+router.emitNavigation('/products/8'); // events emits a NavigationEnd; router.url already reads it
+expect(router.navigate).toHaveBeenCalledWith(['/checkout']);
+```
+
+**Do not hand-write `createAutoMock<Router>({ events: of(), url: '/' }, { returns: { navigate:
+Promise.resolve(true) } })`** — the line 48 hand-rolled providers across two private suites all
+converged on, and every part of it is a guess the component falls through: `of()` never emits again,
+`url` is a string nobody updates, `routerState` is absent, `serializeUrl` throws on the first
+redirect a guard builds. `provideRouterDouble(init)` keeps one URL and derives the rest.
+
+| Call                            | Does                                                                                                         |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `provideRouterDouble(init?)`    | a `FactoryProvider` for the `Router` token — a fresh router per injector; `init` is `{ url }`, default `'/'` |
+| `injectRouterDouble(injector?)` | the handle: `.router`, `.navigate`, `.navigateByUrl`, `setUrl(url)`, `emitNavigation(event?)`                |
+| `createRouterDouble(init?)`     | the same handle without a `TestBed` — for `new AuthGuard(router)`                                            |
+
+Unlike the route, this is **not** an instance of Angular's class: a real `Router` drags the whole
+routing stack in. It is a structural double that answers `url` (serialized as the real router does),
+`events` (a `BehaviorSubject` starting at the `NavigationEnd` that put it there), `navigate` and
+`navigateByUrl` (spies resolving `true`), `serializeUrl` / `parseUrl` / `createUrlTree` (the
+router's own URL work, via `DefaultUrlSerializer` and `createUrlTreeFromSnapshot`) and `routerState`
+(Angular's own, its `snapshot.url` the URL). **Every other member `Router` declares throws by name**
+rather than reading `undefined`.
+
+Four things to know:
+
+- **It does not navigate.** `navigate()` records the call and resolves `true`; it does not move
+  `url`. `setUrl()` and `emitNavigation()` move it; `RouterTestingHarness` over a real
+  `provideRouter()` is what tests a navigation.
+- **`emitNavigation()` takes what you have** — nothing, a URL string, or an event you built. A
+  `NavigationEnd` moves the URL with it; any other event does not.
+- **Ordering does not matter here.** `Router` is `providedIn: 'root'` and `provideRouter()` does not
+  re-provide the token, so the double wins in either order — and a `TestBed` without it hands out a
+  real router, which is what `injectRouterDouble()` says by name.
+- **It builds spies**, so a runtime entry has to be imported in the suite (`vitest-auto-spy/angular`
+  in the same file, or the setup file); the route double needs none.
+
+### Signal forms — `vitest-auto-spy/signal-forms`
+
+```ts
+import { minLength, required } from '@angular/forms/signals';
+import { createForm, registerFormMatchers } from 'vitest-auto-spy/signal-forms';
+
+registerFormMatchers(); // once, in the setup file
+
+const user = createForm({ email: '', name: '' }, (path) => {
+  required(path.email, { message: 'Email is required' });
+  minLength(path.name, 2);
+});
+
+expect(user.email).toHaveFieldErrors([{ kind: 'required', message: 'Email is required' }]);
+
+user.email().value.set('ada@example.test');
+
+expect(user.email).toHaveFieldErrors([]);
+```
+
+Signal forms are stable from Angular 22, and a spec that touches one meets the same two things every
+time. **`form()` injects**, so a call in a `beforeEach` throws `NG0203: The Injector token injection
+failed` — a message about `inject()` that never says "form", whose repair is
+`{ injector: TestBed.inject(Injector) }` or a `TestBed.runInInjectionContext` around the call.
+**`errors()` answers `RequiredValidationError` instances**, each carrying a `fieldTree`
+back-reference, so `toEqual([{ kind: 'required' }])` fails on a property nobody wrote and every
+suite falls back to `errors().some((error) => error.kind === 'required')` — which passes just as
+happily when the field has three other errors nobody expected.
+
+| Call                                          | Does                                                                      |
+| --------------------------------------------- | ------------------------------------------------------------------------- |
+| `createForm(model, schema?, options?)`        | Angular's own `form()`, built in the `TestBed`'s injection context        |
+| `createForm(initialValue, schema?, options?)` | the same, with the model signal made for you                              |
+| `registerFormMatchers()`                      | adds `expect(field).toHaveFieldErrors(kinds)` — the whole set, order-free |
+
+Four things to know:
+
+- **What comes back is Angular's `FieldTree`**, not a double: the states, the validators and the
+  write-through to the model are the framework's. A spec that passes its own `signal()` asserts on it
+  directly; a plain value gets a signal made here, and `user().value()` reads it back either way.
+- **A `computed()` is refused by name** — a form writes into its model, and without the check a
+  derived signal would be wrapped as a value while every write vanished.
+- **`options.injector` is for the validator that injects**: pass `fixture.debugElement.injector`
+  when the service a schema reaches for lives in a component's own `providers`.
+- **`toHaveFieldErrors` compares the whole set**, by `kind`, and by `message` only where the spec
+  names one; `[]` is "no errors". A field tree and its state both read, so `expect(user.email)` and
+  `expect(user.email())` are the same assertion.
+
+**No `FieldTree` double is shipped, on purpose.** It would stand in for a form a component takes as
+an input, and across the measured suites no component takes one: forms are built by the component
+that owns them (assert through `component.form.tags()`), and custom controls — `FormValueControl<T>`,
+`FormCheckboxControl` — are plain components whose contract is `value = model<T>()`, which is
+`renderShallow` plus `setInputs`.
+
+### `window` and `document` over the real ones — `provideWindowDouble` / `provideDocumentDouble`
+
+```ts
+import { provideDocumentDouble, provideWindowDouble } from 'vitest-auto-spy/angular';
+
+TestBed.configureTestingModule({
+  providers: [
+    provideWindowDouble(WINDOW, { screen: { width: 1920, height: 1080 }, devicePixelRatio: 2 }),
+    provideDocumentDouble({ visibilityState: 'hidden' }),
+  ],
+});
+```
+
+**Do not write `useValue: window`, and do not build a `mockDocument` from scratch.** These are the
+two most hand-rolled providers in an Angular suite — 95 `window` ones and 70 `document` ones across
+two private suites — and both hand-written shapes fail the same way. `useValue: window` isolates
+nothing: what the test writes stays on the global for the rest of the worker. A double built from
+scratch, whether a slice (`{ screen: { width: 1280, height: 720 } }`) or a `mockDocument` with one
+hand-written `querySelector`, knows only the members its author thought of, so the component that
+reads `screen.colorDepth` or calls `document.createElement` gets `undefined` and the spec fails
+somewhere unrelated to what it was testing.
+
+These two merge the overrides **over the real jsdom object** instead: everything the spec did not
+name — `location.href`, `getComputedStyle`, `addEventListener`, `document.createElement` — still
+answers the way jsdom answers it.
+
+| Call                                                                  | Does                                                              |
+| --------------------------------------------------------------------- | ----------------------------------------------------------------- |
+| `provideWindowDouble(token, overrides?)`                              | a `FactoryProvider` under the application's own window token      |
+| `provideDocumentDouble(overrides?, token?)`                           | the same under Angular's `DOCUMENT`, or under a token of your own |
+| `createWindowDouble(overrides?)` / `createDocumentDouble(overrides?)` | the same doubles without a `TestBed`                              |
+
+Five things to know:
+
+- **The window helper needs your token.** Angular ships `DOCUMENT` (from `@angular/core` itself
+  since v20) and has never shipped a `WINDOW`: every application declares its own
+  `InjectionToken<Window>`. The helper is generic over the token's type, so an
+  `InjectionToken<AppWindow>` has that interface's members checked in the overrides too.
+- **A plain `{ … }` merges, anything else replaces.** `{ screen: { width: 1920 } }` keeps
+  `screen.colorDepth`; a `vi.fn()`, an array, a `URL` or a stub instance becomes the member whole.
+- **Nothing to restore.** The globals are never patched — the double is a view over them, and every
+  write and delete lands on the view, which is also how a spec moves a value mid-test:
+  `Object.assign(TestBed.inject(WINDOW), { scrollY: 40 })` (`Object.assign` because lib.dom declares
+  most of `Window` `readonly`). There is no handle and no `restoreMockedProps()` in this recipe.
+- **`provideDocumentDouble` hands the double to Angular as well** — the renderer injects `DOCUMENT`
+  too, so replace `createElement` or `body` only where the spec means to.
+- **`location` takes overrides like everything else**, though the platform declares its members
+  unforgeable: `{ location: { reload: vi.fn() } }` — the shape most hand-written window mocks are —
+  records the reload, leaves `location.href` real, and `win.location.href = '/next'` moves the
+  double rather than the address bar. `mockValueProp(TestBed.inject(WINDOW), 'innerWidth', 800)` and
+  its restore work on the double too, and neither touches the global.
+
+### The Material dialog trio — `provideMatDialogData` / `provideMatDialogRef`
+
+```ts
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import { expectEmission, injectMatDialogRef, provideMatDialogData, provideMatDialogRef } from 'vitest-auto-spy/angular';
+
+TestBed.configureTestingModule({
+  providers: [provideMatDialogData<EditUserData>(MAT_DIALOG_DATA, { id: 7, name: 'Ada' }), provideMatDialogRef(MatDialogRef)],
+});
+
+const dialog = injectMatDialogRef(MatDialogRef);
+
+TestBed.createComponent(EditUserDialog).componentInstance.save();
+
+expect(dialog.close).toHaveBeenCalledWith('saved');
+await expect(expectEmission(dialog.ref.afterClosed())).resolves.toBe('saved');
+```
+
+**`@angular/material` is not a dependency of this package and must not become one** — it ships no
+runtime dependencies at all. That is exactly why the token and the ref class are **arguments**:
+`MatDialogRef` is the DI token, the shape the double is measured against and the type the result is
+read off, so the spec's own Material import stays the only place it is named.
+
+**Do not hand-roll `{ close: vi.fn() }`.** 36 of these across two private suites are the same three
+shapes, and the ref one fails twice. `close` is the only member anybody writes, so a component that
+subscribes to `afterClosed()` dies on "is not a function"; the repair written next to it,
+`afterClosed: () => of('saved')`, answers before anything closed the dialog — the spec then passes
+whether or not `close()` was ever called.
+
+| Call                                      | Does                                                                                                      |
+| ----------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `provideMatDialogData(token, data)`       | a typed `{ provide, useValue }` — name the type argument and the data is checked against it               |
+| `provideMatDialogRef(RefClass, init?)`    | a `FactoryProvider` — a fresh ref per injector; `init`: `closedWith`, `disableClose`, `componentInstance` |
+| `injectMatDialogRef(RefClass, injector?)` | the handle: `.ref`, `.close` (the spy), `emitClose(result?)`                                              |
+| `createMatDialogRef(RefClass, init?)`     | the same handle without a `TestBed` — and the ref a spied `MatDialog.open()` hands back                   |
+
+`MatDialog` itself needs no helper of its own: `provideAutoSpy(MatDialog)` already spies it, and the
+ref double is the thing its `open()` was missing.
+
+```ts
+TestBed.configureTestingModule({ providers: [provideAutoSpy(MatDialog)] });
+
+injectSpy(MatDialog).open.mockReturnValue(createMatDialogRef(MatDialogRef, { closedWith: 'saved' }).ref);
+```
+
+Five things to know:
+
+- **`close` is the spy, and it is the same function the ref carries.** `expect(dialog.close)` and
+  `expect(TestBed.inject(MatDialogRef).close)` are one assertion. `emitClose(result?)` is the other
+  half — the user closing the dialog from outside, where the streams move and the spy records
+  nothing, and the only way to close with `undefined` (a dismissal), which `closedWith` cannot say.
+- **`afterClosed()` is replayed, where Material's is a plain `Subject`.** The deliberate departure:
+  in a spec the assertion usually subscribes _after_ the component has closed the dialog, and a
+  `Subject` has nothing left to say by then. `beforeClosed()` is the same stream — the double closes
+  instantly, so there is no window between them, and `afterOpened()` has already emitted.
+- **`MAT_DIALOG_DATA` is `InjectionToken<any>` in Material**, so a hand-written `useValue: null`
+  compiles for a component that reads `data.name`. `provideMatDialogData<EditUserData>(…)` checks the
+  object; a token of your own typed `InjectionToken<EditUserData>` checks it without naming anything.
+  The value is handed out as it is, so build it per test rather than hoisting it to a constant.
+- **`componentInstance` is how the opener drives the dialog**, and it is the one member Material
+  keeps off the prototype, so a double that did not have it would read `undefined` rather than
+  fail. Hand the stand-in over and the opener works against it — checked, member by member, against
+  the component the ref class names:
+
+  ```ts
+  const save = new EventEmitter<string>();
+  const dialog = createMatDialogRef<MatDialogRef<NameInputDialog, string>>(MatDialogRef, {
+    componentInstance: { save, isSaving: signal(false) },
+  });
+
+  injectSpy(MatDialog).open.mockReturnValue(dialog.ref);
+  save.emit('Grace');
+
+  expect(dialog.close).toHaveBeenCalledWith('Grace');
+  ```
+
+- **What it does not answer throws by name.** `backdropClick`, `keydownEvents`, `updateSize`,
+  `updatePosition`, `getState`, `componentRef` and `id` are the dialog doing its own work; the
+  double names them in the failure instead of reading `undefined`, and the real `MatDialogModule` is
+  what answers them. A `componentInstance` nobody handed over says so by name too, and names the
+  init field that fixes it.
+
 ### Which collaborators the code asked for — `trackInjections`
 
 Do **not** reach for `vi.mock('@app/services')` to answer "was this collaborator used". Register the
@@ -2226,8 +2616,41 @@ runEffect(component.highlightEffect); // runs the body now, with the current sig
 ```
 
 `flushEffects()` runs everything currently dirty; `runEffect(ref)` runs one specific effect
-regardless. Prefer asserting the result where practical — `runEffect` reads Angular's reactive node,
-and throws with instructions if a future version moves it.
+regardless. It runs the previous run's cleanup first, the way Angular's own scheduler does, so an
+`onCleanup` callback is observable and the node does not collect one closure per call. An effect
+whose view has been torn down — or which was destroyed on its own — is refused rather than run:
+after `fixture.destroy()` there is nothing production could still produce. Prefer asserting the
+result where practical — `runEffect` reads Angular's reactive node, and throws with instructions if
+a future version moves it.
+
+### Counting recomputations and effect runs — `trackRecomputations` / `trackEffectRuns`
+
+"The template read `total()` six times and the computation ran once" and "changing the filter did
+not re-run the sync effect" are not observable from the outside: a `computed()` returns the same
+value whether it was cached or recomputed. The usual workaround is a counter inside the computation,
+which means editing production code to make a test possible.
+
+```ts
+import { trackEffectRuns, trackRecomputations } from 'vitest-auto-spy/angular';
+
+const recomputed = trackRecomputations(component.total);
+const synced = trackEffectRuns(component.syncEffect);
+
+component.unrelatedFilter.set('open');
+await stable(fixture);
+
+expect(component.total()).toBe(42);
+expect(recomputed.count).toBe(0); // memoised: nothing it reads changed
+expect(synced.count).toBe(0);
+
+recomputed.stop(); // and `restoreMockedProps()` — so `setupAutoSpy()` — takes both off anyway
+```
+
+Both return `{ count, stop() }`. `trackRecomputations` counts the **computation**, not the reads,
+and takes a `computed()` or a `linkedSignal()` — a plain `signal()` has nothing to compute and is
+refused by name. `trackEffectRuns` counts every run whoever asked for it: a flush, a `stable()`, a
+`runEffect()` of the same effect. Both wrap one member of Angular's reactive node through
+`mockValueProp`, so the undo is the journal every other stub in this package uses.
 
 ### ngrx `rxMethod`
 
@@ -2246,6 +2669,10 @@ const { fixture, component } = renderShallow(TaskListComponent, {
 });
 // other options: imports, keepTemplate, keepChildren, template, beforeCreate, detectChanges
 
+// change an input after the first render — one setInput per key, then the wait, in one await
+await setInputs(fixture, { projectId: 7 }); // a name the component does not declare is refused here
+await setInputs(fixture, { projectId: 7 }, { label: 'the task list' }); // options go to stable()
+
 // build a class through DI, every unprovided token auto-spied
 const { instance, spies } = createWithAutoSpies(CartService, {
   providers: [{ provide: TaxService, useValue: realTax }], // explicit providers win
@@ -2262,11 +2689,20 @@ flushEffects(); // the no-fixture half: services, stores, runInInjectionContext
 flushEffects(); // an httpResource issues NO request until something ticks
 httpTesting.expectOne('/api/products').flush([product]);
 await settleResource(products, { label: 'the product resource' });
+// a resource left 'idle' FAILS here — params() returned undefined and value() is still the default;
+// { allowIdle: true } when that is the state under assertion, { turns } is spent exactly as reported
+
+// on a component the resource is a FIELD and renderShallow is the injection context — nothing else changes
+const { component } = renderShallow(ProductListComponent, { providers: [...provideHttpTesting()], keepTemplate: true });
+await expectRequest('/api/products?q=').flush([product]); // both from /angular-http; renderShallow already ticked
+expect(component.products).toHaveResourceValue([product]);
+// after changing a signal the params() computation reads: flushEffects() before the next expectOne/expectRequest
 
 // ...or skip the request entirely when it is not what the spec is about
-const products = mockResourceProp(service, 'products', []);
-products.set([product]); // 'resolved'   products.loading()   products.fail('offline')
-expect(products.reload).toHaveBeenCalled(); // reload is spied, and re-issues nothing
+const products = mockResourceProp(service, 'products', []); // { status: 'idle' } starts it unstarted
+products.set([product]); // 'resolved'   products.loading()   products.fail('offline')   products.idle()
+service.products.set([edited]); // the component's own optimistic write — status → 'local'
+expect(products.reload).toHaveBeenCalled(); // reload is spied, answers true, and re-issues nothing
 
 // signal assertions
 registerSignalMatchers(); // once, in the setup file
@@ -2284,20 +2720,30 @@ Two zoneless traps:
 - `fixture.detectChanges()` runs **one** change-detection pass and does **not** flush pending
   effects. Asserting right after it reads state that has not finished computing. Use `await stable(fixture)`.
 - `expect(someSignal).toBeTruthy()` passes for **every** signal ever created — a signal is a
-  function. Use `toHaveSignalValue`, which also rejects the missing-parentheses mistake.
+  function. Use `toHaveSignalValue`, which also rejects the missing-parentheses mistake — and a
+  spy, which it refuses instead of calling.
 
 And one resource trap, which is the same shape one level up: an `httpResource()` reports `loading`
 with its **default** value until a tick _and_ a microtask after its response is flushed, so a spec
 that asserts too early asserts the default and passes. `settleResource` fails instead of passing
 emptily. Note the order — `flushEffects()` first (the request is issued there, not on creation),
-then the flush, then the wait.
+then the flush, then the wait. The same trap wearing a different hat is a resource still `idle` when
+the wait ends: its `params()` computation returned `undefined`, the loader never ran, and `value()`
+is the default. `settleResource` refuses that too, naming the signal the computation reads;
+`{ allowIdle: true }` is the opt-out for a spec whose subject is the idle state. Each round is a tick
+plus a microtask, and from the third round an event-loop turn as well, so a loader on a real timer
+settles rather than burning the budget in microseconds.
 
 `toHaveResourceValue` is the matcher form of that trap and the reason to prefer it over
 `expect(products.value()).toEqual(...)`: it **fails an unresolved resource even when the default
 value matches**, and names the status it was in. And when the request is not what the spec is about
 at all, do not arrange one — `mockResourceProp(service, 'products', [])` replaces the property with
-a double whose `set` / `fail` / `loading` move it directly, built from real `signal()`s so a
-`computed()` downstream still recomputes. Nothing is in flight, so there is nothing to await.
+a double whose `set` / `fail` / `loading` / `idle` move it directly, built from real `signal()`s so a
+`computed()` downstream still recomputes. The double carries the whole of `ResourceRef`: `value` is
+writable and a write through it lands in `'local'`, `set` / `update` / `asReadonly` / `destroy` /
+`snapshot` behave as Angular's own do, and `hasValue()` is value-based rather than status-based —
+`true` while the resource is loading over a value that is defined, which is what Angular has answered
+since v20. Nothing is in flight, so there is nothing to await.
 
 Per-file timing, to find which specs actually pay for `TestBed`:
 
@@ -2368,12 +2814,16 @@ spec — after which `Spy<Mock>` and `Spy<Interface>` disagree and somebody cast
 **The second argument is not optional as often as it looks.** A spy answers `undefined` until it is
 told otherwise, and that is fatal the moment the code under test _chains_ off it — a constructor
 doing `inject(LOGGER).channel('auth').debug('…')` dies on the `.debug` of `undefined` before the
-spec's first line runs, because nothing in production wrote `?.` there. Seed the link:
+spec's first line runs, because nothing in production wrote `?.` there. Name the link:
 
 ```ts
-provideAutoSpyForToken(LOGGER, { channel: vi.fn().mockReturnThis() });
+provideAutoSpyForToken(LOGGER, undefined, { selfReturning: ['channel'] });
 ```
 
+`channel` stays a spy (assertable, and configured under `strict`) and answers the double itself.
+When every file wants it, register it once — `registerAutoSpyDefaults(LOGGER, { selfReturning:
+['channel'] })` from `vitest-auto-spy/angular` (§5) — and the provider is `provideAutoSpyForToken(LOGGER)`.
+
 For a chain more than one link long, `mockDeep<T>()` is the double that answers every level (§2).
 
 ### A host for a directive under test
@@ -2401,6 +2851,33 @@ _is_ declared; `NG0304` calls a missing directive a missing component; a bare at
 nothing at all). `schemas: [NO_ERRORS_SCHEMA]` next to a standalone component is a dead entry —
 schemas apply to a testing module's `declarations` only.
 
+### A stand-in for a child — `createComponentStub`
+
+Do not hand-write `class MockChartComponent` with a copied selector: nothing checks the copy, so a
+renamed input leaves the parent's binding pointing at nothing and the spec green. Build the stub
+from the real class's compiled definition instead:
+
+```ts
+import { createComponentStub } from 'vitest-auto-spy/angular';
+
+const ChartStub = createComponentStub(ChartComponent); // also a directive or a pipe
+
+TestBed.configureTestingModule({ imports: [DashboardComponent] });
+TestBed.overrideComponent(DashboardComponent, { remove: { imports: [ChartComponent] }, add: { imports: [ChartStub] } });
+
+const chart = fixture.debugElement.query(By.directive(ChartStub)).componentInstance;
+expect(chart.series()).toEqual([1, 2, 3]); // a signal input stays a signal input
+chart.pointSelected.emit(2); // outputs are EventEmitters; a model() stays a model
+```
+
+Copied from `ɵcmp` / `ɵdir` / `ɵpipe`: the selector, every input under its public name (transforms
+included), every output, `exportAs`, a pipe's name and purity. Not copied: the template (the stub
+renders one `<ng-content>` per slot the real one projects — `{ template }` in the third argument
+replaces it), host bindings, providers, lifecycle hooks, queries. The second argument seeds members
+per instance — a method the parent calls through `viewChild`, a pipe's `transform` (identity by
+default). With `renderShallow`: `renderShallow(Parent, { keepTemplate: true, keepChildren: [ChartStub] })`
+— the real child is dropped as a component import and the stub is the one child left.
+
 ### Patching a property of a spy
 
 `mockReadonlyProp` / `mockValueProp` / `mockSignalProp` accept the `Spy<T>` that `injectSpy` returns,
@@ -2618,43 +3095,50 @@ export default [
 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`                                                                                                                                                                                                                                                               |
-| `no-object-define-property`       | `error` | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                                                                                                                                            |
-| `prefer-provide-auto-spy`         | `error` | —                 | a hand-rolled `useValue`, `useFactory`, `useClass` or `useExisting` (also `useValue: new StubMock()`), in a provider **or** a `TestBed.overrideProvider(X, { … })` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`. A name in the slot is followed one step, through an initialiser or a single `beforeEach` assignment |
-| `prefer-create-spy-from-class`    | `error` | —                 | an object literal of 2+ `vi.fn()`s → `createSpyFromClass` (a factory's own seed is exempt)                                                                                                                                                                                                                                          |
-| `no-stub-class-double`            | `warn`  | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy` and delete the stub; a decorated, `implements`-ing, `extends`-ing or unnamed class is exempt — option: `{ minRunnerFns }`                                                                                                                             |
-| `no-structural-double`            | `warn`  | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`; a bare `let fn: Mock` is a callback and never reported — option: `{ minRunnerFns }`                                                                                                                                                      |
-| `prefer-inject-spy`               | `error` | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, inline or via a `const` → `injectSpy(X).m`                                                                                                                                                                                                                                                      |
-| `no-shared-module-level-mock`     | `error` | —                 | an **exported** value holding `vi.fn()`s → export a factory instead                                                                                                                                                                                                                                                                 |
-| `no-mocked-for-spy`               | `error` | `--fix` / suggest | `Mocked<T>` in any type position → `Spy<T>`, import and all — a suggestion where the assigned value is not from a factory of this library                                                                                                                                                                                           |
-| `prefer-as-spy`                   | `error` | `--fix`           | `TestBed.inject(X) as Spy<X>` → `asSpy<X>(TestBed.inject(X))`, import and all                                                                                                                                                                                                                                                       |
-| `no-done-callback`                | `error` | —                 | `it('x', (done) => …)` → `async` + an awaited assertion, and `done.fail(…)` at the call site                                                                                                                                                                                                                                        |
-| `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, or one a `TestBed.overrideProvider` in the same hook replaces → the earlier one never runs; the exact duplicate can be deleted                                                                                                                                                            |
-| `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`           | `warn`  | 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                                                                                                                                        |
-| `no-passthrough-console-spy`      | `error` | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and prints → `installConsoleSpies()` + `consoleXSpy`, or `.mockImplementation(() => undefined)` |
-| `no-console-in-spec`              | `error` | —                 | a spec calling `console.x(…)` itself, or `console.x = …`, which nothing restores → absorb the code's output through `vitest-auto-spy/console` |
-| `no-import-time-console-spies`    | `error` | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and silences every later file → `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` |
-| `no-mistyped-use-value`           | `error` | —                 | `{ provide: TOKEN, useValue }` whose value is not assignable to the primitive `T` of `InjectionToken<T>` (string, number, boolean, bigint, enum, their literals, `null`, `undefined`) — `useValue` is `any`, so `{}` for a `boolean` token compiles and is truthy. **Type-aware**: silent without `parserOptions.project`; object-typed tokens are out of scope |
-| `no-instance-lifecycle-spy`       | `warn`  | —                 | `vi.spyOn(instance, 'ngOnInit')` (and `ngOnDestroy`, `ngDoCheck`, `ngAfterContent*`, `ngAfterView*`) — a view calls the hook read off the prototype, so the instance spy is never called and its stub never runs → `vi.spyOn(Cls.prototype, …)` before `createComponent`, or assert the effect. `ngOnChanges` is exempt: Angular calls it through the instance |
-| `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                                                                                                                                                                                                                   |
-
-Thirty rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
-`no-stub-class-double`, `no-structural-double` and `no-instance-lifecycle-spy`**; three fix on their own, nine offer suggestions. Twenty-eight are syntactic; `no-private-member-access` and `no-mistyped-use-value`
-read types, and both report 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
+| Rule                              | Level   | Fix               | Flags                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| --------------------------------- | ------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `no-expect-in-subscribe`          | `error` | suggest           | `expect()` inside `subscribe()` → `expectEmission` / `firstValueFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `no-object-define-property`       | `error` | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `prefer-provide-auto-spy`         | `error` | —                 | a hand-rolled `useValue`, `useFactory`, `useClass` or `useExisting` (also `useValue: new StubMock()`), in a provider **or** a `TestBed.overrideProvider(X, { … })` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`. A name in the slot is followed one step, through an initialiser or a single `beforeEach` assignment                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `prefer-create-spy-from-class`    | `error` | —                 | an object literal of 2+ `vi.fn()`s → `createSpyFromClass` (a factory's own seed is exempt)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `no-stub-class-double`            | `warn`  | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy` and delete the stub; a decorated, `implements`-ing, `extends`-ing or unnamed class is exempt — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `no-structural-double`            | `warn`  | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`; a bare `let fn: Mock` is a callback and never reported — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `prefer-inject-spy`               | `error` | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, inline or via a `const` → `injectSpy(X).m`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `no-shared-module-level-mock`     | `error` | —                 | an **exported** value holding `vi.fn()`s → export a factory instead                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `no-mocked-for-spy`               | `error` | `--fix` / suggest | `Mocked<T>` in any type position → `Spy<T>`, import and all — a suggestion where the assigned value is not from a factory of this library                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `prefer-as-spy`                   | `error` | `--fix`           | `TestBed.inject(X) as Spy<X>` → `asSpy<X>(TestBed.inject(X))`, import and all                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `no-done-callback`                | `error` | —                 | `it('x', (done) => …)` → `async` + an awaited assertion, and `done.fail(…)` at the call site                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `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, or one a `TestBed.overrideProvider` in the same hook replaces → the earlier one never runs; the exact duplicate can be deleted                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `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`           | `warn`  | 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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `prefer-provide-activated-route`  | `error` | —                 | a hand-built `ActivatedRoute` — any `useValue` / `useClass` / `useFactory` / `useExisting`, and `provideAutoSpy(ActivatedRoute)` too → `provideActivatedRoute({ … })`; the double knows either the streams or the snapshot, never both, and `injectActivatedRoute().setParams(…)` moves them together mid-test                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `no-passthrough-console-spy`      | `error` | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and prints → `installConsoleSpies()` + `consoleXSpy`, or `.mockImplementation(() => undefined)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `no-console-in-spec`              | `error` | —                 | a spec calling `console.x(…)` itself, or `console.x = …`, which nothing restores → absorb the code's output through `vitest-auto-spy/console`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `no-import-time-console-spies`    | `error` | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and silences every later file → `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `no-mistyped-use-value`           | `error` | —                 | `{ provide: TOKEN, useValue }` whose value is not assignable to the primitive `T` of `InjectionToken<T>` (string, number, boolean, bigint, enum, their literals, `null`, `undefined`) — `useValue` is `any`, so `{}` for a `boolean` token compiles and is truthy. **Type-aware**: silent without `parserOptions.project`; object-typed tokens are `no-unknown-use-value-key`'s                                                                                                                                                                                                                                                                                                                                                                      |
+| `no-unknown-use-value-key`        | `error` | —                 | a key of an object `useValue` literal the provided type does not have — `T` of `InjectionToken<T>`, or the instance type of a `provide:` class; `{ provide: ActivatedRoute, useValue: { queryParams$: … } }` compiles, since `useValue` is `any`. Keys only, never assignability (a partial fixture is fine). **Type-aware**; silent on `any` / `unknown` / `object`, an index signature, a spread's keys, `multi: true`                                                                                                                                                                                                                                                                                                                             |
+| `no-instance-lifecycle-spy`       | `warn`  | —                 | `vi.spyOn(instance, 'ngOnInit')` (and `ngOnDestroy`, `ngDoCheck`, `ngAfterContent*`, `ngAfterView*`) — a view calls the hook read off the prototype, so the instance spy is never called and its stub never runs → `vi.spyOn(Cls.prototype, …)` before `createComponent`, or assert the effect. `ngOnChanges` is exempt: Angular calls it through the instance                                                                                                                                                                                                                                                                                                                                                                                       |
+| `no-ts-expect-error-on-double`    | `error` | —                 | `@ts-expect-error` / `@ts-ignore` above `nextWith`, `resolveWith`, `mockReturnValue`, `returnValue`, `calledWith(…)` and the other helpers that check a stub against the method's signature → an overloaded method takes `Spy<X, { overload: { m: 'first' } }>`; otherwise the fixture is the wrong shape, checked against `ReturnType<X['m']>`. A reason after the directive does not silence it; a deliberate out-of-type value keeps it under `eslint-disable-next-line … -- <why>`                                                                                                                                                                                                                                                               |
+| `no-constant-expect`              | `error` | —                 | `expect(true).toBe(true)`, `expect({ … }).toBeDefined()` — a value the spec spelled out, under a matcher whose answer it already fixes (`toBe` / `toEqual` / `toStrictEqual` against a literal; `toBeTruthy`, `toBeDefined`, `toBeNull`… for any literal) → assert on what the code produced, or `expect.fail(…)` for an unreachable branch                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `no-compile-components`           | `error` | suggest           | `compileComponents()` under a builder that inlines `templateUrl` / `styleUrls` — a promise already settled → delete it, and the `async` of a hook that awaits nothing else. **Silent until** `['error', { builder: 'inline-resources' }]`: under a JIT setup that loads resources at run time the call is load-bearing. **Keep the call for a component whose template holds a `@defer` block** — that ships async class metadata, which `TestBed` resolves in this very call whatever the builder did, and dropping it fails the test with `has unresolved metadata`; the rule cannot see another file's template, so such a call keeps its own `// eslint-disable-next-line vitest-auto-spy/no-compile-components -- @defer: async class metadata` |
+| `no-sync-testbed-await`           | `error` | suggest           | `await` on a TestBed call that answers the TestBed or a fixture — `configureTestingModule`, `override*`, `resetTestingModule`, `createComponent`, `getLastFixture`, through `TestBed`, `getTestBed()`, a chain of those, or a name holding one → drop the `await`, and the `async` of a hook that then awaits nothing else; the suggestion does both. Reads **no types**, so it reports without `parserOptions.project`, where `@typescript-eslint/await-thenable` cannot. `inject` and `runInInjectionContext` are never reported: each answers whatever the token or the callback holds, which can be a promise                                                                                                                                    |
+| `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+
+Thirty-six rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+`no-stub-class-double`, `no-structural-double` and `no-instance-lifecycle-spy`**; three fix on their own, eleven offer suggestions. Thirty-three are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
+`no-unknown-use-value-key` read types, and all three report nothing at all without `parserOptions.project` / `projectService`
+rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
+builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it. 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. The
 four `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
 about the _kind_ of finding: every other rule names something wrong or dead, while this one names a
@@ -2787,6 +3271,18 @@ written above it inside a `createComponent` helper. Configure the double after t
 (`injectSpy(X)` in the test), or keep the access lazy: `const api = () => injectSpy(Api)`. The check
 is order-free by design, since a helper declared above the hook still runs after it.
 
+`no-ts-expect-error-on-double` reports the suppression, not the reason written after it. On one
+1759-file suite it reports 34 directives in 15 files and **every one carries a reason** — so an
+escape for "a directive with a reason" would have silenced all of them. Four sat on overloaded
+clients, which `overload` repairs (§5); seven blamed "the collapsed generic" for a fixture the real
+instantiation rejects as well; nineteen hid a fixture or a production type that disagrees with the
+declared one. Four were deliberate — a value outside the declared type, to reach a default branch —
+and that is the case a per-line disable is for:
+`// eslint-disable-next-line vitest-auto-spy/no-ts-expect-error-on-double -- <why>` above the
+directive. The report sits on the directive's line so that comment reaches it. `rejectWith`,
+`failWith` and `throwWith` are not read: their parameter is `unknown`, so a directive there
+suppresses something other than the stub.
+
 The legacy `.eslintrc` `plugins: []` form cannot work — it resolves names to `eslint-plugin-*`
 packages, which a subpath export can never be.
 
@@ -2794,108 +3290,126 @@ packages, which a subpath export can never be.
 
 ## 17. Error → fix
 
-| Message contains                                                                                              | Cause                                                                                                                                                                                                                                                                      | Fix                                                                                                                                                                                                                                                                                                       |
-| ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `No mock adapter registered`                                                                                  | no runtime entry was imported, or the wrong one                                                                                                                                                                                                                            | import `vitest-auto-spy` (Vitest) / `…/bun` / `…/node` once before creating spies                                                                                                                                                                                                                         |
-| `Observable spies require rxjs`                                                                               | the rxjs layer was never loaded                                                                                                                                                                                                                                            | `import 'vitest-auto-spy/rxjs';` once, in the setup file                                                                                                                                                                                                                                                  |
-| `Type 'SubjectLike<T>' is not assignable to type 'Subject<T>'`                                                | 4.0.0: `returnSubject()` is rxjs-typed only where `vitest-auto-spy/rxjs` is in the TypeScript program, and it is not in this one                                                                                                                                           | put `import 'vitest-auto-spy/rxjs';` in a file the spec `tsconfig` includes — a `setupFiles` entry outside `include` is the usual cause                                                                                                                                                                   |
-| `Cannot read properties of undefined (reading 'returnValue')` on `spy.m.and.…`                                | the jasmine namespaces are not installed — the spy was built before them, or nothing installed them at all                                                                                                                                                                 | import from `vitest-auto-spy/jasmine`; on Bun / `node:test`, `enableJasmineCompat()` in the setup file (§20)                                                                                                                                                                                              |
-| `spy.withArgs is not a function`                                                                              | the same, seen from the argument-matching side                                                                                                                                                                                                                             | the same — or write `spy.m.calledWith(a).mockReturnValue(v)`, which needs no layer (§20)                                                                                                                                                                                                                  |
-| `jasmine is not defined`                                                                                      | jasmine's global is the runner's, and Vitest declares none                                                                                                                                                                                                                 | `import { jasmine } from 'vitest-auto-spy/jasmine'`, then `codemod --from jasmine` to rewrite the members (§20)                                                                                                                                                                                           |
-| `done.fail is not a function`                                                                                 | Vitest passes a `TestContext`, not jasmine's `done`; the line usually sits in an `error` callback nobody awaits, so the run stays **green**                                                                                                                                | assert on the failure — `await expect(firstValueFrom(src$)).rejects.toMatchObject({ … })`, or `expect.fail(message)`                                                                                                                                                                                      |
-| a `.withContext('…')` message that never appears in the failure output                                        | Vitest's chai layer has an `@internal` `withContext(flags)`; handed a string it walks the character indices, sets nonsense flags and returns `this`                                                                                                                        | `expect(actual, 'message').toBe(expected)` — the second argument of `expect` is the label. Nothing throws, so nothing warns (§20)                                                                                                                                                                         |
-| `names method(s) that are not on the class prototype`                                                         | typo, or an instance-field callable                                                                                                                                                                                                                                        | fix the name, or move it to `instanceMethodsToSpyOn`                                                                                                                                                                                                                                                      |
-| `All declarations of 'Matchers' must have identical type parameters`                                          | a custom matcher declares `interface Matchers<T = any>` (the Vitest 4 shape) while Vitest 5 declares `Matchers<R, T>`                                                                                                                                                      | declare it on `Chai.Assertion` instead — that interface has no type parameters in either major, so one declaration merges on both (§10)                                                                                                                                                                   |
-| `toHaveBeenCalledTimes` reads `0` for a call an earlier test made, after moving to Vitest 5                   | `clearMocks` defaults to `true` on Vitest 5, so `vi.clearAllMocks()` runs before every test                                                                                                                                                                                | count the calls in a plain variable instead of reading the spy, or set `clearMocks: false` (§10)                                                                                                                                                                                                          |
-| `was configured with 'mustBeCalledWith'`                                                                      | the code called the spy with other arguments                                                                                                                                                                                                                               | that is the assertion firing — fix the code, or relax to `calledWith`                                                                                                                                                                                                                                     |
-| `extendWithAutoSpies needs Vitest 4.1 or newer`                                                               | the `test` handed in has only the object-form `extend` (Vitest ≤ 4.0); the builder form the helper is written against arrived in 4.1                                                                                                                                       | upgrade Vitest, or keep `provideAutoSpy` + `injectSpy` in a `beforeEach` until then                                                                                                                                                                                                                       |
-| `advanceTimers() requires fake timers`                                                                        | no fake timers installed                                                                                                                                                                                                                                                   | `setupFakeTimers()` or `vi.useFakeTimers()` first                                                                                                                                                                                                                                                         |
-| `Nothing configured X.method, and strict mode is on`                                                          | a strict double was asked for a method no line configured                                                                                                                                                                                                                  | configure it (`mockReturnValue` / `resolveWith` / `nextWith` / `calledWith`), or `{ strict: false }` on that double (§5)                                                                                                                                                                                  |
-| `[vitest-auto-spy] "…" wrote to the console N time(s) and nothing absorbed it`                                | `setupAutoSpy({ strayConsole })` — the test printed, and nothing that does not call through stood on `console`: no `/console` spy installed for it, no `mockImplementation`. A bare `vi.spyOn(console, m)` calls through, and a `console.warn` from this library counts too| absorb and assert: `installConsoleSpies()` in a `beforeEach`, then `expect(consoleErrorSpy)…`; or fix the code that printed. Importing a spy installs nothing under the guard. `strayConsole: { allow: [...] }` only for environment noise no spec can reach                                              |
-| `… wrote to the console N time(s) outside any test`                                                           | output while the file was imported, in a `beforeAll` / `afterAll`, from a callback after its test ended, or from a test whose `afterEach` never ran — the frame names the line                                                                                             | move the work into a test and absorb it there; a callback firing late is a leak — clear it where it is scheduled                                                                                                                                                                                          |
-| `setupAutoSpy({ strict: true })` has no effect — no double throws, a suite with it on stays green             | before this release the default lived in module scope, and `/setup` and the factory bundles each carried a copy; a 1759-file consumer ran 12 717 tests green with it on                                                                                                    | upgrade — the default, `onUnstubbedCall` and `setSpyEngine()` now live on `globalThis`                                                                                                                                                                                                                    |
-| a seeded getter reads `undefined`: `provideAutoSpy(X, { overrides: { remoteConfig } })` next to `gettersToSpyOn` or a `registerAutoSpyDefaults` row| before this release the seed was assigned into the spied accessor's setter, and the getter kept answering `undefined`                                                                                                                                                      | upgrade — `overrides` now seeds the getter spy; a later `accessorSpies.getters.x.mockReturnValue(…)` still wins                                                                                                                                                                                           |
-| `Cannot read properties of undefined (reading 'name')` on `value.constructor.name`, with `createAutoMock<T>()`| `constructor` answered `undefined` on an auto-mock                                                                                                                                                                                                                         | upgrade — it answers `Object`, as every other double does; or seed it: `createAutoMock<T>({ constructor: … })`                                                                                                                                                                                            |
-| `Cannot redefine property: …` from a library accessor spy                                                     | the target is an ES module namespace a bundler inlined                                                                                                                                                                                                                     | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that                                                                                                                                                                                                           |
-| `Cannot spy on this instance in place: it is not extensible`                                                  | `createSpyFromInstance` was handed a frozen or sealed object                                                                                                                                                                                                               | spy it before it is frozen, or build a separate double with `createSpyFromClass` (§2)                                                                                                                                                                                                                     |
-| `Cannot mock the property 'X': it is not configurable`                                                        | the member was defined with `configurable: false`, so it cannot be redefined                                                                                                                                                                                               | members replaced before it are still restorable — `restoreSpiedInstance(instance)` or `restoreMockedProps()`                                                                                                                                                                                              |
-| `overrideComponentProvider(…): the override did not apply`                                                    | the component injects a different token, or a later `overrideProvider` won                                                                                                                                                                                                 | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures                                                                                                                                                                          |
-| `the test ended with N unflushed HttpTestingController request(s)`                                            | `enableAngularDiagnostics({ pendingRequests })` — nothing answered them                                                                                                                                                                                                    | flush each (`controller.expectOne(url).flush(body)`), or `controller.verify()` where absence is the assertion (§13)                                                                                                                                                                                       |
-| `NgModule(s) with an empty runtime scope: …`                                                                  | `ngModuleScopes` (or `assertNgModuleScopes`) — an AOT test bundle stripped `ɵɵsetNgModuleScope`, so the import contributes nothing                                                                                                                                         | declare what the spec needs in the TestBed module directly; pass only modules expected to bring declarations (§13)                                                                                                                                                                                        |
-| `Cannot read properties of undefined`, stack inside the component's own constructor or a field initializer    | a member the double must **hold** rather than spy on is read while the component is being constructed, and the `mockReadonlyProp` that seeds it is written _below_ `TestBed.createComponent` — so it has not run yet, and never will                                       | seed it **before** construction: `provideAutoSpy(X, { overrides: { paymentParams: … } })`, or `provideAutoSpyForToken(TOKEN, { … })`. No later call can repair this — the throw happens inside `createComponent`, so the helper is not reached and cannot say so; the stack names the component (§9, §13) |
-| `arr.map(asInstance)` infers `unknown[]`                                                                      | `asInstance` is overloaded, and passing it **by reference** resolves against the `DeepMockProxy<T>` overload, from which `T` cannot be inferred                                                                                                                            | `arr.map((spy) => asInstance(spy))` — the arrow gives each call its own inference. For a fixed set, `asInstances(a, b, c)` keeps the tuple types (§6)                                                                                                                                                     |
-| `Cannot read properties of undefined (reading 'provide')`, stack inside `render3/di_setup`                    | a barrel chunk had not run when the component's definition was built, so a provider slot is `undefined`                                                                                                                                                                    | `assertComponentDefIntact(Cmp)` before `createComponent` — it names the list and the index (§13)                                                                                                                                                                                                          |
-| `assertComponentDefIntact(): argument N is undefined, which carries no ɵcmp or ɵdir`                          | the class reference itself never arrived — the `Cannot read properties of undefined (reading 'ɵcmp')` case                                                                                                                                                                 | the same split barrel; import the component from its own module, not the barrel (§13)                                                                                                                                                                                                                     |
-| `TS1117: An object literal cannot have multiple properties with the same name`, in a fixture                  | a hundred-line model literal copied into eight specs and edited independently                                                                                                                                                                                              | one `createFixtureFactory<T>(defaults)`; note the runtime keeps the **second** key, so do not auto-fix by dropping one (§12)                                                                                                                                                                              |
-| `configureTestingModule was given N schema(s) that can never apply`                                           | `enableAngularDiagnostics({ deadSchemas })` — `schemas` next to a standalone component, with `declarations` empty                                                                                                                                                          | drop the `schemas` entry and put the missing directive/pipe in the component's own `imports`, or use `createDirectiveHost` (§13)                                                                                                                                                                          |
-| `injectSpy(X): the injector returned a plain instance, not an auto-spy`                                       | the token is provided for real; a `console.warn` once per token and spec file, a **throw** under `enableAngularDiagnostics({ unspiedProviders })` or `setupAutoSpy({ misconfiguration: 'throw' })`                                                                                                                                            | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants                                                                                                                                                                                    |
-| `trackInjections(...).get(X): that token is not tracked by this log`                                          | `get` only answers for tokens whose providers the log created                                                                                                                                                                                                              | add the token to the `trackInjections([...])` list, or read it from the injector directly (§13)                                                                                                                                                                                                           |
-| `Spread syntax requires ...iterable[Symbol.iterator] to be a function`, at load time                          | a module-scope spread of an imported binding, inside a bundle                                                                                                                                                                                                              | build the array in a function or a getter — `no-import-time-spread` (§16)                                                                                                                                                                                                                                 |
-| `the timers APIs are not mocked` in a nested `describe`'s `beforeAll`                                         | fakes armed in `beforeEach` only; Jest armed them for the whole file                                                                                                                                                                                                       | `setupFakeTimers(cfg, { betweenTests: true })` / `setupAutoSpy({ globalFakeTimers: true })`                                                                                                                                                                                                               |
-| setup-file hooks reaching only the first spec file of a worker                                                | the setup module stayed cached (Angular unit-test builder + coverage)                                                                                                                                                                                                      | run coverage with `--isolate`, or call `setupAutoSpy()` from a per-file module                                                                                                                                                                                                                            |
-| `no DOM could be installed`                                                                                   | `bun-angular` preload with no DOM package                                                                                                                                                                                                                                  | `bun add -d @happy-dom/global-registrator` (or `jsdom`)                                                                                                                                                                                                                                                   |
-| `cannot read "…" referenced by …`                                                                             | a `templateUrl` / `styleUrls` path does not resolve                                                                                                                                                                                                                        | fix the path, relative to the component file                                                                                                                                                                                                                                                              |
-| duplicate-copy report from `setupAutoSpy()`                                                                   | two installs, or one loaded as both ESM and CJS                                                                                                                                                                                                                            | dedupe the dependency; `setupAutoSpy({ duplicateCopies: 'warn' })` to downgrade                                                                                                                                                                                                                           |
-| `Type 'Spy<T>' is not assignable to type 'T'`                                                                 | `Spy<T>` drops private members — by design                                                                                                                                                                                                                                 | declare as `Spy<T>`, or use `asInstance()` / `asSpy()` (§6)                                                                                                                                                                                                                                               |
-| a spy is never called, no warning                                                                             | the method is an instance field, not on the prototype                                                                                                                                                                                                                      | `instanceMethodsToSpyOn`, or `createAutoMock<T>()`                                                                                                                                                                                                                                                        |
-| `Cannot access '__vi_import_N__' before initialization`                                                       | `vi.mock()` on `@angular/core` or a relative path                                                                                                                                                                                                                          | you cannot mock it — the specs are bundled. Assert the result instead                                                                                                                                                                                                                                     |
-| `AggregateError at Object.dispatchError`, for a request nothing asserts on                                    | jsdom really served an `XMLHttpRequest` — `blockNetwork` used to cover only `fetch`                                                                                                                                                                                        | `setupAutoSpy({ blockNetwork: true })`, or `{ xhr: 'empty' }` for tracker pings (§10)                                                                                                                                                                                                                     |
-| `localStorage.setItem is not a function`, or `localStorage` undefined                                         | Node's own Web Storage made Vitest's global filter skip the environment's — Node 25 and up, jsdom and happy-dom alike                                                                                                                                                      | on by default in `setupAutoSpy()`; `restoreWebStorage()` on its own (§10)                                                                                                                                                                                                                                 |
-| `Schedulers cannot synchronously execute watches while scheduling`                                            | a timer from a **previous** file, under `isolate: false`                                                                                                                                                                                                                   | track and cancel pending timers/frames in the setup file (§10)                                                                                                                                                                                                                                            |
-| `signal read during notification phase`                                                                       | same — a stray `requestAnimationFrame` callback                                                                                                                                                                                                                            | same                                                                                                                                                                                                                                                                                                      |
-| an assertion error printed to stderr, every test green and the run exiting 0                                  | zone.js swallowed a rejection nobody handled                                                                                                                                                                                                                               | `setupAutoSpy({ strayRejections: true })` fails the test it surfaced in (§10)                                                                                                                                                                                                                             |
-| an `expect()` inside a `.then()` that never seems to run                                                      | nothing awaits the chain, so the test ended first                                                                                                                                                                                                                          | `await` the promise and assert the settled value — `no-floating-assertion` (§16)                                                                                                                                                                                                                          |
-| `trackStrayRejections() found no zone.js on the host`                                                         | `strayRejections` turned on where zone.js is not loaded                                                                                                                                                                                                                    | `import 'zone.js';` in the setup file, or drop the option                                                                                                                                                                                                                                                 |
-| `… .destroy is not a function`                                                                                | an ngrx `rxMethod` replaced with a bare mock                                                                                                                                                                                                                               | `Object.assign(vi.fn(), { destroy: vi.fn() })`                                                                                                                                                                                                                                                            |
-| `NullInjectorError` for a service you did provide                                                             | it is a component-level provider, not a module one                                                                                                                                                                                                                         | `asSpy(fixture.debugElement.injector.get(X))`, not `injectSpy(X)`                                                                                                                                                                                                                                         |
-| `runEffect(): … not an EffectRef returned by effect()`                                                        | passed the callback, a signal, or an unassigned field                                                                                                                                                                                                                      | pass what `effect()` returned; a field may need its lifecycle hook to run first                                                                                                                                                                                                                           |
-| `X is not a constructor`, stack in production code                                                            | a `vi.fn(() => …)` where the code does `new X()`                                                                                                                                                                                                                           | `mockConstructor` / `stubConstructor` / `createSpyClass` (§12)                                                                                                                                                                                                                                            |
-| `Date is not a constructor`                                                                                   | `vi.spyOn(globalThis, 'Date')` — the fakes own it                                                                                                                                                                                                                          | `mockSystemTime(date)` / `vi.setSystemTime`                                                                                                                                                                                                                                                               |
-| `TS2352: … 'accessorSpies' is missing in type 'X'`                                                            | `TestBed.inject(X) as Spy<X>`                                                                                                                                                                                                                                              | `asSpy(TestBed.inject(X))` — never a double assertion (§6)                                                                                                                                                                                                                                                |
-| `TS2739` / `TS2740` / `TS2345` with `Spy<X>` on the left                                                      | a spy handed to an API typed against the class                                                                                                                                                                                                                             | `asInstance(spy)` (§6)                                                                                                                                                                                                                                                                                    |
-| `is missing the following properties: _private, …`                                                            | declared as Vitest's `Mocked<T>`                                                                                                                                                                                                                                           | declare `Spy<T>` (§6)                                                                                                                                                                                                                                                                                     |
-| `AddPromiseSpyMethods<unknown>` vs `WithMockReturnValue<…>`                                                   | a generic class inferred as `Service<any>`                                                                                                                                                                                                                                 | `asSpy<Service>(…)` / `injectSpy<Service>(…)` (§6)                                                                                                                                                                                                                                                        |
-| `'addEventListener' called on an object that is not a valid instance of EventTarget`                          | Node's `AbortSignal` under jsdom + zone.js                                                                                                                                                                                                                                 | `stubAbortController()` (§12)                                                                                                                                                                                                                                                                             |
-| `vi.requireMock is not a function`                                                                            | a mechanical `jest.` → `vi.` rename                                                                                                                                                                                                                                        | there is no equivalent — provide the double through the TestBed instead                                                                                                                                                                                                                                   |
-| a `vi.mock()` factory that never applies, only sometimes                                                      | under `isolate: false` the module was already in the worker's graph                                                                                                                                                                                                        | do not mock it; inject the dependency, or `vi.hoisted()` + a real seam                                                                                                                                                                                                                                    |
-| a `vi.mock()` of a workspace alias that never applies at all                                                  | a bundler inlined the module before the mock could be installed                                                                                                                                                                                                            | `assertMocked(ns, { specifier })` to prove it, then inject instead of mocking                                                                                                                                                                                                                             |
-| `No "default" export is defined on the mock`, thrown inside a dependency                                      | a factory returning bare named exports; the dep probes `default`                                                                                                                                                                                                           | `vi.mock('x', () => moduleNamespace({ … }))`                                                                                                                                                                                                                                                              |
-| `Not implemented: HTMLMediaElement.play`, or `duration` is `NaN` and cannot be set                            | jsdom implements the media elements as a shell                                                                                                                                                                                                                             | `stubMediaElement({ duration })`, then `media.set(el, …)` to fire the events                                                                                                                                                                                                                              |
-| `Cannot set base providers because it has already been called`                                                | zone and zoneless spec files sharing one worker                                                                                                                                                                                                                            | `setupAngularTestEnv({ zoneless, initZone, initZoneless })` (§13)                                                                                                                                                                                                                                         |
-| a stub that works in the first test of the file and in no other                                               | installed at `describe` level or in `beforeAll`, then restored away                                                                                                                                                                                                        | install it in `beforeEach`, or `installPerTest(() => stub…())`                                                                                                                                                                                                                                            |
-| a third-party library failing every other run, no test named                                                  | a test sealed a global with `Object.defineProperty` (non-configurable)                                                                                                                                                                                                     | `setupAutoSpy({ guardGlobals: 'throw' })` names the file; then `mockValueProp`                                                                                                                                                                                                                            |
-| a block of files reported as failed suites with no stack, and zero failing tests                              | a test left an own enumerable key on `Object.prototype`; `mergeHooks` spreads it and collection dies                                                                                                                                                                       | `setupAutoSpy()` guards it by default; `prototypePollution` tunes the reaction                                                                                                                                                                                                                            |
-| `expected [ { at: 1, …(5) }, …(8) ] to deeply equal [ { …(6) }, … ]`                                          | one field moved in every element — usually a frozen clock or an id                                                                                                                                                                                                         | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                                                                                                                                                                                                   |
-| a hand-tuned number of turns waiting for a `resource()` to load                                               | a resource needs a change-detection **tick**, not event-loop turns; `flushEventLoopUntil` never ticks and the resource never even issues its request                                                                                                                       | `flushEffects()`, flush the request, then `await settleResource(r, { label })`                                                                                                                                                                                                                            |
-| a `resource()` assertion that passes but reads the **default** value                                          | the spec asserted before the resource left `loading`                                                                                                                                                                                                                       | `await settleResource(r, { label })` — it fails loudly instead                                                                                                                                                                                                                                            |
-| a spec dying on the runner's 5 s file timeout right after `await stable(fixture)`                             | the fixture never stabilised — an unflushed request, a real `setInterval`                                                                                                                                                                                                  | `stable` now fails at 2000 ms naming the cause; raise `{ timeout }` only once neither is true                                                                                                                                                                                                             |
-| `flushEventLoopUntil` timing out on the **first** such test only, the rest green                              | a cold dynamic `import()` outran the turn budget; later tests hit the module cache                                                                                                                                                                                         | `await settleDynamicImport(() => import('…'))` — await the module, do not count turns                                                                                                                                                                                                                     |
-| `Expected to be running in 'ProxyZone', but it was not found`                                                 | `zone.js/testing` patches jasmine/mocha/jest, not Vitest                                                                                                                                                                                                                   | `import 'vitest-auto-spy/zone'` after zone.js, with `globals: true` (§14)                                                                                                                                                                                                                                 |
-| `nextWith` demanding `HttpEvent<T>` on a generated API client                                                 | `Parameters`/`ReturnType` read the **last** overload                                                                                                                                                                                                                       | `asSpy<Client, { overload: 'first' }>(…)`, or `Overload<M, 0>`                                                                                                                                                                                                                                            |
-| `NG0303` / `NG0304` / nothing at all, from a directive spec                                                   | the host is `standalone: false`, or the module is in the TestBed                                                                                                                                                                                                           | `createDirectiveHost({ template, scope: [Module] })` (§13)                                                                                                                                                                                                                                                |
-| `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 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`                                                                                                                                                                                                                                              |
-| two runs with the same totals, one of them missing a suite                                                    | a lost `describe` and a fixed flake cancel out in the counters                                                                                                                                                                                                             | `compareTestRuns(before, after)` — compare the set of names, not the numbers                                                                                                                                                                                                                              |
-| a 30 s timeout, in a different file each run                                                                  | module-level `vi.fn()` in a fixture shared by files                                                                                                                                                                                                                        | make the fixture a factory (§10)                                                                                                                                                                                                                                                                          |
-| a component's `afterNextRender` state is empty                                                                | `detectChanges()` does not run the after-render phase                                                                                                                                                                                                                      | `await stable(fixture)` (§11)                                                                                                                                                                                                                                                                             |
-| a green test whose only line about a call is `spy.m.calledWith(1);`                                           | that is a **stub**, not an assertion — chai's `expect(fn).to.have.been.calledWith(x)` is the one that checks                                                                                                                                                               | continue the chain, or `expect(spy.m).toHaveBeenCalledWith(1)` — `no-bare-called-with` (§16)                                                                                                                                                                                                              |
-| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers                                | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                                                                                                                                               | the warning on stderr says how many were taken and where the first three were scheduled; `onStrayTimers` gets every one in `timers` (§10)                                                                                                                                                              |
-| `createNestUnit(X): parameter #n of Y is typed as \`Object\``(or`undefined — usually a circular import`)      | the compiler emitted no runtime class for that parameter — interface, union, primitive, or a circular import                                                                                                                                                               | `@Inject(TOKEN)` plus a `providers` entry, or `@Optional()` to receive `undefined`; `@Inject(forwardRef(() => X))` for the import cycle                                                                                                                                                                   |
-| `createNestUnit(X): Y declares n constructor parameter(s) but carries no design:paramtypes metadata`          | no `emitDecoratorMetadata` (esbuild / Vite), or `reflect-metadata` loaded after the class                                                                                                                                                                                  | tsc or SWC with `decoratorMetadata`, `@Injectable()`, `reflect-metadata` first; or `@Inject(X)` on every parameter                                                                                                                                                                                        |
-| `createNestUnit(X): A -> B -> A is a cycle among the classes built for real`                                  | two exposed / `useClass` classes depend on each other; the helper does not resolve `forwardRef` cycles                                                                                                                                                                     | expose one side less, or provide it                                                                                                                                                                                                                                                                       |
-| `createNestUnit(X).spies.get(Y): the unit never asked for that token`                                         | same guard as `createWithAutoSpies` — the spy would not be the one the unit uses                                                                                                                                                                                           | stub the token the unit actually injects (the message lists the auto-spied ones)                                                                                                                                                                                                                          |
-| `createNestUnit(X).spies.get(Y): Y is in \`expose\`, so the unit got a real instance`                         | an exposed class is real, not a spy                                                                                                                                                                                                                                        | read the spies of its own collaborators, or drop it from `expose`                                                                                                                                                                                                                                         |
-| `expect(component.ngOnInit).toHaveBeenCalled()` fails after `fixture.detectChanges()`, or a hook's `.mockImplementation` never runs | the spy was put on the **instance**; a view calls the hook it read off the class prototype when the component was created | `vi.spyOn(Cls.prototype, 'ngOnInit')` before `TestBed.createComponent`, or assert what the hook does — `no-instance-lifecycle-spy` (§16) |
-| a spec runs down the "browser" (or any flag-on) branch whatever its `useValue` says                           | `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>` — `useValue` is `any`, and an object is truthy | a value of the token's type (`useValue: false`) — `no-mistyped-use-value` (§16), with type information |
-| `no request matched …` (with the requests that were made listed)                                              | the URL, verb or predicate does not describe anything the code under test sent, or nothing subscribed                                                                                                                                                                      | read the list in the message — it is the requests that were actually made; then fix the URL, add `{ method }`, or subscribe (§13)                                                                                                                                                                         |
-| `this TestBed has no HttpTestingController`                                                                   | `expectRequest` / `expectNoRequest` on a module that never got the testing backend                                                                                                                                                                                         | `TestBed.configureTestingModule({ providers: [...provideHttpTesting()] })` from `vitest-auto-spy/angular-http` (§13)                                                                                                                                                                                      |
-| `the test ended with N unanswered request(s)`                                                                 | `provideHttpTesting({ verifyOnTeardown })` found a request the spec never flushed                                                                                                                                                                                          | answer it (`await expectRequest(url).flush(body)`), assert its absence (`expectNoRequest(url)`), or `{ verifyOnTeardown: false }` (§13)                                                                                                                                                                   |
+| Message contains                                                                                                                                    | Cause                                                                                                                                                                                                                                                                       | Fix                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| --------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `No mock adapter registered`                                                                                                                        | no runtime entry was imported, or the wrong one                                                                                                                                                                                                                             | import `vitest-auto-spy` (Vitest) / `…/bun` / `…/node` once before creating spies                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `Observable spies require rxjs`                                                                                                                     | the rxjs layer was never loaded                                                                                                                                                                                                                                             | `import 'vitest-auto-spy/rxjs';` once, in the setup file                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `Type 'SubjectLike<T>' is not assignable to type 'Subject<T>'`                                                                                      | 4.0.0: `returnSubject()` is rxjs-typed only where `vitest-auto-spy/rxjs` is in the TypeScript program, and it is not in this one                                                                                                                                            | put `import 'vitest-auto-spy/rxjs';` in a file the spec `tsconfig` includes — a `setupFiles` entry outside `include` is the usual cause                                                                                                                                                                                                                                                                                                                                                                           |
+| `Cannot read properties of undefined (reading 'returnValue')` on `spy.m.and.…`                                                                      | the jasmine namespaces are not installed — the spy was built before them, or nothing installed them at all                                                                                                                                                                  | import from `vitest-auto-spy/jasmine`; on Bun / `node:test`, `enableJasmineCompat()` in the setup file (§20)                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `spy.withArgs is not a function`                                                                                                                    | the same, seen from the argument-matching side                                                                                                                                                                                                                              | the same — or write `spy.m.calledWith(a).mockReturnValue(v)`, which needs no layer (§20)                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `jasmine is not defined`                                                                                                                            | jasmine's global is the runner's, and Vitest declares none                                                                                                                                                                                                                  | `import { jasmine } from 'vitest-auto-spy/jasmine'`, then `codemod --from jasmine` to rewrite the members (§20)                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `done.fail is not a function`                                                                                                                       | Vitest passes a `TestContext`, not jasmine's `done`; the line usually sits in an `error` callback nobody awaits, so the run stays **green**                                                                                                                                 | assert on the failure — `await expect(firstValueFrom(src$)).rejects.toMatchObject({ … })`, or `expect.fail(message)`                                                                                                                                                                                                                                                                                                                                                                                              |
+| a `.withContext('…')` message that never appears in the failure output                                                                              | Vitest's chai layer has an `@internal` `withContext(flags)`; handed a string it walks the character indices, sets nonsense flags and returns `this`                                                                                                                         | `expect(actual, 'message').toBe(expected)` — the second argument of `expect` is the label. Nothing throws, so nothing warns (§20)                                                                                                                                                                                                                                                                                                                                                                                 |
+| `names method(s) that are not on the class prototype`                                                                                               | typo, or an instance-field callable                                                                                                                                                                                                                                         | fix the name, or move it to `instanceMethodsToSpyOn`                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `All declarations of 'Matchers' must have identical type parameters`                                                                                | a custom matcher declares `interface Matchers<T = any>` (the Vitest 4 shape) while Vitest 5 declares `Matchers<R, T>`                                                                                                                                                       | declare it on `Chai.Assertion` instead — that interface has no type parameters in either major, so one declaration merges on both (§10)                                                                                                                                                                                                                                                                                                                                                                           |
+| `toHaveBeenCalledTimes` reads `0` for a call an earlier test made, after moving to Vitest 5                                                         | `clearMocks` defaults to `true` on Vitest 5, so `vi.clearAllMocks()` runs before every test                                                                                                                                                                                 | count the calls in a plain variable instead of reading the spy, or set `clearMocks: false` (§10)                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `was configured with 'mustBeCalledWith'`                                                                                                            | the code called the spy with other arguments                                                                                                                                                                                                                                | that is the assertion firing — fix the code, or relax to `calledWith`                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `extendWithAutoSpies needs Vitest 4.1 or newer`                                                                                                     | the `test` handed in has only the object-form `extend` (Vitest ≤ 4.0); the builder form the helper is written against arrived in 4.1                                                                                                                                        | upgrade Vitest, or keep `provideAutoSpy` + `injectSpy` in a `beforeEach` until then                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `advanceTimers() requires fake timers`                                                                                                              | no fake timers installed                                                                                                                                                                                                                                                    | `setupFakeTimers()` or `vi.useFakeTimers()` first                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `Nothing configured X.method, and strict mode is on`                                                                                                | a strict double was asked for a method no line configured                                                                                                                                                                                                                   | configure it (`mockReturnValue` / `resolveWith` / `nextWith` / `calledWith`), or `{ strict: false }` on that double (§5)                                                                                                                                                                                                                                                                                                                                                                                          |
+| `X.member was read N times and nothing configured it, and strict mode is on` (or `was subscribed to N times and nothing fed it`), after the test    | `setupAutoSpy({ unconfiguredReads })` — the code under test read a strict double's spied getter and got `undefined`, or subscribed to its observable property and nothing ever emitted                                                                                      | configure it: `accessorSpies.getters.member.mockReturnValue(…)`, `overrides: { member }`, `mockReadonlyProp`; `nextWith` / `returnSubject` / `complete` for a stream; `mockReturnValue(undefined)` when `undefined` is the answer meant; `{ strict: false }` on that double (§5)                                                                                                                                                                                                                                  |
+| `[vitest-auto-spy] "…" wrote to the console N time(s) and nothing absorbed it`                                                                      | `setupAutoSpy({ strayConsole })` — the test printed, and nothing that does not call through stood on `console`: no `/console` spy installed for it, no `mockImplementation`. A bare `vi.spyOn(console, m)` calls through, and a `console.warn` from this library counts too | absorb and assert: `installConsoleSpies()` in a `beforeEach`, then `expect(consoleErrorSpy)…`; or fix the code that printed. Importing a spy installs nothing under the guard. `strayConsole: { allow: [...] }` only for environment noise no spec can reach                                                                                                                                                                                                                                                      |
+| `… wrote to the console N time(s) outside any test`                                                                                                 | output while the file was imported, in a `beforeAll` / `afterAll`, from a callback after its test ended, or from a test whose `afterEach` never ran — the frame names the line                                                                                              | move the work into a test and absorb it there; a callback firing late is a leak — clear it where it is scheduled                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `setupAutoSpy({ strict: true })` has no effect — no double throws, a suite with it on stays green                                                   | before this release the default lived in module scope, and `/setup` and the factory bundles each carried a copy; a 1759-file consumer ran 12 717 tests green with it on                                                                                                     | upgrade — the default, `onUnstubbedCall` and `setSpyEngine()` now live on `globalThis`                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| a seeded getter reads `undefined`: `provideAutoSpy(X, { overrides: { remoteConfig } })` next to `gettersToSpyOn` or a `registerAutoSpyDefaults` row | before this release the seed was assigned into the spied accessor's setter, and the getter kept answering `undefined`                                                                                                                                                       | upgrade — `overrides` now seeds the getter spy; a later `accessorSpies.getters.x.mockReturnValue(…)` still wins                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `Cannot read properties of undefined (reading 'name')` on `value.constructor.name`, with `createAutoMock<T>()`                                      | `constructor` answered `undefined` on an auto-mock                                                                                                                                                                                                                          | upgrade — it answers `Object`, as every other double does; or seed it: `createAutoMock<T>({ constructor: … })`                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `Cannot redefine property: …` from a library accessor spy                                                                                           | the target is an ES module namespace a bundler inlined                                                                                                                                                                                                                      | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `Cannot spy on this instance in place: it is not extensible`                                                                                        | `createSpyFromInstance` was handed a frozen or sealed object                                                                                                                                                                                                                | spy it before it is frozen, or build a separate double with `createSpyFromClass` (§2)                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `Cannot mock the property 'X': it is not configurable`                                                                                              | the member was defined with `configurable: false`, so it cannot be redefined                                                                                                                                                                                                | members replaced before it are still restorable — `restoreSpiedInstance(instance)` or `restoreMockedProps()`                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `overrideComponentProvider(…): the override did not apply`                                                                                          | the component injects a different token, or a later `overrideProvider` won                                                                                                                                                                                                  | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures                                                                                                                                                                                                                                                                                                                                                                                  |
+| `the test ended with N unflushed HttpTestingController request(s)`                                                                                  | `enableAngularDiagnostics({ pendingRequests })` — nothing answered them                                                                                                                                                                                                     | flush each (`controller.expectOne(url).flush(body)`), or `controller.verify()` where absence is the assertion (§13)                                                                                                                                                                                                                                                                                                                                                                                               |
+| `NgModule(s) with an empty runtime scope: …`                                                                                                        | `ngModuleScopes` (or `assertNgModuleScopes`) — an AOT test bundle stripped `ɵɵsetNgModuleScope`, so the import contributes nothing                                                                                                                                          | declare what the spec needs in the TestBed module directly; pass only modules expected to bring declarations (§13)                                                                                                                                                                                                                                                                                                                                                                                                |
+| `Cannot read properties of undefined`, stack inside the component's own constructor or a field initializer                                          | a member the double must **hold** rather than spy on is read while the component is being constructed, and the `mockReadonlyProp` that seeds it is written _below_ `TestBed.createComponent` — so it has not run yet, and never will                                        | seed it **before** construction: `provideAutoSpy(X, { overrides: { paymentParams: … } })`, or `provideAutoSpyForToken(TOKEN, { … })`. No later call can repair this — the throw happens inside `createComponent`, so the helper is not reached and cannot say so; the stack names the component (§9, §13)                                                                                                                                                                                                         |
+| `arr.map(asInstance)` infers `unknown[]`                                                                                                            | `asInstance` is overloaded, and passing it **by reference** resolves against the `DeepMockProxy<T>` overload, from which `T` cannot be inferred                                                                                                                             | `arr.map((spy) => asInstance(spy))` — the arrow gives each call its own inference. For a fixed set, `asInstances(a, b, c)` keeps the tuple types (§6)                                                                                                                                                                                                                                                                                                                                                             |
+| `Cannot read properties of undefined (reading 'provide')`, stack inside `render3/di_setup`                                                          | a barrel chunk had not run when the component's definition was built, so a provider slot is `undefined`                                                                                                                                                                     | `assertComponentDefIntact(Cmp)` before `createComponent` — it names the list and the index (§13)                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `assertComponentDefIntact(): argument N is undefined, which carries no ɵcmp or ɵdir`                                                                | the class reference itself never arrived — the `Cannot read properties of undefined (reading 'ɵcmp')` case                                                                                                                                                                  | the same split barrel; import the component from its own module, not the barrel (§13)                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `TS1117: An object literal cannot have multiple properties with the same name`, in a fixture                                                        | a hundred-line model literal copied into eight specs and edited independently                                                                                                                                                                                               | one `createFixtureFactory<T>(defaults)`; note the runtime keeps the **second** key, so do not auto-fix by dropping one (§12)                                                                                                                                                                                                                                                                                                                                                                                      |
+| `configureTestingModule was given N schema(s) that can never apply`                                                                                 | `enableAngularDiagnostics({ deadSchemas })` — `schemas` next to a standalone component, with `declarations` empty                                                                                                                                                           | drop the `schemas` entry and put the missing directive/pipe in the component's own `imports`, or use `createDirectiveHost` (§13)                                                                                                                                                                                                                                                                                                                                                                                  |
+| `injectSpy(X): the injector returned a plain instance, not an auto-spy`                                                                             | the token is provided for real; a `console.warn` once per token and spec file, a **throw** under `enableAngularDiagnostics({ unspiedProviders })` or `setupAutoSpy({ misconfiguration: 'throw' })`                                                                          | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants                                                                                                                                                                                                                                                                                                                                                                                            |
+| `trackInjections(...).get(X): that token is not tracked by this log`                                                                                | `get` only answers for tokens whose providers the log created                                                                                                                                                                                                               | add the token to the `trackInjections([...])` list, or read it from the injector directly (§13)                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `Spread syntax requires ...iterable[Symbol.iterator] to be a function`, at load time                                                                | a module-scope spread of an imported binding, inside a bundle                                                                                                                                                                                                               | build the array in a function or a getter — `no-import-time-spread` (§16)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `the timers APIs are not mocked` in a nested `describe`'s `beforeAll`                                                                               | fakes armed in `beforeEach` only; Jest armed them for the whole file                                                                                                                                                                                                        | `setupFakeTimers(cfg, { betweenTests: true })` / `setupAutoSpy({ globalFakeTimers: true })`                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| setup-file hooks reaching only the first spec file of a worker                                                                                      | the setup module stayed cached (Angular unit-test builder + coverage)                                                                                                                                                                                                       | run coverage with `--isolate`, or call `setupAutoSpy()` from a per-file module                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `no DOM could be installed`                                                                                                                         | `bun-angular` preload with no DOM package                                                                                                                                                                                                                                   | `bun add -d @happy-dom/global-registrator` (or `jsdom`)                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `cannot read "…" referenced by …`                                                                                                                   | a `templateUrl` / `styleUrls` path does not resolve                                                                                                                                                                                                                         | fix the path, relative to the component file                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| duplicate-copy report from `setupAutoSpy()`                                                                                                         | two installs, or one loaded as both ESM and CJS                                                                                                                                                                                                                             | dedupe the dependency; `setupAutoSpy({ duplicateCopies: 'warn' })` to downgrade. A setup file that initialises the Angular test environment before the library loads splits Angular the same way — two copies, a second `TestBed`, and `No mock adapter registered` or overrides that never apply: `resolve.dedupe: ['@angular/core', '@angular/common', '@angular/platform-browser', '@angular/compiler', 'rxjs']` plus `test.server.deps.inline: ['vitest-auto-spy']` (Vitest 1 and up) leaves one copy of each |
+| `Type 'Spy<T>' is not assignable to type 'T'`                                                                                                       | `Spy<T>` drops private members — by design                                                                                                                                                                                                                                  | declare as `Spy<T>`, or use `asInstance()` / `asSpy()` (§6)                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| a spy is never called, no warning                                                                                                                   | the method is an instance field, not on the prototype                                                                                                                                                                                                                       | `instanceMethodsToSpyOn`, or `createAutoMock<T>()`                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `Cannot access '__vi_import_N__' before initialization`                                                                                             | `vi.mock()` on `@angular/core` or a relative path                                                                                                                                                                                                                           | you cannot mock it — the specs are bundled. Assert the result instead                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `AggregateError at Object.dispatchError`, for a request nothing asserts on                                                                          | jsdom really served an `XMLHttpRequest` — `blockNetwork` used to cover only `fetch`                                                                                                                                                                                         | `setupAutoSpy({ blockNetwork: true })`, or `{ xhr: 'empty' }` for tracker pings (§10)                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `localStorage.setItem is not a function`, or `localStorage` undefined                                                                               | Node's own Web Storage made Vitest's global filter skip the environment's — Node 25 and up, jsdom and happy-dom alike                                                                                                                                                       | on by default in `setupAutoSpy()`; `restoreWebStorage()` on its own (§10)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Schedulers cannot synchronously execute watches while scheduling`                                                                                  | a timer from a **previous** file, under `isolate: false`                                                                                                                                                                                                                    | track and cancel pending timers/frames in the setup file (§10)                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `signal read during notification phase`                                                                                                             | same — a stray `requestAnimationFrame` callback                                                                                                                                                                                                                             | same                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| an assertion error printed to stderr, every test green and the run exiting 0                                                                        | zone.js swallowed a rejection nobody handled                                                                                                                                                                                                                                | `setupAutoSpy({ strayRejections: true })` fails the test it surfaced in (§10)                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| an `expect()` inside a `.then()` that never seems to run                                                                                            | nothing awaits the chain, so the test ended first                                                                                                                                                                                                                           | `await` the promise and assert the settled value — `no-floating-assertion` (§16)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `trackStrayRejections() found no zone.js on the host`                                                                                               | `strayRejections` turned on where zone.js is not loaded                                                                                                                                                                                                                     | `import 'zone.js';` in the setup file, or drop the option                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `… .destroy is not a function`                                                                                                                      | an ngrx `rxMethod` replaced with a bare mock                                                                                                                                                                                                                                | `Object.assign(vi.fn(), { destroy: vi.fn() })`                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `NullInjectorError` for a service you did provide                                                                                                   | it is a component-level provider, not a module one                                                                                                                                                                                                                          | `asSpy(fixture.debugElement.injector.get(X))`, not `injectSpy(X)`                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `runEffect(): … not an EffectRef returned by effect()`                                                                                              | passed the callback, a signal, or an unassigned field                                                                                                                                                                                                                       | pass what `effect()` returned; a field may need its lifecycle hook to run first                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `runEffect(): this effect has been destroyed`                                                                                                       | the fixture was destroyed, or effectRef.destroy() ran                                                                                                                                                                                                                       | move the call above `fixture.destroy()`, or assert what the teardown left behind                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `trackRecomputations(): this signal keeps no computation`                                                                                           | a plain `signal()`, which holds a value rather than computing one                                                                                                                                                                                                           | track the `computed()` that reads it, or `trackEffectRuns()` the effect that does                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `mockSignalProp: '…' is an input() signal`                                                                                                          | an `input()` replaced instead of set                                                                                                                                                                                                                                        | `fixture.componentRef.setInput(name, value)`, or `renderShallow(C, { inputs: { … } })`                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `mockSignalProp: '…' is a read-only signal something has already read`                                                                              | a `computed()` member swapped after the first render                                                                                                                                                                                                                        | patch before the first `detectChanges()` / `stable(fixture)`, or expose the member as a writable `signal()`                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `expected a signal (a zero-argument getter), received a spy`                                                                                        | `toHaveSignalValue` was handed a spied method instead of a signal — usually a typo, or a signal member spied as a method                                                                                                                                                    | assert the spy itself with `toHaveBeenCalled`, or put a real signal on the property with `mockSignalProp`; the matcher refuses it rather than calling it                                                                                                                                                                                                                                                                                                                                                          |
+| `X is not a constructor`, stack in production code                                                                                                  | a `vi.fn(() => …)` where the code does `new X()`                                                                                                                                                                                                                            | `mockConstructor` / `stubConstructor` / `createSpyClass` (§12)                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `Date is not a constructor`                                                                                                                         | `vi.spyOn(globalThis, 'Date')` — the fakes own it                                                                                                                                                                                                                           | `mockSystemTime(date)` / `vi.setSystemTime`                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `TS2352: … 'accessorSpies' is missing in type 'X'`                                                                                                  | `TestBed.inject(X) as Spy<X>`                                                                                                                                                                                                                                               | `asSpy(TestBed.inject(X))` — never a double assertion (§6)                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `TS2739` / `TS2740` / `TS2345` with `Spy<X>` on the left                                                                                            | a spy handed to an API typed against the class                                                                                                                                                                                                                              | `asInstance(spy)` (§6)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `is missing the following properties: _private, …`                                                                                                  | declared as Vitest's `Mocked<T>`                                                                                                                                                                                                                                            | declare `Spy<T>` (§6)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `AddPromiseSpyMethods<unknown>` vs `WithMockReturnValue<…>`                                                                                         | a generic class inferred as `Service<any>`                                                                                                                                                                                                                                  | `asSpy<Service>(…)` / `injectSpy<Service>(…)` (§6)                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `createComponentStub(): X carries no ɵcmp, ɵdir or ɵpipe to copy`                                                                                   | the class is not an Angular declaration, or the import resolved to `undefined` (a barrel split across chunks)                                                                                                                                                               | pass the `@Component` / `@Directive` / `@Pipe` class, imported from its own file (§13)                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `'isKeyEnabled' does not exist in type 'MethodReturns<{ remoteConfig: any; }>'`                                                                     | generic class: `createSpyFromClass(Config, { gettersToSpyOn: ['remoteConfig'], returns: { … } })` reads `T` back from the list, because the generic class argument is checked after the configuration                                                                       | generic class: spell out the type argument — `createSpyFromClass<Config>(Config, …)`; `provideAutoSpy` from `/angular` infers it (§6)                                                                                                                                                                                                                                                                                                                                                                             |
+| `'addEventListener' called on an object that is not a valid instance of EventTarget`                                                                | Node's `AbortSignal` under jsdom + zone.js                                                                                                                                                                                                                                  | `stubAbortController()` (§12)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `vi.requireMock is not a function`                                                                                                                  | a mechanical `jest.` → `vi.` rename                                                                                                                                                                                                                                         | there is no equivalent — provide the double through the TestBed instead                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| a `vi.mock()` factory that never applies, only sometimes                                                                                            | under `isolate: false` the module was already in the worker's graph                                                                                                                                                                                                         | do not mock it; inject the dependency, or `vi.hoisted()` + a real seam                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| a `vi.mock()` of a workspace alias that never applies at all                                                                                        | a bundler inlined the module before the mock could be installed                                                                                                                                                                                                             | `assertMocked(ns, { specifier })` to prove it, then inject instead of mocking                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `No "default" export is defined on the mock`, thrown inside a dependency                                                                            | a factory returning bare named exports; the dep probes `default`                                                                                                                                                                                                            | `vi.mock('x', () => moduleNamespace({ … }))`                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `Not implemented: HTMLMediaElement.play`, or `duration` is `NaN` and cannot be set                                                                  | jsdom implements the media elements as a shell                                                                                                                                                                                                                              | `stubMediaElement({ duration })`, then `media.set(el, …)` to fire the events                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `Cannot set base providers because it has already been called`                                                                                      | zone and zoneless spec files sharing one worker                                                                                                                                                                                                                             | `setupAngularTestEnv({ zoneless, initZone, initZoneless })` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| a stub that works in the first test of the file and in no other                                                                                     | installed at `describe` level or in `beforeAll`, then restored away                                                                                                                                                                                                         | install it in `beforeEach`, or `installPerTest(() => stub…())`                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| a third-party library failing every other run, no test named                                                                                        | a test sealed a global with `Object.defineProperty` (non-configurable)                                                                                                                                                                                                      | `setupAutoSpy({ guardGlobals: 'throw' })` names the file; then `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| a block of files reported as failed suites with no stack, and zero failing tests                                                                    | a test left an own enumerable key on `Object.prototype`; `mergeHooks` spreads it and collection dies                                                                                                                                                                        | `setupAutoSpy()` guards it by default; `prototypePollution` tunes the reaction                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `expected [ { at: 1, …(5) }, …(8) ] to deeply equal [ { …(6) }, … ]`                                                                                | one field moved in every element — usually a frozen clock or an id                                                                                                                                                                                                          | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| a hand-tuned number of turns waiting for a `resource()` to load                                                                                     | a resource needs a change-detection **tick**, not event-loop turns; `flushEventLoopUntil` never ticks and the resource never even issues its request                                                                                                                        | `flushEffects()`, flush the request, then `await settleResource(r, { label })`                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| a `resource()` assertion that passes but reads the **default** value                                                                                | the spec asserted before the resource left `loading`                                                                                                                                                                                                                        | `await settleResource(r, { label })` — it fails loudly instead                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `settleResource: … never started — its status is 'idle'`                                                                                            | the `params()` / `request()` computation returned `undefined`, so the loader never ran and `value()` is still the default                                                                                                                                                   | set the signal that computation reads, `flushEffects()`, then await again — or `{ allowIdle: true }` when idle is the state under assertion                                                                                                                                                                                                                                                                                                                                                                       |
+| a spec dying on the runner's 5 s file timeout right after `await stable(fixture)`                                                                   | the fixture never stabilised — an unflushed request, a real `setInterval`                                                                                                                                                                                                   | `stable` now fails at 2000 ms naming the cause; raise `{ timeout }` only once neither is true                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `flushEventLoopUntil` timing out on the **first** such test only, the rest green                                                                    | a cold dynamic `import()` outran the turn budget; later tests hit the module cache                                                                                                                                                                                          | `await settleDynamicImport(() => import('…'))` — await the module, do not count turns                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `Expected to be running in 'ProxyZone', but it was not found`                                                                                       | `zone.js/testing` patches jasmine/mocha/jest, not Vitest                                                                                                                                                                                                                    | `import 'vitest-auto-spy/zone'` after zone.js, with `globals: true` (§14)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `nextWith` demanding `HttpEvent<T>` on a generated API client                                                                                       | `Parameters`/`ReturnType` read the **last** overload                                                                                                                                                                                                                        | `asSpy<Client, { overload: 'first' }>(…)`, or `Overload<M, 0>` — never `@ts-expect-error`, which `no-ts-expect-error-on-double` reports (§16)                                                                                                                                                                                                                                                                                                                                                                     |
+| `NG0303` / `NG0304` / nothing at all, from a directive spec                                                                                         | the host is `standalone: false`, or the module is in the TestBed                                                                                                                                                                                                            | `createDirectiveHost({ template, scope: [Module] })` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `setInputs: … declares no input named …`                                                                                                            | the key is not an input of that component — a typo, an input renamed since, or one of its own fields                                                                                                                                                                        | set the names the message lists; a signal the component owns is moved through the signal (§13)                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `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 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`                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| two runs with the same totals, one of them missing a suite                                                                                          | a lost `describe` and a fixed flake cancel out in the counters                                                                                                                                                                                                              | `compareTestRuns(before, after)` — compare the set of names, not the numbers                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| a 30 s timeout, in a different file each run                                                                                                        | module-level `vi.fn()` in a fixture shared by files                                                                                                                                                                                                                         | make the fixture a factory (§10)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| a component's `afterNextRender` state is empty                                                                                                      | `detectChanges()` does not run the after-render phase                                                                                                                                                                                                                       | `await stable(fixture)` (§11)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| a green test whose only line about a call is `spy.m.calledWith(1);`                                                                                 | that is a **stub**, not an assertion — chai's `expect(fn).to.have.been.calledWith(x)` is the one that checks                                                                                                                                                                | continue the chain, or `expect(spy.m).toHaveBeenCalledWith(1)` — `no-bare-called-with` (§16)                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers                                                                      | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                                                                                                                                                | the warning on stderr says how many were taken and where the first three were scheduled; `onStrayTimers` gets every one in `timers` (§10)                                                                                                                                                                                                                                                                                                                                                                         |
+| `createNestUnit(X): parameter #n of Y is typed as \`Object\``(or`undefined — usually a circular import`)                                            | the compiler emitted no runtime class for that parameter — interface, union, primitive, or a circular import                                                                                                                                                                | `@Inject(TOKEN)` plus a `providers` entry, or `@Optional()` to receive `undefined`; `@Inject(forwardRef(() => X))` for the import cycle                                                                                                                                                                                                                                                                                                                                                                           |
+| `createNestUnit(X): Y declares n constructor parameter(s) but carries no design:paramtypes metadata`                                                | no `emitDecoratorMetadata` (esbuild / Vite), or `reflect-metadata` loaded after the class                                                                                                                                                                                   | tsc or SWC with `decoratorMetadata`, `@Injectable()`, `reflect-metadata` first; or `@Inject(X)` on every parameter                                                                                                                                                                                                                                                                                                                                                                                                |
+| `createNestUnit(X): A -> B -> A is a cycle among the classes built for real`                                                                        | two exposed / `useClass` classes depend on each other; the helper does not resolve `forwardRef` cycles                                                                                                                                                                      | expose one side less, or provide it                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `createNestUnit(X).spies.get(Y): the unit never asked for that token`                                                                               | same guard as `createWithAutoSpies` — the spy would not be the one the unit uses                                                                                                                                                                                            | stub the token the unit actually injects (the message lists the auto-spied ones)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `createNestUnit(X).spies.get(Y): Y is in \`expose\`, so the unit got a real instance`                                                               | an exposed class is real, not a spy                                                                                                                                                                                                                                         | read the spies of its own collaborators, or drop it from `expose`                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `expect(component.ngOnInit).toHaveBeenCalled()` fails after `fixture.detectChanges()`, or a hook's `.mockImplementation` never runs                 | the spy was put on the **instance**; a view calls the hook it read off the class prototype when the component was created                                                                                                                                                   | `vi.spyOn(Cls.prototype, 'ngOnInit')` before `TestBed.createComponent`, or assert what the hook does — `no-instance-lifecycle-spy` (§16)                                                                                                                                                                                                                                                                                                                                                                          |
+| `TS2345: Argument of type 'InjectionToken<X>' is not assignable to parameter of type 'ClassType<unknown>'`, on `registerAutoSpyDefaults`            | the core entry's `registerAutoSpyDefaults` takes a class only — it may not name Angular's token type                                                                                                                                                                        | import `registerAutoSpyDefaults` (and `clearAutoSpyDefaults`) from `vitest-auto-spy/angular`, which also takes an `InjectionToken` (§5)                                                                                                                                                                                                                                                                                                                                                                           |
+| `selfReturning names 'x', which is not a spied method`                                                                                              | the name is not a method of the double — a typo, or a restricting `onlyMethodsToSpyOn` left it out; on a type-driven double, `then` and `constructor` are never spies                                                                                                       | fix the name or the whitelist; the value is silently never returned otherwise (§5)                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| a spec green over a `useValue` fixture whose key the code never reads — `queryParams$` on an `ActivatedRoute`                                       | `useValue` is `any`, so a renamed or misspelled key of an object literal compiles                                                                                                                                                                                           | the member's real name — `no-unknown-use-value-key` (§16), with type information; or `provideAutoSpy(X, { overrides })`, which the compiler checks                                                                                                                                                                                                                                                                                                                                                                |
+| a spec runs down the "browser" (or any flag-on) branch whatever its `useValue` says                                                                 | `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>` — `useValue` is `any`, and an object is truthy                                                                                                                                                     | a value of the token's type (`useValue: false`) — `no-mistyped-use-value` (§16), with type information                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `no request matched …` (with the requests that were made listed)                                                                                    | the URL, verb or predicate does not describe anything the code under test sent, or nothing subscribed                                                                                                                                                                       | read the list in the message — it is the requests that were actually made; then fix the URL, add `{ method }`, or subscribe (§13)                                                                                                                                                                                                                                                                                                                                                                                 |
+| `this TestBed has no HttpTestingController`                                                                                                         | `expectRequest` / `expectNoRequest` on a module that never got the testing backend                                                                                                                                                                                          | `TestBed.configureTestingModule({ providers: [...provideHttpTesting()] })` from `vitest-auto-spy/angular-http` (§13)                                                                                                                                                                                                                                                                                                                                                                                              |
+| `the test ended with N unanswered request(s)`                                                                                                       | `provideHttpTesting({ verifyOnTeardown })` found a request the spec never flushed                                                                                                                                                                                           | answer it (`await expectRequest(url).flush(body)`), assert its absence (`expectNoRequest(url)`), or `{ verifyOnTeardown: false }` (§13)                                                                                                                                                                                                                                                                                                                                                                           |
+| `injectActivatedRoute(): nothing provides ActivatedRoute here`                                                                                      | no `ActivatedRoute` provider in the injector it read                                                                                                                                                                                                                        | `provideActivatedRoute({ … })` from `vitest-auto-spy/angular-router` in `providers`; `injectActivatedRoute(fixture.debugElement.injector)` for a component-level one (§13)                                                                                                                                                                                                                                                                                                                                        |
+| `the ActivatedRoute here is … not one provideActivatedRoute() built`                                                                                | a later provider of `ActivatedRoute` won — `provideRouter()`, `RouterModule`, a `useValue`, `provideAutoSpy(ActivatedRoute)`                                                                                                                                                | list `provideActivatedRoute()` last, or drop the other provider (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `provideActivatedRoute: the installed @angular/router does not wire ActivatedRoute …`                                                               | a router major builds `ActivatedRoute` with different internal constructors                                                                                                                                                                                                 | report it with the `@angular/router` version; provide the route by hand until then (§13)                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `provideRouterDouble: the Router double has no …`                                                                                                   | the code under test reached for a `Router` member the double does not cover — `getCurrentNavigation`, `isActive`, `resetConfig`                                                                                                                                             | the double covers `url`, `events`, `navigate`, `navigateByUrl`, `createUrlTree`, `serializeUrl`, `parseUrl` and `routerState`; past that, a real `provideRouter([])` with `RouterTestingHarness` (§13)                                                                                                                                                                                                                                                                                                            |
+| `injectRouterDouble(): the Router here is Angular's own …`                                                                                          | `Router` is `providedIn: 'root'`, so a `TestBed` without the double hands out a real one                                                                                                                                                                                    | add `provideRouterDouble({ … })` from `vitest-auto-spy/angular-router` to `providers` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
 **Seven of these are library defects, not spec ones.** On anything below 3.8.0, upgrade and change
 nothing in the spec: `of(double)` never emitting; `accessorSpies.setters.X` still `undefined` after
@@ -2920,58 +3434,62 @@ diagnostic and is free to change: print it, never assert on it.
 
 ## 18. Do not write this
 
-| ❌                                                                          | ✅                                                                      |
-| --------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| `import … from 'jest-auto-spies'`                                           | `import … from 'vitest-auto-spy'`                                       |
-| `vitest-auto-spy` inside a `bun test` file                                  | `vitest-auto-spy/bun`                                                   |
-| `let s: MyService = createSpyFromClass(MyService)`                          | `let s: Spy<MyService> = …`                                             |
-| `createSpyFromClass(X) as unknown as X`                                     | `asInstance(createSpyFromClass(X))`                                     |
-| `{ provide: X, useValue: { a: vi.fn(), b: vi.fn() } }`                      | `provideAutoSpy(X)`                                                     |
-| `vi.spyOn(TestBed.inject(X), 'method')`                                     | `injectSpy(X).method`                                                   |
-| `vi.spyOn(component, 'ngOnInit')` after `createComponent`                   | `vi.spyOn(Cls.prototype, 'ngOnInit')` before it, or assert the effect   |
-| `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>`   | `useValue: false` — a value of the type the token declares             |
-| `Object.defineProperty(service, 'ready', { value: true })`                  | `mockReadonlyProp(service, 'ready', true)`                              |
-| `source$.subscribe(v => expect(v).toBe(1))`                                 | `await expect(expectEmission(source$)).resolves.toBe(1)`                |
-| `await lastValueFrom(done$, { defaultValue: undefined })`                   | `await expectCompletion(done$)`                                         |
-| `{ timeout: 0 }` on every helper because timers are faked                   | `setEmissionTimeout(100)` once, in the setup file                       |
-| `{ provide: AbstractToken, useValue: createAutoMock<T>() }`                 | `provideAutoSpy(AbstractToken)`                                         |
-| `mockDeep<T>()` for a chain that goes through a **call**                    | `mockDeep<T>({}, { selfReturning: true })`                              |
-| `await expect(expectEmission(x$)).rejects.toBe(originalError)`              | `await expect(expectError(x$)).resolves.toBe(originalError)`            |
-| `source$.pipe(skip(1))` / `pipe(filter(p))` in front of the helper          | `expectEmission(source$, { skip: 1 })` / `{ until: p }`                 |
-| hold the promise, `vi.runAllTimers()`, then await                           | `expectEmission(source$, { advance: () => vi.runAllTimers() })`         |
-| `injectSpy(X)` then a `mockReturnValue` per method in `beforeEach`          | `provideAutoSpy(X, { returns: { … }, overrides: { … } })`               |
-| a local `injectSpy` wrapper with `as never` + `as Spy<T>`                   | the library's — it also takes an `InjectionToken`                       |
-| a hand-written double for a token with `Observable` members                 | `provideAutoSpyForToken(T, undefined, { observablePropsToSpyOn: […] })` |
-| `mockDeep<T>() as unknown as T` to satisfy an API typed against `T`         | `asInstance(mockDeep<T>())`                                             |
-| `from([double])` to stop `of(double)` swallowing the double                 | `of(double)` — `schedule` is no longer answered (§2)                    |
-| `spy.instanceField.mockReturnValue(…)` on a member Angular moved            | `provideAutoSpy(X, { instanceMethodsToSpyOn: ['…'] })` (§5)             |
-| `expect(component.total).toBeTruthy()` (a signal)                           | `expect(component.total).toHaveSignalValue(3)`                          |
-| `fixture.detectChanges()` then assert signal state                          | `await stable(fixture)` then assert                                     |
-| `onlyMethodsToSpyOn: [...]` "to add a method"                               | omit it, or use `instanceMethodsToSpyOn`                                |
-| a `vi.fn()` the code calls with `new`                                       | `createSpyClass(Foo)` / `mockConstructor(factory)`                      |
-| an exported `const` fixture holding `vi.fn()`s                              | an exported **factory** that returns it (§10)                           |
-| `let s: Mocked<MyService>` (Vitest's own type)                              | `let s: Spy<MyService>`                                                 |
-| `it('x', (done) => …)` / `beforeEach((done) => …)`                          | `async` + `await` — Vitest passes a `TestContext`, not `done`           |
-| `{ ...modelInstance, flag: true }` (drops every getter)                     | `withOverrides(modelInstance, { flag: true })`                          |
-| `if ('params' in link) … else throw` in every spec                          | `narrow.byKey(link, 'params')`                                          |
-| five `asInstance(...)` in one call                                          | `...asInstances(a, b, c, d, e)`                                         |
-| `vi.stubGlobal('Image', vi.fn(() => ({ src: '' })))`                        | `stubConstructor(globalThis, 'Image', () => ({ src: '' }))`             |
-| `Object.defineProperty(document, 'cookie', { value })`                      | `mockValueProp(document, 'cookie', value)`                              |
-| `vi.spyOn(globalThis, 'Date')`                                              | `mockSystemTime('2025-04-30T00:00:00Z')`                                |
-| ten `await Promise.resolve()` for a dynamic `import()`                      | `await settleDynamicImport(() => import('…'))`                          |
-| `await fixture.whenRenderingDone()`                                         | `await stable(fixture)`                                                 |
-| an exported `const` provider with `vi.fn()` inside                          | an exported **factory** returning it (§10)                              |
-| `.overrideProvider(X, provideAutoSpy(X))` (works, but says the wrong thing) | `.overrideProvider(X, overrideAutoSpy(X))`                              |
-| `TestBed.overrideComponent` to swap a provider                              | `overrideComponentProvider(Cmp, X)`                                     |
-| `{ target, isIntersecting } as unknown as IntersectionObserverEntry`        | `intersectionEntry(target, true)`                                       |
-| an assertion containing a date, with no clock set                           | `mockSystemTime(iso)` first                                             |
-| `configureTestingModule` inside every `it()`                                | one per `describe`                                                      |
-| `vi.mock('@angular/core')` to neutralise `effect()`                         | set the signals, `await stable(fixture)`, assert the result             |
-| a second `vi.spyOn(console, 'error')`                                       | `consoleErrorSpy` from `vitest-auto-spy/console`, installed with `installConsoleSpies()` |
-| `import { consoleErrorSpy } from 'vitest-auto-spy/console'` as the install | `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` — the import installs once per worker |
-| a bare `vi.spyOn(console, 'error')` to keep a spec quiet                    | `.mockImplementation(() => undefined)` — without it the line still prints |
-| `mockReadonlyProp(c, 'items', vi.fn(() => []))`                             | `mockReadonlyProp(c, 'items', signal([]))` — a real signal              |
-| `spy.m.mockReturnValue(subject$)` for a `vi.fn(() => subject$)`             | `spy.m.mockImplementation(() => subject$)` — the variable is re-read    |
+| ❌                                                                              | ✅                                                                                                               |
+| ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `import … from 'jest-auto-spies'`                                               | `import … from 'vitest-auto-spy'`                                                                                |
+| `vitest-auto-spy` inside a `bun test` file                                      | `vitest-auto-spy/bun`                                                                                            |
+| `let s: MyService = createSpyFromClass(MyService)`                              | `let s: Spy<MyService> = …`                                                                                      |
+| `createSpyFromClass(X) as unknown as X`                                         | `asInstance(createSpyFromClass(X))`                                                                              |
+| `{ provide: X, useValue: { a: vi.fn(), b: vi.fn() } }`                          | `provideAutoSpy(X)`                                                                                              |
+| `{ provide: ActivatedRoute, useValue: { snapshot: { params } } }`               | `provideActivatedRoute({ params })` — streams and snapshot from one record                                       |
+| `createAutoMock<Router>({ events: of(), url: '/' }, { returns: { navigate } })` | `provideRouterDouble({ url })` — one URL behind `url`, `routerState` and `events`                                |
+| `vi.spyOn(TestBed.inject(X), 'method')`                                         | `injectSpy(X).method`                                                                                            |
+| `vi.spyOn(component, 'ngOnInit')` after `createComponent`                       | `vi.spyOn(Cls.prototype, 'ngOnInit')` before it, or assert the effect                                            |
+| `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>`        | `useValue: false` — a value of the type the token declares                                                       |
+| `Object.defineProperty(service, 'ready', { value: true })`                      | `mockReadonlyProp(service, 'ready', true)`                                                                       |
+| `source$.subscribe(v => expect(v).toBe(1))`                                     | `await expect(expectEmission(source$)).resolves.toBe(1)`                                                         |
+| `await lastValueFrom(done$, { defaultValue: undefined })`                       | `await expectCompletion(done$)`                                                                                  |
+| `{ timeout: 0 }` on every helper because timers are faked                       | `setEmissionTimeout(100)` once, in the setup file                                                                |
+| `{ provide: AbstractToken, useValue: createAutoMock<T>() }`                     | `provideAutoSpy(AbstractToken)`                                                                                  |
+| `mockDeep<T>()` for a chain that goes through a **call**                        | `mockDeep<T>({}, { selfReturning: true })`                                                                       |
+| `await expect(expectEmission(x$)).rejects.toBe(originalError)`                  | `await expect(expectError(x$)).resolves.toBe(originalError)`                                                     |
+| `source$.pipe(skip(1))` / `pipe(filter(p))` in front of the helper              | `expectEmission(source$, { skip: 1 })` / `{ until: p }`                                                          |
+| hold the promise, `vi.runAllTimers()`, then await                               | `expectEmission(source$, { advance: () => vi.runAllTimers() })`                                                  |
+| `injectSpy(X)` then a `mockReturnValue` per method in `beforeEach`              | `provideAutoSpy(X, { returns: { … }, overrides: { … } })`                                                        |
+| a local `injectSpy` wrapper with `as never` + `as Spy<T>`                       | the library's — it also takes an `InjectionToken`                                                                |
+| a hand-written double for a token with `Observable` members                     | `provideAutoSpyForToken(T, undefined, { observablePropsToSpyOn: […] })`                                          |
+| `mockDeep<T>() as unknown as T` to satisfy an API typed against `T`             | `asInstance(mockDeep<T>())`                                                                                      |
+| `from([double])` to stop `of(double)` swallowing the double                     | `of(double)` — `schedule` is no longer answered (§2)                                                             |
+| `spy.instanceField.mockReturnValue(…)` on a member Angular moved                | `provideAutoSpy(X, { instanceMethodsToSpyOn: ['…'] })` (§5)                                                      |
+| `expect(component.total).toBeTruthy()` (a signal)                               | `expect(component.total).toHaveSignalValue(3)`                                                                   |
+| `fixture.detectChanges()` then assert signal state                              | `await stable(fixture)` then assert                                                                              |
+| `onlyMethodsToSpyOn: [...]` "to add a method"                                   | omit it, or use `instanceMethodsToSpyOn`                                                                         |
+| a `vi.fn()` the code calls with `new`                                           | `createSpyClass(Foo)` / `mockConstructor(factory)`                                                               |
+| an exported `const` fixture holding `vi.fn()`s                                  | an exported **factory** that returns it (§10)                                                                    |
+| `let s: Mocked<MyService>` (Vitest's own type)                                  | `let s: Spy<MyService>`                                                                                          |
+| `it('x', (done) => …)` / `beforeEach((done) => …)`                              | `async` + `await` — Vitest passes a `TestContext`, not `done`                                                    |
+| `{ ...modelInstance, flag: true }` (drops every getter)                         | `withOverrides(modelInstance, { flag: true })`                                                                   |
+| `if ('params' in link) … else throw` in every spec                              | `narrow.byKey(link, 'params')`                                                                                   |
+| five `asInstance(...)` in one call                                              | `...asInstances(a, b, c, d, e)`                                                                                  |
+| `vi.stubGlobal('Image', vi.fn(() => ({ src: '' })))`                            | `stubConstructor(globalThis, 'Image', () => ({ src: '' }))`                                                      |
+| `Object.defineProperty(document, 'cookie', { value })`                          | `mockValueProp(document, 'cookie', value)`                                                                       |
+| `vi.spyOn(globalThis, 'Date')`                                                  | `mockSystemTime('2025-04-30T00:00:00Z')`                                                                         |
+| ten `await Promise.resolve()` for a dynamic `import()`                          | `await settleDynamicImport(() => import('…'))`                                                                   |
+| `await fixture.whenRenderingDone()`                                             | `await stable(fixture)`                                                                                          |
+| an exported `const` provider with `vi.fn()` inside                              | an exported **factory** returning it (§10)                                                                       |
+| `.overrideProvider(X, provideAutoSpy(X))` (works, but says the wrong thing)     | `.overrideProvider(X, overrideAutoSpy(X))`                                                                       |
+| `TestBed.overrideComponent` to swap a provider                                  | `overrideComponentProvider(Cmp, X)`                                                                              |
+| `{ target, isIntersecting } as unknown as IntersectionObserverEntry`            | `intersectionEntry(target, true)`                                                                                |
+| `@Component({ selector: 'app-chart' }) class MockChartComponent { @Input() … }` | `createComponentStub(ChartComponent)` — the selector cannot drift                                                |
+| a `TestingStorage` class assigned to `globalThis.localStorage`                  | `stubWebStorage('localStorage')`, restored with the other patches                                                |
+| an assertion containing a date, with no clock set                               | `mockSystemTime(iso)` first                                                                                      |
+| `configureTestingModule` inside every `it()`                                    | one per `describe`                                                                                               |
+| `vi.mock('@angular/core')` to neutralise `effect()`                             | set the signals, `await stable(fixture)`, assert the result                                                      |
+| a second `vi.spyOn(console, 'error')`                                           | `consoleErrorSpy` from `vitest-auto-spy/console`, installed with `installConsoleSpies()`                         |
+| `import { consoleErrorSpy } from 'vitest-auto-spy/console'` as the install      | `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` — the import installs once per worker |
+| a bare `vi.spyOn(console, 'error')` to keep a spec quiet                        | `.mockImplementation(() => undefined)` — without it the line still prints                                        |
+| `mockReadonlyProp(c, 'items', vi.fn(() => []))`                                 | `mockReadonlyProp(c, 'items', signal([]))` — a real signal                                                       |
+| `spy.m.mockReturnValue(subject$)` for a `vi.fn(() => subject$)`                 | `spy.m.mockImplementation(() => subject$)` — the variable is re-read                                             |
 
 **The one mechanical rename in a migration that is not equivalent.** `vi.fn(() => x)` reads `x`
 when the double is _called_; `mockReturnValue(x)` freezes the value `x` had when the double was
@@ -3032,7 +3550,7 @@ Full reference: <https://asdalexey.github.io/vitest-auto-spy/utilities/cli>.
 ### If you were asked why a suite is slow
 
 ```bash
-npx vitest-auto-spy perf              # runs the suite once and reports; always exits 0
+npx vitest-auto-spy perf              # runs the suite once and reports; exits 0 without --gate
 npx vitest-auto-spy perf src/some/dir # a path is passed through to Vitest as a file filter
 ```
 
@@ -3066,6 +3584,37 @@ is the default, resident memory measured at 1.42 GB plus ~155 MB per worker, and
 about 2.8 % of wall clock. Do not quote a worker count as universally right — it is a property of
 the machine.
 
+**A bare `vitest run` is not every repository's suite, and `perf` refuses to pretend otherwise.**
+Where the suite is assembled by something else — an Angular builder, an Nx target, a script that
+generates a config per project — there is no root `vite(st).config.*`, the Vitest defaults sweep up
+every `*.spec.*` in the tree with no globals and no aliases, and every file fails to collect. The
+phase table that comes out of that is real seconds spent on nothing: measured on one such workspace,
+1 830 files, 29 s of wall clock and **zero** test bodies executed. `perf` checks for that shape
+before it runs anything, and refuses any report in which no body finished (exit 2). Measure the
+repository's own command instead:
+
+```bash
+npx vitest-auto-spy perf --command 'npm test'                          # measure that command
+npx vitest-auto-spy perf --command 'npm test -- {paths:--include=}' --gate
+```
+
+`--command` puts `VITEST_AUTO_SPY_PERF_OUT` and `VITEST_AUTO_SPY_PERF_REPORTER` in that command's
+environment; the configuration it reaches attaches the reporter itself (`reporters: perf ===
+undefined ? ['default'] : ['default', perf]`), and the reporter writes nothing at all when the first
+variable is unset, so it can be declared permanently. `{paths}` / `{paths:<prefix>}` is where the
+files of a confirmation pass go.
+
+**`--gate` is the only part of this command that fails anything**, and three rules keep it honest.
+It judges the `tests` phase alone, because the other five are the harness and the machine rather than
+anybody's code. A file is over budget only when it is over both an absolute floor and `--factor` ×
+the median file **of the same run**, which is what makes the verdict the same on a loaded CI runner
+and on an idle laptop. And every candidate is re-measured on its own before it may fail anything: a
+file that is fast when it has the machine to itself is reported as _not reproduced_, an `info` rather
+than a finding. Without a way to re-measure, findings are warnings that fail nothing unless
+`--no-confirm` says one reading is enough. Exit `1` is "over budget", exit `2` is "there was nothing
+to judge" — including a red suite, which the gate will not judge at all, since a failed test is
+measured until its timeout and 30 s of timeout looks exactly like 30 s of slow code.
+
 `--json <path>` re-analyses a report an earlier `--out <path>` run wrote, instead of running Vitest
 again. Full reference: <https://asdalexey.github.io/vitest-auto-spy/utilities/cli>.