vitest-auto-spy 5.21.1 → 5.22.0

package/AGENTS.md

@@ -1300,6 +1300,29 @@ line that triggers the source, because the `await` is the same statement as the
 the test deadlocks against a source that only emits once something pokes it. Hold the promise
 first, poke, then await.
 
+### `createLog()` — the order between the spies
+
+```ts
+const log = createLog<'drop-cache' | 'flush-telemetry' | 'stop-engine'>();
+
+engine.onShutdown(log.fn('drop-cache'));
+engine.onShutdown(log.fn('stop-engine'));
+engine.onShutdown(log.fn('flush-telemetry'));
+
+engine.shutdown();
+
+expect(log.result()).toBe('drop-cache; flush-telemetry; stop-engine'); // fails with the real order
+```
+
+Emission helpers answer a sequence _within one source_. The order of calls **across** collaborators
+is the gap `toHaveBeenCalled` papers over — three green checks that would accept the sequence
+backwards — and `toHaveBeenCalledBefore` covers pairwise. One journal the code under test writes into
+(`add`, `fn(value)` for a labelled callback, `clear`, `items`, `result()`) makes the sequence a
+single comparable value; `T` is a string union so a step nobody declared is a compile error. In
+Angular, provide it and let the component report its own lifecycle:
+`providers: [{ provide: PANEL_LOG, useValue: log }]`. Ported from Angular's own `Log`, which the
+framework keeps three copies of.
+
 ---
 
 ## 9. Patching properties (and putting them back)
@@ -1659,6 +1682,14 @@ a behaviour change —`stubConstructor(globalThis, 'WebSocket', …)` is the too
   Plain data in `body` goes out as JSON with `application/json`; an `ok` that disagrees with
   `status` throws. A body can be read once: for a stub answering several calls use
   `mockImplementation(async () => stubResponse(…))`, not `mockResolvedValue`.
+- **`body: null` is the JSON literal, and only `undefined` or an omitted `body` send no body.** It
+  reverses what the field used to mean: `null` sent no body, so `.json()` threw
+  `Unexpected end of JSON input` on it while `0`, `false`, `[]` and `{}` round-tripped — the one
+  literal a reader had no reason to expect to be different, and the shape a backend answering
+  "nothing here" (an empty login, an absent profile) really sends. A spec that meant "no body"
+  drops the field. `{ body: null, status: 204 }` throws by name rather than letting the constructor
+  raise "Response with null body status cannot have body" about a field whose old meaning was the
+  opposite; 205 and 304 are the same.
 - `blockNetwork` leaves `fetch` alone while `Symbol.for('fetch-interceptor')` is on `globalThis`
   (MSW `setupServer`, nock 14), so MSW handlers keep answering; XHR stays blocked for what MSW does
   not handle. MSW's `onUnhandledRequest: 'error'` exempts asset-looking URLs (`.svg`, `.json`,
@@ -2703,12 +2734,12 @@ response reaches the resource, tick again so the view reading it is current. Mis
 `expectOne` reports a request that was never sent; miss the fifth and the assertion reads the
 resource's **default** value and passes.
 
