vitest-auto-spy 5.31.0 → 5.32.1

package/AGENTS.md

@@ -16,7 +16,9 @@ Setting this up for a team? `npx vitest-auto-spy init` writes a pointer to this
 instruction files this repository's agents actually read — `AGENTS.md` (Codex, Cursor, Copilot and
 most of the field), `CLAUDE.md` (Claude Code) and `GEMINI.md` (Gemini CLI), plus the glob-scoped
 rule file of any tool whose own directory already exists. `--check` is the CI form; `--only
-CLAUDE.md,.claude` limits it to the files a repository keeps untracked. Full table:
+CLAUDE.md,.claude` limits it to the files a repository keeps untracked. A hand-made copy of the
+package's skill in `.claude/skills/vitest-auto-spy/` is reported `stale` (and fails `--check`): delete
+it and re-run `init`. Full table:
 <https://asdalexey.github.io/vitest-auto-spy/agents>.
 
 | Resource                | Where                                                                                                                                                           |
@@ -54,22 +56,22 @@ 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`, `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 |
-| Angular diagnostics | `vitest-auto-spy/angular/diagnostics` | `enableAngularDiagnostics` and the whole TestBed timing family (§13). Companion to `/angular` like `/angular-http` — no core re-export; **moved off `/angular` in 5.21.0** so importing spies stops evaluating it                                                               |
-| Angular doubles     | `vitest-auto-spy/angular/doubles`     | The Material dialog trio and the `Window`/`Document` platform doubles (§13). Companion to `/angular`; registers the Vitest adapter, so its doubles spy out of the box; **moved off `/angular` in 5.21.0**                                                                       |
-| Angular matchers    | `vitest-auto-spy/angular/matchers`    | `registerDirectiveMatchers`, `registerResourceMatchers`, `registerSignalMatchers` (§13). Companion to `/angular` — no core re-export; **moved off `/angular` in 5.21.0**                                                                                                        |
-| 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()`, `blockNetwork()`, `stubResponse()`; the entry imports Vitest, so it is not for `bun test`                                                                                                                                                |
-| 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), `stubAnimationFrame`, `stubElementRect`, `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                  |
+| Angular diagnostics | `vitest-auto-spy/angular/diagnostics` | `enableAngularDiagnostics` and the whole TestBed timing family (§13). Companion to `/angular` like `/angular-http` — no core re-export; **moved off `/angular` in 5.21.0** so importing spies stops evaluating it                                                                                |
+| Angular doubles     | `vitest-auto-spy/angular/doubles`     | The Material dialog trio and the `Window`/`Document` platform doubles (§13). Companion to `/angular`; registers the Vitest adapter, so its doubles spy out of the box; **moved off `/angular` in 5.21.0**                                                                                        |
+| Angular matchers    | `vitest-auto-spy/angular/matchers`    | `registerDirectiveMatchers`, `registerResourceMatchers`, `registerSignalMatchers` (§13). Companion to `/angular` — no core re-export; **moved off `/angular` in 5.21.0**                                                                                                                         |
+| 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()`, `blockNetwork()`, `stubResponse()`; the entry imports Vitest, so it is not for `bun test`                                                                                                                                                                 |
+| 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.
@@ -146,7 +148,10 @@ and is only ever asserted on — `createAutoMock`. Handed to the function under
 it has to satisfy `T` at the call site _and_ expose the spy helpers at the assertion, and
 `autoMocked<T>()` is that intersection — otherwise every call site needs an `asInstance()` and the
 noise scales with the number of them. Both take the same second argument (`returns`, `name`, `strict`,
-`observablePropsToSpyOn`).
+`observablePropsToSpyOn`). A `let` assigned in `beforeEach` is declared `AutoMocked<T>`,
+not with the intersection spelt out. `returns` also takes an optional method written as a property,
+`getMinZoom?: (() => number) | undefined` — the way Leaflet and other third-party typings declare
+them.
 
 `createMock<T>()` is the one to reach for on data shapes — it returns a plain `T`, so it satisfies a
 `no-type-assertion` lint rule without an `eslint-disable` on every fixture. `createMock<T>(undefined)`
@@ -654,7 +659,9 @@ order**, a `Date` by its time, a `RegExp` by its source and flags, an `Error` by
 `message` plus its own enumerable fields, a function by identity, and symbol-keyed properties
 participate like string ones. Cycles are handled, so a component graph with a back-edge is a legal
 argument. `mustBeCalledWith` uses the same map, and its `Wanted:` line renders a matcher as
-`Any<Number>` rather than as the object it serialises to.
+`Any<Number>` rather than as the object it serialises to. With one config set up, its first line
+names the first argument that differs — `argument 2: expected 'eu', got 'us'` — and it names the
+class only on a strict double (`UserService.getName`), the method alone otherwise.
 
 Each `calledWith(...)` / `mustBeCalledWith(...)` call hands back **its own** handle, so a chain kept
 in a variable stays attached to the arguments it was written with:
@@ -733,8 +740,11 @@ one rather than disappearing.
 
 `nextWithValues` on an observable **property** builds a new stream, which a subscriber that already
 holds the old one never sees — the spec's values go nowhere and the assertion below reads the
-initial state. That case is reported now rather than passing silently; `nextWith` pushes into the
-subject the current subscriber is on and is the one to reach for mid-test.
+initial state. That case is reported rather than passing silently —
+`Feed.items$.nextWithValues() ran after something subscribed to Feed.items$` on a strict double, the
+member name alone otherwise — once per property as a warning, and at every such call as a throw under
+`setupAutoSpy({ misconfiguration: 'throw' })`. `nextWith` pushes into the subject the current
+subscriber is on and is the one to reach for mid-test.
 
 What that does **not** change: `vi.clearAllMocks()` and `clearMocks: true` still cannot reach it,
 for the same reason they cannot reach a `calledWith` chain — that state lives in this library's
@@ -819,7 +829,8 @@ be told apart from an instance field and stays silent.
 Only `onlyMethodsToSpyOn` warns, because only a restricting list can be silently destructive — a
 misspelling there leaves the real method unspied, and the code under test then calls something that
 is not there:
-`[vitest-auto-spy] createSpyFromClass(X): onlyMethodsToSpyOn names method(s) that are not on the class prototype: …`.
+`[vitest-auto-spy] createSpyFromClass(CartService): onlyMethodsToSpyOn names 'lod' (did you mean 'load'?), not a method of CartService.`
+A name with nothing close gets `instanceMethodsToSpyOn: ['x']` as the fix instead.
 
 Also true, and worth not re-deriving:
 
@@ -959,8 +970,10 @@ users.currentTenant(); // throws here, not four frames later inside the componen
 ```
 
 ```
