vitest-auto-spy 5.45.0 → 5.46.0

package/CHANGELOG.md

@@ -10,6 +10,84 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.46.0] - 2026-09-27
+
+### Added
+
+- **`stubAnimationFrame(...).lastHandle`: the handle the latest `requestAnimationFrame` returned.**
+  5.40.0 moved the stub's handles above 2^30 so a native frame's cancel could be told apart, and a
+  spec that asserted `expect(frames.cancelAnimationFrame).toHaveBeenLastCalledWith(1)` broke on the
+  upgrade with nothing in that entry saying so. `lastHandle` is `undefined` before the first request,
+  so the assertion reads `toHaveBeenLastCalledWith(frames.lastHandle)` and survives any numbering.
+- **`injectHttpTesting()` from `/angular-http`: the `HttpTestingController` `provideHttpTesting()`
+  installed.** A spec of a service that returns an Observable has its request out before the method
+  returns, so it calls `expectOne` / `match` / `expectNone` synchronously, and `expectRequest` (which
+  ticks and flushes asynchronously) is not a drop-in there; such specs kept a
+  `TestBed.inject(HttpTestingController)` beside `...provideHttpTesting()`. Without the providers it
+  throws the message `expectRequest` gives, naming `provideHttpTesting()`.
+- **`expectRequest(...).error(status, { error })`: the payload the `HttpErrorResponse` carries.** The
+  helper always failed the request with `new ProgressEvent('error')`, so a spec that pinned
+  `HttpErrorResponse.error` stayed on `HttpTestingController`. The default is unchanged. `error(0)` is
+  documented as the network failure it is.
+- **`{ tick: false }` on `expectRequest` and `expectNoRequest`.** Both tick the app first, and a module
+  that provides a partial `DOCUMENT` double fails that tick inside Angular
+  (`inject(...).body?.querySelector is not a function`). The option skips the tick before the lookup and
+  after the answer, for an `HttpClient` call whose request is already out.
+
+### Fixed
+
+- **`toHaveSignalValue` and `toHaveResourceValue` compare the contents of a `Set` and a `Map`.** They
+  called the matcher context's `equals` without `iterableEquality`, so a collection had no own keys to
+  compare and any two Sets, or any two Maps, were equal:
+  `expect(signal(new Set(['a']))).toHaveSignalValue(new Set(['b']), { strict: true })` passed, nested
+  in an object as well. Both now compare with the testers `toEqual` uses, and `{ strict: true }` with
+  those of `toStrictEqual` (array holes inside a collection and `ArrayBuffer` bytes included). The
+  non-strict branch also ignored testers registered through `expect.addEqualityTesters`; both modes
+  apply them now. An assertion on a Set- or Map-valued signal that passed only because of this can
+  newly fail.
+- **A tick that fails on a doubled `DOCUMENT` says so.** `expectRequest` / `expectNoRequest` failed with
+  Angular's bare `TypeError`; when the module's `DOCUMENT` is not the real document, the error now names
+  it and `{ tick: false }`, with Angular's error as `cause`. A tick failure under the real document is
+  rethrown as it was.
+- **`jasmine.mapContaining` / `setContaining` / `arrayWithExactContents` compare a nested `Set` or
+  `Map` by its contents**, for the same reason: `new Map([['a', new Set([1])]])` contained
+  `new Map([['a', new Set([2])]])`.
+
+### Changed
+
+- **`stubAnimationFrame`'s spies are typed `Mock<RequestAnimationFrameFn>` /
+  `Mock<CancelAnimationFrameFn>`** instead of `(...args: any[]) => any`, so
+  `frames.requestAnimationFrame.mock.calls` compiles and is typed. Both function types are exported
+  from `/dom-stubs` and spelled without the DOM lib. A spec that called the spy with arguments
+  `requestAnimationFrame` does not take now fails to compile.
+
+### Size
+
+`/angular/matchers` **2799 → 2936 B** min+gzip (+137 B, +4.9 %) and +1.0 kB to import (22906 →
+23887 B, one module more): the shared equality module the signal and resource matchers now use.
+`/jasmine` 19161 → 19203 B (+42 B) and +1.3 kB to import (148816 → 150096 B, one module more): the
+same module, for the collection matchers. `/angular-http` 3770 → 3997 B (+227 B, +6.0 %) and +0.9 kB
+to import (31370 → 32313 B): `injectHttpTesting`, the `{ tick }` option, the doubled-`DOCUMENT`
+message and the `error` payload. `/dom-stubs` +14 B.
+
+### Documentation
+
+- **The 5.40.0 handle range is a change a spec may have to act on.** A literal handle (`1`, `2`) in an
+  assertion against `frames.cancelAnimationFrame` fails from 5.40.0; assert against `frames.lastHandle`
+  or the value `requestAnimationFrame` returned. The frame page, `agent-docs/doubles.md`, the README
+  and the skill say so.
+- **`SubjectOf` from `/angular` is still rxjs's `Subject` only with `vitest-auto-spy/rxjs` in the
+  program.** `agent-docs/return-helpers.md` and the API page recommended the `/angular` export for a
+  variable holding `returnSubject()` without repeating that; without the import it is `SubjectLike`,
+  so `next()` compiles and `pipe()` does not. `SubjectLike`'s member list in `agent-docs` gains
+  `unsubscribe`.
+- **Asserting the errors `flushUnhandledObservableErrors()` returned, without `.map(({ error }) => error)`:**
+  `expect(flushUnhandledObservableErrors()).toMatchObject([{ error: new Error('502') }])` checks the
+  count and ignores `test`. The setup page and `agent-docs/setup.md` show it.
+- **"Only these console channels" is `expect(Object.keys(consoleOutput())).toStrictEqual(['info'])`**,
+  keys in alphabetical order; `{ info: expect.any(Array) }` trips `no-unsafe-assignment`.
+  `agent-docs/setup.md` and the `consoleOutput` docs show it.
+
 ## [5.45.0] - 2026-09-27
 
 ### Added