-| Call                               | Does                                                                                            |
-| ---------------------------------- | ----------------------------------------------------------------------------------------------- |
-| `provideHttpTesting(opts?)`        | `provideHttpClient()` + `provideHttpClientTesting()`; `{ verifyOnTeardown }` defaults to `true` |
-| `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"             |
-| `verifyNoPendingRequests()`        | the teardown check by hand, for mid-test use or a suite with `verifyOnTeardown: false`          |
+| Call                               | Does                                                                                                                                                                         |
+| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `provideHttpTesting(opts?)`        | `provideHttpClient()` + `provideHttpClientTesting()`; `{ verifyOnTeardown }` defaults to `true`, and takes `{ ignoreCancelled }` instead of `false`                          |
+| `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"                                                                                          |
+| `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 |
 
 `matcher` is a URL (matched against either `url` or `urlWithParams`), a `RegExp` over
 `urlWithParams`, or a predicate `(request) => boolean`. `{ method }` is case-insensitive.
@@ -2755,11 +2786,11 @@ is `undefined` on the `{ params: of(…) }` one, and a spec that updates one hal
 no navigation produces. `provideActivatedRoute(init)` provides **Angular's own `ActivatedRoute`**
 built over one record, so every stream, both `ParamMap`s and `snapshot` read the same values.
 
-| Call                              | Does                                                                                                                                               |
-| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `provideActivatedRoute(init?)`    | a `FactoryProvider` — a fresh route per injector; `init`: `params`, `queryParams`, `data`, `fragment`, `url`, `outlet`, `component`, `routeConfig` |
-| `injectActivatedRoute(injector?)` | the handle: `.route`, `setParams`, `setQueryParams`, `setData`, `setFragment`, `setUrl`, `set({ … })`                                              |
-| `createActivatedRoute(init?)`     | the same handle without a `TestBed` — for `new Page(route)`, or a guard given `route.snapshot`                                                     |
+| Call                              | Does                                                                                                                                                                   |
+| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `provideActivatedRoute(init?)`    | a `FactoryProvider` — a fresh route per injector; `init`: `params`, `queryParams`, `data`, `title`, `fragment`, `url`, `outlet`, `component`, `routeConfig`, `resolve` |
+| `injectActivatedRoute(injector?)` | the handle: `.route`, `setParams`, `setQueryParams`, `setData`, `setFragment`, `setUrl`, `set({ … })`                                                                  |
+| `createActivatedRoute(init?)`     | the same handle without a `TestBed` — for `new Page(route)`, or a guard given `route.snapshot`                                                                         |
 
 A setter behaves like the router after a navigation: it **replaces** (not merges) that part, builds
 a new snapshot first, then emits only the streams whose value changed (router equality: same keys,
@@ -2773,11 +2804,14 @@ Four things to know:
   still works as `relativeTo` for `router.createUrlTree`.
 - **One node, no tree.** `root` is the route itself, `parent` / `firstChild` are `null`. For
   `route.parent.params` patch that member with `mockReadonlyProp`, or use `RouterTestingHarness`.
-- **No `title`, no navigation, no input binding** — `title` emits `undefined`, `Router.navigate`
-  does not move it (the setters do), and `withComponentInputBinding()` is the outlet's job
-  (`fixture.componentRef.setInput`).
+- **`title` is given, not resolved; no navigation, no input binding.** `provideActivatedRoute({
+title: 'Product 7' })` answers `route.snapshot.title` — the double puts the string under the
+  router's own `RouteTitleKey`, read off the installed router, and does not run a `title: () => …`
+  resolver. `Router.navigate` does not move it (the setters do), and `withComponentInputBinding()`
+  is the outlet's job (`fixture.componentRef.setInput`).
 - **Its own entry, like `/angular-http`.** It does not re-export the core, imports no runner, and is
-  the only file that reaches `@angular/router` — an optional peer.
+  the only file that reaches `@angular/router` — an optional peer. The `Location` double below wraps
+  `@angular/common/testing`, which `@angular/router` itself depends on, so it adds no peer.
 
 ### `Router` from one URL — `vitest-auto-spy/angular-router`
 
@@ -2803,6 +2837,7 @@ redirect a guard builds. `provideRouterDouble(init)` keeps one URL and derives t
 | `provideRouterDouble(init?)`    | a `FactoryProvider` for the `Router` token — a fresh router per injector; `init` is `{ url }`, default `'/'`                       |
 | `injectRouterDouble(injector?)` | the handle: `.router`, `.navigate`, `.navigateByUrl`, `setUrl(url)`, `emitNavigation(event?)`, `setCurrentNavigation(navigation?)` |
 | `createRouterDouble(init?)`     | the same handle without a `TestBed` — for `new AuthGuard(router)`                                                                  |
+| `collectRouterEvents(events)`   | the recording of what `router.events` emits, `expect([[Class, url], …])` in one line — Angular's own integration-spec idiom        |
 
 Unlike the route, this is **not** an instance of Angular's class: a real `Router` drags the whole
 routing stack in. It is a structural double that answers `url` (serialized as the real router does),
@@ -2821,7 +2856,9 @@ Five things to know:
   `url`. `setUrl()` and `emitNavigation()` move it; `RouterTestingHarness` over a real
   `provideRouter()` is what tests a navigation.
 - **`emitNavigation()` takes what you have** — nothing, a URL string, or an event you built. A
-  `NavigationEnd` moves the URL with it; any other event does not.
+  `NavigationEnd` moves the URL with it; any other event does not. It resolves once the event is
+  delivered and a navigation it ended is back to `null` — the moment `navigate()` resolves in an
+  application; the work is synchronous, so ignoring the promise changes nothing.
 - **The navigation in flight follows the events, and a terminal event ends it _after_ delivering
   it.** `setCurrentNavigation({ extras: { state } })` puts one up and `setCurrentNavigation(null)`
   ends it; a `NavigationStart` pushed through `emitNavigation()` starts one with that event's id,
@@ -2839,6 +2876,28 @@ Five things to know:
 - **It builds spies**, so a runtime entry has to be imported in the suite (`vitest-auto-spy/angular`
   in the same file, or the setup file); the route double needs none.
 
+### `Location` from Angular's own testing classes — `vitest-auto-spy/angular-router`
+
+```ts
+import { injectLocationDouble, provideLocationDouble } from 'vitest-auto-spy/angular-router';
+
+TestBed.configureTestingModule({ providers: [provideLocationDouble()] });
+
+const location = injectLocationDouble();
+
+location.go('/reports/7');
+location.simulateUrlPop('/'); // the popstate no method call can cause
+```
+
+**A wrap, not a rival.** Angular ships the double — `SpyLocation` with a real history array, a
+`urlChanges` journal for assertions, and `simulateUrlPop()` / `simulateHashChange()` for the
+browser's half of the contract — and this entry puts it in the family shape of the route and the
+router: one provider call, an `injectLocationDouble()` whose errors name the instance that won
+(`Location` is `providedIn: 'root'`, so the quiet failure is the real `Location` nobody configured).
+`createLocationDouble()` is the same without a `TestBed`. One asymmetry worth knowing: `back()` and
+`forward()` wake the popstate subscribers but do not write `urlChanges` — the journal holds what the
+app asked for, the subscribers carry what the browser did.
+
 ### Signal forms — `vitest-auto-spy/signal-forms`
 
 ```ts