-[vitest-auto-spy] Nothing configured Cart.checkout, and strict mode is on.
-Called as: Cart.checkout(1,'now')
+[vitest-auto-spy] Cart.checkout(1, 'now') was called; this strict double has nothing configured for it.
+Called from src/app/cart.component.ts:41:12
+Configure it in the test: cart.checkout.calledWith(1, 'now').mockReturnValue(…) for these arguments, or .mockReturnValue(…) for any — .resolveWith(…) / .nextWith(…) when it returns a Promise / Observable.
+Docs: https://asdalexey.github.io/vitest-auto-spy/core/strict-mode#the-message
 ```
 
 Also on `createAutoMock`, `provideAutoSpy`, and suite-wide as `setupAutoSpy({ strict: true })` — which
@@ -992,7 +1005,9 @@ Precedence, first one set wins: the double's `onUnstubbedCall` → the double's
 - **A throw something swallowed still fails the test.** Under `setupAutoSpy({ strict: true })` every
   strict throw is recorded, and one that a `try`/`catch` in the code under test or an RxJS error with
   no handler (its rethrow waits on a fake clock) kept from the test fails it after the test
-  (`swallowedStrictCalls`, `'throw'` by default with `strict: true`). Provoking one on purpose:
+  (`swallowedStrictCalls`, `'throw'` by default with `strict: true`). The report quotes each call
+  with its arguments and the line that made it, and says what swallowed it — a `catch` in the code
+  under test, or an RxJS subscriber with no error callback. Provoking one on purpose:
   `expect(() => cart.total()).toThrow(…)` then `expect(takeStrictViolations()).toHaveLength(1)`.
 - **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
@@ -1012,7 +1027,7 @@ member, kind, count })` — suite-wide or per double, same precedence as `onUnst
   `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
   a throw there broke the teardown for every test after it. The calls are still recorded.
-- A class instance or DOM node in the `Called as:` line prints as `[ClassName]`, data up to 200
+- A class instance or DOM node in the call the message quotes prints as `[ClassName]`, data up to 200
   characters per argument; `provideAutoSpyForToken` names the token (`createAutoMock` takes `name`).
 - Use `onUnstubbedCall` to survey a suite before turning the throw on — it is handed
   `{ className, method, args }` and whatever it returns is what the call answers, so a handler that
@@ -1151,6 +1166,12 @@ resetAutoSpy(service); // calls AND configuration (calledWith / resolveWith / mo
 Both cover method spies **and** accessor spies, on `createSpyFromClass` spies and `createAutoMock`
 proxies alike. Reach for these instead of looping over methods calling `mockClear` by hand.
 
+**`mockReset()` on one method keeps its `calledWith` chains** — they live in the library's state, where
+the runner's reset cannot reach — so `spy.isFeatureOn.mockReset(); spy.isFeatureOn.mockReturnValue(true)`
+still reports that `mockReturnValue()` replaced a configured chain (and throws under `strict`). To
+answer one value for every call after a `beforeEach` configured `calledWith(…)`, drop the chain with
+`resetAutoSpy(spy.isFeatureOn)` first; the report names it.
+
 **`resetAutoSpy` is `vi.resetAllMocks()` for one double**, and two things it used to leave behind now
 go with the rest: a pending `mockReturnValueOnce` / `mockResolvedValueOnce` queue (it used to answer
 the first call _after_ the reset, in a later test) and an accessor spy's configuration (a
@@ -1210,6 +1231,15 @@ wait then runs to the runner's own test timeout, which is the trade. The source
 `subscribe` takes a bare callback) and hand-rolled subscribables all work — and every helper infers
 the emitted type, so `expectEmission(of(1))` is a `Promise<number>`.
 
+**A `void` stream calls its listener with one argument, `undefined`.** `output<void>().emit()` and
+`Subject<void>.next()` both do, so a `vi.fn()` subscribed to one records `[undefined]`, and
+`expect(listener).toHaveBeenCalledExactlyOnceWith()` fails on `[] vs [undefined]` — the form a
+`prefer-called-with` autofix used to write. The assertion is the emission itself:
+`await expect(expectEmission(component.closed)).resolves.toBeUndefined()`, or
+`subscribeSpyTo(subject$).getValuesLength()` to count. A listener kept anyway is typed
+`vi.fn<() => void>()` (`(value: void) => void` trips `no-invalid-void-type`) and asserted
+`toHaveBeenCalledExactlyOnceWith(undefined)`.
+
 `expectCompletion` is the one to reach for on a stream whose value is not the point — a save, a
 purge, an `Observable<void>`, a `Subject` a teardown closes. `firstValueFrom` rejects such a stream
 with rxjs's `EmptyError`, and the workaround people arrive at,
@@ -1512,7 +1542,8 @@ setupAutoSpy({ strayTimers: true }); // wrap the schedulers, sweep the survivors
 The pieces are exported too — `trackStrayTimers()` (idempotent, returns the undo),
 `cancelStrayTimers()` (returns how many it cancelled), `countStrayTimers()` and
 `describeStrayTimers()` (each pending timer's `kind`, the `delay` of a timeout or interval, the spec
-`file` that scheduled it and up to five `frames`), all from `vitest-auto-spy/setup`. Use
+`file` that scheduled it, up to five `frames`, and `test` — the `suite > test` that scheduled it — or
+`outsideTest: 'import' | 'hook'` when no test was running), all from `vitest-auto-spy/setup`. Use
 `expect(countStrayTimers()).toBe(0)` in an `afterEach` to make a leak fail rather than be tidied
 away, or take the per-file report from the sweep itself — `timers` carries the same origins, so the
 failure diff names the file and the scheduling call:
