vitest-auto-spy 5.29.0 → 5.30.0

package/AGENTS.md

@@ -216,7 +216,10 @@ the test must not touch the real one.
 verbose for the most common thing it says — _observe one method of the object under test and let it
 run_ — so the helper says exactly that and hands back the single spy. It is also the drop-in for a
 bare `vi.spyOn(component, 'method')` where a preset's `no-restricted-properties` bans `vi.spyOn`:
-same default semantics, record and call through, and `restoreSpiedInstance` puts it back.
+same default semantics, record and call through, and `restoreSpiedInstance` puts it back. It is a
+core export — `import { spyOnOwnMethod } from 'vitest-auto-spy'`, or the runner entry on
+`bun test` / `node --test` — while `vitest-auto-spy/angular` and `vitest-auto-spy/nestjs` have no
+core re-export, so those suites import it from the root; `spyOnVoidMethod` below is the same.
 
 **Do not `createSpyFromInstance` a DOM node that must keep living a DOM life.** Discovery walks the
 node's prototype chain, and past the component's own class that chain is the engine's: happy-dom's
@@ -1508,15 +1511,22 @@ 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 spec file that scheduled it and up to five
-frames), 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:
+`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
+`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:
 
 ```ts
 setupAutoSpy({ strayTimers: true, onStrayTimers: ({ timers }) => expect(timers).toEqual([]) });
 ```
 
+`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`. A handler that prints its own message should print `kind`, `delay` 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.
 
@@ -3883,6 +3893,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-unregistered-inject-spy`      | `error` | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `prefer-render-shallow`           | `warn`  | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `prefer-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`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
@@ -3910,14 +3921,14 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `prefer-native-spy-api`           | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
-Forty-eight rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+Forty-nine rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `prefer-create-mock`, `no-instance-lifecycle-spy`,
-`prefer-set-inputs` and `no-unasserted-argument`**; five fix on their own, eighteen offer suggestions. Forty-five are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
+`prefer-set-inputs`, `no-unasserted-argument` and `prefer-spy-on-own-method`**; six fix on their own, nineteen offer suggestions. Forty-six are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
 `no-unknown-use-value-key` read types, and all three report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
 builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. The
-seven `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
+eight `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
 about the _kind_ of finding: every other rule names something wrong or dead, while this one names a
 file that could render more cheaply, and `renderShallow` is a migration a suite either takes or does
 not. At `error` the plugin would gate that migration — 491 findings across 398 of one consumer's
@@ -3940,7 +3951,8 @@ repair _needs_ rather than on its evidence: both of its readings are facts out o
 subject some other test in the same file pins with `toHaveBeenCalledWith`, a title saying `with` over
 a body whose every assertion is a bare call — but the repair is the argument list the test should
 have named, which is the one thing the rule cannot supply. Every `error` here names an edit or names
-a helper; this one names a question for the author. Set any of the seven `warn`s to `'error'` once the batch is done. Three of
+a helper; this one names a question for the author. `prefer-spy-on-own-method` names a shorter spelling of a correct call — the
+`createSpyFromInstance` it reports does exactly what the helper does — and its exact shapes carry a fix. Set any of the eight `warn`s to `'error'` once the batch is done. Three of
 them can report on a _correct_ project, and only one has an option:
 `jasmine-namespace-without-entry` takes `['error', { setupModules: ['./test-setup'] }]`, naming the
 file where `enableJasmineCompat()` is called; `prefer-native-spy-api` goes `'off'` for as long as a

package/CHANGELOG.md

@@ -10,6 +10,51 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.30.0] - 2026-09-25
+
+### Added
+
+- **`prefer-spy-on-own-method`, in `recommended` at `warn`.** It finds the long spelling of the two
+  5.29 helpers, which a text search misses once the call spans several lines:
+  `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` — is
+  `spyOnOwnMethod(x, 'm')`, and the same whitelist with `returns: { m: undefined }` is
+  `spyOnVoidMethod(x, 'm')`. Both are exact, so `--fix` rewrites the call and every `v.m` read, imports
+  the helper beside the factory and drops the factory's import once nothing else uses it. A
+  `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed,
+  whose discovery also spies every other method, is offered as a suggestion only on a real event or
+  element (`new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement`, one name away
+  included), never on a double. `warn`, because the call it reports is correct. `/eslint-plugin`
+  grows 51.61 → 53.56 kB min+gzip (+1.96 kB, +3.8 %), all of it this rule: the fixer that follows
+  every `v.m` read, rewrites imports and the `Spy<X>` annotation. The plugin runs in the linter, never
+  in a test, and no runtime entry imports it.
+
+### Fixed
+
+- **A stray timer's origin names the code that scheduled it, not the tracking wrapper.** Built from
+  `dist`, the report quoted `at captureOrigin (…/node_modules/vitest-auto-spy/dist/setup.js)`: the
+  filter for the wrapper's own frames matched the source file name, which the bundle does not have,
+  and twelve frames ran out inside a zone or an rxjs scheduler before the first line outside
+  dependencies, so the fallback quoted the wrapper. The stack is now cut at the installed
+  `setTimeout` / `setInterval` / `requestAnimationFrame` wrapper and taken forty frames deep below it;
+  the package's own frames are never quoted, and when the call came from dependencies only, their
+  frames stand in. The same `dist` filter now applies to stray listeners, console calls and
+  rejections. A flaky stray that shows up only under a slow coverage run is now actionable from the
+  first report.
+- **`StrayTimer` carries the `delay`, and the `--detect-async-leaks` warning prints it.** Each
+  timeout and interval in `describeStrayTimers()` and in `onStrayTimers`' `timers` now has the delay
+  it was scheduled with (a frame has none), and the warning reads `timeout (300 ms) from …` instead
+  of `timeout from …`. An additive field; a handler that prints its own message should print `kind`,
+  `delay` and `frames[0]`.
+
+### Docs
+
+- **`AGENTS.md` says which entry `spyOnOwnMethod` and `spyOnVoidMethod` come from.** The §2
+  introduction sat in Angular-flavoured company, and `vitest-auto-spy/angular` has no core
+  re-export — an Angular-suite reader importing the helper there hit a missing export. The
+  paragraph now names the core entry (root, or the runner entry off Vitest), as the docs-site
+  page already does.
+
 ## [5.29.0] - 2026-09-24
 
 ### Added