@@ -3640,6 +3699,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-set-inputs`               | `warn`  | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101`                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `prefer-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | `no-hand-assigned-global`         | `error` | —                 | a double assigned to a global (`global.fetch = vi.fn()`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }`) with no restore in `afterEach` / `afterAll` / `onTestFinished` → `mockValueProp(globalThis, name, value)` or `vi.stubGlobal` + `unstubGlobals`; `blockNetwork()` for network globals, `stubWebStorage()` for the storages; the three observers stay with `prefer-observer-stub`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `prefer-stub-response`            | `error` | —                 | an object literal cast to `Response` (`as Response`, `as unknown as Response`, `<Response>{ … }`) or `createMock<Response>(…)` / `createAutoMock<Response>(…)` → `stubResponse({ body })` from `/setup`; the literal answers `undefined` for every member it does not list (`status`, `headers`, `text()`) and the cast is what makes that compile. `Response` must resolve to the **global**, so an Express handler's or a generated client's `Response` is never reported                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `prefer-provide-activated-route`  | `error` | —                 | a hand-built `ActivatedRoute` — any `useValue` / `useClass` / `useFactory` / `useExisting`, and `provideAutoSpy(ActivatedRoute)` too → `provideActivatedRoute({ … })`; the double knows either the streams or the snapshot, never both, and `injectActivatedRoute().setParams(…)` moves them together mid-test                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `no-passthrough-console-spy`      | `error` | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and prints → `installConsoleSpies()` + `consoleXSpy`, or `.mockImplementation(() => undefined)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `no-console-in-spec`              | `error` | —                 | a spec calling `console.x(…)` itself, or `console.x = …`, which nothing restores → absorb the code's output through `vitest-auto-spy/console`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
@@ -3657,7 +3717,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `prefer-native-spy-api`           | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 
-Thirty-nine rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+Forty rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `no-instance-lifecycle-spy` and `prefer-set-inputs`**; four fix on their own, thirteen offer suggestions. Thirty-six are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
 `no-unknown-use-value-key` read types, and all three report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
@@ -3969,7 +4029,7 @@ packages, which a subpath export can never be.
 | a spec runs down the "browser" (or any flag-on) branch whatever its `useValue` says                                                                 | `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>` — `useValue` is `any`, and an object is truthy                                                                                                                                                     | a value of the token's type (`useValue: false`) — `no-mistyped-use-value` (§16), with type information                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `no request matched …` (with the requests that were made listed)                                                                                    | the URL, verb or predicate does not describe anything the code under test sent, or nothing subscribed                                                                                                                                                                       | read the list in the message — it is the requests that were actually made; then fix the URL, add `{ method }`, or subscribe (§13)                                                                                                                                                                                                                                                                                                                                                                                 |
 | `this TestBed has no HttpTestingController`                                                                                                         | `expectRequest` / `expectNoRequest` on a module that never got the testing backend                                                                                                                                                                                          | `TestBed.configureTestingModule({ providers: [...provideHttpTesting()] })` from `vitest-auto-spy/angular-http` (§13)                                                                                                                                                                                                                                                                                                                                                                                              |
-| `the test ended with N unanswered request(s)`                                                                                                       | `provideHttpTesting({ verifyOnTeardown })` found a request the spec never flushed                                                                                                                                                                                           | answer it (`await expectRequest(url).flush(body)`), assert its absence (`expectNoRequest(url)`), or `{ verifyOnTeardown: false }` (§13)                                                                                                                                                                                                                                                                                                                                                                           |
+| `the test ended with N unanswered request(s)`                                                                                                       | `provideHttpTesting({ verifyOnTeardown })` found a request the spec never flushed                                                                                                                                                                                           | answer it (`await expectRequest(url).flush(body)`), assert its absence (`expectNoRequest(url)`), forgive an unsubscribed one with `{ verifyOnTeardown: { ignoreCancelled: true } }`, or `{ verifyOnTeardown: false }` (§13)                                                                                                                                                                                                                                                                                       |
 | `injectActivatedRoute(): nothing provides ActivatedRoute here`                                                                                      | no `ActivatedRoute` provider in the injector it read                                                                                                                                                                                                                        | `provideActivatedRoute({ … })` from `vitest-auto-spy/angular-router` in `providers`; `injectActivatedRoute(fixture.debugElement.injector)` for a component-level one (§13)                                                                                                                                                                                                                                                                                                                                        |
 | `the ActivatedRoute here is … not one provideActivatedRoute() built`                                                                                | a later provider of `ActivatedRoute` won — `provideRouter()`, `RouterModule`, a `useValue`, `provideAutoSpy(ActivatedRoute)`                                                                                                                                                | list `provideActivatedRoute()` last, or drop the other provider (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `provideActivatedRoute: the installed @angular/router does not wire ActivatedRoute …`                                                               | a router major builds `ActivatedRoute` with different internal constructors                                                                                                                                                                                                 | report it with the `@angular/router` version; provide the route by hand until then (§13)                                                                                                                                                                                                                                                                                                                                                                                                                          |

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-22.5%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-22.6%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)
@@ -80,7 +80,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored; `moduleNamespace(await importOriginal(), { passthrough: true })` is Vitest's `{ spy: true }` with `calledWith` on top, on any runner
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — thirty-nine rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, thirteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade
+- 📏 Lint rules and one-line test-run hygiene — forty rules in `vitest-auto-spy/eslint-plugin` (four `--fix`, thirteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
 - 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-and-init) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
@@ -1291,11 +1291,19 @@ runner's cleanups (`vi.restoreAllMocks()` restores spies, `vi.unstubAllGlobals()
 `vi.stubGlobal`), so the fake answers every later test of the file. The `no-hand-assigned-global` lint
 rule reports it. `vi.stubGlobal('fetch', …)` with `unstubGlobals: true` in the config is the runner's
 own equivalent. `stubResponse` builds a real `Response` from the environment's own constructor —