@@ -1524,10 +1555,11 @@ setupAutoSpy({ strayTimers: true, onStrayTimers: ({ timers }) => expect(timers).
 `frames` starts below the tracking wrapper and is up to forty frames deep, so a zone or an rxjs
 scheduler in between does not hide the caller: project frames come first; when the call came from
 dependencies only, their frames stand in. The package's own frames are never quoted, from source or
-from `dist`. `onStrayTimers: 'throw'` fails the file with a message that lists every stray as
-`timeout (300 ms) from <file> <frames[0]>`; a handler that prints its own message should print the
-same `kind`, `delay`, `file` and `frames[0]` — they are what makes a report that only reproduces
-under a slow coverage run actionable the first time.
+from `dist`. `onStrayTimers: 'throw'` fails the file with a message that names the file and lists
+every stray as `setTimeout 300 ms, scheduled in "<test>" at <frames[0]>`, then the one fix; a handler
+that prints its own message should print the same `kind`, `delay`, `file`, `test` and `frames[0]` —
+they are what makes a report that only reproduces under a slow coverage run actionable the first
+time.
 
 A stray whose `file` is not the file that failed was scheduled after the previous file's sweep —
 the previous file is the one to fix.
@@ -1546,8 +1578,9 @@ arrive at the same timer from opposite ends and the quiet one wins: the sweep ca
 Vitest collects its leaks afterwards, and a cancelled timeout is no longer referenced, so the run
 reports **no leaks** for a file that leaks. Cancelling is still the right default — a callback firing
 during a later file is the more expensive failure — so when both are on and no `onStrayTimers` is
-given, the sweep prints one line to stderr saying how many it took away and where the first three
-were scheduled; `onStrayTimers` gets all of them. Vitest's own report, with `strayTimers` off, points
+given, the sweep prints to stderr the report `'throw'` fails with — the file, the first three timers
+and the test that scheduled each — closed by one sentence saying they are missing from Vitest's
+"Async Leaks" report; `onStrayTimers` gets all of them. Vitest's own report, with `strayTimers` off, points
 its code frame at the `setTimeout` in the spec, because the library's own scheduler wrappers go
 through `vi.defineHelper` and are dropped from the stack.
 
@@ -1662,14 +1695,17 @@ initialisation — and the `afterAll` takes off everything added since. The piec
 `trackStrayListeners()` (idempotent, returns the undo), `baselineStrayListeners()`,
 `removeStrayListeners()` (returns how many), `countStrayListeners()` (throws before
 `trackStrayListeners()` has run, like the timer counter) and `describeStrayListeners()` — each
-stray's target, type, spec file and up to five frames, the list `onStrayListeners({ removed, listeners })`
-receives when a file should fail instead: `onStrayListeners: ({ removed }) => expect(removed).toBe(0)`,
-or `onStrayListeners: 'throw'`, whose message lists each as `keydown on document from <file> <frames[0]>`.
+stray's target, type, spec file, up to five frames and the same `test` / `outsideTest` as a timer,
+the list `onStrayListeners({ removed, listeners })` receives when a file should fail instead:
+`onStrayListeners: ({ removed }) => expect(removed).toBe(0)`, or `onStrayListeners: 'throw'`, whose
+message names the file and lists each as `keydown on document, added in "<test>" at <frames[0]>`.
 A listener has `type` and `target` where a timer has `kind` and `delay` — a handler that prints its own
-message prints those four fields instead.
+message prints those fields instead.
 With `strayTimers` on too, both reports run after both sweeps and both run even if the first throws —
-a handler or `'throw'` alike; two failures surface as one `AggregateError`, so a throwing report never
-leaves a timer uncancelled.
+a handler or `'throw'` alike; two failures surface as one `AggregateError`
+(`2 file-end checks failed when a.spec.ts ended:`, each report a numbered block with its `Docs:`
+line), so a throwing report never leaves a timer uncancelled. The stray-console file report runs in
+the same sweep.
 Under jsdom a listener registered with `{ once: true }` that already fired stays counted until
 something removes it: the wrapper cannot observe the firing without breaking identity-based
 `removeEventListener` from the code under test, and removing an already-fired listener is a no-op
@@ -1783,7 +1819,7 @@ Every channel is closed by default; the object is for narrowing it:
 
 | option   | default    | what it does                                                                                                                    |
 | -------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `fetch`  | `true`     | `fetch` rejects, naming what was requested                                                                                      |
+| `fetch`  | `true`     | `fetch` rejects, naming the method, the URL and the test, and the `stubResponse` line that answers it                           |
 | `xhr`    | `'reject'` | `'reject'` fails the request (`status` 0, an `error` event); `'empty'` answers 200 with an empty body; `false` leaves XHR alone |
 | `beacon` | `true`     | `navigator.sendBeacon` answers `false` — only where the environment has one                                                     |
 
@@ -2134,17 +2170,21 @@ setupAutoSpy({ strayConsole: 'throw' }); // default 'off'; 'warn' prints the sam
 Any call to a console method that writes (`log`, `info`, `warn`, `error`, `debug`, `trace`, `table`,
 `dir`, `dirxml`, `timeLog`, `timeEnd`, `count`; `group` with a label; a falsy `assert`) made during a
 test that nothing absorbed fails **that test**, quoting the method, the first three lines and the first
-frame outside `node_modules`:
+frame outside `node_modules`, and naming the spy that absorbs it:
 
 ```
-[vitest-auto-spy] "CartService > reports a failed load" wrote to the console 1 time(s) and nothing absorbed it:
+[vitest-auto-spy] "CartService > reports a failed load" wrote to console.error 1 time and nothing absorbed it:
   - console.error: Error: load failed
       at CartService.load (src/app/cart.service.ts:41:15)
+Absorb what the test expects — installConsoleSpies() in a beforeEach, then assert consoleErrorSpy — or fix the code if the output is a defect.
+Docs: https://asdalexey.github.io/vitest-auto-spy/utilities/setup#_16-console-output-nothing-absorbed
 ```
 
 - **Absorbed** means the call never reached the console: a `/console` spy installed for the test or
   the file, `vi.spyOn(console, m).mockImplementation(…)`, any replacement that does not call
-  through. A bare `vi.spyOn(console, m)` calls through and **counts**.
+  through. A bare `vi.spyOn(console, m)` calls through and **counts** — the report says so and names
+  `.mockImplementation(() => undefined)`; a method with no `/console` spy (`table`, `dir`) gets a
+  silent `vi.spyOn` instead.
 - **This library's own `'warn'`-grade reports are not stray console output.** `guardGlobals`,
   `prototypePollution`, `unconfiguredReads`, `swallowedStrictCalls`, `misconfiguration`, the
   duplicate-copy report, the skipped-teardown net and the `test.concurrent` notice write past the
@@ -2153,15 +2193,22 @@ frame outside `node_modules`:
   channel checks that the guard's own wrapper is the installed method and steps aside when anything
   sits on top of it.
 - Output **outside any test** — collection/import, `beforeAll` / `afterAll`, a callback after its
-  test ended — fails the **file** in `afterAll` (`… outside any test …`).
+  test ended — fails the **file** at its end, in the same sweep as the timer and listener reports. The
+  report names the phase — `while the file was being imported`, `in a beforeAll`,
+  `after a test had ended`, or `outside any test` when they mix — and gives that phase's advice: for
+  import-time output, the module and the line to fix. A recognised line (`NG0912`, any `NGxxxx`)
+  adds a `Likely cause:` block. It always names the file that wrote the output: when that file's end
+  never ran (its own `afterAll` threw), the next file reports it and says
+  `It is reported at the end of b.spec.ts: the file-end check of a.spec.ts did not run.`
 - Every console method a test replaced is put back after it; one a file replaced, after the file.
 - Under the guard, **importing `vitest-auto-spy/console` installs nothing** — call
   `installConsoleSpies()` in a `beforeEach` (or at the top of the file). Spies an import installed
   before the guard armed are taken off.
-- `strayConsole: { allow: ['…', /…/] }` is the last resort, for environment noise no spec can reach.
-  Output written to `process.stdout` / `process.stderr` directly, and jsdom's own virtual console, is
-  not seen. An Angular suite that resets modules under `isolate: false` allows `/NG0912/`, Angular's import-time
-  component-ID collision warning, which the guard otherwise blames on whichever file is importing.
+- `strayConsole: { allow: ['…', /…/] }` is the last resort, for a line from a dependency no spec can
+  reach — the import-time report offers it, with the pattern, only when the quoted frame is inside
+  `node_modules`. Output written to `process.stdout` / `process.stderr` directly, and jsdom's own
+  virtual console, is not seen. `NG0912` is not noise to allow: it means two copies of one component
+  in the bundle, fixed by importing the component from one place.
 - The wrapper forwards every call unchanged, so Vitest's attribution and `onConsoleLog` still work.
   `guardStrayConsole(reaction)` registers the same guard on its own.
 
@@ -2179,12 +2226,13 @@ an unconfigured call returns — a semantic switch, not a grade; the name was ta
 `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 `onStrayTimers: 'throw'`, whose message
-names each one's file, or `onStrayTimers: ({ timers }) => expect(timers).toEqual([])`), and
+names the file and the test that scheduled each one, or `onStrayTimers: ({ timers }) => expect(timers).toEqual([])`), and
 `enableAngularDiagnostics()`, which lives in `/angular/diagnostics` — call it in the same setup file as the Angular half of strict.
 
 `misconfiguration: 'throw'` on its own makes the library's misuse reports — an `onlyMethodsToSpyOn`
 typo, `gettersToSpyOn` naming a method, a `returns` key no spy answers to, `injectSpy` handed a real
-instance, a `jasmine.DEFAULT_TIMEOUT_INTERVAL` write, `providedMethodNames` — throw at the call site,
+instance, a `jasmine.DEFAULT_TIMEOUT_INTERVAL` write, `providedMethodNames`, a `nextWithValues()` on an
+observable property something already subscribed to — throw at the call site,
 every occurrence. The grade is process-wide and released after the file. The printed grade of the
 `injectSpy` warning is de-duplicated per token **per spec file**, no longer per worker.
 
@@ -2411,6 +2459,37 @@ once and leaves a working storage alone; this one replaces whatever is there, fo
 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.
 
+### Animation frames and element boxes
+
+Do not assign `window.requestAnimationFrame` by hand, and do not stub `getBoundingClientRect` with a
+partial literal. Both have a stub on `/dom-stubs`:
+
+```ts
+import { stubAnimationFrame, stubElementRect } from 'vitest-auto-spy/dom-stubs';
+
+beforeEach(() => {
+  stubAnimationFrame(); // 'immediate': the callback runs before requestAnimationFrame returns
+  stubElementRect(container, { width: 800, height: 600 }); // x / y default to 0
+});
+
+it('scrolls after the next frame', () => {
+  const frames = stubAnimationFrame({ mode: 'queued' });
+
+  list.scrollToSelected();
+  expect(frames.pending).toBe(1);
+
+  frames.flush(); // one frame; the timestamp defaults to performance.now()
+  expect(list.scrolled).toBe(true);
+});
+```
+
+`stubAnimationFrame` stubs `cancelAnimationFrame` too, and hands both spies back as
+`frames.requestAnimationFrame` / `frames.cancelAnimationFrame`. A frame requested from inside a
+running frame is queued in either mode, so a loop that requests its own next frame advances one step
+per `flush()`. `stubElementRect` returns a real `DOMRect` per call, edges derived, and returns the undo.
+Both go through `mockValueProp`, so `restoreMockedProps()` (and `setupAutoSpy()` between tests) takes
+them off; `frames.restore()` does it sooner.
+
 ### A module mock that did nothing
 
 `vi.mock()` is the one thing in a ported suite that fails **silently**. Under a bundler
@@ -3246,7 +3325,7 @@ TestBed.configureTestingModule({ providers: [provideAutoSpy(MatDialog)] });
 injectSpy(MatDialog).open.mockReturnValue(createMatDialogRef(MatDialogRef, { closedWith: 'saved' }).ref);
 ```
 
-Five things to know:
+Six 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
@@ -3259,7 +3338,15 @@ Five things to know:
 - **`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.
+  With the type argument named the token parameter is `InjectionToken<unknown>`, so the call passes
+  `@typescript-eslint/no-unsafe-argument` — do not drop the type argument to silence that rule, it
+  only turns the data back into `any`. The value is handed out as it is, so build it per test rather than hoisting it to a constant.
+- **Name the ref type as a type argument, not as an instantiation expression.**
+  `injectMatDialogRef(MatDialogRef<NameInputDialog, string>)` reads `Ref` off the class's `prototype`,
+  which Material types `MatDialogRef<any, any>`, so the handle comes back `any`-typed and assigning it
+  to a typed variable is `no-unsafe-assignment`. Write
+  `injectMatDialogRef<MatDialogRef<NameInputDialog, string>>(MatDialogRef)` — the same for
+  `createMatDialogRef` and `provideMatDialogRef`.
 - **`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
@@ -3409,6 +3496,16 @@ await setInputs(fixture, { projectId: 7 }, { label: 'the task list' }); // optio
 // a fixture whose componentType carries no ɵcmp is refused by name too, not as a bare TypeError
 // aliases resolve by CLASS FIELD name, and an input a hostDirectives entry exposes is accepted
 
+// a typed element instead of Angular's `any` — never `fixture.nativeElement as HTMLElement`
+const host = hostElement(fixture); // HTMLElement, checked with instanceof
+queryElement(fixture, '.close').click(); // HTMLElement; throws naming the selector when nothing matches
+queryElement(fixture.debugElement, 'input[name=q]', HTMLInputElement).value; // typed; wrong type throws
+// also on /bun-angular; queryElement takes an element found earlier as its root too
+// a null source (debugElement.query() that matched nothing) throws saying so, not 'Cannot read properties of null'
+expect(queryElement(fixture, '.title').textContent.trim()).toBe('Orders'); // present: read through queryElement
+expect(host.querySelector('.empty-state')).toBeNull(); // absent: querySelector on the typed host, no cast
+// NOT host.querySelector('.title')?.textContent.trim() — a miss is undefined, which toBeFalsy() accepts
+
 // build a class through DI, every unprovided token auto-spied
 const { instance, spies } = createWithAutoSpies(CartService, {
   providers: [{ provide: TaxService, useValue: realTax }], // explicit providers win
@@ -3903,7 +4000,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-set-inputs`               | `warn`  | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `prefer-spy-on-own-method`        | `warn`  | `--fix` / suggest | `createSpyFromInstance(x, { onlyMethodsToSpyOn: ['m'], passthrough: true })` read for `m` alone — `.m` on the call, `const { m } = …`, a bare statement, or a name read only as `v.m` → `spyOnOwnMethod(x, 'm')`; the same whitelist with `returns: { m: undefined }` → `spyOnVoidMethod(x, 'm')`. Both fix, import and all; a `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed is a suggestion, offered only on a real event or element — `new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement` — never on a double                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `prefer-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `no-hand-assigned-global`         | `error` | —                 | a double assigned to a global (`global.fetch = vi.fn()`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }`) with no restore in `afterEach` / `afterAll` / `onTestFinished` → `mockValueProp(globalThis, name, value)` or `vi.stubGlobal` + `unstubGlobals`; `blockNetwork()` for network globals, `stubWebStorage()` for the storages; the three observers stay with `prefer-observer-stub`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `no-hand-assigned-global`         | `error` | `--fix`           | a double assigned to a global (`global.fetch = vi.fn()`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }`) with no restore in `afterEach` / `afterAll` / `onTestFinished` → `mockValueProp(globalThis, name, value)` or `vi.stubGlobal` + `unstubGlobals`; `blockNetwork()` for network globals, `stubWebStorage()` for the storages; the three observers stay with `prefer-observer-stub`; any value written into an imported object (`environment.production = true`) → `mockValueProp(environment, 'production', true)`, fixed in a test or `beforeEach`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `prefer-stub-response`            | `error` | —                 | an object literal cast to `Response` (`as Response`, `as unknown as Response`, `<Response>{ … }`) or `createMock<Response>(…)` / `createAutoMock<Response>(…)` → `stubResponse({ body })` from `/setup`; the literal answers `undefined` for every member it does not list (`status`, `headers`, `text()`) and the cast is what makes that compile. `Response` must resolve to the **global**, so an Express handler's or a generated client's `Response` is never reported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `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)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
@@ -4110,6 +4207,10 @@ rules answer the same way they did — the ordering rules (`no-inject-before-ove
 decide by range, `prefer-render-shallow` asks the template-read question once per file, and
 `no-redundant-smoke-test` indexes identifiers only where a smoke test exists to judge.
 
+**A rule message names what it found and one repair, and ends in `Docs: <url>`** — the rule's own
+section of the rules page (`utilities/eslint-rules#<rule-name>`), which is also its `meta.docs.url`.
+The reasoning a message leaves out lives in that section; read it before overriding a severity.
+
 The legacy `.eslintrc` `plugins: []` form cannot work — it resolves names to `eslint-plugin-*`
 packages, which a subpath export can never be.
 
@@ -4119,10 +4220,11 @@ packages, which a subpath export can never be.
 
 | Message contains                                                                                                                                   | Cause                                                                                                                                                                                                                                                                       | Fix                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | -------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `No mock adapter registered`                                                                                                                       | no runtime entry was imported, or the wrong one — or the setup file that imports it never ran: an `@angular/build:unit-test` / `@nx/angular:unit-test` target runs only the `setupFiles` it names (`doctor` reports `builder-setup-unreached`)                              | import `vitest-auto-spy` (Vitest) / `…/bun` / `…/node` once before creating spies; under the unit-test builder, name the setup file in the target's `setupFiles`                                                                                                                                                                                                                                                                                                                                                  |
+| `No mock adapter registered`                                                                                                                       | no runtime entry was imported, or the wrong one — or the setup file that imports it never ran: an `@angular/build:unit-test` / `@nx/angular:unit-test` target runs only the `setupFiles` it names (`doctor` reports `builder-setup-unreached`)                              | the one import the message names — it detects the runner (Vitest, `bun:test`, `node:test`, Rstest) and links that runner's installation section; under the unit-test builder, name the setup file in the target's `setupFiles`                                                                                                                                                                                                                                                                                    |
 | `No "X" export is defined on the "<m>" mock`, in a spec whose `vi.mock('<m>')` has no factory                                                      | another spec file mocked `<m>` with a factory, and under `isolate: false` Vitest hands that factory to a later automock or `{ spy: true }` mock of the same module (`doctor` reports `module-mock-leak`)                                                                    | mock it the same way in both files, or `vi.resetModules()` in this file before importing it                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `Observable spies require rxjs`                                                                                                                    | the rxjs layer was never loaded                                                                                                                                                                                                                                             | `import 'vitest-auto-spy/rxjs';` once, in the setup file                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `… is not subscribable (…)`                                                                                                                        | the argument is not an observable — most often the value it emits, or a promise                                                                                                                                                                                             | pass the observable itself; `await` a promise directly (§8)                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `expectEmission(x): no value within N ms (0 received)`                                                                                             | nothing triggered the stream — or, when the message says timers are fake, the callbacks feeding it wait on a clock this watchdog never advances                                                                                                                             | check the call that should make it emit and the spy feeding it (`nextWith`); under fake timers pass `{ advance: () => vi.advanceTimersByTime(ms) }` (§8)                                                                                                                                                                                                                                                                                                                                                          |
 | ``… the `advance` callback threw: …``                                                                                                              | the `{ advance }` callback failed; the original is on `cause` and the subscription is torn down                                                                                                                                                                             | fix the callback — a `vi.runAllTimers()` with no fake timers installed is the usual one (§8)                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `expectEmissions(source$, 0) can never succeed`                                                                                                    | a count below 1 — usually `expectEmissions(s, expected.length)` with an empty expectation                                                                                                                                                                                   | `expectNoEmission(source$)`, which is the assertion that was meant (§8)                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `setEmissionTimeout(NaN) needs a non-negative number of milliseconds`                                                                              | arithmetic on something unset reached the setter                                                                                                                                                                                                                            | pass a number, `0` or `Infinity` for no watchdog (§8)                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
@@ -4133,42 +4235,51 @@ packages, which a subpath export can never be.
 | `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`                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `onlyMethodsToSpyOn names 'x' (did you mean 'y'?), not a method of X`                                                                              | a typo, or a method the constructor assigns (an arrow property, a `signal()` field, a `signalStore()` method)                                                                                                                                                               | take the name the message suggests; with no suggestion it names `instanceMethodsToSpyOn: ['x']`, which adds to the discovered methods (§5)                                                                                                                                                                                                                                                                                                                                                                        |
 | `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`                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `X.method is set up with mustBeCalledWith, and this call matches none of its configs`                                                              | the code called the spy with other arguments; with one config set up the line ends with the first that differs (`argument 2: expected 'eu', got 'us'`). `X.` appears on a strict double only                                                                                | that is the assertion firing — fix the value the code under test passes, or configure that call too; relax to `calledWith` when other arguments are fine                                                                                                                                                                                                                                                                                                                                                          |
 | `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `advanceTimers() found only the clock faked, not the timers`                                                                                       | `mockSystemTime()` installed `Date` alone, so there is nothing to advance and the call used to pass having done nothing                                                                                                                                                     | `setupFakeTimers()` (or `vi.useFakeTimers()`) in the test that drives timers (§11)                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `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                                                                                                                                                                                                                                                      |
+| `X.method(…) was called; this strict double has nothing configured for it`                                                                         | a strict double was asked for a method no line configured                                                                                                                                                                                                                   | paste the call the `Configure it in the test:` line names (`calledWith(args).mockReturnValue(…)`, or `mockReturnValue(…)` for any); `Called from` is the calling line; or `{ strict: false }` on that double (§5)                                                                                                                                                                                                                                                                                                 |
+| `X.member was read N times on a strict double and nothing configured it` (or `was subscribed to N times on a strict double and never emitted`)     | `setupAutoSpy({ unconfiguredReads })`, after the test — the code under test read a strict double's spied getter and got `undefined`, or subscribed to its observable property and nothing ever emitted                                                                      | the advice under each finding names the member: `accessorSpies.getters.url.mockReturnValue(…)` for a getter, `events.nextWith(…)` or `overrides: { events: new Subject() }` for a stream; `mockReturnValue(undefined)` when `undefined` is the answer meant (§5)                                                                                                                                                                                                                                                  |
+| `[vitest-auto-spy] "…" wrote to console.<method> 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 | the report names the spy to assert (`installConsoleSpies()` in a `beforeEach`, then `consoleErrorSpy`, …), or says the `vi.spyOn` calls through and needs `.mockImplementation(() => undefined)`; or fix the code that printed. Importing a spy installs nothing under the guard                                                                                                                                                                                                                                  |
 | `… 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                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `… wrote to console.<method> N time(s) while the file was being imported`                                                                          | a module the file imports wrote while it was evaluated (a static block, a decorator, a top-level call), or a `describe` body did — before any hook, so no spy absorbs it; it lands on the first file of the worker to import that module                                    | fix the line the report names, reading the `Likely cause:` block (`NG0912`: two copies of one component in the bundle — import it from one place); `strayConsole: { allow: [...] }` only for a line inside `node_modules`, which the report offers itself                                                                                                                                                                                                                                                         |
+| `It is reported at the end of b.spec.ts: the file-end check of a.spec.ts did not run.`                                                             | `a.spec.ts`'s own `afterAll` threw, so its file-end checks never ran and its console output was carried into the next file                                                                                                                                                  | fix that `afterAll` first — its error is in `a.spec.ts`'s output — then the output the report quotes, in the file it names                                                                                                                                                                                                                                                                                                                                                                                        |
+| `"…" made N call(s) a strict double had nothing configured for, and the throw never reached the test`                                              | `setupAutoSpy({ strict: true })` — a strict double threw, and a `catch` in the code under test or an RxJS subscriber with no error callback swallowed it; each call is quoted with its arguments and the line that made it                                                  | configure that method (`.mockReturnValue`, `.calledWith` or `returns`), or drain it with `takeStrictViolations()` when the test provokes it on purpose (§5)                                                                                                                                                                                                                                                                                                                                                       |
+| `a.spec.ts left N timer(s) pending when it ended`                                                                                                  | `onStrayTimers: 'throw'` — a timer outlived its file; each line names the test that scheduled it (or `while the file was imported`, `outside any test`), and it was cancelled                                                                                               | clear it in the test named — `clearTimeout`, unsubscribe, `fixture.destroy()` — or run it out with fake timers before the test ends (§10)                                                                                                                                                                                                                                                                                                                                                                         |
+| `a.spec.ts left N window/document listener(s) attached when it ended`                                                                              | `onStrayListeners: 'throw'` — a listener outlived its file; each line names the test that added it, and it was removed                                                                                                                                                      | remove it in that test — `removeEventListener` with the same capture flag, an `AbortSignal`, `fixture.destroy()` (§10)                                                                                                                                                                                                                                                                                                                                                                                            |
+| `N file-end checks failed when a.spec.ts ended`                                                                                                    | several file-end reports failed together — stray timers, listeners, console output — and each numbered block is one of them                                                                                                                                                 | fix each block on its own; Vitest also lists every member error separately                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `fetch is stubbed in unit tests — GET <url>. The test "…" requested it`                                                                            | `blockNetwork` refused a request the named test made (a blocked `XMLHttpRequest` carries the same marker on `statusText`)                                                                                                                                                   | answer it in that test — `vi.spyOn(globalThis, 'fetch').mockResolvedValue(stubResponse({ body: … }))` — or `blockNetwork({ xhr: 'empty' })` for an XHR nobody reads (§10)                                                                                                                                                                                                                                                                                                                                         |
+| `X.member.nextWithValues() ran after something subscribed to X.member`                                                                             | `nextWithValues` on an observable property publishes a new stream, which the subscriber already holding the old one never sees; `X.` appears on a strict double only                                                                                                        | call it before the code under test subscribes, or push into the held stream with `nextWith()`; a throw under `setupAutoSpy({ misconfiguration: 'throw' })`                                                                                                                                                                                                                                                                                                                                                        |
+| `assertMocked(…): x is the real function — … did not apply` (or `no export is a mock`)                                                             | the module mock did not reach the code under test; the message names the cause that fits the run — `isolate: false` with the module already loaded, or the code importing it through another path                                                                           | under `isolate: false` mock it in the earlier file too or run this file isolated; otherwise `vi.mock` the specifier the code imports, or inject the dependency                                                                                                                                                                                                                                                                                                                                                    |
 | `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: { flagsConfig } })` 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)                                                                                                                                                                                                                                                                                                                                                                                               |
+| `overrideComponentProvider(…): the override did not apply — C resolved T to …`                                                                     | the component injects a different token, or something configured the token again after the call; the message says whether the real service or a different double won                                                                                                        | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures                                                                                                                                                                                                                                                                                                                                                                                  |
 | `.value() was read while the resource is in the error state: …`                                                                                    | `mockResourceProp`'s double after `fail(reason)`, as a real `ResourceRef` behaves; the reason is on `cause`                                                                                                                                                                 | branch on `hasValue()` / `status()` first, or assert with `toHaveResourceError()` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `@angular/core <version> no longer carries …, which this package reads`                                                                            | an Angular internal this package reads has moved; checked once per worker                                                                                                                                                                                                   | nothing is fixable from a spec — report the version in the message and pin the previous Angular until a release reads the new shape (§13)                                                                                                                                                                                                                                                                                                                                                                         |
 | `provideHttpTesting(): globalThis.__vitest_worker__ is not there`                                                                                  | the runner does not say which test is running, so the end-of-test check cannot arm — `bun:test`, `node:test`                                                                                                                                                                | call `verifyNoPendingRequests()` yourself (§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)                                                                                                                                                                                                                                                                                                                                                                                                |
+| `ngModuleScopes: X is imported into the testing module but contributes nothing`                                                                    | `enableAngularDiagnostics({ ngModuleScopes })` — an AOT test bundle stripped `ɵɵsetNgModuleScope`, so the directives it exports are missing (`NG0303` / `NG0304`)                                                                                                           | import the directives it exports directly, or declare them in the TestBed (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `assertNgModuleScopes(): X has an empty runtime scope`                                                                                             | the same stripped `ɵɵsetNgModuleScope`, found by the manual check; a module with providers of its own may be providers-only, and the message says so                                                                                                                        | declare what the spec needs in the TestBed module directly; leave a providers-only module out of the call (§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                                                                                                                                                                                                                                                                                                                                                                                            |
+| `injectSpy(X): got a real X` (or `got a plain value, not an auto-spy` for an `InjectionToken`)                                                     | nothing in the testing module provides a double; a `console.warn` once per token and spec file, a **throw** under `enableAngularDiagnostics({ unspiedProviders })` or `setupAutoSpy({ misconfiguration: 'throw' })`                                                         | the fix the message names: `provideAutoSpy(X)` in `providers`, or `{ provide: TOKEN, useValue: createAutoMock<T>() }` for a token; `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `cannot read "…" referenced by …: ENOENT at …`                                                                                                     | a `templateUrl` / `styleUrl` path does not resolve; the errno (`ENOENT`, `EACCES`) and the resolved path say why                                                                                                                                                            | 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>()`                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
@@ -4212,7 +4323,7 @@ packages, which a subpath export can never be.
 | `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 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 test; then the `mock*Prop` helper the message names                                                                                                                                                                                                                                                                                                                                                                                                           |
 | a spec green alone that fails only in a full run, on something it reads off `<body>` / `<html>` (`querySelector('[data-…]')`, a class)             | an earlier file in the worker left an attribute on the shared document                                                                                                                                                                                                      | `setupAutoSpy({ documentPollution: 'throw' })` (in `preset: 'strict'`) names the test; take the attribute off in `ngOnDestroy` / `DestroyRef.onDestroy` or an `afterEach`                                                                                                                                                                                                                                                                                                                                         |
 | `A metric with the name … has already been registered` as a failed suite with 0 failed tests, only in a full run                                   | under `@angular/build:unit-test` with `isolate: false` a workspace module can run its module scope once **per spec file**, while an external package such as `prom-client` keeps one default registry per worker                                                            | not something a hook can catch — it throws at import. Look the metric up before creating it: `register.getSingleMetric(name) ?? new Histogram({ name, … })`, or give the module its own `new Registry()`                                                                                                                                                                                                                                                                                                          |
 | `NotSupportedError: This name has already been registered in the registry` at import                                                               | the same per-spec-file evaluation reaching a module-scope `customElements.define` — the registry belongs to the worker's document                                                                                                                                           | `if (!customElements.get(name)) customElements.define(name, Element)`; a definition cannot be undone, so nothing can sweep it                                                                                                                                                                                                                                                                                                                                                                                     |
@@ -4226,10 +4337,10 @@ packages, which a subpath export can never be.
 | `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)                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `setInputs: X carries no ɵcmp, so there are no inputs to set`                                                                                      | the fixture's `componentType` is not a compiled `@Component` — a `@Directive` or `@Pipe` class, or one Angular never compiled (a barrel import that resolved to `undefined`)                                                                                                | pass a component fixture; a directive takes its inputs through the host element that applies it (`createDirectiveHost`), and for `undefined` import the class from its own file (§13)                                                                                                                                                                                                                                                                                                                             |
+| `setInputs: … declares no input named …` (with a `Did you mean` for a near typo)                                                                   | the key is not an input of that component — a typo, an input renamed since, or one of its own fields                                                                                                                                                                        | take the suggestion, or set a name the message lists; a signal the component owns is moved through the signal (§13)                                                                                                                                                                                                                                                                                                                                                                                               |
+| `setInputs: X carries no ɵcmp, so there are no inputs to set` (or `the component class is undefined`, `X is a @Pipe`)                              | the fixture's `componentType` is not a compiled `@Component` — a `@Pipe`, a class Angular never compiled, or `undefined` from a barrel split across chunks                                                                                                                  | pass the `@Component` class the fixture was created from; call a pipe's `transform()` directly; for `undefined` import the class from its own file (§13)                                                                                                                                                                                                                                                                                                                                                          |
 | `TypeError: dependencies is not a function`, from `renderShallow({ keepTemplate: true })`                                                          | the compiled `ɵcmp.dependencies` is the flat array AOT emits when no cycle forced a factory, and the trim called it                                                                                                                                                         | upgrade — all three shapes (array, factory, `null`) are read; nothing to change in the spec                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `renderShallow(X, { keepTemplate: true }): … declared by an NgModule rather than standalone`                                                       | an AOT dependency list: ngtsc flattened an imported `NgModule`'s exported declarations into it, and Angular takes only standalone declarations and `NgModule`s in `imports`                                                                                                 | drop `keepTemplate` when the spec reads TypeScript state only, or build the component with `TestBed` directly and keep its compiled scope — the declarations named are not the thing to change                                                                                                                                                                                                                                                                                                                    |
+| `renderShallow(X, { keepTemplate: true }): … is declared by Module, not standalone` (or `by an NgModule`)                                          | an AOT dependency list: ngtsc flattened an imported `NgModule`'s exported declarations into it, and Angular takes only standalone declarations and `NgModule`s in `imports`                                                                                                 | name that module in `keepModules: [Module]` and it is put back whole — the message names it when the spec imports it; or drop `keepTemplate` when the spec reads TypeScript state only                                                                                                                                                                                                                                                                                                                            |
 | `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`                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -4249,7 +4360,7 @@ packages, which a subpath export can never be.
 | 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)                                                                                                                                                                                                                                                                                                                                                                         |
+| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers                                                                     | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                                                                                                                                                | the stderr report names the file, the first three timers and the test that scheduled each; `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
@@ -4257,17 +4368,22 @@ packages, which a subpath export can never be.
 | `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; a method the constructor assigns (an ngrx `rxMethod`) is not on the prototype                        | fix the name or the whitelist, or list a constructor-assigned method in `instanceMethodsToSpyOn`; the value is silently never returned otherwise (§5)                                                                                                                                                                                                                                                                                                                                                             |
+| `returns names 'x', not a method of X` (or `which onlyMethodsToSpyOn left out`)                                                                    | 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; a method the constructor assigns (an ngrx `rxMethod`) is not on the prototype                        | the message names the fix: the close method it meant, adding it to `onlyMethodsToSpyOn`, or `instanceMethodsToSpyOn` for a constructor-assigned method; 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)                                                                                                                                                                                                                                                                                                                                                                                 |
+| `expectRequest: no request matched … Made instead: …`                                                                                              | the URL or predicate describes nothing the code under test sent                                                                                                                                                                                                             | compare with the requests listed — they are the ones actually made; then fix the URL or the predicate (§13)                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `expectRequest: no POST … — but GET … was made`                                                                                                    | only the verb differs                                                                                                                                                                                                                                                       | pass `{ method }` for the verb the code sends, or fix the verb it sends (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `expectRequest: no GET …?page=2 — but GET …?page=3 was made; the query differs`                                                                    | the same path, another query string                                                                                                                                                                                                                                         | name the query the code sends, or match the path alone: `expectRequest('/api/products')` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `expectRequest: no request matched … — nothing was requested at all`                                                                               | an `httpResource()` whose `request()` returned no URL yet, or an `HttpClient` call nothing subscribed to                                                                                                                                                                    | set the signal the resource reads, or subscribe to the call (§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)`), forgive an unsubscribed one with `{ verifyOnTeardown: { ignoreCancelled: true } }`, or `{ verifyOnTeardown: false }` (§13)                                                                                                                                                                                                                                                                                       |
+| `X was never answered (end of "…")` / `N requests were never answered`                                                                             | `provideHttpTesting({ verifyOnTeardown })` or `enableAngularDiagnostics({ pendingRequests })` — the test left a request open; the message names its URL and the test                                                                                                        | answer it with the line the message prints (`await expectRequest(url).flush(body)`, `controller.expectOne(url).flush(body)` under diagnostics), or assert its absence (`expectNoRequest(url)`); a cancelled one is forgiven with the `ignoreCancelled` opt-in the message names (§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)                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `provideActivatedRoute: @angular/router <version> 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)                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `provideActivatedRoute({ title }): @angular/router <version> keeps the route title under a key …`                                                  | that router version stores the resolved title under a key this helper could not find                                                                                                                                                                                        | leave `title` out of the init for now, and report it with the `@angular/router` version (§13)                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `provideRouterDouble: the Router double has no …`                                                                                                  | the code under test reached for a `Router` member the double does not cover — `isActive`, `resetConfig`, `lastSuccessfulNavigation`                                                                                                                                         | the double covers `url`, `events`, `navigate`, `navigateByUrl`, `createUrlTree`, `serializeUrl`, `parseUrl`, `routerState` and `currentNavigation` / `getCurrentNavigation()`; 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)                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `collectRouterEvents().expect(): the events differ at #N` (or `#N … never came`, `#N … was not expected`)                                          | the recorded navigation events part from the expected ones there; the message prints both sequences under it                                                                                                                                                                | read the `Expected:` / `Recorded:` lines under it, then fix the expectation or the navigation the test drives (§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
@@ -4474,8 +4590,12 @@ Full reference: <https://asdalexey.github.io/vitest-auto-spy/utilities/cli>.
 Exit codes, as the commands implement them: **0** is "ran, nothing to report"; **1** is "ran, and
 here is the finding" — `doctor` with an error, `init --check` with a stale block, `codemod` with any
 note, `perf --gate` over budget; **2** is "there was nothing to judge" — no command, an unknown
-command, an unknown flag, an unreadable `--only` / `--from` value, a path matching no file, and a
-`perf` run that measured nothing (including a red suite, which the gate will not judge at all).
+command, an unknown flag, a flag value it cannot use (an `--min-severity` word it does not know, a
+number flag given a word or a negative number, a value flag with nothing after it, an `--ignore` id
+`doctor` has no check for), an unreadable `--only` / `--from` value, a path matching no file, and a
+`perf` run that measured nothing (including a red suite, which the gate will not judge at all). An
+invalid flag value stops the command before it does anything: the message says so (`Nothing ran.`),
+and a typo in a command, a flag, `--only` or `--ignore` gets a `Did you mean`.
 
 **Reading the output from a script: `--format json`**, on `doctor` and on `perf`. One JSON document
 on stdout — `schema`, `exitCode`, `tally` (`errors`, `warnings`, `notes`), every finding with
@@ -4483,13 +4603,15 @@ on stdout — `schema`, `exitCode`, `tally` (`errors`, `warnings`, `notes`), eve
 per candidate, `outcome` one of `confirmed`, `not reproduced`, `unconfirmed`, `single reading`,
 `over budget`). Parse that rather than the text: the text is wrapped to the terminal (80 columns in a
 pipe), groups one cause found in many files into one block, and ends in a tally line that starts