@@ -7845,7 +7890,8 @@ by hand there, in more than one place, by more than one person.
   `mockAccessorsProp`.
 - Dual ESM + CJS build with type declarations; 100% test coverage.
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.29.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.30.0...HEAD
+[5.30.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.29.0...v5.30.0
 [5.29.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.28.0...v5.29.0
 [5.28.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.27.0...v5.28.0
 [5.27.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.26.0...v5.27.0

package/README.md

@@ -81,7 +81,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored; `moduleNamespace(await importOriginal(), { passthrough: true })` is Vitest's `{ spy: true }` with `calledWith` on top, on any runner
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`, and `outOfType()` for the fixture that is outside its type on purpose
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — forty-eight rules in `vitest-auto-spy/eslint-plugin` (five `--fix`, eighteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
+- 📏 Lint rules and one-line test-run hygiene — forty-nine rules in `vitest-auto-spy/eslint-plugin` (six `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
 - 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-and-init) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
@@ -3206,7 +3206,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `guardGlobalPatches(reaction)`                                                                              | `/setup`                      | Name the test that redefined a property of `document` / `navigator` / `globalThis` as non-configurable                                                                                                                                                                                                                                                  |
 | `guardStrayConsole(reaction)`                                                                               | `/setup`                      | Fail a test that wrote to the console without absorbing it, and a file that wrote outside any test ([details](#test-run-hygiene))                                                                                                                                                                                                                       |
 | `withoutStrayTimerTracking(work)`                                                                           | `/setup`                      | Run setup work whose timers the stray-timer tracker neither counts nor cancels — jsdom schedules one per Web Storage write                                                                                                                                                                                                                              |
-| `describeStrayTimers()`                                                                                     | `/setup`                      | Every timer still pending, with its kind, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets. Blind to anything scheduled under fake timers — `vi.useFakeTimers()` assigns over the wrapper                                                                                                                      |
+| `describeStrayTimers()`                                                                                     | `/setup`                      | Every timer still pending, with its kind and delay, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets. Blind to anything scheduled under fake timers — `vi.useFakeTimers()` assigns over the wrapper                                                                                                            |
 | `guardPrototypePollution(reaction)`                                                                         | `/setup`                      | Name the test that left a key on `Object.prototype` — it stops later files collecting ([details](#test-run-hygiene))                                                                                                                                                                                                                                    |
 | `guardDocumentPollution(option)`                                                                            | `/setup`                      | Name the test that left an attribute on `<html>` / `<body>`, and put it back ([details](#test-run-hygiene))                                                                                                                                                                                                                                             |
 | `installPerTest(install)`                                                                                   | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                                                                                                                                                                                                                             |
@@ -3790,7 +3790,7 @@ export default [
 ];
 ```
 
-One of the four exceptions is `prefer-render-shallow`, which ships as a **`warn`**, and its reason is the kind
+One of the exceptions is `prefer-render-shallow`, which ships as a **`warn`**, and its reason is the kind
 of thing it says rather than how much it matters. Every other rule here names something wrong or dead
 — a double that drifts from its class, an assertion that never runs, a provider the container already
 dropped, a schema guarding nothing. That one names a file that could render more cheaply, which is a
@@ -3800,6 +3800,10 @@ it was measured against the rule reports 491 times across 398 files — a first
 have to answer with a project-wide `warn` of its own. A project that has decided to make the move sets
 it to `'error'` in the same one line that turns the others down.
 
+`prefer-spy-on-own-method` is graded on the same reading. The `createSpyFromInstance` call it reports is
+correct and does exactly what `spyOnOwnMethod` / `spyOnVoidMethod` does: the rule names a shorter
+spelling, not a defect, and its exact shapes carry a fix, so `'error'` is one `eslint --fix` away.
+
 The other two, `no-stub-class-double` and `no-structural-double` (5.5.0), are graded on the
 _evidence_ rather than on the kind of finding. Both report the same drift
 `prefer-create-spy-from-class` reports at `error` — a double whose shape was written by hand and is
@@ -3862,6 +3866,7 @@ export can never be.
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `prefer-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer 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 `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `no-hand-assigned-global`         |   `error`   | —                 | `global.fetch = vi.fn(…)` and any other double assigned to a global with no restore in a teardown hook → `mockValueProp(globalThis, …)` / `vi.stubGlobal` + `unstubGlobals`, `blockNetwork()` for a spec that only stays offline, `stubWebStorage()` for the storages                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `prefer-stub-response`            |   `error`   | —                 | an object literal cast to `Response` (`as Response`, `as unknown as Response`, `<Response>{ … }`) or a `createMock<Response>(…)` / `createAutoMock<Response>(…)` call → `stubResponse({ body })` from `/setup`, which builds the platform's own and answers every member; `Response` has to resolve to the global, so an Express handler's or a generated client's envelope of the same name is left alone                                                                                                                                                                                                                                                                                                                                                                                    |
@@ -3893,7 +3898,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Five of the forty-eight fix on their own, eighteen offer suggestions**, and the split is not about how hard
+**Six of the forty-nine fix on their own, nineteen offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -4064,7 +4069,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the forty-eight rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the forty-nine rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -4081,7 +4086,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of forty-eight rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of forty-nine rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 

package/dist/cli.js

@@ -3088,7 +3088,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.28.0";
+var EXPORT_MAP_VERSION = "5.29.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular/diagnostics vitest-auto-spy/angular/doubles vitest-auto-spy/angular/matchers vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin vitest-auto-spy/perf-reporter";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 20 21 22",

package/dist/eslint-plugin.cjs

@@ -478,8 +478,8 @@ var preferSettleDynamicImport = defineRule({
       }
       const messageId = consumption === "await" ? "awaitedDynamicImport" : "thenedDynamicImport";
       const suggestion = wrap(context, node);
-      const report = { node, messageId };
-      context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+      const report2 = { node, messageId };
+      context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
     }
   })
 });
@@ -966,8 +966,8 @@ var noCompileComponents = defineRule({
   create: (context) => inlinesResources(context) && !namesIgnoredComponent(context) ? {
     'CallExpression[callee.computed=false][callee.property.name="compileComponents"]': (node) => {
       const suggestion = removal(context, node);
-      const report = { node, messageId: "noCompileComponents" };
-      context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+      const report2 = { node, messageId: "noCompileComponents" };
+      context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
     }
   } : {}
 });
@@ -1792,8 +1792,8 @@ var preferCreateMock = defineRule({
         return;
       }
       const suggestion = buildFixture(context, node);
-      const report = { node, messageId: "castFixture", data: { type } };
-      context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+      const report2 = { node, messageId: "castFixture", data: { type } };
+      context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
     }
   })
 });
@@ -1876,12 +1876,12 @@ var noMockCast = defineRule({
       const member = node.expression.property;
       const configured = isIdentifier(member) && CONFIGURATION_MEMBERS.has(member.name);
       const suggestion = readFromDi(context, node, node.expression);
-      const report = {
+      const report2 = {
         node,
         messageId: configured ? "configurationCast" : "mockCast",
         data: { member: context.sourceCode.getText(member), type }
       };
-      context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+      context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
     }
   })
 });
@@ -1981,7 +1981,7 @@ var preferObserverStub = defineRule({
     preferObserverStubOverRunner: "`{{observer}}` is being faked through the runner. `{{helper}}()` from `vitest-auto-spy/dom-stubs` replaces the whole of that and returns a handle rather than a static field: `observers.last.emit([{{entry}}(\u2026)])` drives the callback, `observers.last.targets` is what was observed, `observers.last.disconnected` is the teardown assertion, and `observers.instances.length` counts constructions \u2014 which is what a spy on the constructor was being counted for. Two things the runner form does not give you. It is not a constructor: `vi.fn().mockImplementation((callback) => ({ observe() {} }))` is an arrow, `new {{observer}}(callback)` inside the component cannot call it, and the `TypeError` lands in application code with the spec still looking correct. And it is not undone: `{{helper}}()` registers its undo with `restoreMockedProps()`, which `setupAutoSpy()` runs after every test, so nothing has to remember `vi.unstubAllGlobals()` or an `afterEach`."
   },
   create: (context) => {
-    const report = (node, target, messageId) => context.report({ node, messageId, data: target });
+    const report2 = (node, target, messageId) => context.report({ node, messageId, data: target });
     const spiedObserver = (node) => {
       const target = node.arguments[0];
       return target !== void 0 && isGlobalReceiver(target) ? observerNamed(node.arguments[1]) : void 0;
@@ -1990,7 +1990,7 @@ var preferObserverStub = defineRule({
       AssignmentExpression: (node) => {
         const target = observerOn(node.left);
         if (target !== void 0 && isDouble(context, node.right)) {
-          report(node, target, "preferObserverStub");
+          report2(node, target, "preferObserverStub");
         }
       },
       CallExpression: (node) => {
@@ -1998,13 +1998,13 @@ var preferObserverStub = defineRule({
           const stubbed = observerNamed(node.arguments[0]);
           const value = node.arguments[1];
           if (stubbed !== void 0 && value !== void 0 && isDouble(context, value)) {
-            report(node, stubbed, "preferObserverStubOverRunner");
+            report2(node, stubbed, "preferObserverStubOverRunner");
           }
           return;
         }
         const spied = isRunnerCall(node, SPY_ON3) ? spiedObserver(node) : void 0;
         if (spied !== void 0) {
-          report(node, spied, "preferObserverStubOverRunner");
+          report2(node, spied, "preferObserverStubOverRunner");
         }
       }
     };
@@ -2387,7 +2387,7 @@ var preferNativeSpyApi = defineRule({
     preferNativeSpyApi: "`{{from}}` is the compatibility layer speaking; `{{to}}` is what this library calls the same thing, and the only spelling the rest of its documentation uses. The layer is a bridge \u2014 it exists so a `jasmine-auto-spies` suite runs before it is rewritten \u2014 so this is worth doing once the suite is green and not before: rewrite, then delete the `vitest-auto-spy/jasmine` import. `npx vitest-auto-spy codemod --from jasmine` does the whole suite in one pass. The edit is applied only where the receiver came out of one of this library\u2019s factories; anywhere else the same rewrite is offered as a suggestion, because a `.calls` on somebody else\u2019s object is somebody else\u2019s method."
   },
   create: (context) => {
-    const report = (rewrite2, spy) => {
+    const report2 = (rewrite2, spy) => {
       if (!rewrite2) {
         return;
       }
@@ -2398,8 +2398,8 @@ var preferNativeSpyApi = defineRule({
       );
     };
     return {
-      'MemberExpression[property.name="and"]': (node) => report(andRewrite(context, node), node.object),
-      'MemberExpression[property.name="calls"]': (node) => report(callsRewrite(context, node), node.object)
+      'MemberExpression[property.name="and"]': (node) => report2(andRewrite(context, node), node.object),
+      'MemberExpression[property.name="calls"]': (node) => report2(callsRewrite(context, node), node.object)
     };
   }
 });
@@ -2416,15 +2416,15 @@ var noJasmineGlobals = defineRule({
   },
   create: (context) => ({
     'MemberExpression[object.name="jasmine"]': (node) => {
-      const report = jasmineMemberReport(context, node);
-      if (report) {
-        context.report({ node, ...report });
+      const report2 = jasmineMemberReport(context, node);
+      if (report2) {
+        context.report({ node, ...report2 });
       }
     },
     [BARE_GLOBAL_SELECTOR]: (node) => {
-      const report = bareGlobalReport(context, node);
-      if (report) {
-        context.report({ node, ...report });
+      const report2 = bareGlobalReport(context, node);
+      if (report2) {
+        context.report({ node, ...report2 });
       }
     },
     'MemberExpression[property.name="withContext"]': (node) => {
@@ -2736,12 +2736,12 @@ function describeReport(context, finding, dead) {
   const { fn, hook, node, placement, reset } = finding;
   const target = placement.statement ?? hookStatement(fn);
   const data = { flag: FLAG[reset.kind], hook };
-  const report = { data, messageId: dead ? "deadReset" : "repeatedReset", node };
+  const report2 = { data, messageId: dead ? "deadReset" : "repeatedReset", node };
   if (target === void 0) {
-    return report;
+    return report2;
   }
   const desc = placement.statement ? "Delete this reset" : `Delete this reset, and the ${hook} it is the whole of`;
-  return dead ? { ...report, fix: removal2(context, target) } : { ...report, suggest: [{ desc, fix: removal2(context, target) }] };
+  return dead ? { ...report2, fix: removal2(context, target) } : { ...report2, suggest: [{ desc, fix: removal2(context, target) }] };
 }
 var noRedundantMockReset = defineRule({
   anchor: "-a-double-more-than-one-spec-uses",
@@ -3041,12 +3041,12 @@ var noOverriddenProvider = defineRule({
     return {
       ArrayExpression: (node) => {
         overriddenProviders(context, node).forEach(({ element, token, kind, survivor }) => {
-          const report = {
+          const report2 = {
             node: element,
             messageId: OVERRIDE_MESSAGES[kind],
             data: { token, line: String(survivor.loc.start.line) }
           };
-          context.report(kind === "duplicate" ? { ...report, suggest: [deleteProviderSuggestion(context, element, token)] } : report);
+          context.report(kind === "duplicate" ? { ...report2, suggest: [deleteProviderSuggestion(context, element, token)] } : report2);
         });
         if (isTestingModuleProviders(node)) {
           registrations.push(...survivingRegistrations(context, node));
@@ -3745,8 +3745,8 @@ var noReflectMemberAccess = defineRule({
       if (writes && isDouble2(context, target)) {
         const data = { key, target: context.sourceCode.getText(target) };
         const suggestion = restoreSuggestion(context, node);
-        const report = { node, messageId: "reflectSetOnDouble", data };
-        context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+        const report2 = { node, messageId: "reflectSetOnDouble", data };
+        context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
         return;
       }
       const messageId = writes ? isFixtureLiteral(context, target) ? "reflectSetOnFixture" : "reflectSet" : "reflectGet";
@@ -4070,8 +4070,8 @@ var preferSetInputs = defineRule({
         }
         const callback = enclosingFunction(node);
         const rewritable = callback && isHookCallback(callback) && bindingState(context.sourceCode.getScope(node), HELPER4) !== "taken" ? callback : void 0;
-        const report = { node, messageId: "preferSetInputs" };
-        context.report(rewritable ? { ...report, suggest: [{ desc: EDIT, fix: rewrite(context, run, rewritable) }] } : report);
+        const report2 = { node, messageId: "preferSetInputs" };
+        context.report(rewritable ? { ...report2, suggest: [{ desc: EDIT, fix: rewrite(context, run, rewritable) }] } : report2);
       }
     };
   }
@@ -4275,9 +4275,9 @@ function reportBlock(context, block, names) {
       subject: context.sourceCode.getText(subject)
     };
     const statement = node.parent;
-    const report = { data, messageId: "noRedundantSmokeTest", node };
+    const report2 = { data, messageId: "noRedundantSmokeTest", node };
     context.report(
-      isExpressionStatement(statement) ? { ...report, suggest: [{ desc: "Remove this test", fix: removal3(context, statement) }] } : report
+      isExpressionStatement(statement) ? { ...report2, suggest: [{ desc: "Remove this test", fix: removal3(context, statement) }] } : report2
     );
   });
 }
@@ -4330,6 +4330,227 @@ var noRedundantSmokeTest = defineRule({
   }
 });
 
+// src/lib/eslint/spy-on-own-method.ts
+var FACTORY = "createSpyFromInstance";
+var OWN = "spyOnOwnMethod";
+var VOID = "spyOnVoidMethod";
+var CORE_ENTRIES = new Set(
+  ["", "/bun", "/bun-angular", "/node", "/rstest", "/react", "/vue", "/svelte"].map((entry) => `${PACKAGE}${entry}`)
+);
+var METHOD_NAME = /^[$A-Z_a-z][\w$]*$/;
+var EVENT_CONSTRUCTOR = /^[A-Za-z]*Event$/;
+var DOM_GLOBALS = /* @__PURE__ */ new Set(["document", "window"]);
+var NODE_FACTORIES = /* @__PURE__ */ new Set(["createElement", "createElementNS", "createEvent", "getElementById", "querySelector"]);
+var NODE_MEMBERS = /* @__PURE__ */ new Set(["body", "documentElement"]);
+var FIXTURE_NAME2 = /fixture$/i;
+var DECLARATION_KINDS = /* @__PURE__ */ new Set(["const", "let", "var"]);
+function isObjectPattern(node) {
+  return node.type === "ObjectPattern";
+}
+function isUnwrapped(node) {
+  return isCast(node) || node.type === "TSNonNullExpression";
+}
+function unwrap(node) {
+  return isUnwrapped(node) ? node.expression : node;
+}
+function methodString(node) {
+  const value = node.type === "Literal" ? Reflect.get(node, "value") : void 0;
+  return typeof value === "string" && METHOD_NAME.test(value) ? value : void 0;
+}
+function listedMethod(value) {
+  const list = unwrap(value);
+  const elements = isArrayExpression(list) ? list.elements : [];
+  const names = elements.filter((element) => element !== null).map(methodString);
+  return elements.length === 1 ? names[0] : void 0;
+}
+function isUndefined(node) {
+  return isIdentifier(node) && node.name === "undefined";
+}
+function seededVoid(value) {
+  const entries2 = isObjectExpression(value) ? value.properties : [];
+  const seeds = entries2.filter((entry) => propertyName(entry) !== void 0 && isUndefined(propertyValue(entry)));
+  const names = seeds.map((entry) => String(propertyName(entry))).filter((name) => METHOD_NAME.test(name));
+  return entries2.length === 1 ? names[0] : void 0;
+}
+function seedOf(options) {
+  if (!isObjectExpression(options)) {
+    return void 0;
+  }
+  const keys = options.properties.map(propertyName);
+  const listed = findProperty(options, "onlyMethodsToSpyOn");
+  const method = listed ? listedMethod(listed.value) : void 0;
+  const returns = findProperty(options, "returns");
+  const seeded = returns ? seededVoid(returns.value) : void 0;
+  const passthrough = findProperty(options, "passthrough")?.value;
+  if (keys.length === 1 && seeded !== void 0) {
+    return { helper: VOID, method: seeded, exact: false };
+  }
+  if (keys.length !== 2 || method === void 0) {
+    return void 0;
+  }
+  if (passthrough?.type === "Literal" && Reflect.get(passthrough, "value") === true) {
+    return { helper: OWN, method, exact: true };
+  }
+  return seeded === method ? { helper: VOID, method, exact: true } : void 0;
+}
+function readsMethod(member, method) {
+  const named = member.computed ? methodString(member.property) : memberName(member);
+  const { parent } = member;
+  return named === method && !(isAssignmentExpression(parent) && parent.left === member);
+}
+function isRealObject(scope, node, follow) {
+  const value = unwrap(node);
+  if (isIdentifier(value)) {
+    const bound = follow ? boundValueOf(scope, value) : void 0;
+    return bound ? isRealObject(scope, bound, false) : DOM_GLOBALS.has(value.name) && bindingState(scope, value.name) === "free";
+  }
+  if (isNewExpression(value)) {
+    return isIdentifier(value.callee) && EVENT_CONSTRUCTOR.test(value.callee.name) && bindingState(scope, value.callee.name) === "free";
+  }
+  if (isCallExpression(value)) {
+    return isMemberExpression(value.callee) && NODE_FACTORIES.has(String(memberName(value.callee))) && isRealObject(scope, value.callee.object, follow);
+  }
+  const name = memberName(value);
+  if (isMemberExpression(value) && name === "nativeElement") {
+    return isRenderedBy(value.object);
+  }
+  return isMemberExpression(value) && NODE_MEMBERS.has(String(name)) && isRealObject(scope, value.object, follow);
+}
+function isRenderedBy(node) {
+  if (isIdentifier(node)) {
+    return FIXTURE_NAME2.test(node.name);
+  }
+  return memberName(node) === "debugElement" || isCallExpression(node) && memberName(node.callee) === "query";
+}
+function annotationEdit(context, id, method) {
+  const annotation = id.typeAnnotation?.typeAnnotation;
+  if (!annotation) {
+    return { edits: [], typed: false, blocked: false };
+  }
+  const { sourceCode } = context;
+  const spy = isTypeReference(annotation) && sourceCode.getText(annotation.typeName) === "Spy" && annotation.typeArguments?.params.length === 1;
+  const edits = spy ? [[annotation, `${sourceCode.getText(annotation)}['${method}']`]] : [];
+  return { edits, typed: true, blocked: !spy };
+}
+function variableRewrite(context, call, id, method) {
+  const variable = findBinding(context.sourceCode.getScope(call), id.name);
+  const declarator = variable?.defs.map((definition) => definition.node).find(isVariableDeclarator);
+  if (!variable || !declarator || !isIdentifier(declarator.id)) {
+    return void 0;
+  }
+  const declaration = declarator.parent;
+  const writes = variable.references.filter((reference) => reference.writeExpr);
+  const members = variable.references.flatMap((reference) => reference.writeExpr ? [] : [reference.identifier.parent]);
+  const reads = members.filter((member) => isMemberExpression(member) && readsMethod(member, method));
+  if (writes.length !== 1 || !writes.every((write) => write.writeExpr === call) || reads.length !== members.length || !DECLARATION_KINDS.has(String(Reflect.get(declaration, "kind"))) || declaration.parent.type === "ExportNamedDeclaration") {
+    return void 0;
+  }
+  const annotation = annotationEdit(context, declarator.id, method);
+  return { ...annotation, target: call, edits: [...annotation.edits, ...reads.map((read) => [read, id.name])] };
+}
+function patternRewrite(call, pattern, method) {
+  const [property] = pattern.properties;
+  const local = property && propertyName(property) === method ? propertyValue(property) : void 0;
+  if (pattern.properties.length !== 1 || !local || !isIdentifier(local)) {
+    return void 0;
+  }
+  return { target: call, edits: [[pattern, local.name]], typed: false, blocked: pattern.typeAnnotation !== void 0 };
+}
+function rewriteOf(context, call, method) {
+  const { parent } = call;
+  if (isExpressionStatement(parent)) {
+    return { target: call, edits: [], typed: false, blocked: false };
+  }
+  if (isMemberExpression(parent) && parent.object === call) {
+    return readsMethod(parent, method) ? { target: parent, edits: [], typed: false, blocked: false } : void 0;
+  }
+  if (isVariableDeclarator(parent) && isObjectPattern(parent.id)) {
+    return patternRewrite(call, parent.id, method);
+  }
+  if (isVariableDeclarator(parent) && isIdentifier(parent.id)) {
+    return variableRewrite(context, call, parent.id, method);
+  }
+  return isAssignmentExpression(parent) && isIdentifier(parent.left) && isExpressionStatement(parent.parent) ? variableRewrite(context, call, parent.left, method) : void 0;
+}
+function swapSpecifier(context, fixer, specifier, helper) {
+  const { specifiers } = specifier.parent;
+  const others = specifiers.filter((candidate) => candidate !== specifier).map((candidate) => context.sourceCode.getText(candidate));
+  const keys = others.map((text) => text.toLowerCase());
+  const ordered = keys.every((key, index) => keys.slice(0, index).every((before2) => before2 <= key));
+  if (!ordered || !specifiers.every(isNamedImportSpecifier)) {
+    return fixer.replaceText(specifier, helper);
+  }
+  others.splice(keys.filter((key) => key < helper.toLowerCase()).length, 0, helper);
+  return fixer.replaceTextRange(
+    [Math.min(...specifiers.map((candidate) => candidate.range[0])), Math.max(...specifiers.map((candidate) => candidate.range[1]))],
+    others.join(", ")
+  );
+}
+function importEdits(context, fixer, call, helper, factory) {
+  const specifier = factory ? importSpecifierOf(factory) : void 0;
+  const module = specifier ? String(specifier.parent.source.value) : PACKAGE;
+  const home = CORE_ENTRIES.has(module) ? module : PACKAGE;
+  const orphaned = factory?.references.length === 1;
+  const drop = orphaned ? dropNamedImport(context.sourceCode, fixer, factory) : void 0;
+  const dropped = drop ? [drop] : [];
+  if (bindingState(context.sourceCode.getScope(call), helper) === "imported") {
+    return dropped;
+  }
+  if (specifier && orphaned && home === module) {
+    return [swapSpecifier(context, fixer, specifier, helper)];
+  }
+  return [importNamed(fixer, call, helper, home), ...dropped];
+}
+var MESSAGES = {
+  ownMethod: "`createSpyFromInstance(\u2026, { onlyMethodsToSpyOn: ['{{method}}'], passthrough: true })`, read for `{{method}}` alone, says nothing `spyOnOwnMethod(target, '{{method}}')` does not: one method recorded and calling through, the rest of the object real, the spy handed back directly. Name the method once.",
+  voidExact: "`createSpyFromInstance(\u2026, { onlyMethodsToSpyOn: ['{{method}}'], returns: { {{method}}: undefined } })` names `{{method}}` twice to say what `spyOnVoidMethod(target, '{{method}}')` says once: one void method recorded, answering `undefined`, the rest real.",
+  voidOnRealObject: "This seeds `{{method}}` of a real event or element with `undefined`, and discovery spies every other method of it too \u2014 on a DOM node that reaches the engine's own internals. `spyOnVoidMethod(target, '{{method}}')` patches `{{method}}` alone. A suggestion, not a fix: check the test does not rely on another method being stubbed."
+};
+function report(context, call, target, seed, rewrite2) {
+  const scope = context.sourceCode.getScope(call);
+  const text = `${seed.helper}(${context.sourceCode.getText(target)}, '${seed.method}')`;
+  const factory = findBinding(scope, FACTORY);
+  const fix = (fixer) => [
+    fixer.replaceText(rewrite2.target, text),
+    ...rewrite2.edits.map(([node, replacement]) => fixer.replaceText(node, replacement)),
+    ...importEdits(context, fixer, call, seed.helper, factory)
+  ];
+  const fixable = !rewrite2.blocked && !call.typeArguments && bindingState(scope, seed.helper) !== "taken";
+  const safe = seed.exact && !rewrite2.typed;
+  const messageId = seed.helper === OWN ? "ownMethod" : seed.exact ? "voidExact" : "voidOnRealObject";
+  context.report({
+    node: call,
+    messageId,
+    data: { method: seed.method },
+    ...fixable && safe ? { fix } : {},
+    ...fixable && !safe ? { suggest: [{ desc: `Replace with ${text}`, fix }] } : {}
+  });
+}
+var preferSpyOnOwnMethod = defineRule({
+  anchor: "-an-object-the-test-already-holds",
+  description: "Spy one method of a real object with spyOnOwnMethod / spyOnVoidMethod instead of a one-method createSpyFromInstance",
+  messages: MESSAGES,
+  fixable: true,
+  hasSuggestions: true,
+  create: (context) => ({
+    CallExpression: (call) => {
+      const [target, options, ...rest] = call.arguments;
+      if (!isIdentifier(call.callee) || call.callee.name !== FACTORY || !target || !options || rest.length > 0) {
+        return;
+      }
+      const scope = context.sourceCode.getScope(call);
+      const seed = seedOf(options);
+      if (!seed || bindingState(scope, FACTORY) === "taken" || !seed.exact && !isRealObject(scope, target, true)) {
+        return;
+      }
+      const rewrite2 = rewriteOf(context, call, seed.method);
+      if (rewrite2) {
+        report(context, call, target, seed, rewrite2);
+      }
+    }
+  })
+});
+
 // src/lib/eslint/stub-response.ts
 var RESPONSE = "Response";
 var TYPE_ARGUMENT_DOUBLES = /* @__PURE__ */ new Set(["createAutoMock", "createMock"]);
@@ -4781,8 +5002,8 @@ var noExpectInSubscribe = defineRule({
       "Program:exit": () => {
         assertions.forEach(({ count, repair }, subscribeCall) => {
           const suggestion = rewrites.get(subscribeCall);
-          const report = { node: subscribeCall, messageId: repair, data: { count: String(count) } };
-          context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+          const report2 = { node: subscribeCall, messageId: repair, data: { count: String(count) } };
+          context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
         });
       }
     };
@@ -4958,8 +5179,8 @@ var noImportTimeSpread = defineRule({
       }
       const suggestion = lazyValueSuggestion(context, node);
       const messageId = spreadFailureMode(node) === "object" ? "noImportTimeSpreadObject" : "noImportTimeSpread";
-      const report = { node, messageId, data: { name: imported.name } };
-      context.report(suggestion ? { ...report, suggest: [suggestion] } : report);
+      const report2 = { node, messageId, data: { name: imported.name } };
+      context.report(suggestion ? { ...report2, suggest: [suggestion] } : report2);
     }
   })
 });
@@ -5031,6 +5252,7 @@ var rules = {
   "no-redundant-smoke-test": noRedundantSmokeTest,
   "no-self-called-spy": noSelfCalledSpy,
   "prefer-set-inputs": preferSetInputs,
+  "prefer-spy-on-own-method": preferSpyOnOwnMethod,
   ...jasmineRules
 };
 
@@ -5081,6 +5303,7 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-redundant-mock-reset`]: "error",
   [`${PLUGIN_NAME}/no-unasserted-argument`]: "warn",
   [`${PLUGIN_NAME}/prefer-set-inputs`]: "warn",
+  [`${PLUGIN_NAME}/prefer-spy-on-own-method`]: "warn",
   [`${PLUGIN_NAME}/jasmine-namespace-without-entry`]: "error",
   [`${PLUGIN_NAME}/no-jasmine-globals`]: "error",
   [`${PLUGIN_NAME}/no-save-arguments-by-value`]: "error",

package/dist/setup.d.ts

@@ -575,16 +575,24 @@ interface SchedulerHost {
 /** One outstanding callback, and where it came from — what {@link describeStrayTimers} hands back. */
 interface StrayTimer {
     readonly kind: 'frame' | 'interval' | 'timeout';
+    /** The delay a timeout or interval was scheduled with, in milliseconds; `undefined` for a frame. */
+    readonly delay?: number;
     /** The spec file that was running when it was scheduled; `undefined` outside a Vitest file. */
     readonly file: string | undefined;
-    /** Up to five frames of the scheduling call, those outside dependencies first. */
+    /**
+     * Up to five frames of the scheduling call, starting below the tracking wrapper: those outside
+     * dependencies first, then — when the call came from dependencies only — theirs, never this package's.
+     */
     readonly frames: readonly string[];
 }
 /** The stack is taken now and formatted only if the callback turns out to be a stray. */
 interface Origin {
     readonly kind: StrayTimer['kind'];
+    readonly delay: number | undefined;
     readonly file: unknown;
-    readonly trace: Error;
+    readonly trace: {
+        readonly stack?: string;
+    };
 }
 /** Undo the wrapping installed by {@link trackStrayTimers}, cancelling anything still outstanding. */
 type StopTrackingTimers = () => void;

package/dist/setup.js

@@ -1102,12 +1102,15 @@ function currentSpecFile() {
 
 // src/lib/stack-frames.ts
 var FOREIGN_FRAME = /node_modules|node:internal|\(node:/;
+var LIBRARY_FRAME = /[/\\]vitest-auto-spy[/\\]dist[/\\]|[/\\]\.vite[/\\]deps[^/\\]*[/\\]vitest-auto-spy[^/\\]*\.js/;
 function stackFrames(stack) {
   return String(stack).split("\n").filter((line) => /^\s*at\s/.test(line)).map((line) => line.trim());
 }
 function ownFrames(frames, limit) {
-  const own = frames.filter((frame) => !FOREIGN_FRAME.test(frame));
-  return (own.length > 0 ? own : frames).slice(0, limit);
+  const outside = frames.filter((frame) => !LIBRARY_FRAME.test(frame));
+  const own = outside.filter((frame) => !FOREIGN_FRAME.test(frame));
+  const shown = [own, outside].find((candidates) => candidates.length > 0) ?? frames;
+  return shown.slice(0, limit);
 }
 
 // src/lib/stray-listeners.ts
@@ -2357,7 +2360,8 @@ function defaultHost2() {
 function defineScheduler(host, name, value) {
   Object.defineProperty(host, name, { configurable: true, writable: true, value });
 }
-function scheduleTracked(schedule, callback, handles, kind, numeric) {
+function scheduleTracked(schedule, callback, handles, origin, numeric) {
+  const { kind } = origin;
   const oneShot = kind !== "interval";
   let handle;
   const forgetting = (...args) => {
@@ -2369,19 +2373,32 @@ function scheduleTracked(schedule, callback, handles, kind, numeric) {
     callback(...args);
   };
   handle = schedule(oneShot && typeof callback === "function" ? forgetting : callback);
-  handles.set(handle, captureOrigin2(kind));
+  handles.set(handle, captureOrigin2(origin));
   const id = numeric && numericIdOf(handle);
   if (numeric && id !== void 0) {
     numeric.set(id, handle);
   }
   return handle;
 }
-function captureOrigin2(kind) {
+var ORIGIN_DEPTH = 40;
+function captureOrigin2({ kind, delay, boundary }) {
   const limit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 12;
-  const trace = new Error();
+  Error.stackTraceLimit = ORIGIN_DEPTH;
+  const trace = captureTrace(boundary);
   Error.stackTraceLimit = limit;
-  return { kind, file: currentSpecFile(), trace };
+  return { kind, delay, file: currentSpecFile(), trace };
+}
+function captureTrace(boundary) {
+  if (typeof Error.captureStackTrace !== "function") {
+    return new Error();
+  }
+  const holder = {};
+  Error.captureStackTrace(holder, boundary);
+  return holder;
+}
+function delayOf(value) {
+  const delay = Number(value);
+  return Number.isFinite(delay) && delay > 0 ? delay : 0;
 }
 function numericIdOf(handle) {
   return typeof handle === "object" && handle !== null && Symbol.toPrimitive in handle ? Number(handle) : void 0;
@@ -2415,7 +2432,8 @@ function wrapTimerScheduler(host, name, sets) {
       sets.opaque.add(handle);
       return handle;
     }
-    return scheduleTracked((tracked) => original(tracked, ...rest), callback, sets.handles, kind, sets.numeric);
+    const origin = { kind, delay: delayOf(rest[0]), boundary: wrapper };
+    return scheduleTracked((tracked) => original(tracked, ...rest), callback, sets.handles, origin, sets.numeric);
   });
   if (promisified !== void 0) {
     Object.defineProperty(wrapper, PROMISIFY_CUSTOM, { configurable: true, value: promisified });
@@ -2441,7 +2459,7 @@ function wrapFrameScheduler(host, frames, pause) {
     return () => void 0;
   }
   const request = defineHelper(
-    (callback) => pause.paused ? original(callback) : scheduleTracked((tracked) => original(tracked), callback, frames, "frame")
+    (callback) => pause.paused ? original(callback) : scheduleTracked((tracked) => original(tracked), callback, frames, { kind: "frame", delay: void 0, boundary: request })
   );
   markOwnedPatch(request);
   host.requestAnimationFrame = request;
@@ -2535,9 +2553,10 @@ function pendingHandles(tracked) {
   return pending;
 }
 var OWN_MODULE_FRAME2 = /stray-timers\.[jt]s/;
-function describeOrigin({ kind, file, trace }) {
+function describeOrigin({ kind, delay, file, trace }) {
   const frames = stackFrames(trace.stack).filter((frame) => !OWN_MODULE_FRAME2.test(frame));
-  return { kind, file: typeof file === "string" ? file : void 0, frames: ownFrames(frames, 5) };
+  const described = { kind, file: typeof file === "string" ? file : void 0, frames: ownFrames(frames, 5) };
+  return delay === void 0 ? described : { ...described, delay };
 }
 function describeStrayTimers(host = defaultHost2()) {
   const tracked = registry5().get(host);
@@ -2729,8 +2748,11 @@ function warnAboutSuppressedLeaks(cancelled, write = writeWarning, timers = [])
   );
 }
 function describeTimerOrigins(timers) {
-  const lines = timers.slice(0, 3).map(({ kind, file, frames }) => `
-  - ${kind} from ${file ?? "no spec file"} ${frames[0] ?? ""}`.trimEnd());
+  const lines = timers.slice(0, 3).map(({ kind, delay, file, frames }) => {
+    const scheduled = delay === void 0 ? kind : `${kind} (${delay} ms)`;
+    return `
+  - ${scheduled} from ${file ?? "no spec file"} ${frames[0] ?? ""}`.trimEnd();
+  });
   return lines.length > 0 ? `
 Scheduled at:${lines.join("")}` : "";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.29.0",
+  "version": "5.30.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",

package/skills/vitest-auto-spy/SKILL.md

@@ -167,126 +167,126 @@ it('loads', async () => {
 
 ## Reach for these before hand-rolling
 
-| Situation                                                                                         | Helper                                                                                                                                                                            |
-| ------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| a `signal()` / `computed()` field on the class under test                                         | `mockSignalProp(obj, prop, initial)` — writes through a writable one, `asReadonly()` included; an `input()` is refused                                                            |
-| a resource field, when the HTTP round trip is not the point                                       | `mockResourceProp(obj, prop, initial)` — `set` / `fail` / `loading`; `value()` after `fail()` throws                                                                              |
-| the HTTP round trip _is_ the point                                                                | `expectRequest(url).flush(body)` — `/angular-http`, settling included                                                                                                             |
-| a component or service that reads `ActivatedRoute`                                                | `provideActivatedRoute({ params })`, then `injectActivatedRoute().setParams(…)` — `/angular-router`                                                                               |
-| a guard or a class built with `new` that takes the route                                          | `createActivatedRoute({ params })` — the same handle, no `TestBed`                                                                                                                |
-| a node:test suite whose heap grows all run                                                        | `trackNodeMocks()` — `/node`, a private MockTracker                                                                                                                               |
-| a Nest provider whose constructor keeps changing                                                  | `createNestUnit(Target, { expose })` — built from its DI metadata                                                                                                                 |
-| asserting a resource's value _and_ status together                                                | `registerResourceMatchers()` (`/angular/matchers`) → `toHaveResourceValue` / `toBeLoading`                                                                                        |
-| a callback or config object the code under test built                                             | `captureArg<T>()` in the assertion, then read `.value`; `{ where }` records only what it accepts                                                                                  |
-| an object the test already holds — a real service, a client, `TestBed.inject(X)`                  | `createSpyFromInstance(obj, config?)` — patches it in place, `restoreSpiedInstance` undoes it                                                                                     |
-| assert calls on a real object or service but keep it working                                      | `createSpyFromInstance(obj, { passthrough: true })` — real method runs until configured; not with `strict: true` on the same call                                                 |
-| one method of the object under test, recorded and still running                                   | `spyOnOwnMethod(sut, 'method')` — the `onlyMethodsToSpyOn` + `passthrough` packed; the drop-in for a bare banned `vi.spyOn`                                                       |
-| a native void method a handler is meant to call (`preventDefault`, `focus`)                       | `spyOnVoidMethod(event, 'preventDefault')` — records the call and seeds `undefined`, so `strict` does not throw on it                                                             |
-| a `vi.mock` factory's `vi.fn()` needs `calledWith` / `resolveWith`                                | `adoptMock(api.load).calledWith(7).resolveWith(…)` — same object, history kept                                                                                                    |
-| real module, one case configured                                                                  | `vi.mock('x', async (orig) => moduleNamespace(await orig(), { passthrough: true }))`                                                                                              |
-| feeding a stubbed `fetch`                                                                         | `vi.fn(async () => stubResponse({ body: data }))` from `/setup` — a real `Response`, no `as Response`; a body reads once                                                          |
-| a backend that answers the JSON literal `null`                                                    | `stubResponse({ body: null })` — the literal, not "no body"; `undefined` or an omitted `body` is the way to send none                                                             |
-| the code under test lazy-loads on a click and the spec has no promise                             | `await settleDynamicImport(() => import('./thing'))` — a bare `await import(…)` waits for the module, not for the handler's continuation                                          |
-| MSW handlers not answering under `setupAutoSpy({ blockNetwork: true })`                           | upgrade — `blockNetwork` now leaves `fetch` to MSW's interceptor; end the handlers with `http.all('*', () => HttpResponse.error())`                                               |
-| `mockDeep` member read by index, or an unmocked call that should fail                             | `mock.items[0].x = 1` makes a real array (re-read `mock.items` after); `mockDeep<T>({}, { fallbackMockImplementation: () => { throw … } })` — options are the **second** argument |
-| mocking `PrismaClient`                                                                            | `mockDeep<PrismaClient>()` + `resolveWith` / `rejectWith` / `resolveWithPerCall`; `$transaction.mockImplementation((run) => run(asInstance(prisma)))`                             |
-| `[Function] is not a spy or a call to a spy!` inside a Storybook `play`                           | import `expect` from `vitest` in that story file, or `setSpyEngine('runner')` from `/setup`                                                                                       |
-| `vi.spyOn(Class.prototype, 'x')` → `The property "x" is not defined on the object.`               | `x` is an instance field (arrow, signal) — `createSpyFromClass(C, { instanceMethodsToSpyOn: ['x'] })`                                                                             |
-| a spy or a `mock*Prop` patch leaking into the next `bun test` test                                | `/setup` is Vitest-only — preload `afterEach(() => { restoreMockedProps(); mock.restore(); })`                                                                                    |
-| a `calledWith` that is not matching and you cannot see why                                        | `explainSpy(spy, 'method')` from `/diagnostics` — configs, calls, which hit which                                                                                                 |
-| a method that has to throw — for all calls, or for some arguments                                 | `spy.m.failWith(err)` / `spy.m.calledWith(x).failWith(err)` — **not** `throwWith`                                                                                                 |
-| a `TestBed` spec on Vitest 4.1+, to drop `let` + `beforeEach`                                     | `extendWithAutoSpies(test, { cart: CartService })` (`/angular`)                                                                                                                   |
-| an `effect()` whose trigger is now a static signal                                                | `runEffect(effectRef)`                                                                                                                                                            |
-| the component constructs its own `IntersectionObserver`                                           | `stubIntersectionObserver()` (+ `Resize` / `Mutation`) — `last.host` is the callback’s 2nd argument                                                                               |
-| a green run exiting 1 with `AbortError` under happy-dom                                           | `setupAutoSpy({ blockNetwork: true })`                                                                                                                                            |
-| a real request going out of a unit run (`fetch`, XHR, `sendBeacon`)                               | `setupAutoSpy({ blockNetwork: true })` — `{ xhr: 'empty' }` for pings                                                                                                             |
-| timers or frames from a previous file failing this one                                            | `setupAutoSpy({ strayTimers: true })` — mutes `--detect-async-leaks`; blind under fake timers                                                                                     |
-| an assertion error in stderr, every test green and the run at 0                                   | `setupAutoSpy({ strayRejections: true })` — zone.js swallowed it                                                                                                                  |
-| a run getting slower the longer it goes, on `isolate: false`                                      | `setupAutoSpy({ pruneMockRegistry: true })` — the mock registry                                                                                                                   |
-| a listener or a replaced global from a previous file answering in this one, on `isolate: false`   | `setupAutoSpy({ strayListeners: true, restoreGlobals: true })`                                                                                                                    |
-| the same, piece by piece                                                                          | `trackStrayListeners` / `baselineStrayListeners` / `removeStrayListeners` / `countStrayListeners` / `describeStrayListeners`; `captureGlobalBaseline` / `restoreGlobals`          |
-| a storage spy still recording after `vi.restoreAllMocks()` under happy-dom                        | `restoreStorageSpies` — on by default; `restoreStorageSpies()` alone                                                                                                              |
-| a stream that must emit exactly these values and complete                                         | `await expectAllEmissions(source$)`                                                                                                                                               |
-| a fixture outside its type on purpose (the `null` a backend sends)                                | `outOfType<T>(value)` — no cast                                                                                                                                                   |
-| one setup file for the Angular unit-test builder and plain Vitest                                 | `if (!isAngularUnitTestBuilder()) TestBed.initTestEnvironment(…)`                                                                                                                 |
-| `JavaScript heap out of memory` on a suite of wide generated clients                              | nothing to configure — the default shares one placeholder per method name (215 B per untouched 100-method double); `lazySpies: 'proxy'` retains 19× more now                      |
-| `Cannot read properties of undefined (reading 'now')`                                             | `restoreTimerGlobals` — on by default                                                                                                                                             |
-| `localStorage.setItem is not a function`, or it is `undefined`                                    | `restoreWebStorage` — on by default; Vitest's global filter, Node 25+                                                                                                             |
-| a spy handed to an API typed against the real class                                               | `asInstance()` / `asSpy()`                                                                                                                                                        |
-| the code under test does `new X()` (a global, a vendor SDK)                                       | `mockConstructor(factory)` / `stubConstructor(obj, key, factory)`                                                                                                                 |
-| `X is not a constructor`, with a stack in production code                                         | same — a `vi.fn(() => …)` cannot serve `new`                                                                                                                                      |
-| waiting for a dynamic `import()` under fake timers                                                | `settleDynamicImport(() => import('…'))` / `flushEventLoop()`                                                                                                                     |
-| `addEventListener(…, { signal })` throwing about `EventTarget`                                    | `stubAbortController()`                                                                                                                                                           |
-| `codemod` reporting a truncated repository scan                                                   | `VITEST_AUTO_SPY_SCAN_CAP=<n>` — raises the 50 000-file cap                                                                                                                       |
-| a suite ported from Jest's `fakeTimers.enableGlobally`                                            | `setupAutoSpy({ globalFakeTimers: true })`                                                                                                                                        |
-| `toHaveBeenCalledBefore` across an auto-spy and a hand-written `vi.fn()`                          | `setSpyEngine('runner')` / `getSpyEngine()` — `/setup`, Vitest only                                                                                                               |
-| a nested `describe`'s `beforeAll` landing on real timers                                          | `setupFakeTimers(cfg, { betweenTests: true })`                                                                                                                                    |
-| setup hooks applying to the first spec file of a worker only                                      | the setup module is cached — run coverage with `--isolate`                                                                                                                        |
-| `fakeAsync` inside `test.concurrent`                                                              | `installProxyZonePatch({ scope: 'callback' })`                                                                                                                                    |
-| an assertion containing a date                                                                    | `mockSystemTime(iso)` — never `vi.spyOn(globalThis, 'Date')`                                                                                                                      |
-| a spec asserting on tick _order_ under a frozen clock                                             | `useCountingClock()`                                                                                                                                                              |
-| a dependency declared in the component's own `providers`                                          | `overrideComponentProvider(Cmp, Token)` — it verifies on the first fixture that the override applied                                                                              |
-| a double answering `undefined` for a method nobody configured                                     | `{ strict: true }`, or `setupAutoSpy({ strict: true })` suite-wide                                                                                                                |
-| a strict throw caught by a `try`/`catch` or an operator, the test still green                     | `setupAutoSpy({ swallowedStrictCalls: 'throw' })`; provoked on purpose — `takeStrictViolations()` from `/setup`                                                                   |
-| a strict double's getter answering `undefined`, or its `items$` never emitting                    | `setupAutoSpy({ unconfiguredReads: 'throw' })` reports it after the test; survey first with `onUnstubbedRead`                                                                     |
-| an `afterEach` that exists only to reset one spy                                                  | `using spy = createSpyFromClass(X)` — `[Symbol.dispose]` runs `resetAutoSpy`, which is `vi.resetAllMocks()` for one double                                                        |
-| a dead NgModule import, dead `schemas`, an unflushed HTTP request                                 | `enableAngularDiagnostics()` (`/angular/diagnostics`) in the setup file, after `initTestEnvironment`                                                                              |
-| the spy is provided but the component resolves its own, so the test runs the real service         | `enableAngularDiagnostics({ shadowedProviders })` or `assertNoShadowedProviders(Component, fixture)` — `/angular/diagnostics`                                                     |
-| "which collaborators did this actually inject?"                                                   | `trackInjections([A, TOKEN])` — providers plus the record, not `vi.mock`                                                                                                          |
-| `NG0303` / `NG0301` / `NG0304` from an imported NgModule                                          | `assertNgModuleScopes(Module)` — an AOT bundle stripped its scope                                                                                                                 |
-| `Cannot read properties of undefined (reading 'provide')` in `di_setup`                           | `assertComponentDefIntact(Cmp)` — a barrel chunk left a hole in `ɵcmp`                                                                                                            |
-| a focus assertion failing as `expected false to deeply equal true`                                | `registerFocusMatchers()` + `expect(el).toHaveFocus()`                                                                                                                            |
-| a collaborator passed as an argument, then asserted on                                            | `autoMocked<T>()` — typed `T & Spy<T>`                                                                                                                                            |
-| a `<video>` / `<audio>`: `play()` throws, `duration` is `NaN`                                     | `stubMediaElement({ duration })`, then `media.set(el, …)`                                                                                                                         |
-| a `vi.mock()` that silently did nothing under a bundler                                           | `assertMocked(ns, { specifier, exports })`                                                                                                                                        |
-| `No "default" export is defined on the mock`                                                      | `vi.mock('x', () => moduleNamespace({ … }))` — a `default` you spell out is kept                                                                                                  |
-| waiting for a `resource()` / an SDK to become ready                                               | `flushEventLoopUntil(() => …, { label })` — budgeted, not tuned                                                                                                                   |
-| `expected [ { at: 1, …(5) }, …(8) ] to deeply equal …`                                            | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                                                                           |
-| a stub that works only in the first test of the file                                              | `installPerTest(() => stub…())` — or install it in `beforeEach`                                                                                                                   |
-| a library failing every other run after a `defineProperty` on DOM                                 | `setupAutoSpy({ guardGlobals: 'throw' })` names the file — it sees an added name, not an existing one redefined                                                                   |
-| a block of files failing to collect, with no stack and zero failing tests                         | `setupAutoSpy()` names the file that left a key on `Object.prototype` (`prototypePollution`, on by default)                                                                       |
-| the same check in a suite that does not call `setupAutoSpy()`                                     | `guardPrototypePollution('throw')` from `/setup`                                                                                                                                  |
-| a spec failing only in a full run on an attribute of `<body>` / `<html>` another file left        | `setupAutoSpy({ documentPollution: 'throw' })` names the test and puts the document back (in `preset: 'strict'`)                                                                  |
-| the same document check without `setupAutoSpy()`                                                  | `guardDocumentPollution('throw')` from `/setup`                                                                                                                                   |
-| `A metric with the name … has already been registered` / `customElements.define` twice, at import | a module scope evaluated once per spec file under the Angular builder — guard the registration (`getSingleMetric`, `customElements.get`)                                          |
-| console output a test never asserted on (a `'warn'` from this library does not count)             | `setupAutoSpy({ strayConsole: 'throw' })` fails that test; absorb with `installConsoleSpies()` in `beforeEach`                                                                    |
-| every guard at its strictest grade in one line                                                    | `setupAutoSpy({ preset: 'strict' })` — plus `enableAngularDiagnostics()` from `/angular/diagnostics` for Angular                                                                  |
-| an `onlyMethodsToSpyOn` typo or `injectSpy` on a real instance that only warned                   | `setupAutoSpy({ misconfiguration: 'throw' })` throws at the call                                                                                                                  |
-| which file and call scheduled a timer that outlived its file                                      | `onStrayTimers: ({ timers }) => expect(timers).toEqual([])`, or `describeStrayTimers()` from `/setup`                                                                             |
-| stray timers charged to a file that only writes `localStorage` (jsdom)                            | `withoutStrayTimerTracking(() => seed())` from `/setup` — its timers are neither counted nor cancelled                                                                            |
-| `import { consoleErrorSpy }` silencing other files under `isolate: false`                         | `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` — the import installs once per worker                                                                  |
-| `Cannot set base providers because it has already been called`                                    | `setupAngularTestEnv({ zoneless, initZone, initZoneless })`                                                                                                                       |
-| a dependency behind an `InjectionToken`, with no class to spy                                     | `provideAutoSpyForToken(TOKEN)` + `injectSpy(TOKEN)`; a chained call → `{ selfReturning: ['channel'] }` as the third argument                                                     |
-| `Expected to be running in 'ProxyZone', but it was not found`                                     | `import 'vitest-auto-spy/zone'` (needs `globals: true`)                                                                                                                           |
-| `Property 'mockReturnValue' does not exist on type 'never'`                                       | upgrade — the spy no longer collapses on an unreadable return type                                                                                                                |
-| `TS2345` inside `mockReturnValue` / `mockImplementation` / `mockResolvedValue`                    | the stub is checked against the method's return type now — fix the stub, not the spy                                                                                              |
-| `TS2540: Cannot assign to 'x'` on a double whose runtime write works                              | `Spy<T>` keeps `readonly` on purpose — `mockValueProp(spy, 'x', v)`, which a spied **accessor** also needs                                                                        |
-| a signal-valued getter that `gettersToSpyOn` will not accept                                      | it accepts any key now; for a signal prefer `mockSignalProp`                                                                                                                      |
-| five `asInstance(…)` in one call, found one per `tsc` run                                         | `...asInstances(a, b, c, d, e)`                                                                                                                                                   |
-| `nextWith` demanding `HttpEvent<T>` on a generated client                                         | `asSpy<Client, { overload: 'first' }>(…)` / `Overload<M, 0>`                                                                                                                      |
-| `not assignable to parameter of type 'HttpEvent<…>'` in a stub of the real body                   | same thing — the helpers read the **last** overload; `{ overload: { m: 'first' } }`, not `@ts-expect-error`                                                                       |
-| a fixture that needs a nested object built by its own call                                        | `createMock<T>({ a: { b: 1 } })` — deep partial, still exact                                                                                                                      |
-| the same 100-line model literal copied into eight specs (`TS1117`)                                | one `createFixtureFactory<T>(defaults)`; specs call it with what they change                                                                                                      |
-| `'params' in link` ladders, or a cast, to pick a union branch                                     | `narrow.byKey(link, 'params')` / `narrow.observable(x)`                                                                                                                           |
-| `{ ...modelInstance, flag: true }` losing every getter                                            | `withOverrides(modelInstance, { flag: true })`                                                                                                                                    |
-| `NG0303` / `NG0304` / silence from a directive spec                                               | `createDirectiveHost({ template, scope: [Module] })`                                                                                                                              |
-| a hand-written `class MockChartComponent` restating a child's selector                            | `createComponentStub(ChartComponent)` (`/angular`) — selector, inputs, outputs read from `ɵcmp`                                                                                   |
-| a `TestingStorage` class for `localStorage` / `sessionStorage`                                    | `stubWebStorage('localStorage', { items })` from `/dom-stubs` — `snapshot()` to assert                                                                                            |
-| a hand-written `MockWorker` whose `addEventListener` sets `onmessage`                             | `stubWorker({ respond })` from `/dom-stubs` — `last.emit(data)`, `last.messages`                                                                                                  |
-| `'x' does not exist in type 'MethodReturns<{ y: any; }>'` on a generic class                      | spell out the type argument — `createSpyFromClass<Config>(Config, …)`; `provideAutoSpy` infers it                                                                                 |
-| `injectSpy(ModalRef)` reads a generic class at its constraint, not its default                    | `injectSpy<ModalRef<Data>>(ModalRef)` — a constructor taking `T` hides the default                                                                                                |
-| "did the migration lose a test?" with matching counters                                           | `compareTestRuns(before, after)` — `counts` reports `name (×2 → ×1)`                                                                                                              |
-| an input that has to change after the first render                                                | `await setInputs(fixture, { … })` — aliases and `hostDirectives` inputs resolve, unknown names refused                                                                            |
-| a component that navigates, or reads `router.url`                                                 | `provideRouterDouble({ url })` + `injectRouterDouble()` — `/angular-router`                                                                                                       |
-| a component that reads `router.currentNavigation()` for `extras.state` or `trigger`               | `setCurrentNavigation({ extras: { state } })` on the same handle — no `instanceMethodsToSpyOn`                                                                                    |
-| the sequence of router events, not just the final URL                                             | `collectRouterEvents(router.events)` — `expect([[NavigationStart, '/checkout'], [NavigationEnd, '/checkout']])`                                                                   |
-| a component that reads `location.back()`, or asserts where a redirect landed                      | `provideLocationDouble()` + `injectLocationDouble()` — Angular's own `SpyLocation`; without the provider, `Location` is `providedIn: 'root'` and the real one answers             |
-| "did A run before B?" across three collaborators                                                  | `createLog<'drop-cache' \| 'flush'>()` — hand `log.fn('drop-cache')` to each, assert `log.result()` once                                                                          |
-| a `window` or `document` behind a DI token                                                        | `provideWindowDouble(WINDOW, { screen })` / `provideDocumentDouble({ … })` — `/angular/doubles`                                                                                   |
-| `MAT_DIALOG_DATA` and `MatDialogRef` provided by hand                                             | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(MatDialogRef)` + `injectMatDialogRef(Ref)` — `/angular/doubles`                                                        |
-| asserting a `computed()` did **not** recompute                                                    | `trackRecomputations(sig)` / `trackEffectRuns(ref)` — `{ count, stop() }`                                                                                                         |
-| `form()` in a spec, or `errors()` read by hand                                                    | `createForm(model, schema)` + `registerFormMatchers()` — then `toHaveFieldErrors([…])` (`/signal-forms`)                                                                          |
-| any of those doubles without a `TestBed`                                                          | `createRouterDouble` (`/angular-router`) / `createWindowDouble` / `createDocumentDouble` / `createMatDialogRef` (`/angular/doubles`)                                              |
+| Situation                                                                                         | Helper                                                                                                                                                                                            |
+| ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| a `signal()` / `computed()` field on the class under test                                         | `mockSignalProp(obj, prop, initial)` — writes through a writable one, `asReadonly()` included; an `input()` is refused                                                                            |
+| a resource field, when the HTTP round trip is not the point                                       | `mockResourceProp(obj, prop, initial)` — `set` / `fail` / `loading`; `value()` after `fail()` throws                                                                                              |
+| the HTTP round trip _is_ the point                                                                | `expectRequest(url).flush(body)` — `/angular-http`, settling included                                                                                                                             |
+| a component or service that reads `ActivatedRoute`                                                | `provideActivatedRoute({ params })`, then `injectActivatedRoute().setParams(…)` — `/angular-router`                                                                                               |
+| a guard or a class built with `new` that takes the route                                          | `createActivatedRoute({ params })` — the same handle, no `TestBed`                                                                                                                                |
+| a node:test suite whose heap grows all run                                                        | `trackNodeMocks()` — `/node`, a private MockTracker                                                                                                                                               |
+| a Nest provider whose constructor keeps changing                                                  | `createNestUnit(Target, { expose })` — built from its DI metadata                                                                                                                                 |
+| asserting a resource's value _and_ status together                                                | `registerResourceMatchers()` (`/angular/matchers`) → `toHaveResourceValue` / `toBeLoading`                                                                                                        |
+| a callback or config object the code under test built                                             | `captureArg<T>()` in the assertion, then read `.value`; `{ where }` records only what it accepts                                                                                                  |
+| an object the test already holds — a real service, a client, `TestBed.inject(X)`                  | `createSpyFromInstance(obj, config?)` — patches it in place, `restoreSpiedInstance` undoes it                                                                                                     |
+| assert calls on a real object or service but keep it working                                      | `createSpyFromInstance(obj, { passthrough: true })` — real method runs until configured; not with `strict: true` on the same call                                                                 |
+| one method of the object under test, recorded and still running                                   | `spyOnOwnMethod(sut, 'method')` — the `onlyMethodsToSpyOn` + `passthrough` packed; the drop-in for a bare banned `vi.spyOn`; `prefer-spy-on-own-method` (`warn`, `--fix`) finds the long spelling |
+| a native void method a handler is meant to call (`preventDefault`, `focus`)                       | `spyOnVoidMethod(event, 'preventDefault')` — records the call and seeds `undefined`, so `strict` does not throw on it                                                                             |
+| a `vi.mock` factory's `vi.fn()` needs `calledWith` / `resolveWith`                                | `adoptMock(api.load).calledWith(7).resolveWith(…)` — same object, history kept                                                                                                                    |
+| real module, one case configured                                                                  | `vi.mock('x', async (orig) => moduleNamespace(await orig(), { passthrough: true }))`                                                                                                              |
+| feeding a stubbed `fetch`                                                                         | `vi.fn(async () => stubResponse({ body: data }))` from `/setup` — a real `Response`, no `as Response`; a body reads once                                                                          |
+| a backend that answers the JSON literal `null`                                                    | `stubResponse({ body: null })` — the literal, not "no body"; `undefined` or an omitted `body` is the way to send none                                                                             |
+| the code under test lazy-loads on a click and the spec has no promise                             | `await settleDynamicImport(() => import('./thing'))` — a bare `await import(…)` waits for the module, not for the handler's continuation                                                          |
+| MSW handlers not answering under `setupAutoSpy({ blockNetwork: true })`                           | upgrade — `blockNetwork` now leaves `fetch` to MSW's interceptor; end the handlers with `http.all('*', () => HttpResponse.error())`                                                               |
+| `mockDeep` member read by index, or an unmocked call that should fail                             | `mock.items[0].x = 1` makes a real array (re-read `mock.items` after); `mockDeep<T>({}, { fallbackMockImplementation: () => { throw … } })` — options are the **second** argument                 |
+| mocking `PrismaClient`                                                                            | `mockDeep<PrismaClient>()` + `resolveWith` / `rejectWith` / `resolveWithPerCall`; `$transaction.mockImplementation((run) => run(asInstance(prisma)))`                                             |
+| `[Function] is not a spy or a call to a spy!` inside a Storybook `play`                           | import `expect` from `vitest` in that story file, or `setSpyEngine('runner')` from `/setup`                                                                                                       |
+| `vi.spyOn(Class.prototype, 'x')` → `The property "x" is not defined on the object.`               | `x` is an instance field (arrow, signal) — `createSpyFromClass(C, { instanceMethodsToSpyOn: ['x'] })`                                                                                             |
+| a spy or a `mock*Prop` patch leaking into the next `bun test` test                                | `/setup` is Vitest-only — preload `afterEach(() => { restoreMockedProps(); mock.restore(); })`                                                                                                    |
+| a `calledWith` that is not matching and you cannot see why                                        | `explainSpy(spy, 'method')` from `/diagnostics` — configs, calls, which hit which                                                                                                                 |
+| a method that has to throw — for all calls, or for some arguments                                 | `spy.m.failWith(err)` / `spy.m.calledWith(x).failWith(err)` — **not** `throwWith`                                                                                                                 |
+| a `TestBed` spec on Vitest 4.1+, to drop `let` + `beforeEach`                                     | `extendWithAutoSpies(test, { cart: CartService })` (`/angular`)                                                                                                                                   |
+| an `effect()` whose trigger is now a static signal                                                | `runEffect(effectRef)`                                                                                                                                                                            |
+| the component constructs its own `IntersectionObserver`                                           | `stubIntersectionObserver()` (+ `Resize` / `Mutation`) — `last.host` is the callback’s 2nd argument                                                                                               |
+| a green run exiting 1 with `AbortError` under happy-dom                                           | `setupAutoSpy({ blockNetwork: true })`                                                                                                                                                            |
+| a real request going out of a unit run (`fetch`, XHR, `sendBeacon`)                               | `setupAutoSpy({ blockNetwork: true })` — `{ xhr: 'empty' }` for pings                                                                                                                             |
+| timers or frames from a previous file failing this one                                            | `setupAutoSpy({ strayTimers: true })` — mutes `--detect-async-leaks`; blind under fake timers                                                                                                     |
+| an assertion error in stderr, every test green and the run at 0                                   | `setupAutoSpy({ strayRejections: true })` — zone.js swallowed it                                                                                                                                  |
+| a run getting slower the longer it goes, on `isolate: false`                                      | `setupAutoSpy({ pruneMockRegistry: true })` — the mock registry                                                                                                                                   |
+| a listener or a replaced global from a previous file answering in this one, on `isolate: false`   | `setupAutoSpy({ strayListeners: true, restoreGlobals: true })`                                                                                                                                    |
+| the same, piece by piece                                                                          | `trackStrayListeners` / `baselineStrayListeners` / `removeStrayListeners` / `countStrayListeners` / `describeStrayListeners`; `captureGlobalBaseline` / `restoreGlobals`                          |
+| a storage spy still recording after `vi.restoreAllMocks()` under happy-dom                        | `restoreStorageSpies` — on by default; `restoreStorageSpies()` alone                                                                                                                              |
+| a stream that must emit exactly these values and complete                                         | `await expectAllEmissions(source$)`                                                                                                                                                               |
+| a fixture outside its type on purpose (the `null` a backend sends)                                | `outOfType<T>(value)` — no cast                                                                                                                                                                   |
+| one setup file for the Angular unit-test builder and plain Vitest                                 | `if (!isAngularUnitTestBuilder()) TestBed.initTestEnvironment(…)`                                                                                                                                 |
+| `JavaScript heap out of memory` on a suite of wide generated clients                              | nothing to configure — the default shares one placeholder per method name (215 B per untouched 100-method double); `lazySpies: 'proxy'` retains 19× more now                                      |
+| `Cannot read properties of undefined (reading 'now')`                                             | `restoreTimerGlobals` — on by default                                                                                                                                                             |
+| `localStorage.setItem is not a function`, or it is `undefined`                                    | `restoreWebStorage` — on by default; Vitest's global filter, Node 25+                                                                                                                             |
+| a spy handed to an API typed against the real class                                               | `asInstance()` / `asSpy()`                                                                                                                                                                        |
+| the code under test does `new X()` (a global, a vendor SDK)                                       | `mockConstructor(factory)` / `stubConstructor(obj, key, factory)`                                                                                                                                 |
+| `X is not a constructor`, with a stack in production code                                         | same — a `vi.fn(() => …)` cannot serve `new`                                                                                                                                                      |
+| waiting for a dynamic `import()` under fake timers                                                | `settleDynamicImport(() => import('…'))` / `flushEventLoop()`                                                                                                                                     |
+| `addEventListener(…, { signal })` throwing about `EventTarget`                                    | `stubAbortController()`                                                                                                                                                                           |
+| `codemod` reporting a truncated repository scan                                                   | `VITEST_AUTO_SPY_SCAN_CAP=<n>` — raises the 50 000-file cap                                                                                                                                       |
+| a suite ported from Jest's `fakeTimers.enableGlobally`                                            | `setupAutoSpy({ globalFakeTimers: true })`                                                                                                                                                        |
+| `toHaveBeenCalledBefore` across an auto-spy and a hand-written `vi.fn()`                          | `setSpyEngine('runner')` / `getSpyEngine()` — `/setup`, Vitest only                                                                                                                               |
+| a nested `describe`'s `beforeAll` landing on real timers                                          | `setupFakeTimers(cfg, { betweenTests: true })`                                                                                                                                                    |
+| setup hooks applying to the first spec file of a worker only                                      | the setup module is cached — run coverage with `--isolate`                                                                                                                                        |
+| `fakeAsync` inside `test.concurrent`                                                              | `installProxyZonePatch({ scope: 'callback' })`                                                                                                                                                    |
+| an assertion containing a date                                                                    | `mockSystemTime(iso)` — never `vi.spyOn(globalThis, 'Date')`                                                                                                                                      |
+| a spec asserting on tick _order_ under a frozen clock                                             | `useCountingClock()`                                                                                                                                                                              |
+| a dependency declared in the component's own `providers`                                          | `overrideComponentProvider(Cmp, Token)` — it verifies on the first fixture that the override applied                                                                                              |
+| a double answering `undefined` for a method nobody configured                                     | `{ strict: true }`, or `setupAutoSpy({ strict: true })` suite-wide                                                                                                                                |
+| a strict throw caught by a `try`/`catch` or an operator, the test still green                     | `setupAutoSpy({ swallowedStrictCalls: 'throw' })`; provoked on purpose — `takeStrictViolations()` from `/setup`                                                                                   |
+| a strict double's getter answering `undefined`, or its `items$` never emitting                    | `setupAutoSpy({ unconfiguredReads: 'throw' })` reports it after the test; survey first with `onUnstubbedRead`                                                                                     |
+| an `afterEach` that exists only to reset one spy                                                  | `using spy = createSpyFromClass(X)` — `[Symbol.dispose]` runs `resetAutoSpy`, which is `vi.resetAllMocks()` for one double                                                                        |
+| a dead NgModule import, dead `schemas`, an unflushed HTTP request                                 | `enableAngularDiagnostics()` (`/angular/diagnostics`) in the setup file, after `initTestEnvironment`                                                                                              |
+| the spy is provided but the component resolves its own, so the test runs the real service         | `enableAngularDiagnostics({ shadowedProviders })` or `assertNoShadowedProviders(Component, fixture)` — `/angular/diagnostics`                                                                     |
+| "which collaborators did this actually inject?"                                                   | `trackInjections([A, TOKEN])` — providers plus the record, not `vi.mock`                                                                                                                          |
+| `NG0303` / `NG0301` / `NG0304` from an imported NgModule                                          | `assertNgModuleScopes(Module)` — an AOT bundle stripped its scope                                                                                                                                 |
+| `Cannot read properties of undefined (reading 'provide')` in `di_setup`                           | `assertComponentDefIntact(Cmp)` — a barrel chunk left a hole in `ɵcmp`                                                                                                                            |
+| a focus assertion failing as `expected false to deeply equal true`                                | `registerFocusMatchers()` + `expect(el).toHaveFocus()`                                                                                                                                            |
+| a collaborator passed as an argument, then asserted on                                            | `autoMocked<T>()` — typed `T & Spy<T>`                                                                                                                                                            |
+| a `<video>` / `<audio>`: `play()` throws, `duration` is `NaN`                                     | `stubMediaElement({ duration })`, then `media.set(el, …)`                                                                                                                                         |
+| a `vi.mock()` that silently did nothing under a bundler                                           | `assertMocked(ns, { specifier, exports })`                                                                                                                                                        |
+| `No "default" export is defined on the mock`                                                      | `vi.mock('x', () => moduleNamespace({ … }))` — a `default` you spell out is kept                                                                                                                  |
+| waiting for a `resource()` / an SDK to become ready                                               | `flushEventLoopUntil(() => …, { label })` — budgeted, not tuned                                                                                                                                   |
+| `expected [ { at: 1, …(5) }, …(8) ] to deeply equal …`                                            | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                                                                                           |
+| a stub that works only in the first test of the file                                              | `installPerTest(() => stub…())` — or install it in `beforeEach`                                                                                                                                   |
+| a library failing every other run after a `defineProperty` on DOM                                 | `setupAutoSpy({ guardGlobals: 'throw' })` names the file — it sees an added name, not an existing one redefined                                                                                   |
+| a block of files failing to collect, with no stack and zero failing tests                         | `setupAutoSpy()` names the file that left a key on `Object.prototype` (`prototypePollution`, on by default)                                                                                       |
+| the same check in a suite that does not call `setupAutoSpy()`                                     | `guardPrototypePollution('throw')` from `/setup`                                                                                                                                                  |
+| a spec failing only in a full run on an attribute of `<body>` / `<html>` another file left        | `setupAutoSpy({ documentPollution: 'throw' })` names the test and puts the document back (in `preset: 'strict'`)                                                                                  |
+| the same document check without `setupAutoSpy()`                                                  | `guardDocumentPollution('throw')` from `/setup`                                                                                                                                                   |
+| `A metric with the name … has already been registered` / `customElements.define` twice, at import | a module scope evaluated once per spec file under the Angular builder — guard the registration (`getSingleMetric`, `customElements.get`)                                                          |
+| console output a test never asserted on (a `'warn'` from this library does not count)             | `setupAutoSpy({ strayConsole: 'throw' })` fails that test; absorb with `installConsoleSpies()` in `beforeEach`                                                                                    |
+| every guard at its strictest grade in one line                                                    | `setupAutoSpy({ preset: 'strict' })` — plus `enableAngularDiagnostics()` from `/angular/diagnostics` for Angular                                                                                  |
+| an `onlyMethodsToSpyOn` typo or `injectSpy` on a real instance that only warned                   | `setupAutoSpy({ misconfiguration: 'throw' })` throws at the call                                                                                                                                  |
+| which file and call scheduled a timer that outlived its file                                      | `onStrayTimers: ({ timers }) => expect(timers).toEqual([])`, or `describeStrayTimers()` from `/setup`                                                                                             |
+| stray timers charged to a file that only writes `localStorage` (jsdom)                            | `withoutStrayTimerTracking(() => seed())` from `/setup` — its timers are neither counted nor cancelled                                                                                            |
+| `import { consoleErrorSpy }` silencing other files under `isolate: false`                         | `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` — the import installs once per worker                                                                                  |
+| `Cannot set base providers because it has already been called`                                    | `setupAngularTestEnv({ zoneless, initZone, initZoneless })`                                                                                                                                       |
+| a dependency behind an `InjectionToken`, with no class to spy                                     | `provideAutoSpyForToken(TOKEN)` + `injectSpy(TOKEN)`; a chained call → `{ selfReturning: ['channel'] }` as the third argument                                                                     |
+| `Expected to be running in 'ProxyZone', but it was not found`                                     | `import 'vitest-auto-spy/zone'` (needs `globals: true`)                                                                                                                                           |
+| `Property 'mockReturnValue' does not exist on type 'never'`                                       | upgrade — the spy no longer collapses on an unreadable return type                                                                                                                                |
+| `TS2345` inside `mockReturnValue` / `mockImplementation` / `mockResolvedValue`                    | the stub is checked against the method's return type now — fix the stub, not the spy                                                                                                              |
+| `TS2540: Cannot assign to 'x'` on a double whose runtime write works                              | `Spy<T>` keeps `readonly` on purpose — `mockValueProp(spy, 'x', v)`, which a spied **accessor** also needs                                                                                        |
+| a signal-valued getter that `gettersToSpyOn` will not accept                                      | it accepts any key now; for a signal prefer `mockSignalProp`                                                                                                                                      |
+| five `asInstance(…)` in one call, found one per `tsc` run                                         | `...asInstances(a, b, c, d, e)`                                                                                                                                                                   |
+| `nextWith` demanding `HttpEvent<T>` on a generated client                                         | `asSpy<Client, { overload: 'first' }>(…)` / `Overload<M, 0>`                                                                                                                                      |
+| `not assignable to parameter of type 'HttpEvent<…>'` in a stub of the real body                   | same thing — the helpers read the **last** overload; `{ overload: { m: 'first' } }`, not `@ts-expect-error`                                                                                       |
+| a fixture that needs a nested object built by its own call                                        | `createMock<T>({ a: { b: 1 } })` — deep partial, still exact                                                                                                                                      |
+| the same 100-line model literal copied into eight specs (`TS1117`)                                | one `createFixtureFactory<T>(defaults)`; specs call it with what they change                                                                                                                      |
+| `'params' in link` ladders, or a cast, to pick a union branch                                     | `narrow.byKey(link, 'params')` / `narrow.observable(x)`                                                                                                                                           |
+| `{ ...modelInstance, flag: true }` losing every getter                                            | `withOverrides(modelInstance, { flag: true })`                                                                                                                                                    |
+| `NG0303` / `NG0304` / silence from a directive spec                                               | `createDirectiveHost({ template, scope: [Module] })`                                                                                                                                              |
+| a hand-written `class MockChartComponent` restating a child's selector                            | `createComponentStub(ChartComponent)` (`/angular`) — selector, inputs, outputs read from `ɵcmp`                                                                                                   |
+| a `TestingStorage` class for `localStorage` / `sessionStorage`                                    | `stubWebStorage('localStorage', { items })` from `/dom-stubs` — `snapshot()` to assert                                                                                                            |
+| a hand-written `MockWorker` whose `addEventListener` sets `onmessage`                             | `stubWorker({ respond })` from `/dom-stubs` — `last.emit(data)`, `last.messages`                                                                                                                  |
+| `'x' does not exist in type 'MethodReturns<{ y: any; }>'` on a generic class                      | spell out the type argument — `createSpyFromClass<Config>(Config, …)`; `provideAutoSpy` infers it                                                                                                 |
+| `injectSpy(ModalRef)` reads a generic class at its constraint, not its default                    | `injectSpy<ModalRef<Data>>(ModalRef)` — a constructor taking `T` hides the default                                                                                                                |
+| "did the migration lose a test?" with matching counters                                           | `compareTestRuns(before, after)` — `counts` reports `name (×2 → ×1)`                                                                                                                              |
+| an input that has to change after the first render                                                | `await setInputs(fixture, { … })` — aliases and `hostDirectives` inputs resolve, unknown names refused                                                                                            |
+| a component that navigates, or reads `router.url`                                                 | `provideRouterDouble({ url })` + `injectRouterDouble()` — `/angular-router`                                                                                                                       |
+| a component that reads `router.currentNavigation()` for `extras.state` or `trigger`               | `setCurrentNavigation({ extras: { state } })` on the same handle — no `instanceMethodsToSpyOn`                                                                                                    |
+| the sequence of router events, not just the final URL                                             | `collectRouterEvents(router.events)` — `expect([[NavigationStart, '/checkout'], [NavigationEnd, '/checkout']])`                                                                                   |
+| a component that reads `location.back()`, or asserts where a redirect landed                      | `provideLocationDouble()` + `injectLocationDouble()` — Angular's own `SpyLocation`; without the provider, `Location` is `providedIn: 'root'` and the real one answers                             |
+| "did A run before B?" across three collaborators                                                  | `createLog<'drop-cache' \| 'flush'>()` — hand `log.fn('drop-cache')` to each, assert `log.result()` once                                                                                          |
+| a `window` or `document` behind a DI token                                                        | `provideWindowDouble(WINDOW, { screen })` / `provideDocumentDouble({ … })` — `/angular/doubles`                                                                                                   |
+| `MAT_DIALOG_DATA` and `MatDialogRef` provided by hand                                             | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(MatDialogRef)` + `injectMatDialogRef(Ref)` — `/angular/doubles`                                                                        |
+| asserting a `computed()` did **not** recompute                                                    | `trackRecomputations(sig)` / `trackEffectRuns(ref)` — `{ count, stop() }`                                                                                                                         |
+| `form()` in a spec, or `errors()` read by hand                                                    | `createForm(model, schema)` + `registerFormMatchers()` — then `toHaveFieldErrors([…])` (`/signal-forms`)                                                                                          |
+| any of those doubles without a `TestBed`                                                          | `createRouterDouble` (`/angular-router`) / `createWindowDouble` / `createDocumentDouble` / `createMatDialogRef` (`/angular/doubles`)                                                              |
 
 ## Rules that prevent most of the mistakes
 
@@ -444,7 +444,7 @@ npx vitest-auto-spy codemod --verify  # after a migration: anything the transfor
 Most of this library's guarantees are type-level, so a green run that does not type-check is not
 done. Report failures with their output rather than describing them as passing.
 
-**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The forty-eight rules in
+**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The forty-nine rules in
 `vitest-auto-spy/eslint-plugin` are lint, not typecheck: `no-mocked-for-spy` rewrites a declaration
 to `Spy<T>` and cannot see what the name is assigned two lines below, so a clean lint pass is not
 evidence that the types still hold. Where it cannot prove the rename it downgrades to a suggestion —