@@ -5922,7 +6000,8 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.45.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.46.0...HEAD
+[5.46.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.45.0...v5.46.0
 [5.45.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.44.0...v5.45.0
 [5.44.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.43.0...v5.44.0
 [5.43.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.42.0...v5.43.0

package/README.md

@@ -1581,7 +1581,7 @@ Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runti
 | `vitest-auto-spy/angular/diagnostics` | `enableAngularDiagnostics` and the whole TestBed timing family — a companion to `/angular`, no core re-export; moved off `/angular` in 5.21.0                                                                                                                                                                                                                                                                                                                             | `@angular/core`                                          |   ✅   |
 | `vitest-auto-spy/angular/doubles`     | the `window` / `document` and Material-dialog doubles; registers the Vitest adapter, so its doubles spy out of the box; moved off `/angular` in 5.21.0                                                                                                                                                                                                                                                                                                                    | `@angular/core`                                          |   ✅   |
 | `vitest-auto-spy/angular/matchers`    | `registerDirectiveMatchers`, `registerResourceMatchers`, `registerSignalMatchers` — a companion to `/angular`, no core re-export; moved off `/angular` in 5.21.0                                                                                                                                                                                                                                                                                                          | `@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/angular-http`        | `provideHttpTesting`, `expectRequest`, `expectNoRequest`, `verifyNoPendingRequests`, `injectHttpTesting` — the `httpResource()` / `HttpClient` recipe in two lines, settling included                                                                                                                                                                                                                                                                                     | `@angular/common`                                        |   ✅   |
 | `vitest-auto-spy/angular-router`      | `provideActivatedRoute`, `injectActivatedRoute`, `createActivatedRoute` — Angular's own `ActivatedRoute` over one record, streams and snapshot moved together; `provideRouterDouble` / `injectRouterDouble` for the `Router` beside it, with `collectRouterEvents()` asserting the events that follow; `provideLocationDouble` wrapping the `SpyLocation` Angular ships                                                                                                   | `@angular/router`, `@angular/common`                     |   ✅   |
 | `vitest-auto-spy/signal-forms`        | `createForm` — Angular's own `form()` built where it can inject — and `registerFormMatchers()` for `toHaveFieldErrors`                                                                                                                                                                                                                                                                                                                                                    | `@angular/forms` (>=22)                                  |   ✅   |
 | `vitest-auto-spy/bun`                 | the same core, driven by Bun's `bun:test` mocks                                                                                                                                                                                                                                                                                                                                                                                                                           | `bun:test`                                               |   ✅   |
@@ -3139,7 +3139,9 @@ it('loads the products', async () => {
 `expectRequest` ticks before it looks — an `httpResource()` has issued nothing until something does —
 and `flush()` / `error()` settle before they resolve, which is why the value reads on the next line.
 Match by URL (either `url` or `urlWithParams`), by `RegExp`, or by a predicate over the request, with
-`{ method }` to tell a read from a write. `provideHttpTesting()` fails, by default, any test that
+`{ method }` to tell a read from a write. `error(0)` is a network failure, and
+`error(status, { error })` sets the payload the `HttpErrorResponse` carries. `{ tick: false }` skips
+the tick, for a module whose partial `DOCUMENT` double the tick cannot run against. `provideHttpTesting()` fails, by default, any test that
 ends holding a request nothing answered; `provideHttpTesting({ verifyOnTeardown: false })` turns that
 off, and `verifyNoPendingRequests()` runs the same check by hand. An interceptor under test goes in
 the same spread — `provideHttpTesting({ interceptors: [authInterceptor] })`, or
@@ -3289,7 +3291,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `stubAbortController()`                                                                                     | `/dom-stubs`                  | A realm-consistent `AbortController`, so `addEventListener(…, { signal })` works under jsdom + zone.js                                                                                                                                                                                                                                                                                    |
 | `stubWebStorage(key?, opts?)`                                                                               | `/dom-stubs`                  | An in-memory `localStorage` / `sessionStorage` for this test, with `snapshot()` to assert on ([details](#how-to-mock-localstorage-and-sessionstorage))                                                                                                                                                                                                                                    |
 | `stubWorker(opts?)`                                                                                         | `/dom-stubs`                  | A `Worker` whose script is the spec — listeners stack, replies arrive on a microtask, `emit()` / `fail()` from the worker's side ([details](#how-to-mock-a-web-worker))                                                                                                                                                                                                                   |
-| `stubAnimationFrame(opts?)`                                                                                 | `/dom-stubs`                  | `requestAnimationFrame` / `cancelAnimationFrame` run on the spot or on `flush(timestamp?)`; a frame requested inside a frame waits for the next flush; `onError` intercepts a throwing callback                                                                                                                                                                                           |
+| `stubAnimationFrame(opts?)`                                                                                 | `/dom-stubs`                  | `requestAnimationFrame` / `cancelAnimationFrame` run on the spot or on `flush(timestamp?)`; a frame requested inside a frame waits for the next flush; `onError` intercepts a throwing callback; `lastHandle` is the latest handle issued (they start above 2^30)                                                                                                                         |
 | `stubElementRect(el, rect?)`                                                                                | `/dom-stubs`                  | `getBoundingClientRect()` answering a real `DOMRect` built from a partial `DOMRectInit`; returns the undo, plus the installed spy as `.getBoundingClientRect`                                                                                                                                                                                                                             |
 | `flushEventLoop(turns?)` / `settleDynamicImport(load, turns?)`                                              | core                          | Real event-loop turns while the timers are faked — for a dynamic `import()` or native `async` in a dependency                                                                                                                                                                                                                                                                             |
 | `flushEventLoopUntil(isDone, opts?)`                                                                        | core                          | Real turns until a condition holds — a `resource()` leaving `loading` — with a budget instead of a hang                                                                                                                                                                                                                                                                                   |
@@ -4317,7 +4319,7 @@ another, and the next one is in that same file.
 | `stubAbortController()`                                                                                                                     | A realm-consistent `AbortController` / `AbortSignal` for jsdom + zone.js, statics (`abort`, `timeout`, `any`) included                                                                                                                                                                                                   |
 | `stubWebStorage(key?, opts?)` _(`/dom-stubs`)_                                                                                              | An in-memory `localStorage` / `sessionStorage` a spec installs for itself, seeded or empty; `snapshot()` reads it back as a plain record                                                                                                                                                                                 |
 | `stubWorker(opts?)` _(`/dom-stubs`)_                                                                                                        | A `Worker` a spec drives from the worker's side: `respond` per message, `messages` / `terminated` to assert, `emit()` / `fail()`; returns `WorkerStub<TIn, TOut>`                                                                                                                                                        |
-| `stubAnimationFrame(opts?)` _(`/dom-stubs`)_                                                                                                | Frames on the spec's schedule: `'immediate'` or `'queued'` + `flush()`, `pending`, both globals as spies; returns `AnimationFrameStub`                                                                                                                                                                                   |
+| `stubAnimationFrame(opts?)` _(`/dom-stubs`)_                                                                                                | Frames on the spec's schedule: `'immediate'` or `'queued'` + `flush()`, `pending`, `lastHandle`, both globals as spies; returns `AnimationFrameStub`                                                                                                                                                                     |
 | `stubElementRect(el, rect?)` _(`/dom-stubs`)_                                                                                               | A box for `getBoundingClientRect()` — missing fields `0`, edges derived; returns `ElementRectRestore` (callable undo plus `.getBoundingClientRect`)                                                                                                                                                                      |
 | `createComponentStub(Class, overrides?, opts?)` _(`/angular`)_                                                                              | A standalone stand-in for a child component, directive or pipe, built from its compiled definition so the selector cannot drift                                                                                                                                                                                          |
 | `flushEventLoop(turns?)` / `settleDynamicImport(load, turns?)`                                                                              | Real event-loop turns under fake timers; wait for a dynamic `import()`                                                                                                                                                                                                                                                   |
@@ -4339,6 +4341,7 @@ another, and the next one is in that same file.
 | `settleResource(resource, opts?)` _(Angular)_                                                                                               | Tick until an `httpResource()` / `resource()` / `rxResource()` leaves `loading`                                                                                                                                                                                                                                          |
 | `provideHttpTesting(opts?)` / `expectRequest(matcher, opts?)` _(`/angular-http`)_                                                           | `provideHttpClient(...features)` + `provideHttpClientTesting()` in one spread — `{ interceptors, features }` for the interceptors under test; find the one matching request and `flush` / `error` it with the settling included                                                                                          |
 | `expectNoRequest(matcher?, opts?)` / `verifyNoPendingRequests(opts?)` _(`/angular-http`)_                                                   | Assert that nothing was requested / that the test left nothing unanswered; `{ ignoreCancelled: true }` — also accepted by `provideHttpTesting({ verifyOnTeardown })` — forgives a request the code under test unsubscribed from                                                                                          |
+| `injectHttpTesting()` _(`/angular-http`)_                                                                                                   | The `HttpTestingController` `provideHttpTesting()` installed, for a synchronous `expectOne` / `match` / `expectNone` on an Observable service; names the missing providers when there are none                                                                                                                           |
 | `provideActivatedRoute(init?)` / `injectActivatedRoute(injector?)` _(`/angular-router`)_                                                    | An `ActivatedRoute` provider whose streams, `paramMap`s and snapshot share one record, and the handle whose setters move them together                                                                                                                                                                                   |
 | `createActivatedRoute(init?)` _(`/angular-router`)_                                                                                         | The same double without a `TestBed` — `.route` plus the setters                                                                                                                                                                                                                                                          |
 | `provideRouterDouble(init?)` / `injectRouterDouble(injector?)` / `createRouterDouble(init?)` _(`/angular-router`)_                          | A `Router` derived from one URL — `navigate` spies, `setUrl`, `emitNavigation`, `setCurrentNavigation`, and the router's own URL serialization                                                                                                                                                                           |

package/agent-docs/angular.md

@@ -478,6 +478,7 @@ resource's **default** value and passes.
 | `provideHttpTesting(opts?)` | `provideHttpClient(...features)` + `provideHttpClientTesting()`; `{ verifyOnTeardown }` defaults to `true`, and takes `{ ignoreCancelled }` instead of `false`; `{ interceptors: [fn] }` for functional interceptors under test, `{ features: [...] }` for any other `provideHttpClient()` feature |
 | `expectRequest(matcher, opts?)` | tick, then the one match — `.request`, `.flush(body, opts?)`, `.error(status, opts?)` |
 | `expectNoRequest(matcher?, opts?)` | tick, then assert nothing matched; no argument means "nothing at all was requested" |
+| `injectHttpTesting()` | the `HttpTestingController` itself, for a synchronous `expectOne` / `match` / `expectNone` on an Observable service — no tick needed; throws the same missing-providers message |
 | `verifyNoPendingRequests(opts?)` | the teardown check by hand, for mid-test use or a suite with `verifyOnTeardown: false`; `{ ignoreCancelled: true }` forgives a request the code under test unsubscribed from |
 
 An interceptor under test goes into the same call, and the teardown check stays armed — do not
@@ -506,6 +507,10 @@ provided after it, so it wins over `withXhr()`.
 
 `matcher` is a URL (matched against either `url` or `urlWithParams`), a `RegExp` over
 `urlWithParams`, or a predicate `(request) => boolean`. `{ method }` is case-insensitive.
+`.error(0)` is a network failure; `.error(status, { error })` sets the payload `HttpErrorResponse.error`
+carries (default `new ProgressEvent('error')`). A module that provides a partial `DOCUMENT` double
+fails Angular's tick (`inject(...).body?.querySelector is not a function`, reported as a doubled
+`DOCUMENT`): pass `{ tick: false }` to `expectRequest` / `expectNoRequest` when the request is already out.
 `flush()` and `error()` are `async` because settling requires letting a microtask run — `await` them,
 and the next line reads the settled value.
 

package/agent-docs/doubles.md

@@ -156,7 +156,10 @@ running frame is queued in either mode, so a loop that requests its own next fra
 per `flush()`; `frames.flushAll()` runs such a chain until nothing is pending (and throws after 1000
 rounds, on a loop that never stops). A `cancelAnimationFrame` for a handle the stub did not issue — a
 native frame requested before it was installed, such as zoneless Angular's scheduler frame — is
-passed on to the real `cancelAnimationFrame`, so installing the stub after the render leaks no timer. A callback that throws stops `flush()` (or propagates out of `requestAnimationFrame`
+passed on to the real `cancelAnimationFrame`, so installing the stub after the render leaks no timer.
+The stub's own handles start above 2^30 (since 5.40.0), so assert a cancel against the handle it
+issued — `expect(frames.cancelAnimationFrame).toHaveBeenLastCalledWith(frames.lastHandle)`, or the
+value `requestAnimationFrame` returned — never against a literal such as `1`. A callback that throws stops `flush()` (or propagates out of `requestAnimationFrame`
 in `'immediate'` mode); pass `onError: (error) => { … }` to intercept it instead — rethrow from
 inside to keep the default for an error you did not mean to swallow. `stubElementRect` returns a real
 `DOMRect` per call, edges derived, plus the installed spy as `.getBoundingClientRect` for

package/agent-docs/errors.md

@@ -168,6 +168,7 @@ Part of the agent reference [`AGENTS.md`](../AGENTS.md), which maps every sectio
 | `expectRequest: no GET …?page=2 — but GET …?page=3 was made; the query differs` | the same path, another query string | name the query the code sends, or match the path alone: `expectRequest('/api/products')` (§13) |
 | `expectRequest: no request matched … — nothing was requested at all` | an `httpResource()` whose `request()` returned no URL yet, or an `HttpClient` call nothing subscribed to | set the signal the resource reads, or subscribe to the call (§13) |
 | `this TestBed has no HttpTestingController` | `expectRequest` / `expectNoRequest` on a module that never got the testing backend | `TestBed.configureTestingModule({ providers: [...provideHttpTesting()] })` from `vitest-auto-spy/angular-http` (§13) |
+| `TestBed.tick() failed, and this TestBed provides its own DOCUMENT` (cause: `inject(...).body?.querySelector is not a function`) | `expectRequest` / `expectNoRequest` ticked the app, and Angular's tick reads members a partial `DOCUMENT` double lacks | `expectRequest(url, { tick: false })` when the request is already out (an `HttpClient` call), or provide a real document |
 | `X was never answered (end of "…")` / `N requests were never answered` | `provideHttpTesting({ verifyOnTeardown })` or `enableAngularDiagnostics({ pendingRequests })` — the test left a request open; the message names its URL and the test | answer it with the line the message prints (`await expectRequest(url).flush(body)`, `controller.expectOne(url).flush(body)` under diagnostics in a module built on `provideHttpClientTesting()`), or assert its absence (`expectNoRequest(url)`); a cancelled one is forgiven with the `ignoreCancelled` opt-in the message names (§13) |
 | `injectActivatedRoute(): nothing provides ActivatedRoute here` | no `ActivatedRoute` provider in the injector it read | `provideActivatedRoute({ … })` from `vitest-auto-spy/angular-router` in `providers`; `injectActivatedRoute(fixture.debugElement.injector)` for a component-level one (§13) |
 | `the ActivatedRoute here is … not one provideActivatedRoute() built` | a later provider of `ActivatedRoute` won — `provideRouter()`, `RouterModule`, a `useValue`, `provideAutoSpy(ActivatedRoute)` | list `provideActivatedRoute()` last, or drop the other provider (§13) |

package/agent-docs/return-helpers.md

@@ -29,7 +29,7 @@ produce `nextWith is not a function` with nothing pointing at the duplicate. `Pr
 
 `returnSubject()` and `nextWithPerCall()` return `SubjectOf<T>` — rxjs's own `Subject<T>` wherever
 `import 'vitest-auto-spy/rxjs'` is in the TypeScript program, the structural `SubjectLike<T>`
-(`next` / `error` / `complete` / `asObservable` / `closed`) where it is not. The switch is one
+(`next` / `error` / `complete` / `unsubscribe` / `asObservable` / `closed`) where it is not. The switch is one
 augmentable interface, `AutoSpyRxjsTypes<T>`, which `/rxjs` fills in with `subject: Subject<T>`;
 augment it yourself only to plug in a different subject type. If
 `const s: Subject<T> = spy.m.returnSubject()` fails to compile, the import is missing from the
@@ -48,6 +48,10 @@ the Subject it returns is dropped. Keep it when the spec pushes through it later
 `void spy.items$.returnSubject();` when it never does — the rule's default `ignoreVoid: true` accepts
 that.
 
+`SubjectOf` is rxjs's `Subject` only where `import 'vitest-auto-spy/rxjs'` is in the program — the
+`/angular` export does not add it. Without it the variable is `SubjectLike`: `next` / `error` /
+`complete` compile, `pipe()` or an argument typed `Subject<T>` does not.
+
 ```ts
 // argument dispatch — other arguments return undefined
 users.getName.calledWith(1).mockReturnValue('Ada');

package/agent-docs/setup.md

@@ -92,7 +92,9 @@ error as `cause`; one scheduled outside a test fails the file at the sweep. The
 it is still installed (`globalFakeTimers` is); a rethrow `config.onUnhandledError` takes reports
 nothing. Fix it where the stream is subscribed — an error callback or `catchError` — or assert the
 error. `flushUnhandledObservableErrors()` is the same check by hand: it returns `{ error, test }` (or
-`{ error, outsideTest }`) for each rethrow that threw.
+`{ error, outsideTest }`) for each rethrow that threw; assert the errors alone with
+`expect(flushUnhandledObservableErrors()).toMatchObject([{ error: new Error('502') }])` — it checks the
+count and ignores `test`, with no `.map(({ error }) => error)`.
 
 **`countStrayTimers()` cannot see a timer scheduled under fake timers, and that does not compose
 away.** `vi.useFakeTimers()` assigns its own `setTimeout` over the tracking wrapper, so everything
@@ -768,6 +770,8 @@ Docs: https://asdalexey.github.io/vitest-auto-spy/utilities/setup#_16-console-ou
 - **Pin everything a test logged in one assertion:** `consoleOutput()` from `/console` returns
   `{ error?, warn?, info?, log?, debug?, trace? }`, each the argument lists of its calls, only the
   channels written to — `expect(consoleOutput()).toStrictEqual({ info: [['done']] })`; `{}` is silence.
+  "Only these channels, whatever they said" is `expect(Object.keys(consoleOutput())).toStrictEqual(['info'])`
+  (keys in alphabetical order), which `no-unsafe-assignment` accepts where `{ info: expect.any(Array) }` does not.
   It throws while no spy is on `console`, so it never reports silence it did not hear.
 - The wrapper forwards every call unchanged, so Vitest's attribution and `onConsoleLog` still work.
   `guardStrayConsole(reaction)` registers the same guard on its own.

package/dist/angular-http.d.ts

@@ -1,45 +1,18 @@
 import { HttpInterceptorFn, HttpFeature, HttpFeatureKind, HttpRequest } from '@angular/common/http';
-import { TestRequest } from '@angular/common/http/testing';
+import { TestRequest, HttpTestingController } from '@angular/common/http/testing';
 import { EnvironmentProviders, Provider } from '@angular/core';
 
-/**
- * `provideHttpTesting()` + `expectRequest()` — the `httpResource()` and `HttpClient` dance in two
- * lines.
- *
- * Answering one request from a zoneless spec takes six steps today, and the order of them is not
- * guessable: tick (an `httpResource()` issues *nothing* until something does), inject the
- * `HttpTestingController`, `expectOne`, `flush`, let one microtask run so the response reaches the
- * resource, tick again so what read it is up to date. Miss the first tick and `expectOne` finds no
- * request; miss the microtask and the assertion reads the resource's *default* value — a green test
- * that asserts nothing until the day the default changes.
- *
- * ```ts
- * TestBed.configureTestingModule({ providers: [...provideHttpTesting()] });
- *
- * const products = TestBed.runInInjectionContext(() => httpResource<Product[]>(() => '/api/products'));
- *
- * await expectRequest('/api/products').flush([product]);
- *
- * expect(products.value()).toEqual([product]); // no tick, no microtask, no detectChanges
- * ```
- *
- * **This module is why `vitest-auto-spy/angular-http` is its own entry.** It is the only file in
- * the package that imports `@angular/common`, and `vitest-auto-spy/angular` has to keep loading in
- * a project that has `@angular/core` and not `@angular/common` — the same invariant that keeps
- * rxjs behind `vitest-auto-spy/rxjs`. The optional peer is paid for by the suites that import this
- * entry and by nobody else.
- *
- * It cooperates with `enableAngularDiagnostics({ pendingRequests })` rather than competing: both
- * take the open requests with `match(() => true)`, which is one-shot, so whichever looks first
- * owns them and one unanswered request is never reported twice.
- */
-
 /** How a request is named: a URL, a pattern, or a question asked of the request itself. */
 type RequestMatcher = RegExp | string | ((request: HttpRequest<unknown>) => boolean);
 /** Options for {@link expectRequest} and {@link expectNoRequest}. */
 interface ExpectRequestOptions {
     /** Narrow to one verb, for a URL that is both read and written in the same test. Case-insensitive. */
     method?: string;
+    /**
+     * `false` skips the `TestBed.tick()` before the lookup and after the answer, for a module whose
+     * doubled `DOCUMENT` the app's tick cannot run against. The request must already be out. Default `true`.
+     */
+    tick?: boolean;
 }
 /** Options for {@link provideHttpTesting}. */
 interface HttpTestingOptions {
@@ -73,8 +46,13 @@ interface HttpTestingOptions {
 type ResponseBody = Parameters<TestRequest['flush']>[0];
 /** `headers` / `status` / `statusText`, exactly as `TestRequest#flush` takes them. */
 type FlushOptions = NonNullable<Parameters<TestRequest['flush']>[1]>;
-/** `headers` / `statusText` for {@link RequestExpectation.error} — the status is its first argument. */
-type RequestErrorOptions = Omit<NonNullable<Parameters<TestRequest['error']>[1]>, 'status'>;
+/**
+ * `headers` / `statusText` for {@link RequestExpectation.error} — the status is its first argument —
+ * and `error`, the payload `HttpErrorResponse.error` carries. Default `new ProgressEvent('error')`.
+ */
+type RequestErrorOptions = Omit<NonNullable<Parameters<TestRequest['error']>[1]>, 'status'> & {
+    error?: Parameters<TestRequest['error']>[0];
+};
 /** The one request {@link expectRequest} found, and the two ways to answer it. */
 interface RequestExpectation {
     /** The request as the code under test sent it — URL, method, headers, body. */
@@ -84,7 +62,10 @@ interface RequestExpectation {
      * reads it has been ticked.
      */
     flush(body: ResponseBody, options?: FlushOptions): Promise<void>;
-    /** Fail the request with an HTTP status, then settle the same way {@link RequestExpectation.flush} does. */
+    /**
+     * Fail the request with an HTTP status, then settle the same way {@link RequestExpectation.flush} does.
+     * Status `0` is a network failure: no response reached the client.
+     */
     error(status: number, options?: RequestErrorOptions): Promise<void>;
 }
 /**
@@ -148,5 +129,10 @@ declare function expectNoRequest(matcher?: RequestMatcher, options?: ExpectReque
 declare function verifyNoPendingRequests(options?: {
     ignoreCancelled?: boolean;
 }): void;
+/**
+ * The `HttpTestingController` `provideHttpTesting()` installed, for a synchronous `expectOne` / `match` /
+ * `expectNone` on an Observable service. Throws with the missing providers named when there is none.
+ */
+declare function injectHttpTesting(): HttpTestingController;
 
-export { type ExpectRequestOptions, type FlushOptions, type HttpTestingOptions, type RequestErrorOptions, type RequestExpectation, type RequestMatcher, type ResponseBody, expectNoRequest, expectRequest, provideHttpTesting, verifyNoPendingRequests };
+export { type ExpectRequestOptions, type FlushOptions, type HttpTestingOptions, type RequestErrorOptions, type RequestExpectation, type RequestMatcher, type ResponseBody, expectNoRequest, expectRequest, injectHttpTesting, provideHttpTesting, verifyNoPendingRequests };

package/dist/angular-http.js

@@ -5,6 +5,7 @@ import './chunk-HVNKTPKG.js';
 import { count, taskName } from './chunk-DYAS4OK4.js';
 import { angularHttpNoRequest, angularHttpPending, angularHttpController, angularHttpExpectRequest } from './chunk-5FQZGJLJ.js';
 import { withDocs } from './chunk-ENCEEH23.js';
+import { DOCUMENT } from '@angular/common';
 import { withInterceptors, provideHttpClient } from '@angular/common/http';
 import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';
 import { InjectionToken, provideEnvironmentInitializer } from '@angular/core';
@@ -166,15 +167,37 @@ Narrow it: \`expectRequest(url, { method: "POST" })\`, name the full \`urlWithPa
     )
   );
 }
-async function settle() {
+async function settle(tick) {
   for (let round = 0; round < SETTLE_ROUNDS; round += 1) {
     await Promise.resolve();
+    if (tick) {
+      tickApp("expectRequest");
+    }
+  }
+}
+function tickApp(caller) {
+  try {
     flushEffects();
+  } catch (error) {
+    if (TestBed.inject(DOCUMENT) === globalThis.document) {
+      throw error;
+    }
+    throw new Error(
+      withDocs(
+        `[vitest-auto-spy] ${caller}: TestBed.tick() failed, and this TestBed provides its own DOCUMENT \u2014 Angular reads the real document's members while it ticks, which a partial double does not have.
+Pass { tick: false } to answer without ticking (the request must already be out), or provide a DOCUMENT that is a real document.`,
+        angularHttpExpectRequest
+      ),
+      { cause: error }
+    );
   }
 }
 function expectRequest(matcher, options = {}) {
   const controller = readController("expectRequest");
-  flushEffects();
+  const tick = options.tick ?? true;
+  if (tick) {
+    tickApp("expectRequest");
+  }
   const [first, ...rest] = controller.match(toPredicate(matcher, options));
   if (first === void 0) {
     throw noMatch(controller, matcher, options);
@@ -186,17 +209,19 @@ function expectRequest(matcher, options = {}) {
     request: first.request,
     flush: async (body, flushOptions) => {
       first.flush(body, flushOptions);
-      await settle();
+      await settle(tick);
     },
-    error: async (status, errorOptions) => {
-      first.error(new ProgressEvent("error"), { ...errorOptions, status });
-      await settle();
+    error: async (status, { error = new ProgressEvent("error"), ...errorOptions } = {}) => {
+      first.error(error, { ...errorOptions, status });
+      await settle(tick);
     }
   };
 }
 function expectNoRequest(matcher = () => true, options = {}) {
   const controller = readController("expectNoRequest");
-  flushEffects();
+  if (options.tick ?? true) {
+    tickApp("expectNoRequest");
+  }
   const matched = controller.match(toPredicate(matcher, options));
   if (matched.length === 0) {
     return;
@@ -212,6 +237,9 @@ Something the test did asked for data it was asserted not to need \u2014 a resou
 function verifyNoPendingRequests(options = {}) {
   verifyPending(options.ignoreCancelled === true);
 }
+function injectHttpTesting() {
+  return readController("injectHttpTesting");
+}
 function pendingOf(request) {
   return { method: request.request.method, urlWithParams: request.request.urlWithParams, cancelled: request.cancelled };
 }
@@ -228,4 +256,4 @@ function verifyPending(ignoreCancelled, test) {
   }
 }
 
-export { expectNoRequest, expectRequest, provideHttpTesting, verifyNoPendingRequests };
+export { expectNoRequest, expectRequest, injectHttpTesting, provideHttpTesting, verifyNoPendingRequests };

package/dist/angular-matchers.js

@@ -1,3 +1,4 @@
+import { strictEquals, looseEquals } from './chunk-B6JUBFBA.js';
 import { sourceClassName, count } from './chunk-DYAS4OK4.js';
 import { angularDirectiveApplied } from './chunk-5FQZGJLJ.js';
 import { withDocs } from './chunk-ENCEEH23.js';
@@ -205,7 +206,7 @@ function toHaveResourceValue(received, expected) {
     };
   }
   const actual = received.value();
-  const pass = this.equals(actual, expected);
+  const pass = looseEquals(this, actual, expected);
   return {
     pass,
     actual,
@@ -243,12 +244,6 @@ function registerResourceMatchers() {
 function isSpy(received) {
   return "mock" in received || "calls" in received;
 }
-function sameClass(a, b) {
-  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) && Array.isArray(b)) {
-    return void 0;
-  }
-  return Object.getPrototypeOf(a) === Object.getPrototypeOf(b) ? void 0 : false;
-}
 function registerSignalMatchers() {
   expect.extend({
     toHaveSignalValue(received, expected, { strict = false } = {}) {
@@ -261,7 +256,7 @@ function registerSignalMatchers() {
         );
       }
       const actual = received();
-      const pass = strict ? this.equals(actual, expected, [...this.customTesters, sameClass], true) : this.equals(actual, expected);
+      const pass = strict ? strictEquals(this, actual, expected) : looseEquals(this, actual, expected);
       return {
         pass,
         actual,

package/dist/chunk-B6JUBFBA.js

@@ -0,0 +1,25 @@
+// src/lib/matcher-equality.ts
+function sameClass(a, b) {
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) && Array.isArray(b)) {
+    return void 0;
+  }
+  return Object.getPrototypeOf(a) === Object.getPrototypeOf(b) ? void 0 : false;
+}
+function arrayBufferEquality(a, b) {
+  if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
+    return void 0;
+  }
+  const left = new Uint8Array(a);
+  const right = new Uint8Array(b);
+  return left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function looseEquals(context, actual, expected) {
+  return context.equals(actual, expected, [...context.customTesters, context.utils.iterableEquality]);
+}
+function strictEquals(context, actual, expected) {
+  const testers = [...context.customTesters, context.utils.iterableEquality, sameClass, arrayBufferEquality];
+  const sparseArrayEquality = (a, b) => Array.isArray(a) && Array.isArray(b) ? context.equals(a, b, testers, true) && context.equals(Object.keys(a), Object.keys(b)) : void 0;
+  return context.equals(actual, expected, [...testers, sparseArrayEquality], true);
+}
+
+export { looseEquals, strictEquals };

package/dist/cli.js

@@ -3865,7 +3865,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.44.0";
+var EXPORT_MAP_VERSION = "5.45.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",
@@ -3925,6 +3925,7 @@ var EXPORTED_BY = {
   BlockNetworkOptions: "23",
   CallbackSubscribable: "0 1 2 3 4 12 20 21 22",
   CallLog: "0 1 2 3 4 20 21 22",
+  CancelAnimationFrameFn: "7",
   cancelStrayTimers: "23",
   captureArg: "0 1 2 3 4 20 21 22",
   CaptureArgOptions: "0 1 2 3 4 20 21 22",
@@ -4058,6 +4059,7 @@ var EXPORTED_BY = {
   hostElement: "2 12",
   HttpTestingOptions: "16",
   injectActivatedRoute: "17",
+  injectHttpTesting: "16",
   InjectionLog: "12 19",
   injectLocationDouble: "17",
   injectMatDialogRef: "14",
@@ -4182,6 +4184,7 @@ var EXPORTED_BY = {
   RenderShallowOptions: "2 12",
   reportPropsOutsideHooks: "0 1 2 3 4 20 21 22",
   reportSpecTiming: "13",
+  RequestAnimationFrameFn: "7",
   RequestErrorOptions: "16",
   RequestExpectation: "16",
   RequestMatcher: "16",

package/dist/console.d.ts

@@ -50,7 +50,7 @@ declare global {
 declare function installConsoleSpies(): ConsoleSpies;
 /** A console method that writes, as `consoleOutput()` keys it. */
 type ConsoleChannel = 'debug' | 'error' | 'info' | 'log' | 'trace' | 'warn';
-/** What a test wrote, per channel: the arguments of each call. A channel nothing wrote to is absent. */
+/** What a test wrote, per channel: the arguments of each call. A channel nothing wrote to is absent; keys come in alphabetical order. */
 type ConsoleOutput = Partial<Record<ConsoleChannel, unknown[][]>>;
 /**
  * Everything the console spies recorded, as one value. Only the channels written to appear, so an
@@ -61,6 +61,7 @@ type ConsoleOutput = Partial<Record<ConsoleChannel, unknown[][]>>;
  * cli.run(['--dry-run']);
  * expect(consoleOutput()).toStrictEqual({ info: [['done']] });
  * expect(consoleOutput()).toStrictEqual({}); // wrote nothing at all
+ * expect(Object.keys(consoleOutput())).toStrictEqual(['info']); // only info, whatever it said
  * ```
  */
 declare function consoleOutput(): ConsoleOutput;

package/dist/dom-stubs.d.ts

@@ -1,7 +1,7 @@
 import { F as Func } from './types-Dxw-oWfr.js';
 export { W as WebStorageKey, a as WebStorageStub, b as WebStorageStubOptions, s as stubWebStorage } from './web-storage-dwQ9E7Lm.js';
+import { Mock } from 'vitest';
 import { R as RestoreProp } from './prop-mock-WOpRQPUc.js';
-import 'vitest';
 
 /**
  * A host-runner mock function: a callable spy (Vitest `vi.fn()`, Bun `mock()`,
@@ -196,14 +196,23 @@ interface AnimationFrameStubOptions {
      */
     onError?: (error: unknown) => void;
 }
+/** `requestAnimationFrame` as the stub installs it, spelled without the DOM lib. */
+type RequestAnimationFrameFn = (callback: (timestamp: number) => void) => number;
+/** `cancelAnimationFrame` as the stub installs it. */
+type CancelAnimationFrameFn = (handle: number) => void;
 /** The handle {@link stubAnimationFrame} returns. */
 interface AnimationFrameStub {
     /** How many requested frames have not run yet. */
     readonly pending: number;
+    /**
+     * The handle the latest `requestAnimationFrame` call returned, or `undefined` before the first one.
+     * Handles start above 2^30, so assert against this rather than a literal such as `1`.
+     */
+    readonly lastHandle: number | undefined;
     /** The spy installed as `requestAnimationFrame`. */
-    readonly requestAnimationFrame: MockFn;
+    readonly requestAnimationFrame: Mock<RequestAnimationFrameFn>;
     /** The spy installed as `cancelAnimationFrame`. */
-    readonly cancelAnimationFrame: MockFn;
+    readonly cancelAnimationFrame: Mock<CancelAnimationFrameFn>;
     /**
      * Run every frame requested so far, as one browser frame. A frame requested from inside one of
      * them waits for the next `flush()`, as it waits for the next frame in a browser.
@@ -458,4 +467,4 @@ interface ResizeEntryRect {
  */
 declare function resizeEntry(target: Element, rect?: ResizeEntryRect): ResizeObserverEntry;
 
-export { type AnimationFrameMode, type AnimationFrameStub, type AnimationFrameStubOptions, type ElementRectRestore, type IntersectionEntryOverrides, type IntersectionObserverStubOptions, type MediaElementState, type MediaElementStub, type MediaElementStubOptions, type MutationRecordInit, type ObserverGlobal, type ObserverInstance, type ObserverStub, type ObserverStubOptions, type ResizeEntryRect, type WorkerInstance, type WorkerScript, type WorkerStub, type WorkerStubOptions, intersectionEntry, mutationRecord, resizeEntry, stubAbortController, stubAnimationFrame, stubElementRect, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, stubWorker };
+export { type AnimationFrameMode, type AnimationFrameStub, type AnimationFrameStubOptions, type CancelAnimationFrameFn, type ElementRectRestore, type IntersectionEntryOverrides, type IntersectionObserverStubOptions, type MediaElementState, type MediaElementStub, type MediaElementStubOptions, type MutationRecordInit, type ObserverGlobal, type ObserverInstance, type ObserverStub, type ObserverStubOptions, type RequestAnimationFrameFn, type ResizeEntryRect, type WorkerInstance, type WorkerScript, type WorkerStub, type WorkerStubOptions, intersectionEntry, mutationRecord, resizeEntry, stubAbortController, stubAnimationFrame, stubElementRect, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, stubWorker };

package/dist/dom-stubs.js

@@ -1279,18 +1279,22 @@ function stubAnimationFrame(options = {}) {
     get pending() {
       return queue.size;
     },
-    requestAnimationFrame: request,
-    cancelAnimationFrame: cancel,
-    flush,
-    flushAll: (timestamp) => {
-      flushUntilIdle(queue, () => flush(timestamp));
+    get lastHandle() {
+      return lastId === FIRST_HANDLE ? void 0 : lastId;
     },
+    requestAnimationFrame: asRunnerMock2(request),
+    cancelAnimationFrame: asRunnerMock2(cancel),
+    flush,
+    flushAll: (timestamp) => flushUntilIdle(queue, () => flush(timestamp)),
     restore() {
       [...restores].reverse().forEach((undo) => undo());
       queue.clear();
     }
   };
 }
+function asRunnerMock2(mock) {
+  return mock;
+}
 function runQueued(queue, run) {
   for (const handle of [...queue.keys()]) {
     const callback = queue.get(handle);

package/dist/jasmine.js

@@ -1,5 +1,6 @@
 import { enableJasmineCompat } from './chunk-3ZBRBPOL.js';
 export { enableJasmineCompat } from './chunk-3ZBRBPOL.js';
+import { looseEquals } from './chunk-B6JUBFBA.js';
 import { createSpyFromClass } from './chunk-I6CB4CNT.js';
 import { useVitestAdapter } from './chunk-IB72SVKT.js';
 import './chunk-QGLUX55Q.js';
@@ -174,7 +175,7 @@ function registerValueMatchers() {
 function registerCollectionMatchers() {
   expect.extend({
     jasmineMapContaining(received, sample) {
-      const missing = received instanceof Map ? mapMissing(received, sample, this.equals.bind(this)) : [];
+      const missing = received instanceof Map ? mapMissing(received, sample, (a, b) => looseEquals(this, a, b)) : [];
       const pass = received instanceof Map && missing.length === 0;
       return {
         pass,
@@ -182,7 +183,7 @@ function registerCollectionMatchers() {
       };
     },
     jasmineSetContaining(received, sample) {
-      const missing = received instanceof Set ? setMissing(received, sample, this.equals.bind(this)) : [];
+      const missing = received instanceof Set ? setMissing(received, sample, (a, b) => looseEquals(this, a, b)) : [];
       const pass = received instanceof Set && missing.length === 0;
       return {
         pass,
@@ -190,7 +191,7 @@ function registerCollectionMatchers() {
       };
     },
     jasmineArrayWithExactContents(received, sample) {
-      const diff = Array.isArray(received) ? exactContentsDiff(received, sample, this.equals.bind(this)) : { missing: [], extra: [] };
+      const diff = Array.isArray(received) ? exactContentsDiff(received, sample, (a, b) => looseEquals(this, a, b)) : { missing: [], extra: [] };
       const pass = Array.isArray(received) && diff.missing.length === 0 && diff.extra.length === 0;
       return {
         pass,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.45.0",
+  "version": "5.46.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

@@ -187,7 +187,7 @@ it('loads', async () => {
 | ---------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | 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                                                                                                                                                                              |
+| the HTTP round trip _is_ the point                                                                         | `expectRequest(url).flush(body)` — `/angular-http`, settling included; a synchronous `expectOne` on an Observable service: `injectHttpTesting()`                                                                                                   |
 | an interceptor under test: `provideHttpClient(withInterceptors([...]))` + `provideHttpClientTesting()`     | `provideHttpTesting({ interceptors: [fn], features: [withInterceptorsFromDi()] })` — keeps the end-of-test check                                                                                                                                   |
 | 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`                                                                                                                                                                                 |
@@ -296,7 +296,7 @@ it('loads', async () => {
 | 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`                                                                                                                                                                   |
-| `window.requestAnimationFrame = (cb) => { cb(0); return 0; }`, or an array of callbacks looped over        | `stubAnimationFrame()` / `stubAnimationFrame({ mode: 'queued' })` from `/dom-stubs` — `flush()`, `flushAll()` for nested frames, `pending`; a foreign handle's cancel reaches the real one                                                         |
+| `window.requestAnimationFrame = (cb) => { cb(0); return 0; }`, or an array of callbacks looped over        | `stubAnimationFrame()` / `stubAnimationFrame({ mode: 'queued' })` from `/dom-stubs` — `flush()`, `flushAll()` for nested frames, `pending`; a foreign handle's cancel reaches the real one; assert a cancel with `frames.lastHandle`, not `1`      |
 | `mockValueProp(el, 'getBoundingClientRect', () => new DOMRect(…))`, or a `({ height })` literal            | `stubElementRect(el, { width, height })` from `/dom-stubs` — missing fields are `0`, edges derived                                                                                                                                                 |
 | `'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                                                                                                                                                                 |