-with `N errors, N warnings, N notes`. `--format markdown` renders the same document as tables — for a
+with `N errors, N warnings, N notes`. In the text, every finding ends in a `Docs:` line — its own
+section of the CLI page (`utilities/cli#<check-id>`), or of the codemod page for a codemod note. `--format markdown` renders the same document as tables — for a
 merge request note or a job summary, not for parsing.
 
 **`doctor --ignore <check,…>`** leaves the named checks out of the report, the tally, the exit code
 and the `--code-quality` file. Use it only for a finding the repository has answered in a way
 `doctor` cannot see — `no-agent-instructions` in CI where the instruction files are kept out of git,
-`angular-build-splitting-off` under a patched builder. `--min-severity` hides findings from the text
+`angular-build-splitting-off` under a patched builder. An id `doctor` has no check for is exit 2,
+with the closest id suggested. `--min-severity` hides findings from the text
 only; `--ignore` removes them.
 
 ### If you were asked why a suite is slow
@@ -4514,8 +4636,9 @@ assumed safe — do not treat an undecided file as a candidate, and do not add p
 yourself; a false positive breaks someone's suite on `document is not defined`. When `import`
 dominates, `perf-import` names specs that reach their subject through a barrel (`index`/`public-api`
 re-exporting a whole directory). When `environment` + `setup` + `prepare` together dominate,