-plain data goes out as JSON — and a body reads once, so answer with a fresh one per call
+plain data goes out as JSON, `null` included, while `undefined` and an omitted `body` send no body
+at all — and a body reads once, so answer with a fresh one per call
 (`vi.fn(async () => stubResponse(…))`) rather than `mockResolvedValue`. A spec that only has to stay
 off the network wants [`blockNetwork()`](#test-run-hygiene), which leaves `fetch` to MSW's interceptor
 when `server.listen()` installed one.
 
+`body: null` is a **behaviour change**: it used to send no body, so `.json()` threw
+`Unexpected end of JSON input` on the one JSON literal that did not round-trip while `0`, `false`,
+`[]` and `{}` all did. It is now the literal — which is what a backend answering "nothing here"
+sends — and "no body" is `undefined` or an omitted field, the spelling every caller already used.
+A spec that wanted the old reading drops the field; `{ body: null, status: 204 }` throws by name,
+since those statuses carry no body.
+
 ### How to mock: the console
 
 A test that expects output absorbs it, and asserts on it:
@@ -1442,34 +1450,34 @@ 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`, `setInputs`, `createWithAutoSpies`, `stable`/`flushEffects`, `settleResource`, `mockResourceProp`, the `mock*Prop` helpers, `trackRecomputations` / `trackEffectRuns` — the diagnostics, doubles and matchers below moved off this entry in 5.21.0 | `@angular/core`                                          |   ✅   |
-| `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-router`      | `provideActivatedRoute`, `injectActivatedRoute`, `createActivatedRoute` — Angular's own `ActivatedRoute` over one record, streams and snapshot moved together; `provideRouterDouble` / `injectRouterDouble` for the `Router` beside it                                                             | `@angular/router`                                        |   ✅   |
-| `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`                                               |   ✅   |
-| `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/rstest`              | the same core, driven by Rstest's `rstest.fn()` / `rstest.spyOn()`                                                                                                                                                                                                                                 | `@rstest/core`                                           |   ✅   |
-| `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/dom-stubs`           | the globals a component builds for itself — `stubIntersectionObserver`, `stubResizeObserver`, `stubMutationObserver`, `stubObserver`, `stubMediaElement`, `stubAbortController`, the entry builders, and `stubWebStorage` with its `snapshot()`. On the root entry until 4.0.0                     | —                                                        |   ✅   |
-| `vitest-auto-spy/diagnostics`         | `compareTestRuns` / `summarizeTestRun` / `formatTestRunComparison`, `diffByField` and `explainSpy` — the two reports a counter cannot give; pure functions, so a plain Node script can import this one too. On the root entry until 4.0.0                                                          | —                                                        |   ✅   |
-| `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`, `setInputs`, `createWithAutoSpies`, `stable`/`flushEffects`, `settleResource`, `mockResourceProp`, the `mock*Prop` helpers, `trackRecomputations` / `trackEffectRuns` — the diagnostics, doubles and matchers below moved off this entry in 5.21.0                                                                      | `@angular/core`                                          |   ✅   |
+| `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-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`                                               |   ✅   |
+| `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/rstest`              | the same core, driven by Rstest's `rstest.fn()` / `rstest.spyOn()`                                                                                                                                                                                                                                                                                                      | `@rstest/core`                                           |   ✅   |
+| `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/dom-stubs`           | the globals a component builds for itself — `stubIntersectionObserver`, `stubResizeObserver`, `stubMutationObserver`, `stubObserver`, `stubMediaElement`, `stubAbortController`, the entry builders, and `stubWebStorage` with its `snapshot()`. On the root entry until 4.0.0                                                                                          | —                                                        |   ✅   |
+| `vitest-auto-spy/diagnostics`         | `compareTestRuns` / `summarizeTestRun` / `formatTestRunComparison`, `diffByField` and `explainSpy` — the two reports a counter cannot give; pure functions, so a plain Node script can import this one too. On the root entry until 4.0.0                                                                                                                               | —                                                        |   ✅   |
+| `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)).
 
