vitest-auto-spy 4.6.0 → 5.0.0

package/AGENTS.md

@@ -66,6 +66,23 @@ Add-ons, orthogonal to the runner:
 `vitest-auto-spy/jasmine` is Vitest-only, because it registers the Vitest adapter. On `bun test` and
 `node --test` call `enableJasmineCompat()` from `vitest-auto-spy/jasmine-compat` instead.
 
+The rxjs peer is **>= 7.2**, not `>=7`. The observable layer used to pull `concatMap`, `delay`,
+`switchMap`, `take`, `takeUntil` and `takeWhile` from `rxjs/operators`; rxjs 8 removes that deep path,
+so the specifier moved to the root `rxjs` entry — which is where rxjs re-exported them in 7.2 — and
+the floor moved with it. Any Angular project already satisfies it: Angular 16 through 22 all peer on
+`^6.5.3 || ^7.4.0`.
+
+The Angular entries need **Angular >= 20** — `@angular/core`, `@angular/common` and
+`@angular/platform-browser`, all optional peers on the same range. Below 20 the failure is a link
+error, not a missing helper: `/angular` imports `ɵSIGNAL` (Angular 18+) as a value on the first line
+of its bundle, so on 16 and 17 the whole entry fails to load, and `/bun-angular` imports
+`provideZonelessChangeDetection` (Angular 20+; called `provideExperimentalZonelessChangeDetection`
+in 18 and 19), so on anything older the preload throws before the first spec. Angular 19 and
+everything under it is out of Angular's own support window as well, so the floor cuts nothing that
+still gets fixes. `@angular/platform-browser` is a declared peer since this major — `By` in the
+directive matchers and `platformBrowserTesting()` in the Bun preload are both value imports of it,
+and under pnpm's isolated layout it never resolved before.
+
 The package is **ESM**. Only `vitest-auto-spy/node` and `vitest-auto-spy/eslint-plugin` also ship a
 CommonJS build; every other subpath is ESM-only (a `require()` of a Vitest-backed entry always threw —
 Vitest refuses to be required).
@@ -1135,7 +1152,7 @@ setSpyEngine('runner'); // every double built afterwards is `vi.fn()` per method
 ```
 
 **On Vitest 5 the registry story changes, and this library follows it.** Vitest 5 keeps registered
-mocks behind `WeakRef`s and its `clearAllMocks()` visits only the ones *called* since the last
+mocks behind `WeakRef`s and its `clearAllMocks()` visits only the ones _called_ since the last
 sweep — so a spy that is not a `vi.fn()` has to make itself reachable to that sweep deliberately. It
 does, which is why `vi.clearAllMocks()`, `vi.resetAllMocks()` and the `clearMocks: true` default
 (new in Vitest 5) clear these doubles exactly as they clear the runner's own. Nothing in a spec
@@ -1145,6 +1162,12 @@ What Vitest 5 does break is the runner's own doing, not this library's: with `cl
 default, a test asserting on a call that an **earlier** test or a `beforeAll` recorded now reads
 zero. Count it in a plain variable rather than in the spy, or set `clearMocks: false`.
 
+**The one exception to "nothing in a spec changes".** `setupAutoSpy({ pruneMockRegistry: true })`
+discovers long-lived mocks by walking the runner's registry, which Vitest 5 no longer exposes — the
+automatic half is a no-op there. `keepMockRegistered(mock)` works on every version and is the fix;
+recommend it whenever a suite on Vitest 5 loses a shared mock's implementation to
+`vi.resetAllMocks()`.
+
 `getSpyEngine()` reports the current one, `'auto-spy'` is the default, and doubles already built keep
 the engine they were built with. The switch is Vitest-only: on Bun and `node:test` the runner's own
 matchers recognise only the runner's own mocks, so those adapters keep using them.
@@ -1479,6 +1502,14 @@ For the three observers, prefer the purpose-built stubs (§13). For `AbortContro
 in a jsdom run for a reason involving none of the three parties in the stack trace — use
 `stubAbortController()`.
 
+The stub carries `AbortSignal.abort()`, `AbortSignal.timeout()` and `AbortSignal.any()` as well —
+the three statics are how modern code makes a signal without a controller, `fetch(url, { signal:
+AbortSignal.timeout(5_000) })` most of all. `timeout()` aborts through `setTimeout`, so
+`vi.useFakeTimers()` drives it exactly as it drives the platform's, and it aborts with a
+`TimeoutError` rather than an `AbortError` because that is the distinction the platform draws. A
+signal's `reason` is the platform's `DOMException`, so code branching on
+`signal.reason.name === 'AbortError'` takes the same branch it takes in a browser.
+
 ### `<video>` and `<audio>`
 
 jsdom implements them as a shell: `play()` throws, `duration` is `NaN` and is an accessor with no
@@ -1499,6 +1530,10 @@ expect(media.play).toHaveBeenCalledTimes(1);
 
 State is per element, so an ad and the content report different durations.
 
+`currentTime` is a get/set pair, so a player restarting itself with `video.currentTime = 0` reaches
+the record and fires `timeupdate` too — `media.set()` is not the only way in, and the component's own
+handler runs where it used to stay unrun while the assertion read the new value.
+
 ### A module mock that did nothing
 
 `vi.mock()` is the one thing in a ported suite that fails **silently**. Under a bundler
@@ -1541,7 +1576,8 @@ const myService = injectSpy(MyService); // Spy<MyService>
 
 `provideAutoSpy` defaults to `lazySpies: true` (the plain `createSpyFromClass` does not). Pass
 `{ lazySpies: false }` to opt out. The spies never touch `NgZone`, so they work zoneless and with
-zone.js alike.
+zone.js alike. The entry needs **Angular >= 20** (§1); on 16 or 17 it does not link at all, because
+`ɵSIGNAL` is not there to import.
 
 ### The same thing as fixtures — `extendWithAutoSpies` (Vitest 4.1+)
 
@@ -2066,6 +2102,11 @@ if (process.env['SPEC_TIMING']) {
 preload = ["vitest-auto-spy/bun-angular"]
 ```
 