-`perf-isolation` suggests `test.isolate: false` and links to this package's own memory measurements
-of that trade rather than restating them — read that page before recommending the flag, since it
+`perf-isolation` suggests `isolate: false` in the config it names, kept only if peak memory stays
+acceptable; its `Docs:` line leads to the check's section of the CLI page, which links this
+package's own memory measurements of that trade — read them before recommending the flag, since it
 raises peak memory.
 
 Two more findings are about settings rather than files. `perf-environment-engine` fires when
@@ -4523,11 +4646,14 @@ Two more findings are about settings rather than files. `perf-environment-engine
 mentions `happy-dom`: measured on this package's own 117-file Angular suite, `happy-dom` is 23.2 s of
 user CPU against jsdom's 26.5 s, and on a spec that builds a DOM and does nothing else the gap is
 253 ms against 119 ms per file. It is a swap, not a flag — `happy-dom` implements less of the
-platform — so take one project at a time. `perf-workers` fires on a run over a minute of summed CPU
+platform — so take one project at a time; the finding names the config that sets `jsdom`, and the
+numbers stay in the docs section. `perf-workers` fires on a run over a minute of summed CPU
 that declares no `maxWorkers`, and it is the one finding here about **memory**: one worker per core
 is the default, resident memory measured at 1.42 GB plus ~155 MB per worker, and a cap of four costs
-about 2.8 % of wall clock. Do not quote a worker count as universally right — it is a property of
-the machine.
+about 2.8 % of wall clock. The finding itself counts this machine's cores
+(`os.availableParallelism()`) and suggests half of them as `maxWorkers` in the config it names; the
+figures above are in the docs section, not in the message. 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