@@ -3099,6 +3107,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `stubMediaElement(opts?)`                                                                                   | `/dom-stubs`                  | A `<video>` / `<audio>` that plays, reports a duration and fires the media events jsdom never does                                                                                                                                                                                                                                                      |
 | `assertMocked(namespace, opts?)`                                                                            | core                          | Fail when the `vi.mock()` a spec relies on silently did not apply (a bundled alias, `isolate: false`)                                                                                                                                                                                                                                                   |
 | `moduleNamespace(exports, opts?)`                                                                           | core                          | The `vi.mock` factory result an interop probe recognises — `default` + `__esModule` in place — a `default` the factory spells out is kept; `{ passthrough: true }` spies every function export through to the real one                                                                                                                                  |
+| `createLog<Step>()`                                                                                         | core                          | The order of calls **across** collaborators as one comparable value — `add`, `fn(value)` for a labelled callback, `clear`, `items`, `result()`; `Step` is a string union, so a step nobody declared is a compile error rather than a typo the journal records                                                                                           |
 | `diffByField(actual, expected)`                                                                             | `/diagnostics`                | Which field of an array of records moved, and in how many elements — the diff the reporter collapses                                                                                                                                                                                                                                                    |
 | `captureArg<T>(options?)`                                                                                   | core                          | Take hold of a callback or config the code under test built, instead of describing its shape — assertions only, never `calledWith`; `{ where }` records only what it accepts and fails the position on anything else ([details](#taking-hold-of-an-argument--capturearg))                                                                               |
 | `explainSpy(spy, method?)`                                                                                  | `/diagnostics`                | Every configured argument list next to every recorded call, each attributed to the config it hit — before anything failed                                                                                                                                                                                                                               |
@@ -3127,11 +3136,13 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `setInputs(fixture, inputs, opts?)`                                                                         | `/angular`                    | Change a component input mid-test — one `setInput` per name, checked against the compiled definition, then one wait                                                                                                                                                                                                                                     |
 | `trackRecomputations(signal)` / `trackEffectRuns(ref)`                                                      | `/angular`                    | Count what the reactive graph actually did: `{ count, stop() }`, so "the filter change did not re-run the sync effect" is an assertion                                                                                                                                                                                                                  |
 | `provideRouterDouble(init?)` / `injectRouterDouble()`                                                       | `/angular-router`             | A `Router` derived from one URL — real `serializeUrl` / `createUrlTree`, `navigate` spies, `emitNavigation()` over a `BehaviorSubject`, `currentNavigation()` and `setCurrentNavigation()`                                                                                                                                                              |
+| `collectRouterEvents(events)`                                                                               | `/angular-router`             | The router events that followed, as one comparable value — `expect([[NavigationStart, '/checkout'], [NavigationEnd, '/checkout']])`, a class-and-URL pair per event, failing with the event that was there instead                                                                                                                                      |
+| `provideLocationDouble()` / `injectLocationDouble()` / `createLocationDouble()`                             | `/angular-router`             | Angular's own `SpyLocation` and `MockLocationStrategy` in one call — a real history, the `urlChanges` journal, `simulateUrlPop()` / `simulateHashChange()` for the browser's half of the contract; `Location` is `providedIn: 'root'`, so a spec that forgets the provider silently drives the platform's real one                                      |
 | `createForm(model, schema?)` / `registerFormMatchers()`                                                     | `/signal-forms`               | A signal form built where `form()` can inject, and `expect(field).toHaveFieldErrors(['required'])` over what it produced                                                                                                                                                                                                                                |
 | `provideWindowDouble(TOKEN, over?)` / `provideDocumentDouble(over?)`                                        | `/angular/doubles`            | A `window` / `document` merged **over** the real jsdom one, so members the spec never named still answer; the globals stay untouched                                                                                                                                                                                                                    |
 | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(Ref, init?)`                                     | `/angular/doubles`            | The Material dialog trio without `@angular/material` as a dependency — the token and the ref class are arguments, `afterClosed()` still answers after the close                                                                                                                                                                                         |
 | `blockNetwork(options?)`                                                                                    | `/setup`                      | Close `fetch`, `XMLHttpRequest` and `sendBeacon`, naming what was requested; called twice, the last caller's mode wins; `fetch` is left to an applied MSW / nock interceptor ([details](#test-run-hygiene))                                                                                                                                             |
-| `stubResponse(init?)`                                                                                       | `/setup`                      | A real `Response` for a stubbed `fetch` — `body` (plain data → JSON), `status`, `ok`, `statusText`, `headers`, `url`; no cast ([recipe](#how-to-mock-fetch-and-other-globals))                                                                                                                                                                          |
+| `stubResponse(init?)`                                                                                       | `/setup`                      | A real `Response` for a stubbed `fetch` — `body` (plain data and `null` → JSON, `undefined` → no body), `status`, `ok`, `statusText`, `headers`, `url`; no cast ([recipe](#how-to-mock-fetch-and-other-globals))                                                                                                                                        |
 | `trackStrayRejections()` / `flushStrayRejections()` / `countStrayRejections()`                              | `/setup`                      | Read back the promise rejections zone.js swallowed into `console.error`, so one can fail a test ([details](#test-run-hygiene))                                                                                                                                                                                                                          |
 | `trackStrayTimers()` / `cancelStrayTimers()` / `countStrayTimers()`                                         | `/setup`                      | Timers a file left pending: record every timeout, interval and frame it hands out, cancel what is still outstanding when the file ends (and how many that was), or count what stands and fail on it — the two halves `setupAutoSpy({ strayTimers: true })` installs ([details](#test-run-hygiene))                                                      |
 | `guardGlobalPatches(reaction)`                                                                              | `/setup`                      | Name the test that redefined a property of `document` / `navigator` / `globalThis` as non-configurable                                                                                                                                                                                                                                                  |
@@ -3786,6 +3797,7 @@ export can never be.
 | `prefer-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer that with `NG0101` |
 | `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                                                                                                                                                                                                                                                                                    |
 | `no-hand-assigned-global`         |   `error`   | —                 | `global.fetch = vi.fn(…)` and any other double assigned to a global with no restore in a teardown hook → `mockValueProp(globalThis, …)` / `vi.stubGlobal` + `unstubGlobals`, `blockNetwork()` for a spec that only stays offline, `stubWebStorage()` for the storages                                                                                                                                                                                                                                            |
+| `prefer-stub-response`            |   `error`   | —                 | an object literal cast to `Response` (`as Response`, `as unknown as Response`, `<Response>{ … }`) or a `createMock<Response>(…)` / `createAutoMock<Response>(…)` call → `stubResponse({ body })` from `/setup`, which builds the platform's own and answers every member; `Response` has to resolve to the global, so an Express handler's or a generated client's envelope of the same name is left alone                                                                                                       |
 | `prefer-provide-activated-route`  |   `error`   | —                 | a hand-built `ActivatedRoute` — any `useValue` / `useClass` / `useFactory`, and `provideAutoSpy(ActivatedRoute)` too → `provideActivatedRoute({ … })`; the double knows either the streams or the snapshot, never both, and `injectActivatedRoute().setParams(…)` moves them together mid-test                                                                                                                                                                                                                   |
 | `no-passthrough-console-spy`      |   `error`   | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and still prints → `installConsoleSpies()` from `vitest-auto-spy/console`, or `.mockImplementation(() => undefined)`                                                                                                                                                                                                                                                                                                                   |
 | `no-console-in-spec`              |   `error`   | —                 | a spec that calls `console.x(…)` itself, or replaces a method with `console.x = …`, which nothing puts back — under `isolate: false` every later file inherits it                                                                                                                                                                                                                                                                                                                                                |
@@ -3807,7 +3819,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Four of the thirty-nine fix on their own, thirteen offer suggestions**, and the split is not about how hard
+**Four of the forty fix on their own, thirteen offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -3978,7 +3990,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the thirty-nine rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the forty rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3995,7 +4007,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of thirty-nine rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of forty rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -4103,10 +4115,12 @@ another, and the next one is in that same file.
 | `stable(fixture, opts?)` / `flushEffects()` _(Angular)_                                                                                     | Zoneless waiting: flush effects, then await the fixture, with a 2 s budget that names the cause                                                                                                                                                                               |
 | `settleResource(resource, opts?)` _(Angular)_                                                                                               | Tick until an `httpResource()` / `resource()` / `rxResource()` leaves `loading`                                                                                                                                                                                               |
 | `provideHttpTesting(opts?)` / `expectRequest(matcher, opts?)` _(`/angular-http`)_                                                           | `provideHttpClient()` + `provideHttpClientTesting()` in one spread; find the one matching request and `flush` / `error` it with the settling included                                                                                                                         |
-| `expectNoRequest(matcher?, opts?)` / `verifyNoPendingRequests()` _(`/angular-http`)_                                                        | Assert that nothing was requested / that the test left nothing unanswered                                                                                                                                                                                                     |
+| `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                                               |
 | `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                                                                                                                                |
+| `collectRouterEvents(events)` _(`/angular-router`)_                                                                                         | The double's router events as one comparable value — `expect([[NavigationStart, '/checkout'], …])`, a class-and-URL pair per event                                                                                                                                            |
+| `provideLocationDouble()` / `injectLocationDouble(injector?)` / `createLocationDouble()` _(`/angular-router`)_                              | Angular's own `SpyLocation` and `MockLocationStrategy` in one call — a real history, the `urlChanges` journal, `simulateUrlPop()` for the popstate no method call can cause                                                                                                   |
 | `createForm(model, schema?, options?)` / `registerFormMatchers()` _(`/signal-forms`)_                                                       | Angular's own signal `form()`, built in the `TestBed`'s injection context, and the `toHaveFieldErrors` matcher over its `errors()`                                                                                                                                            |
 | `registerSignalMatchers()` _(Angular)_                                                                                                      | Adds `expect(sig).toHaveSignalValue(value)`                                                                                                                                                                                                                                   |
 | `trackRecomputations(signal)` / `trackEffectRuns(effectRef)` _(Angular)_                                                                    | Count what the reactive graph re-ran — `{ count, stop() }`, undone by `restoreMockedProps()`                                                                                                                                                                                  |
@@ -4117,6 +4131,7 @@ another, and the next one is in that same file.
 | `stubMediaElement(opts?)`                                                                                                                   | A `<video>` / `<audio>` that plays, reports a duration and fires the media events                                                                                                                                                                                             |
 | `assertMocked(namespace, opts?)` / `moduleNamespace(exports, opts?)`                                                                        | Prove a `vi.mock()` applied; give its factory the shape an interop probe recognises, or spy the real module through (`passthrough`)                                                                                                                                           |
 | `flushEventLoopUntil(isDone, opts?)`                                                                                                        | Real event-loop turns until a condition holds, with a budget instead of a hang                                                                                                                                                                                                |
+| `createLog<Step>()`                                                                                                                         | The order of calls across collaborators as one comparable value — `add`, `fn(value)`, `items`, `result()`; the step union makes an undeclared step a compile error                                                                                                            |
 | `diffByField(actual, expected)`                                                                                                             | Which field of an array of records moved, and in how many elements                                                                                                                                                                                                            |
 | `guardGlobalPatches(reaction)` / `installPerTest(install)` _(`/setup`)_                                                                     | Name the test that sealed a global property; re-install a stub before every test                                                                                                                                                                                              |
 | `guardStrayConsole(reaction)` / `withoutStrayTimerTracking(work)` _(`/setup`)_                                                              | Fail a test on console output nothing absorbed; keep setup work's timers out of the stray-timer count                                                                                                                                                                         |

package/dist/angular-diagnostics.js

@@ -1,14 +1,14 @@
 import { instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-KOR5OK4H.js';
 export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-KOR5OK4H.js';
-import { failOnUnspiedProvider } from './chunk-NEFATXWT.js';
-import { assertAngularInternals } from './chunk-NS3Y6AQB.js';
-import './chunk-S5ARWUD4.js';
-import './chunk-I6JZIWIZ.js';
-import './chunk-SA2QIER3.js';
+import { failOnUnspiedProvider } from './chunk-45W5LBPY.js';
+import { assertAngularInternals } from './chunk-WYYKUPXW.js';
+import './chunk-MBSPAUUD.js';
+import './chunk-DQ3SPSCH.js';
+import './chunk-MG7LKE4R.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-4SJY7ZHM.js';
-import { isAutoSpyLike } from './chunk-R3DF5ZEO.js';
-import { DOCS_LINKS } from './chunk-JJVTDL5R.js';
+import './chunk-LZVIH54N.js';
+import { isAutoSpyLike } from './chunk-BBPYNKGB.js';
+import { DOCS_LINKS } from './chunk-QO4BPR3V.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';
 import { getTestBed } from '@angular/core/testing';
 import { beforeEach, afterEach } from 'vitest';

package/dist/angular-doubles.js

@@ -1,12 +1,12 @@
-import { useVitestAdapter } from './chunk-BN2QV45R.js';
-import './chunk-2KBFEQOV.js';
+import { useVitestAdapter } from './chunk-V6TIK7XU.js';
+import './chunk-MUZZBRUP.js';
 import './chunk-YHDBRBGU.js';
-import './chunk-ITOFGQTX.js';
-import './chunk-SA2QIER3.js';
+import './chunk-CPLUHRHD.js';
+import './chunk-MG7LKE4R.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-4SJY7ZHM.js';
-import './chunk-R3DF5ZEO.js';
-import { DOCS_LINKS } from './chunk-JJVTDL5R.js';
+import { createFunctionSpy } from './chunk-LZVIH54N.js';
+import './chunk-BBPYNKGB.js';
+import { DOCS_LINKS } from './chunk-QO4BPR3V.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';
 import { TestBed } from '@angular/core/testing';
 import { ReplaySubject } from 'rxjs';

package/dist/angular-http.d.ts

@@ -49,8 +49,14 @@ interface HttpTestingOptions {
      * A request nobody flushed is a spec whose code under test is still waiting on a response — every
      * assertion after that call is about a state the test never reached. Left alone it also leaks:
      * the next test's `expectRequest` matches a request the previous one made.
+     *
+     * An object keeps the check on and carries its option to it: `{ ignoreCancelled: true }` is the
+     * same opt-in as `verifyNoPendingRequests({ ignoreCancelled: true })` — a request the code under
+     * test cancelled, by unsubscribing, no longer fails the test.
      */
-    verifyOnTeardown?: boolean;
+    verifyOnTeardown?: boolean | {
+        ignoreCancelled?: boolean;
+    };
 }
 /** The body types `TestRequest#flush` takes, read off Angular rather than restated here. */
 type ResponseBody = Parameters<TestRequest['flush']>[0];
@@ -121,8 +127,14 @@ declare function expectNoRequest(matcher?: RequestMatcher, options?: ExpectReque
  * it — and because a suite that turned `verifyOnTeardown` off still wants it in the two specs where
  * it matters.
  *
+ * `ignoreCancelled: true` is the opt-in `HttpTestingController.verify({ ignoreCancelled })` names:
+ * a request the code under test cancelled — an unsubscribed `httpResource()`, a `takeUntil` that
+ * cut a call — is taken but no longer held against the test. Default `false`, like Angular's own.
+ *
  * A no-op when the test configured no HTTP testing at all.
  */
-declare function verifyNoPendingRequests(): void;
+declare function verifyNoPendingRequests(options?: {
+    ignoreCancelled?: boolean;
+}): void;
 
 export { type ExpectRequestOptions, type FlushOptions, type HttpTestingOptions, type RequestErrorOptions, type RequestExpectation, type RequestMatcher, type ResponseBody, expectNoRequest, expectRequest, provideHttpTesting, verifyNoPendingRequests };