+The preload imports `provideZonelessChangeDetection` and `platformBrowserTesting` as values, so it
+wants **Angular >= 20** and a declared `@angular/platform-browser`; on 18 or 19 it throws while
+loading, because the zoneless provider was still called
+`provideExperimentalZonelessChangeDetection` there.
+
 It re-exports everything in this section except `registerSignalMatchers`,
 `registerResourceMatchers`, `mockSignalProp` / `mockResourceProp` and the TestBed diagnostics — the
 matchers and diagnostics need the runner's `expect.extend` and suite-level hooks, and the `mock*Prop`
@@ -2222,7 +2263,7 @@ Spies created **before** the call stay there too. `mock.reset()` in `afterEach`
 
 **A `node:test` spy now prints under its method name.** `mock.fn()` takes no name and has no
 `mockName()`, so a spy inherited the library's internal dispatcher and read back as
-`[Function: dispatch]` everywhere. The adapter names the *implementation* at creation and lets
+`[Function: dispatch]` everywhere. The adapter names the _implementation_ at creation and lets
 `mock.fn()` carry that name onto the mock, which is where a `node:test` mock takes its `name` from;
 `displayName` is set on the mock alongside it. The name survives `mock.reset()`, `mock.restore()`,
 `resetCalls()` and a `mockImplementation()` swap, and it is what `node:assert` diffs, what
@@ -2480,8 +2521,8 @@ packages, which a subpath export can never be.
 | `jasmine is not defined`                                                                                 | jasmine's global is the runner's, and Vitest declares none                                                                                           | `import { jasmine } from 'vitest-auto-spy/jasmine'`, then `codemod --from jasmine` to rewrite the members (§20)                         |
 | `done.fail is not a function`                                                                            | Vitest passes a `TestContext`, not jasmine's `done`; the line usually sits in an `error` callback nobody awaits, so the run stays **green**          | assert on the failure — `await expect(firstValueFrom(src$)).rejects.toMatchObject({ … })`, or `expect.fail(message)`                    |
 | a `.withContext('…')` message that never appears in the failure output                                   | Vitest's chai layer has an `@internal` `withContext(flags)`; handed a string it walks the character indices, sets nonsense flags and returns `this`  | `expect(actual, 'message').toBe(expected)` — the second argument of `expect` is the label. Nothing throws, so nothing warns (§20)       |
-| `requested method(s) not found on the class prototype`                                                   | typo, or an instance-field callable                                                                                                                  | fix the name, or move it to `instanceMethodsToSpyOn`                                                                                    |
-| `All declarations of 'Matchers' must have identical type parameters`                                     | a custom matcher declares `interface Matchers<T = any>` (the Vitest 4 shape) while Vitest 5 declares `Matchers<R, T>`                                 | declare it on `Chai.Assertion` instead — that interface has no type parameters in either major, so one declaration merges on both (§10) |
+| `names method(s) that are not on the class prototype`                                                   | typo, or an instance-field callable                                                                                                                  | fix the name, or move it to `instanceMethodsToSpyOn`                                                                                    |
+| `All declarations of 'Matchers' must have identical type parameters`                                     | a custom matcher declares `interface Matchers<T = any>` (the Vitest 4 shape) while Vitest 5 declares `Matchers<R, T>`                                | declare it on `Chai.Assertion` instead — that interface has no type parameters in either major, so one declaration merges on both (§10) |
 | `toHaveBeenCalledTimes` reads `0` for a call an earlier test made, after moving to Vitest 5              | `clearMocks` defaults to `true` on Vitest 5, so `vi.clearAllMocks()` runs before every test                                                          | count the calls in a plain variable instead of reading the spy, or set `clearMocks: false` (§10)                                        |
 | `was configured with 'mustBeCalledWith'`                                                                 | the code called the spy with other arguments                                                                                                         | that is the assertion firing — fix the code, or relax to `calledWith`                                                                   |
 | `extendWithAutoSpies needs Vitest 4.1 or newer`                                                          | the `test` handed in has only the object-form `extend` (Vitest ≤ 4.0); the builder form the helper is written against arrived in 4.1                 | upgrade Vitest, or keep `provideAutoSpy` + `injectSpy` in a `beforeEach` until then                                                     |
@@ -2509,7 +2550,7 @@ packages, which a subpath export can never be.
 | a spy is never called, no warning                                                                        | the method is an instance field, not on the prototype                                                                                                | `instanceMethodsToSpyOn`, or `createAutoMock<T>()`                                                                                      |
 | `Cannot access '__vi_import_N__' before initialization`                                                  | `vi.mock()` on `@angular/core` or a relative path                                                                                                    | you cannot mock it — the specs are bundled. Assert the result instead                                                                   |
 | `AggregateError at Object.dispatchError`, for a request nothing asserts on                               | jsdom really served an `XMLHttpRequest` — `blockNetwork` used to cover only `fetch`                                                                  | `setupAutoSpy({ blockNetwork: true })`, or `{ xhr: 'empty' }` for tracker pings (§10)                                                   |
-| `localStorage.setItem is not a function`, or `localStorage` undefined                                    | Node's own Web Storage made Vitest's global filter skip the environment's — Node 25 and up, jsdom and happy-dom alike                               | on by default in `setupAutoSpy()`; `restoreWebStorage()` on its own (§10)                                                               |
+| `localStorage.setItem is not a function`, or `localStorage` undefined                                    | Node's own Web Storage made Vitest's global filter skip the environment's — Node 25 and up, jsdom and happy-dom alike                                | on by default in `setupAutoSpy()`; `restoreWebStorage()` on its own (§10)                                                               |
 | `Schedulers cannot synchronously execute watches while scheduling`                                       | a timer from a **previous** file, under `isolate: false`                                                                                             | track and cancel pending timers/frames in the setup file (§10)                                                                          |
 | `signal read during notification phase`                                                                  | same — a stray `requestAnimationFrame` callback                                                                                                      | same                                                                                                                                    |
 | an assertion error printed to stderr, every test green and the run exiting 0                             | zone.js swallowed a rejection nobody handled                                                                                                         | `setupAutoSpy({ strayRejections: true })` fails the test it surfaced in (§10)                                                           |
@@ -2740,6 +2781,10 @@ migrated by hand. Run it after `--write`, and again after any manual clean-up. `
 select transforms by id, `--list` prints them. Full reference:
 <https://asdalexey.github.io/vitest-auto-spy/utilities/codemod>.
 
+Past 50 000 files the repository scan truncates and the run says so — *Nothing left to migrate* off a
+truncated list is a claim about a tree the tool never looked at. `VITEST_AUTO_SPY_SCAN_CAP` raises
+the cap.
+
 ### If you are writing a codemod over specs
 
 Two traps, both found the hard way on rxjs-heavy code.

package/README.md

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-15.0%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-15.1%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -86,6 +86,23 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🤖 Built for AI agents too — one `npx vitest-auto-spy init` writes the pointer into the files your agents actually read and specialises it for this repository, backed by an offline [`AGENTS.md`](#using-this-library-with-an-ai-agent) inside the package, a [per-agent map](#which-file-your-agent-reads) for **Claude Code**, **OpenAI Codex**, **GLM/z.ai**, **Cursor**, **Copilot**, **Gemini CLI** and the rest, `llms.txt` on the docs site, a Claude Code skill, and errors that name their own fix
 - 🟢 100% test coverage, **zero runtime dependencies** (in-tree arg serializer, no `javascript-stringify`)
 
+## New in 5.0
+
+A major that changes **no helper, no option and no runtime behaviour**. What it changes is what the
+package claims to run on, because both old peer ranges were claims the code could not keep — the
+full list, with what to do about each, is in
+[Upgrading to 5.0](https://asdalexey.github.io/vitest-auto-spy/upgrading-5).
+
+| What you get                                                                                                                                                                                                                        | Verified                                                                                                                            |
+| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| **The Angular range stops being false.** `>=16.0.0` admitted four majors on which an entry point cannot link at all: `ɵSIGNAL` is a value import and arrived in 18, `provideZonelessChangeDetection` in 20. The floor is now `>=20` | Angular 16 through 22 downloaded, their real `export { … }` lists parsed out of `fesm2022/*.mjs`; Angular 19 went EOL on 2026-05-19 |
+| **`@angular/platform-browser` is a declared peer.** `/angular` has always imported `By` from it as a value, and under pnpm's isolated layout that never resolved                                                                    | undeclared → optional peer on the same `>=20` range                                                                                 |
+| **The rxjs range stops promising rxjs 8.** Six operators came from `rxjs/operators`, a path rxjs 8 removes; they now come from the root entry, where rxjs re-exported them in 7.2, and the floor moved with the specifier           | read out of rxjs 7.2.0's own `dist/types/index.d.ts`; every Angular major from 16 to 22 already peers above it                      |
+| **`flushEffects()` is one line.** The `ApplicationRef.tick()` fallback and the spec that deleted `TestBed.tick` at runtime to cover it are both gone                                                                                | `TestBed.tick()` direct; coverage still 100 %                                                                                       |
+
+For almost everyone the whole upgrade is a version number: every Angular still supported by Angular
+satisfies the new floor, and only a project pinning `rxjs@7.0` or `7.1` on purpose has to move.
+
 ## New in 4.0
 
 A major with **one job**: take out of your project the weight this library was making it carry.
@@ -210,8 +227,9 @@ npm i -D vitest-auto-spy
 
 | Tool       | Minimum                                                                           |
 | ---------- | --------------------------------------------------------------------------------- |
-| Node.js    | ≥ 18 for the library — in practice, whatever your runner needs                    |
+| Node.js    | ≥ 22 — 18 and 20 are EOL; CI exercises 22, 24 and 26                              |
 | Vitest     | ≥ 2.1 (required peer) — one install covers 2.1 through 5.x                        |
+| Angular    | ≥ 20 for the Angular entry points — optional peer, nothing else needs it          |
 | Bun        | ≥ 1.4 for `vitest-auto-spy/bun-angular`; any recent Bun for `vitest-auto-spy/bun` |
 | TypeScript | ≥ 4.7 for the typed helpers (plain JS works too, just untyped)                    |
 
@@ -228,7 +246,12 @@ mocks that were called, so a spy engine that is not `vi.fn()` had to make itself
 sweep; and the `Matchers` interface grew a second type parameter, so the bundled matchers declare
 themselves on Chai's `Assertion` instead and keep typing on 4 and 5 alike. The one thing Vitest 5
 can still break is its own doing: `clearMocks` is on by default there, so a spec asserting on a call
-recorded by an *earlier* test now reads zero. Record it in a counter, not in the spy.
+recorded by an _earlier_ test now reads zero. Record it in a counter, not in the spy.
+
+One feature of this package does need a line changed. `setupAutoSpy({ pruneMockRegistry: true })`
+finds long-lived mocks by walking the runner's own registry, and Vitest 5 no longer exposes it — so
+on Vitest 5 the automatic half does nothing and a mock that must survive `vi.resetAllMocks()` has to
+say so: `keepMockRegistered(vi.fn().mockReturnThis())`. Everything after that mark behaves as before.
 
 Measured 2026-09-06 on 40 spec files, 800 tests, 400 spied methods per file, v8 coverage on,
 Node v24.19.0, median of five runs: the same suite takes **1383 ms on Vitest 4.1.11 and 1276 ms on
@@ -237,11 +260,12 @@ shipped since 4.1 is worth another **−6.1 % on Vitest 4 and −8.1 % on Vitest
 every method with the runner's own `vi.fn()` (`setSpyEngine('runner')`). End to end, the slowest
 pairing to the fastest is 1473 ms → 1276 ms, **−13.4 %**.
 
-Node **≥ 18** is the library's own floor and it holds — the published output is ES2022 and every
-entry runs on 18. What moves the real minimum is the runner: **Vitest 4 cannot start on Node 18 at
-all**, because Vite 7 calls `crypto.hash` (added in Node 20.12) and the run dies with
-`TypeError: crypto.hash is not a function` before a spec loads. On Vitest ≤ 3 Node 18 is fine. Which
-version to actually run is measured in
+Node **≥ 22** is the library's own floor now — Node 18 and 20 are both past end of life, and every
+runner this library supports already needed more: Vitest 4 pulls in Vite 7 (`^20.19.0 ||
+>=22.12.0`) and calls `crypto.hash` (added in Node 20.12), so Node 18 died with `TypeError:
+crypto.hash is not a function` before a spec loads. Vitest 5 raises its own floor to `^22.12.0 ||
+^24.0.0 || >=26.0.0`, and `@angular/build` 22 needs `^22.22.3 || ^24.15.0 || >=26.0.0`. CI tests
+Node 22, 24 and 26, so 22 is what is actually exercised. Which version to run is measured in
 [Performance → Which Node version](https://vitest-auto-spy.dev/core/performance#which-node-version):
 the break is between 22 and 24, where a cold import more than halves.
 
@@ -255,14 +279,54 @@ the published package roughly in half.
 
 ### Peer dependencies
 
-All peers are **provided by your project**; `rxjs` and `@angular/core` are **optional** — install
-them only for the matching entry point. The package itself has **zero runtime dependencies**.
-
-| Peer            | Needed for                                                                                                                                 | Optional? |
-| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | --------- |
-| `vitest`        | the default runner                                                                                                                         | no        |
-| `rxjs`          | `vitest-auto-spy/rxjs` observable spies — `>=7`, **no upper bound** (the rxjs 8 line included); not needed to type-check a spy since 4.0.0 | yes       |
-| `@angular/core` | `vitest-auto-spy/angular` helpers                                                                                                          | yes       |
+All peers are **provided by your project**; `rxjs` and the three `@angular/*` packages are
+**optional** — install them only for the matching entry point. The package itself has **zero runtime
+dependencies**.
+
+| Peer                        | Needed for                                                                                                                                   | Optional? |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
+| `vitest`                    | the default runner                                                                                                                           | no        |
+| `rxjs`                      | `vitest-auto-spy/rxjs` observable spies — `>=7.2`, **no upper bound** (the rxjs 8 line included); not needed to type-check a spy since 4.0.0 | yes       |
+| `@angular/core`             | `vitest-auto-spy/angular` and `vitest-auto-spy/bun-angular` helpers — `>=20`                                                                 | yes       |
+| `@angular/common`           | `vitest-auto-spy/angular-http` — `>=20`, that entry only                                                                                     | yes       |
+| `@angular/platform-browser` | `By` and the directive matchers on `vitest-auto-spy/angular`, and the Bun preload's platform — `>=20`                                        | yes       |
+
+**rxjs ≥ 7.2**, and that number moved because an import specifier did. The observable layer builds
+its subjects out of six operators — `concatMap`, `delay`, `switchMap`, `take`, `takeUntil`,
+`takeWhile` — and it took them from `rxjs/operators`, the legacy deep path. **rxjs 8 removes that
+path entirely**, so the old open-ended `>=7.0.0` was promising a version the code could not have
+served. The operators now come from the root `rxjs` entry, which is where rxjs itself re-exported
+them in **7.2** — checked against rxjs 7.2.0's own `dist/types/index.d.ts`, not against its release
+notes. `firstValueFrom`, which is what justified the old 7.0 floor, is still there; 7.2 is simply the
+first version where every symbol this package imports exists at the specifier it imports it from.
+
+It costs an Angular consumer nothing. Every Angular major from 16 to 22 declares its own rxjs peer
+as `^6.5.3 || ^7.4.0`, which is already above what this asks — so only a project that pins `rxjs@7.0`
+or `7.1` on purpose has anything to do.
+
+**Angular ≥ 20**, and two symbols the shipped code imports **as values** are what set the number. A
+missing value import is a link error, so the symptom is never one unavailable helper — it is an
+entry that does not load:
+
+- **`ɵSIGNAL` exists from Angular 18.** `runEffect()` reads it, and that import is the first line of
+  the `/angular` bundle, evaluated eagerly. On Angular 16 or 17 the entry fails to link, taking
+  `provideAutoSpy`, `injectSpy` and the rest with it — not just `runEffect`.
+- **`provideZonelessChangeDetection` exists from Angular 20.** In 18 and 19 the same function was
+  named `provideExperimentalZonelessChangeDetection`; in 16 and 17 there was nothing to name.
+  `vitest-auto-spy/bun-angular` imports it by name, so below 20 `bun test` dies loading the preload,
+  before any spec file.
+
+Angular 20 is also the oldest Angular that Angular still supports — six months active plus twelve
+months LTS put 19 past end of life on **2026-05-19**, and 18, 17 and 16 before it. The technical
+floor and the supported floor are the same number, so nothing still receiving fixes is cut off; the
+range this replaces said `>=16.0.0`, which was a promise on versions where the main entry could not
+link. No upper bound is set on purpose — one would force a release per Angular major and hand
+`ERESOLVE` to whoever upgraded first.
+
+`@angular/platform-browser` is declared for the first time here. `vitest-auto-spy/angular` has
+always imported `By` from it as a value, and the Bun preload boots through `platformBrowserTesting()`.
+Under npm's hoisted `node_modules` it resolved by accident — every Angular workspace has it — while
+under pnpm's isolated layout it did not resolve at all. Declaring it makes the accident a contract.
 
 ## The CLI — `doctor`, `perf`, `codemod` and `init`
 
@@ -412,7 +476,9 @@ enough for `--from auto` to classify a file, for exactly the same reason — tha
 
 **Dry-run by default**, so the first thing a repository sees is a diff it can reject. `--write`
 applies it, `--only` / `--skip` select transforms by id, `--list` prints them together with the
-generated entry-point table.
+generated entry-point table. Past 50 000 files the scan truncates and says so, because *Nothing left
+to migrate* off a truncated list is a claim about a tree it never looked at;
+`VITEST_AUTO_SPY_SCAN_CAP` raises the cap.
 
 What it deliberately does not do is guess. A `jest.*` member with no `vi` twin — `requireMock`,
 `replaceProperty`, `createMockFromModule`, `jest.setTimeout`, `requireActual` — is **left exactly as
@@ -1079,26 +1145,26 @@ the conditional types that pick helpers from a return type — see
 The library ships a framework-agnostic core plus runtime and framework layers, so a plain
 Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runtime bundle**:
 
-| Import                           | Provides                                                                                                                                                                                                       | Pulls in                    | Status |
-| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | :----: |
-| `vitest-auto-spy`                | `createSpyFromClass`, `createAutoMock`, `createFunctionSpy`, sync + promise + accessor spies, `errorHandler`, types                                                                                            | `vitest`                    |   ✅   |
-| `vitest-auto-spy/rxjs`           | observable spies (`nextWith`, `nextWithValues`, `observablePropsToSpyOn`, …) and `createObservableWithValues`                                                                                                  | `rxjs`                      |   ✅   |
-| `vitest-auto-spy/angular`        | `provideAutoSpy`, `injectSpy`, `renderShallow`, `createWithAutoSpies`, `stable`/`flushEffects`, `settleResource`, `mockResourceProp`, the `mock*Prop` helpers, signal & resource matchers, TestBed diagnostics | `@angular/core`             |   ✅   |
-| `vitest-auto-spy/angular-http`   | `provideHttpTesting`, `expectRequest`, `expectNoRequest`, `verifyNoPendingRequests` — the `httpResource()` / `HttpClient` recipe in two lines, settling included                                               | `@angular/common`           |   ✅   |
-| `vitest-auto-spy/bun`            | the same core, driven by Bun's `bun:test` mocks                                                                                                                                                                | `bun:test`                  |   ✅   |
-| `vitest-auto-spy/bun-angular`    | Angular's `TestBed` under `bun test` — DOM, JIT `templateUrl` resolution and a zoneless environment, from one preload                                                                                          | `bun:test`, `@angular/core` |   ✅   |
-| `vitest-auto-spy/node`           | the same core, driven by `node:test`'s `mock.fn()`, plus `trackNodeMocks()` — a private `MockTracker` so dropped spies are actually freed                                                                      | `node:test`                 |   ✅   |
-| `vitest-auto-spy/nestjs`         | `provideAutoSpy`, `injectSpy` for `Test.createTestingModule`                                                                                                                                                   | — (your `@nestjs/*`)        |   ✅   |
-| `vitest-auto-spy/react`          | the core, with a natural import for React Testing Library suites                                                                                                                                               | — (your `react`)            |   ✅   |
-| `vitest-auto-spy/vue`            | `provideAutoSpy` for `global.provide` + Pinia store spying                                                                                                                                                     | — (your `vue`/`pinia`)      |   ✅   |
-| `vitest-auto-spy/svelte`         | the core, with a natural import for Svelte suites                                                                                                                                                              | — (your `svelte`)           |   ✅   |
-| `vitest-auto-spy/console`        | `consoleInfoSpy` & friends — silent typed spies over the global `console`, installed on import                                                                                                                 | `vitest`                    |   ✅   |
-| `vitest-auto-spy/jasmine`        | the drop-in surface for a `jasmine-auto-spies` suite — `.and` / `.calls` / `.withArgs` on every spy, `createSpyObj`, the `jasmine` namespace, `registerJasmineMatchers`                                        | `vitest`                    |   ✅   |
-| `vitest-auto-spy/jasmine-compat` | `enableJasmineCompat()` alone — the same `.and` / `.calls` layer, registering no adapter, for `bun test` and `node --test`                                                                                     | — (your runner)             |   ✅   |
-| `vitest-auto-spy/observer-spy`   | `subscribeSpyTo` / `ObserverSpy` / `SubscriberSpy` — the `@hirez_io/observer-spy` surface, so `/rxjs` does not carry it                                                                                        | `rxjs`                      |   ✅   |
-| `vitest-auto-spy/setup`          | `setupAutoSpy()` — property restore, duplicate-copy detection and mock-registry hygiene in one call; `setupFakeTimers()` / `advanceTimers()`                                                                   | `vitest`                    |   ✅   |
-| `vitest-auto-spy/zone`           | `fakeAsync` / `waitForAsync` on Vitest — the ProxyZone patch `zone.js/testing` does not ship. Reads the `zone.js` **you** loaded; imports none of it                                                           | — (your `zone.js`)          |   ✅   |
-| `vitest-auto-spy/eslint-plugin`  | the lint rules that steer a suite onto these helpers                                                                                                                                                           | — (your `eslint`)           |   ✅   |
+| Import                           | Provides                                                                                                                                                                                                       | Pulls in                                                 | Status |
+| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- | :----: |
+| `vitest-auto-spy`                | `createSpyFromClass`, `createAutoMock`, `createFunctionSpy`, sync + promise + accessor spies, `errorHandler`, types                                                                                            | `vitest`                                                 |   ✅   |
+| `vitest-auto-spy/rxjs`           | observable spies (`nextWith`, `nextWithValues`, `observablePropsToSpyOn`, …) and `createObservableWithValues`                                                                                                  | `rxjs`                                                   |   ✅   |
+| `vitest-auto-spy/angular`        | `provideAutoSpy`, `injectSpy`, `renderShallow`, `createWithAutoSpies`, `stable`/`flushEffects`, `settleResource`, `mockResourceProp`, the `mock*Prop` helpers, signal & resource matchers, TestBed diagnostics | `@angular/core`, `@angular/platform-browser`             |   ✅   |
+| `vitest-auto-spy/angular-http`   | `provideHttpTesting`, `expectRequest`, `expectNoRequest`, `verifyNoPendingRequests` — the `httpResource()` / `HttpClient` recipe in two lines, settling included                                               | `@angular/common`                                        |   ✅   |
+| `vitest-auto-spy/bun`            | the same core, driven by Bun's `bun:test` mocks                                                                                                                                                                | `bun:test`                                               |   ✅   |
+| `vitest-auto-spy/bun-angular`    | Angular's `TestBed` under `bun test` — DOM, JIT `templateUrl` resolution and a zoneless environment, from one preload                                                                                          | `bun:test`, `@angular/core`, `@angular/platform-browser` |   ✅   |
+| `vitest-auto-spy/node`           | the same core, driven by `node:test`'s `mock.fn()`, plus `trackNodeMocks()` — a private `MockTracker` so dropped spies are actually freed                                                                      | `node:test`                                              |   ✅   |
+| `vitest-auto-spy/nestjs`         | `provideAutoSpy`, `injectSpy` for `Test.createTestingModule`                                                                                                                                                   | — (your `@nestjs/*`)                                     |   ✅   |
+| `vitest-auto-spy/react`          | the core, with a natural import for React Testing Library suites                                                                                                                                               | — (your `react`)                                         |   ✅   |
+| `vitest-auto-spy/vue`            | `provideAutoSpy` for `global.provide` + Pinia store spying                                                                                                                                                     | — (your `vue`/`pinia`)                                   |   ✅   |
+| `vitest-auto-spy/svelte`         | the core, with a natural import for Svelte suites                                                                                                                                                              | — (your `svelte`)                                        |   ✅   |
+| `vitest-auto-spy/console`        | `consoleInfoSpy` & friends — silent typed spies over the global `console`, installed on import                                                                                                                 | `vitest`                                                 |   ✅   |
+| `vitest-auto-spy/jasmine`        | the drop-in surface for a `jasmine-auto-spies` suite — `.and` / `.calls` / `.withArgs` on every spy, `createSpyObj`, the `jasmine` namespace, `registerJasmineMatchers`                                        | `vitest`                                                 |   ✅   |
+| `vitest-auto-spy/jasmine-compat` | `enableJasmineCompat()` alone — the same `.and` / `.calls` layer, registering no adapter, for `bun test` and `node --test`                                                                                     | — (your runner)                                          |   ✅   |
+| `vitest-auto-spy/observer-spy`   | `subscribeSpyTo` / `ObserverSpy` / `SubscriberSpy` — the `@hirez_io/observer-spy` surface, so `/rxjs` does not carry it                                                                                        | `rxjs`                                                   |   ✅   |
+| `vitest-auto-spy/setup`          | `setupAutoSpy()` — property restore, duplicate-copy detection and mock-registry hygiene in one call; `setupFakeTimers()` / `advanceTimers()`                                                                   | `vitest`                                                 |   ✅   |
+| `vitest-auto-spy/zone`           | `fakeAsync` / `waitForAsync` on Vitest — the ProxyZone patch `zone.js/testing` does not ship. Reads the `zone.js` **you** loaded; imports none of it                                                           | — (your `zone.js`)                                       |   ✅   |
+| `vitest-auto-spy/eslint-plugin`  | the lint rules that steer a suite onto these helpers                                                                                                                                                           | — (your `eslint`)                                        |   ✅   |
 
 ✅ all entry points published (see [Availability](#availability)).
 
@@ -1341,26 +1407,26 @@ time budget — these cases allocate doubles by the tens of thousands, and GC co
 created rather than elapsed time, so a fixed time budget would have handed a faster arm more
 allocations and made it pay for its own speed.
 
-**Every micro-benchmark table is this library's**, and the margin is against the *best* other arm in
+**Every micro-benchmark table is this library's**, and the margin is against the _best_ other arm in
 that table. The three class sizes are measured project profiles, not round numbers — across four
 private Angular suites (~2 700 spec files, 2 742 doubles built from a class) the median service has
 5-8 methods and the spec touches 1 of them:
 
-| Case (micro) | 4.0 | 4.1 | best other arm | lead |
-| --- | ---: | ---: | ---: | ---: |
-| small project — 6 methods, 1 called | — | **1.42 µs** | 6.83 µs hand-written | 4.82x |
-| medium project — 14 methods, 2 called | — | **2.67 µs** | 15.92 µs hand-written | 5.97x |
-| large project — 45 methods, 2 called | — | **5.79 µs** | 52.79 µs hand-written | 9.11x |
-| worst case — all 14 of 14 methods called | 18.92 µs (0.66x, a loss) | **8.17 µs** | 17.92 µs hand-written | 2.19x |
-| worst case — all 45 of 45 methods called | 75.33 µs (0.71x, a loss) | **26.12 µs** | 62.04 µs hand-written | 2.37x |
-| double from a type — 2 / 10 / 40 members | 3.58 / 18.17 / 72.88 µs (a loss) | **1.00 / 4.67 / 18.92 µs** | 2.79 / 13.83 / 56.79 µs vitest-mock-extended | 2.79-3.00x |
-| deep double, 3 levels, leaf called | 8.83 µs (0.61x, a loss) | **2.29 µs** | 5.46 µs vitest-mock-extended | 2.38x |
-| configure a return + 3 calls — class / type | 3.29 / 2.08 µs (type a loss) | **2.21 / 0.71 µs** | 16.38 µs hand-written / 1.58 µs @golevelup | 7.41x / 2.24x |
-| `calledWith` dispatch, 2 configured + 1 miss | 0.54 µs (parity) | **0.17 µs** | 0.54 µs vitest-mock-extended | 3.25x |
+| Case (micro)                                 |                              4.0 |                        4.1 |                               best other arm |          lead |
+| -------------------------------------------- | -------------------------------: | -------------------------: | -------------------------------------------: | ------------: |
+| small project — 6 methods, 1 called          |                                — |                **1.42 µs** |                         6.83 µs hand-written |         4.82x |
+| medium project — 14 methods, 2 called        |                                — |                **2.67 µs** |                        15.92 µs hand-written |         5.97x |
+| large project — 45 methods, 2 called         |                                — |                **5.79 µs** |                        52.79 µs hand-written |         9.11x |
+| worst case — all 14 of 14 methods called     |         18.92 µs (0.66x, a loss) |                **8.17 µs** |                        17.92 µs hand-written |         2.19x |
+| worst case — all 45 of 45 methods called     |         75.33 µs (0.71x, a loss) |               **26.12 µs** |                        62.04 µs hand-written |         2.37x |
+| double from a type — 2 / 10 / 40 members     | 3.58 / 18.17 / 72.88 µs (a loss) | **1.00 / 4.67 / 18.92 µs** | 2.79 / 13.83 / 56.79 µs vitest-mock-extended |    2.79-3.00x |
+| deep double, 3 levels, leaf called           |          8.83 µs (0.61x, a loss) |                **2.29 µs** |                 5.46 µs vitest-mock-extended |         2.38x |
+| configure a return + 3 calls — class / type  |     3.29 / 2.08 µs (type a loss) |         **2.21 / 0.71 µs** |   16.38 µs hand-written / 1.58 µs @golevelup | 7.41x / 2.24x |
+| `calledWith` dispatch, 2 configured + 1 miss |                 0.54 µs (parity) |                **0.17 µs** |                 0.54 µs vitest-mock-extended |         3.25x |
 
 Six of those rows were losses and one was parity. What changed is that a method spy is no longer a
 `vi.fn()` — see [The spy engine](#the-spy-engine) — plus one thing that is not the engine: a
-`calledWith(x)` of a single primitive argument used to be rendered into a string key on *every call*
+`calledWith(x)` of a single primitive argument used to be rendered into a string key on _every call_
 of that spy, where a `Map` keyed by the value does the same lookup with no allocation.
 
 The three class sizes changed in the same release, from round numbers to measured profiles, so the
@@ -1373,10 +1439,10 @@ vi.fn() per method` arm is in the table precisely so its size stays visible.
 the 4.1 build, 20-method class, `isolate: true`, coverage on, 3 rounds per cell after a discarded
 warm-up, medians of the three):
 
-| Comparison | 1 000 tests | 3 000 tests | 10 000 tests |
-| --- | ---: | ---: | ---: |
-| vitest-auto-spy | 1.33 s | 2.86 s | 10.02 s |
-| hand-written `vi.fn()` | 1.31 s (0.99×) | 2.85 s (1.00×) | 9.25 s (0.92×) |
+| Comparison                  |    1 000 tests |    3 000 tests |    10 000 tests |
+| --------------------------- | -------------: | -------------: | --------------: |
+| vitest-auto-spy             |         1.33 s |         2.86 s |         10.02 s |
+| hand-written `vi.fn()`      | 1.31 s (0.99×) | 2.85 s (1.00×) |  9.25 s (0.92×) |
 | @bugsplat/vitest-auto-spies | 2.00 s (1.50×) | 4.61 s (1.61×) | 15.45 s (1.54×) |
 
 Hand-written doubles are still cheaper — **about 3% at the median**, down from 10-15% before 4.1,
@@ -1387,11 +1453,11 @@ suite swamps it.
 
 **Memory, `isolate: false`, 100-method class, 10 000 tests, peak RSS:**
 
-| Arm | Peak RSS |
-| --- | ---: |
-| hand-written `vi.fn()` | 6366 MB |
-| vitest-auto-spy, default | 2103 MB |
-| vitest-auto-spy, `lazySpies: 'proxy'` | 1851 MB |
+| Arm                                   | Peak RSS |
+| ------------------------------------- | -------: |
+| hand-written `vi.fn()`                |  6366 MB |
+| vitest-auto-spy, default              |  2103 MB |
+| vitest-auto-spy, `lazySpies: 'proxy'` |  1851 MB |
 
 Hand-written doubles use 3.0x the default's peak RSS here — the difference between finishing and an
 OOM'd worker on a large suite.
@@ -1413,7 +1479,7 @@ Full write-up, methodology and the complete suite-scale tables:
 
 ### Reproducing the numbers
 
-Node **>=18** (the project floor); the numbers above were captured on Node v24.19.0. The steps are
+Node **>=22** (the project floor); the numbers above were captured on Node v24.19.0. The steps are
 identical on Windows, macOS and Linux — same Node, same npm, same commands, nothing OS-specific to
 call out:
 
@@ -2508,7 +2574,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `installPerTest(install)`                                                                | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                                                                           |
 | `setupAngularTestEnv(opts)`                                                              | `/angular`                    | Zone and zoneless spec files in one worker, switching platforms per file                                                                                                                              |
 | `restoreTimerGlobals()`                                                                  | `/setup`                      | Put back timer globals that uninstalling the fakes deleted rather than restored                                                                                                                       |
-| `restoreWebStorage(options?)`                                                             | `/setup`                      | Give `globalThis` a `localStorage` / `sessionStorage` that work when the runner's copy never arrived ([details](#test-run-hygiene))                                                                    |
+| `restoreWebStorage(options?)`                                                            | `/setup`                      | Give `globalThis` a `localStorage` / `sessionStorage` that work when the runner's copy never arrived ([details](#test-run-hygiene))                                                                   |
 | `trackMockRegistry()` / `keepMockRegistered(mock)` / `restoreLongLivedImplementations()` | `/setup`                      | Keep @vitest/spy's mock registry to the mocks that outlive a file; mark one the split would miss; put back an implementation a cross-file `vi.resetAllMocks()` dropped ([details](#test-run-hygiene)) |
 | `trackNodeMocks()` / `pruneNodeMocks()` / `countNodeMocks()`                             | `/node`                       | Give this library its own `node:test` `MockTracker` so a dropped spy is freed — 21× less retained heap; sweep by hand, and read the count back                                                        |
 | `setSpyEngine(engine)` / `getSpyEngine()`                                                | `/setup`                      | Build method spies from this library's own mock (`'auto-spy'`, the default) or from `vi.fn()` (`'runner'`) ([details](#the-spy-engine))                                                               |
@@ -2752,10 +2818,10 @@ expensive to diagnose when it is missing. The first three are on by default:
     so the 404 is never written and a routing mistake is reported as a slow test.
 11. **Web Storage the runner never handed over.** On by default, because it only ever repairs.
     Vitest copies a DOM environment's globals onto `globalThis` behind `if (k in global) return
-    KEYS.includes(k)`, and neither `localStorage` nor `sessionStorage` is in `KEYS` — they used to
+KEYS.includes(k)`, and neither `localStorage` nor `sessionStorage` is in `KEYS` — they used to
     arrive only because Node put neither on `globalThis`, so the first half was false. Node's own
     Web Storage made the key exist, and now the environment's storage never arrives: `setItem is
-    not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom alike, since the
+not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom alike, since the
     filter runs before either. A suite stays green with this broken — only the specs that touch
     storage fail — so it arrives as "CI moved to a new Node and eleven unrelated specs died". The
     repair decides by using the storage rather than looking at it, replaces only one that cannot
@@ -2773,7 +2839,7 @@ expensive to diagnose when it is missing. The first three are on by default:
 | `guardGlobals`        | `'off'`   | Report a test that redefines a global property as non-configurable                    |
 | `globalFakeTimers`    | `false`   | Fake timers for every test **and between them** — Jest's `enableGlobally`             |
 | `restoreTimerGlobals` | `true`    | Put back timer globals that uninstalling the fakes deleted                            |
-| `restoreWebStorage`   | `true`    | Give the run a `localStorage` / `sessionStorage` that work                             |
+| `restoreWebStorage`   | `true`    | Give the run a `localStorage` / `sessionStorage` that work                            |
 | `pruneMockRegistry`   | `false`   | Keep @vitest/spy's ever-growing mock registry to the mocks that outlive a file        |
 | `hookTimeoutHint`     | `true`    | Explain a hook that ran out of `hookTimeout` while `testTimeout` is larger            |
 | `frozenClockHint`     | `true`    | Explain a timeout that happened because nothing advanced the fake clock               |
@@ -3192,7 +3258,7 @@ another, and the next one is in that same file.
 | `asInstance(spy)` / `asSpy(instance)`                                                                             | The two named views between `Spy<T>` / `DeepMockProxy<T>` and `T`, instead of `as any`                                                                |
 | `createSpyClass(Class, config?)`                                                                                  | A spy that can be called with `new`; records `calls` and `instances`                                                                                  |
 | `mockConstructor(factory, name?)` / `stubConstructor(obj, key, factory)`                                          | A runner mock that is also a constructor — for a global or an SDK with no class at runtime                                                            |
-| `stubAbortController()`                                                                                           | A realm-consistent `AbortController` / `AbortSignal` for jsdom + zone.js                                                                              |
+| `stubAbortController()`                                                                                           | A realm-consistent `AbortController` / `AbortSignal` for jsdom + zone.js, statics (`abort`, `timeout`, `any`) included                                |
 | `flushEventLoop(turns?)` / `settleDynamicImport(load, turns?)`                                                    | Real event-loop turns under fake timers; wait for a dynamic `import()`                                                                                |
 | `autoMocked<T>(overrides?)`                                                                                       | `createAutoMock` typed as `T & Spy<T>`                                                                                                                |
 | `mockSystemTime` / `withSystemTime` / `mockNow` / `useCountingClock` _(`/setup`)_                                 | Clock control that survives fake timers being re-installed per test                                                                                   |

package/dist/angular-http.js

@@ -1,14 +1,25 @@
-import { flushEffects } from './chunk-5BPM3BLI.js';
+import { flushEffects } from './chunk-ALFMIDWW.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';
 import { provideHttpClient } from '@angular/common/http';
 import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
 import { TestBed } from '@angular/core/testing';
 import { afterEach } from 'vitest';
 
+function verifyOnTeardown(check) {
+  try {
+    check();
+  } catch (error) {
+    TestBed.resetTestingModule();
+    throw error;
+  }
+}
+performance.now.bind(performance);
+
+// src/lib/angular-http.ts
 var SETTLE_ROUNDS = 2;
-var verifyArmed = false;
+var verifyPolicy = false;
 function provideHttpTesting(options = {}) {
-  verifyArmed = options.verifyOnTeardown ?? true;
+  verifyPolicy = options.verifyOnTeardown ?? true;
   return [provideHttpClient(), provideHttpClientTesting()];
 }
 function describeRequest(request) {
@@ -136,11 +147,10 @@ Answer it (\`await expectRequest('/url').flush(body)\`), assert it is absent (\`
   );
 }
 afterEach(() => {
-  if (!verifyArmed) {
+  if (!verifyPolicy) {
     return;
   }
-  verifyArmed = false;
-  verifyNoPendingRequests();
+  verifyOnTeardown(verifyNoPendingRequests);
 });
 
 export { expectNoRequest, expectRequest, provideHttpTesting, verifyNoPendingRequests };

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-LsBDcSNZ.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-BFq3ve6Q.js';
 import { InjectionToken, Provider, Type, Signal, WritableSignal } from '@angular/core';
 import { TestAPI } from 'vitest';
 import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-CQLPjw8z.js';
@@ -57,8 +57,8 @@ interface ExtendWithAutoSpiesOptions {
      * Providers registered alongside the spies, in the same `configureTestingModule` call — the
      * component under test, a real service the spec deliberately keeps, `provideHttpClient()`.
      *
-     * They go in *before* the generated ones, so a provider named here wins over the auto-spy that
-     * would otherwise be made for the same token.
+     * They go in *after* the generated ones, so a provider named here wins over the auto-spy that
+     * would otherwise be made for the same token — Angular resolves duplicate providers last-one-wins.
      */
     providers?: Provider[];
 }