vitest-auto-spy 5.5.0 → 5.6.0

package/AGENTS.md

@@ -56,7 +56,7 @@ Add-ons, orthogonal to the runner:
 | ----------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Observable spies  | `import 'vitest-auto-spy/rxjs'` | `nextWith` & friends. **Side-effect import, once**, and in a file the `tsconfig` includes (§4)                                                                                                                                  |
 | observer-spy shim | `vitest-auto-spy/observer-spy`  | `subscribeSpyTo` — the `@hirez_io/observer-spy` surface (§20). Its own entry so `/rxjs` does not carry it                                                                                                                       |
-| Console spies     | `vitest-auto-spy/console`       | silent typed spies over the global `console`                                                                                                                                                                                    |
+| Console spies     | `vitest-auto-spy/console`       | silent typed spies over the global `console` — `installConsoleSpies()` per test, `restoreConsole()` after                                                                                                                                                                                    |
 | DOM stubs         | `vitest-auto-spy/dom-stubs`     | `stubIntersectionObserver` / `stubResizeObserver` / `stubMutationObserver` / `stubObserver`, `stubMediaElement`, `stubAbortController`, `intersectionEntry` / `resizeEntry` / `mutationRecord`. **Moved off the root in 4.0.0** |
 | Run diagnostics   | `vitest-auto-spy/diagnostics`   | `compareTestRuns`, `summarizeTestRun`, `formatTestRunComparison`, `diffByField`. **Moved off the root in 4.0.0**                                                                                                                |
 | Angular HTTP      | `vitest-auto-spy/angular-http`  | `provideHttpTesting`, `expectRequest` — `httpResource()` / `HttpClient` (§13). Optional `@angular/common` peer, this entry only                                                                                                 |
@@ -720,7 +720,9 @@ users.currentTenant(); // throws here, not four frames later inside the componen
 Called as: Cart.checkout(1,'now')
 ```
 
-Also on `createAutoMock`, `provideAutoSpy`, and suite-wide as `setupAutoSpy({ strict: true })`.
+Also on `createAutoMock`, `provideAutoSpy`, and suite-wide as `setupAutoSpy({ strict: true })` — which
+reaches a double whichever bundle of the package built it: the default lives on `globalThis`. Before
+this release it lived in module scope, and a setup file's `strict: true` reached no double a spec built.
 Precedence, first one set wins: the double's `onUnstubbedCall` → the global `onUnstubbedCall` → the
 double's `strict` (**including `strict: false`**, the only way to exempt one double from a suite-wide
 default) → the global `strict`.
@@ -734,6 +736,12 @@ default) → the global `strict`.
 - **It does not reach** accessor spies, observable-property spies, `mockDeep` nodes, `console-spy`,
   `mockResourceProp`'s `reload` or a standalone `createFunctionSpy`. A strict double still answers
   `undefined` for an unconfigured getter or `items$`. `fillMissing` members **are** covered.
+- **Angular lifecycle hooks are exempt.** `ngOnDestroy`, `ngOnInit`, `ngOnChanges`, `ngDoCheck` and the
+  `ngAfter…` hooks answer `undefined` on a strict double: Angular calls `ngOnDestroy` itself on every
+  provided value at teardown (a `createAutoMock` / `provideAutoSpyForToken` double always has one), and
+  a throw there broke the teardown for every test after it. The calls are still recorded.
+- A class instance or DOM node in the `Called as:` line prints as `[ClassName]`, data up to 200
+  characters per argument; `provideAutoSpyForToken` names the token (`createAutoMock` takes `name`).
 - Use `onUnstubbedCall` to survey a suite before turning the throw on — it is handed
   `{ className, method, args }` and whatever it returns is what the call answers, so a handler that
   pushes to an array records the gap without failing anything.
@@ -1137,23 +1145,28 @@ setupAutoSpy({ strayTimers: true }); // wrap the schedulers, sweep the survivors
 ```
 
 The pieces are exported too — `trackStrayTimers()` (idempotent, returns the undo),
-`cancelStrayTimers()` (returns how many it cancelled) and `countStrayTimers()`, all from
-`vitest-auto-spy/setup`. Use `expect(countStrayTimers()).toBe(0)` in an `afterEach` to make a leak
-fail rather than be tidied away, or take the per-file count from the sweep itself:
+`cancelStrayTimers()` (returns how many it cancelled), `countStrayTimers()` and
+`describeStrayTimers()` (each pending timer's kind, the spec file that scheduled it and up to five
+frames), all from `vitest-auto-spy/setup`. Use `expect(countStrayTimers()).toBe(0)` in an `afterEach`
+to make a leak fail rather than be tidied away, or take the per-file report from the sweep itself —
+`timers` carries the same origins, so the failure diff names the file and the scheduling call:
 
 ```ts
-setupAutoSpy({ strayTimers: true, onStrayTimers: ({ cancelled }) => expect(cancelled).toBe(0) });
+setupAutoSpy({ strayTimers: true, onStrayTimers: ({ timers }) => expect(timers).toEqual([]) });
 ```
 
+A stray whose `file` is not the file that failed was scheduled after the previous file's sweep —
+the previous file is the one to fix.
+
 **With Vitest 4.1's `--detect-async-leaks`, run one or the other — not both silently.** The two
 arrive at the same timer from opposite ends and the quiet one wins: the sweep cancels in `afterAll`,
 Vitest collects its leaks afterwards, and a cancelled timeout is no longer referenced, so the run
 reports **no leaks** for a file that leaks. Cancelling is still the right default — a callback firing
 during a later file is the more expensive failure — so when both are on and no `onStrayTimers` is
-given, the sweep prints one line to stderr saying how many it took away. To see _where_ each one was
-scheduled, re-run that file with `strayTimers` off and read Vitest's report; the code frame points
-at the `setTimeout` in the spec, because the library's own scheduler wrappers go through
-`vi.defineHelper` and are dropped from the stack.
+given, the sweep prints one line to stderr saying how many it took away and where the first three
+were scheduled; `onStrayTimers` gets all of them. Vitest's own report, with `strayTimers` off, points
+its code frame at the `setTimeout` in the spec, because the library's own scheduler wrappers go
+through `vi.defineHelper` and are dropped from the stack.
 
 **The one that keeps a suite green while it is wrong:** zone.js replaces the global `Promise`, and a
 rejection nobody handled is drained into `console.error` and no further — it never reaches
@@ -1546,6 +1559,65 @@ a `useValue` provider or a test double — patch the prototype of the class the
 `guardPrototypePollution(reaction)` from `/setup` registers the same check on its own, for a suite
 that does not call `setupAutoSpy()`.
 
+### Failing on console output nothing absorbed
+
+```ts
+setupAutoSpy({ strayConsole: 'throw' }); // default 'off'; 'warn' prints the same report without failing
+```
+
+Any call to a console method that writes (`log`, `info`, `warn`, `error`, `debug`, `trace`, `table`,
+`dir`, `dirxml`, `timeLog`, `timeEnd`, `count`; `group` with a label; a falsy `assert`) made during a
+test that nothing absorbed fails **that test**, quoting the method, the first three lines and the first
+frame outside `node_modules`:
+
+```
+[vitest-auto-spy] "CartService > reports a failed load" wrote to the console 1 time(s) and nothing absorbed it:
+  - console.error: Error: load failed
+      at CartService.load (src/app/cart.service.ts:41:15)
+```
+
+- **Absorbed** means the call never reached the console: a `/console` spy installed for the test or
+  the file, `vi.spyOn(console, m).mockImplementation(…)`, any replacement that does not call
+  through. A bare `vi.spyOn(console, m)` calls through and **counts**.
+- Output **outside any test** — collection/import, `beforeAll` / `afterAll`, a callback after its
+  test ended — fails the **file** in `afterAll` (`… outside any test …`).
+- Every console method a test replaced is put back after it; one a file replaced, after the file.
+- Under the guard, **importing `vitest-auto-spy/console` installs nothing** — call
+  `installConsoleSpies()` in a `beforeEach` (or at the top of the file). Spies an import installed
+  before the guard armed are taken off.
+- The library's own warnings are console output: under the guard they fail the test that caused them.
+- `strayConsole: { allow: ['…', /…/] }` is the last resort, for environment noise no spec can reach.
+  Output written to `process.stdout` / `process.stderr` directly, and jsdom's own virtual console, is
+  not seen.
+- The wrapper forwards every call unchanged, so Vitest's attribution and `onConsoleLog` still work.
+  `guardStrayConsole(reaction)` registers the same guard on its own.
+
+### One grade for everything — `preset: 'strict'`
+
+```ts
+setupAutoSpy({ preset: 'strict' });
+```
+
+Sets `duplicateCopies`, `propsOutsideHooks`, `guardGlobals`, `prototypePollution`, `strayConsole` and
+`misconfiguration` to `'throw'`, turns `strayTimers` on, and `strayRejections` on when zone.js is
+loaded. An option passed alongside still wins. **Not** included: `strict` (strict doubles change what
+an unconfigured call returns — a semantic switch, not a grade; the name was taken, hence `preset`),
+`blockNetwork` (changes the code under test), `restoreMocks` (drops `beforeAll` spies), failing on
+stray-timer counts (the sweep fails the file from `afterAll`, and a callback scheduled after the
+previous file's sweep is charged to the next — opt in with
+`onStrayTimers: ({ timers }) => expect(timers).toEqual([])`, whose diff names each one's file), and
+`enableAngularDiagnostics()`, which lives in `/angular` — call it in the same setup file as the Angular half of strict.
+
+`misconfiguration: 'throw'` on its own makes the library's misuse reports — an `onlyMethodsToSpyOn`
+typo, `gettersToSpyOn` naming a method, a `returns` key no spy answers to, `injectSpy` handed a real
+instance, a `jasmine.DEFAULT_TIMEOUT_INTERVAL` write, `providedMethodNames` — throw at the call site,
+every occurrence. The grade is process-wide and released after the file. The printed grade of the
+`injectSpy` warning is de-duplicated per token **per spec file**, no longer per worker.
+
+`withoutStrayTimerTracking(work)` runs setup work whose timers `strayTimers` neither counts nor
+cancels — jsdom answers every Web Storage write with a real `setTimeout(…, 0)`, and the library's own
+storage probe runs under it.
+
 ### Hook order differs from Jest
 
 Vitest runs `afterEach` hooks as a stack (innermost / last-registered first); Jest ran them in
@@ -2481,15 +2553,29 @@ mount(Greeting, { global: { provide } });
 import { createSpyFromClass } from 'vitest-auto-spy/react';
 ```
 
-Console spies — importing the entry replaces `console.debug` / `error` / `info` / `log` / `time` /
-`timeEnd` / `trace` / `warn` with silent typed spies, named `console<Method>Spy`:
+Console spies — `installConsoleSpies()` replaces `console.debug` / `error` / `info` / `log` / `time` /
+`timeEnd` / `trace` / `warn` with silent typed spies, named `console<Method>Spy`. Install them per test
+and take them off after it:
 
 ```ts
-import { consoleInfoSpy, consoleWarnSpy, resetConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
+import { type ConsoleSpies, installConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
 
-expect(consoleInfoSpy).toHaveBeenCalledWith('done'); // the output is silenced, not printed
+let consoleSpies: ConsoleSpies;
+
+beforeEach(() => {
+  consoleSpies = installConsoleSpies();
+});
+afterEach(() => restoreConsole());
+
+expect(consoleSpies.consoleInfoSpy).toHaveBeenCalledWith('done'); // the output is silenced, not printed
 ```
 
+The exported `consoleInfoSpy` & co. are the same objects; `restoreConsole()` keeps them and clears
+their calls. **Do not rely on the import to install them**: it does so once per worker, so under
+`isolate: false` the spies go on in whichever file imported them first and silence every later file
+(`no-import-time-console-spies` reports it). Under `setupAutoSpy({ strayConsole })` the import installs
+nothing at all.
+
 Import your runtime entry (`…/bun`, `…/node`) **before** `…/console`, or it registers the Vitest
 adapter. Prefer not to touch the real global? `createAutoMock<Console>()` gives a detached one.
 
@@ -2546,13 +2632,16 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-unregistered-inject-spy`      | `error` | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                            |
 | `prefer-render-shallow`           | `warn`  | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                    |
 | `prefer-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo                                                                                                                                        |
+| `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` |
+| `no-import-time-console-spies`    | `error` | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and silences every later file → `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` |
 | `jasmine-namespace-without-entry` | `error` | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compat layer nowhere — option: `{ setupModules: […] }`                                                                                                                                                                                                 |
 | `no-jasmine-globals`              | `error` | —                 | `jasmine.*`, bare `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(`                                                                                                                                                                                                                        |
 | `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                                                                                                                                                                                                                   |
 
-Twenty-five rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
-`no-stub-class-double` and `no-structural-double`**; three fix on their own, eight offer suggestions. Twenty-four are syntactic; `no-private-member-access` is the one
+Twenty-eight rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+`no-stub-class-double` and `no-structural-double`**; three fix on their own, nine offer suggestions. Twenty-seven are syntactic; `no-private-member-access` is the one
 that reads types, and it reports nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. The
@@ -2709,6 +2798,11 @@ packages, which a subpath export can never be.
 | `extendWithAutoSpies needs Vitest 4.1 or newer`                                                               | the `test` handed in has only the object-form `extend` (Vitest ≤ 4.0); the builder form the helper is written against arrived in 4.1                                                                                                                                       | upgrade Vitest, or keep `provideAutoSpy` + `injectSpy` in a `beforeEach` until then                                                                                                                                                                                                                       |
 | `advanceTimers() requires fake timers`                                                                        | no fake timers installed                                                                                                                                                                                                                                                   | `setupFakeTimers()` or `vi.useFakeTimers()` first                                                                                                                                                                                                                                                         |
 | `Nothing configured X.method, and strict mode is on`                                                          | a strict double was asked for a method no line configured                                                                                                                                                                                                                  | configure it (`mockReturnValue` / `resolveWith` / `nextWith` / `calledWith`), or `{ strict: false }` on that double (§5)                                                                                                                                                                                  |
+| `[vitest-auto-spy] "…" wrote to the console N time(s) and nothing absorbed it`                                | `setupAutoSpy({ strayConsole })` — the test printed, and nothing that does not call through stood on `console`: no `/console` spy installed for it, no `mockImplementation`. A bare `vi.spyOn(console, m)` calls through, and a `console.warn` from this library counts too| absorb and assert: `installConsoleSpies()` in a `beforeEach`, then `expect(consoleErrorSpy)…`; or fix the code that printed. Importing a spy installs nothing under the guard. `strayConsole: { allow: [...] }` only for environment noise no spec can reach                                              |
+| `… wrote to the console N time(s) outside any test`                                                           | output while the file was imported, in a `beforeAll` / `afterAll`, from a callback after its test ended, or from a test whose `afterEach` never ran — the frame names the line                                                                                             | move the work into a test and absorb it there; a callback firing late is a leak — clear it where it is scheduled                                                                                                                                                                                          |
+| `setupAutoSpy({ strict: true })` has no effect — no double throws, a suite with it on stays green             | before this release the default lived in module scope, and `/setup` and the factory bundles each carried a copy; a 1759-file consumer ran 12 717 tests green with it on                                                                                                    | upgrade — the default, `onUnstubbedCall` and `setSpyEngine()` now live on `globalThis`                                                                                                                                                                                                                    |
+| a seeded getter reads `undefined`: `provideAutoSpy(X, { overrides: { remoteConfig } })` next to `gettersToSpyOn` or a `registerAutoSpyDefaults` row| before this release the seed was assigned into the spied accessor's setter, and the getter kept answering `undefined`                                                                                                                                                      | upgrade — `overrides` now seeds the getter spy; a later `accessorSpies.getters.x.mockReturnValue(…)` still wins                                                                                                                                                                                           |
+| `Cannot read properties of undefined (reading 'name')` on `value.constructor.name`, with `createAutoMock<T>()`| `constructor` answered `undefined` on an auto-mock                                                                                                                                                                                                                         | upgrade — it answers `Object`, as every other double does; or seed it: `createAutoMock<T>({ constructor: … })`                                                                                                                                                                                            |
 | `Cannot redefine property: …` from a library accessor spy                                                     | the target is an ES module namespace a bundler inlined                                                                                                                                                                                                                     | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that                                                                                                                                                                                                           |
 | `Cannot spy on this instance in place: it is not extensible`                                                  | `createSpyFromInstance` was handed a frozen or sealed object                                                                                                                                                                                                               | spy it before it is frozen, or build a separate double with `createSpyFromClass` (§2)                                                                                                                                                                                                                     |
 | `Cannot mock the property 'X': it is not configurable`                                                        | the member was defined with `configurable: false`, so it cannot be redefined                                                                                                                                                                                               | members replaced before it are still restorable — `restoreSpiedInstance(instance)` or `restoreMockedProps()`                                                                                                                                                                                              |
@@ -2721,7 +2815,7 @@ packages, which a subpath export can never be.
 | `assertComponentDefIntact(): argument N is undefined, which carries no ɵcmp or ɵdir`                          | the class reference itself never arrived — the `Cannot read properties of undefined (reading 'ɵcmp')` case                                                                                                                                                                 | the same split barrel; import the component from its own module, not the barrel (§13)                                                                                                                                                                                                                     |
 | `TS1117: An object literal cannot have multiple properties with the same name`, in a fixture                  | a hundred-line model literal copied into eight specs and edited independently                                                                                                                                                                                              | one `createFixtureFactory<T>(defaults)`; note the runtime keeps the **second** key, so do not auto-fix by dropping one (§12)                                                                                                                                                                              |
 | `configureTestingModule was given N schema(s) that can never apply`                                           | `enableAngularDiagnostics({ deadSchemas })` — `schemas` next to a standalone component, with `declarations` empty                                                                                                                                                          | drop the `schemas` entry and put the missing directive/pipe in the component's own `imports`, or use `createDirectiveHost` (§13)                                                                                                                                                                          |
-| `injectSpy(X): the injector returned a plain instance, not an auto-spy`                                       | the token is provided for real; a `console.warn` on its own, a **throw** under `enableAngularDiagnostics({ unspiedProviders })`                                                                                                                                            | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants                                                                                                                                                                                    |
+| `injectSpy(X): the injector returned a plain instance, not an auto-spy`                                       | the token is provided for real; a `console.warn` once per token and spec file, a **throw** under `enableAngularDiagnostics({ unspiedProviders })` or `setupAutoSpy({ misconfiguration: 'throw' })`                                                                                                                                            | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants                                                                                                                                                                                    |
 | `trackInjections(...).get(X): that token is not tracked by this log`                                          | `get` only answers for tokens whose providers the log created                                                                                                                                                                                                              | add the token to the `trackInjections([...])` list, or read it from the injector directly (§13)                                                                                                                                                                                                           |
 | `Spread syntax requires ...iterable[Symbol.iterator] to be a function`, at load time                          | a module-scope spread of an imported binding, inside a bundle                                                                                                                                                                                                              | build the array in a function or a getter — `no-import-time-spread` (§16)                                                                                                                                                                                                                                 |
 | `the timers APIs are not mocked` in a nested `describe`'s `beforeAll`                                         | fakes armed in `beforeEach` only; Jest armed them for the whole file                                                                                                                                                                                                       | `setupFakeTimers(cfg, { betweenTests: true })` / `setupAutoSpy({ globalFakeTimers: true })`                                                                                                                                                                                                               |
@@ -2778,7 +2872,7 @@ packages, which a subpath export can never be.
 | a 30 s timeout, in a different file each run                                                                  | module-level `vi.fn()` in a fixture shared by files                                                                                                                                                                                                                        | make the fixture a factory (§10)                                                                                                                                                                                                                                                                          |
 | a component's `afterNextRender` state is empty                                                                | `detectChanges()` does not run the after-render phase                                                                                                                                                                                                                      | `await stable(fixture)` (§11)                                                                                                                                                                                                                                                                             |
 | a green test whose only line about a call is `spy.m.calledWith(1);`                                           | that is a **stub**, not an assertion — chai's `expect(fn).to.have.been.calledWith(x)` is the one that checks                                                                                                                                                               | continue the chain, or `expect(spy.m).toHaveBeenCalledWith(1)` — `no-bare-called-with` (§16)                                                                                                                                                                                                              |
-| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers                                | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                                                                                                                                               | re-run that file with `strayTimers` off; the warning on stderr says how many were taken (§10)                                                                                                                                                                                                             |
+| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers                                | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                                                                                                                                               | the warning on stderr says how many were taken and where the first three were scheduled; `onStrayTimers` gets every one in `timers` (§10)                                                                                                                                                              |
 | `createNestUnit(X): parameter #n of Y is typed as \`Object\``(or`undefined — usually a circular import`)      | the compiler emitted no runtime class for that parameter — interface, union, primitive, or a circular import                                                                                                                                                               | `@Inject(TOKEN)` plus a `providers` entry, or `@Optional()` to receive `undefined`; `@Inject(forwardRef(() => X))` for the import cycle                                                                                                                                                                   |
 | `createNestUnit(X): Y declares n constructor parameter(s) but carries no design:paramtypes metadata`          | no `emitDecoratorMetadata` (esbuild / Vite), or `reflect-metadata` loaded after the class                                                                                                                                                                                  | tsc or SWC with `decoratorMetadata`, `@Injectable()`, `reflect-metadata` first; or `@Inject(X)` on every parameter                                                                                                                                                                                        |
 | `createNestUnit(X): A -> B -> A is a cycle among the classes built for real`                                  | two exposed / `useClass` classes depend on each other; the helper does not resolve `forwardRef` cycles                                                                                                                                                                     | expose one side less, or provide it                                                                                                                                                                                                                                                                       |
@@ -2856,7 +2950,9 @@ diagnostic and is free to change: print it, never assert on it.
 | an assertion containing a date, with no clock set                           | `mockSystemTime(iso)` first                                             |
 | `configureTestingModule` inside every `it()`                                | one per `describe`                                                      |
 | `vi.mock('@angular/core')` to neutralise `effect()`                         | set the signals, `await stable(fixture)`, assert the result             |
-| a second `vi.spyOn(console, 'error')`                                       | `consoleErrorSpy` from `vitest-auto-spy/console`                        |
+| a second `vi.spyOn(console, 'error')`                                       | `consoleErrorSpy` from `vitest-auto-spy/console`, installed with `installConsoleSpies()` |
+| `import { consoleErrorSpy } from 'vitest-auto-spy/console'` as the install | `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` — the import installs once per worker |
+| a bare `vi.spyOn(console, 'error')` to keep a spec quiet                    | `.mockImplementation(() => undefined)` — without it the line still prints |
 | `mockReadonlyProp(c, 'items', vi.fn(() => []))`                             | `mockReadonlyProp(c, 'items', signal([]))` — a real signal              |
 | `spy.m.mockReturnValue(subject$)` for a `vi.fn(() => subject$)`             | `spy.m.mockImplementation(() => subject$)` — the variable is re-read    |
 

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-16.2%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-16.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)
@@ -76,12 +76,12 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored
 - 🧾 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 — twenty-five rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eight suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
+- 📏 Lint rules and one-line test-run hygiene — twenty-eight rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, nine 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
 - 🚚 [`npx vitest-auto-spy codemod`](#codemod--migrating-a-suite-off-jest-auto-spies) — thirteen transforms that move a suite off `jest-auto-spies` and Jest, or off `jasmine-auto-spies` and jasmine (`--from jasmine`), dry-run by default, with a `--verify` pass that also checks a file somebody edited by hand
-- 🔇 Console spies — `import { consoleInfoSpy } from 'vitest-auto-spy/console'` silences `console` and asserts its calls
+- 🔇 Console spies — `import { consoleInfoSpy } from 'vitest-auto-spy/console'` silences `console` and asserts its calls; [`setupAutoSpy({ strayConsole: 'throw' })`](#how-to-mock-the-console) fails any test whose console output nothing absorbed
 - 🧭 [**Spec patterns**](https://asdalexey.github.io/vitest-auto-spy/recipes) — the shapes a ~370-file Angular suite converged on, and the traps that only surface at scale
 - 🤖 Built for AI agents too — one `npx vitest-auto-spy init` writes the pointer into the files your agents actually read and specialises it for this repository, backed by an offline [`AGENTS.md`](#using-this-library-with-an-ai-agent) inside the package, a [per-agent map](#which-file-your-agent-reads) for **Claude Code**, **OpenAI Codex**, **GLM/z.ai**, **Cursor**, **Copilot**, **Gemini CLI** and the rest, `llms.txt` on the docs site, a Claude Code skill, and errors that name their own fix
 - 🟢 100% test coverage, **zero runtime dependencies** (in-tree arg serializer, no `javascript-stringify`)
@@ -153,6 +153,7 @@ includes — that one import is what keeps `returnSubject()` typed as rxjs's own
   - [A class the code under test builds with `new`](#how-to-mock-a-class-the-code-under-test-builds-with-new)
   - [A double more than one spec uses](#how-to-mock-a-double-more-than-one-spec-uses)
   - [A pipe](#how-to-mock-a-pipe)
+  - [The console](#how-to-mock-the-console)
   - [A jasmine suite mid-migration](#how-to-mock-a-jasmine-suite-mid-migration)
 - [Why](#why)
 - [How it works (and what it won't spy)](#how-it-works-and-what-it-wont-spy)
@@ -1055,6 +1056,48 @@ currency.transform.calledWith(10, 'EUR').mockReturnValue('€10');
 In a component spec, provide it (`provideAutoSpy(CurrencyPipe)`) or keep it out of the template
 entirely — `renderShallow` drops it with the rest of the subtree.
 
+### How to mock: the console
+
+A test that expects output absorbs it, and asserts on it:
+
+```ts
+import { type ConsoleSpies, installConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
+
+let consoleSpies: ConsoleSpies;
+
+beforeEach(() => {
+  consoleSpies = installConsoleSpies();
+});
+
+afterEach(() => restoreConsole());
+
+it('reports a failed load', () => {
+  service.load();
+
+  expect(consoleSpies.consoleErrorSpy).toHaveBeenCalledWith('load failed', expect.any(Error));
+});
+```
+
+The exported `consoleErrorSpy` is the same object, so `expect(consoleErrorSpy)` works too. Do not
+rely on the **import** to install them: it does so once per worker, so under `isolate: false` the
+spies go on in whichever file imported them first and silence every later file of the worker — on a
+1759-file Angular consumer, 32 of the 39 files importing the entry relied on that, and three files
+adding `restoreConsole()` was enough to fail 12 tests in 5 others and surface hidden output in 7.
+
+The spies are silent and typed; `vi.spyOn(console, 'error').mockImplementation(() => undefined)` is
+the runner's own equivalent. A **bare** `vi.spyOn(console, 'error')` is not: with no implementation
+it records the call and then calls through, so the line still prints while the spec reads as though
+it silenced the console.
+
+`setupAutoSpy({ strayConsole: 'throw' })` turns the rest into failures — any console output that
+reached the console fails its test, quoting the method, the first lines and the frame that wrote it,
+and output outside any test fails the file. Under the guard the `/console` import installs nothing,
+because under `isolate: false` it ran once per worker and silenced every later file; install the
+spies in a `beforeEach` (or at the top of the file) as above. The `no-passthrough-console-spy`,
+`no-console-in-spec` and `no-import-time-console-spies` lint rules report the three shapes that print
+or silence the wrong file. See
+[Test-run hygiene](#test-run-hygiene).
+
 ### How to mock: a jasmine suite mid-migration
 
 A suite arriving from `jasmine-auto-spies` writes every helper behind `.and`, because that is where
@@ -1752,7 +1795,9 @@ abstract-class fallback) never read a class, so it has no class name to print an
 the method alone.
 
 `strict` is available on `createSpyFromClass`, `createAutoMock` and `provideAutoSpy`, and suite-wide
-through `setupAutoSpy({ strict: true })` — one line rather than an edit per factory call.
+through `setupAutoSpy({ strict: true })` — one line rather than an edit per factory call. (Before
+this release the suite-wide switch reached no double a spec built: it lived in module scope, and
+`/setup` and the factories' bundles each carried their own copy. It now lives on `globalThis`.)
 `onUnstubbedCall` is the general form, and whatever it returns becomes the call's return value: use
 it to _record_ the gap before turning the throw on across a suite, or as a blanket fallback value.
 
@@ -2619,6 +2664,9 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `blockNetwork(options?)`                                                                 | `/setup`                      | Close `fetch`, `XMLHttpRequest` and `sendBeacon`, naming what was requested ([details](#test-run-hygiene))                                                                                            |
 | `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))                                                                        |
 | `guardGlobalPatches(reaction)`                                                           | `/setup`                      | Name the test that redefined a property of `document` / `navigator` / `globalThis` as non-configurable                                                                                                |
+| `guardStrayConsole(reaction)`                                                            | `/setup`                      | Fail a test that wrote to the console without absorbing it, and a file that wrote outside any test ([details](#test-run-hygiene)) |
+| `withoutStrayTimerTracking(work)`                                                        | `/setup`                      | Run setup work whose timers the stray-timer tracker neither counts nor cancels — jsdom schedules one per Web Storage write |
+| `describeStrayTimers()`                                                                  | `/setup`                      | Every timer still pending, with its kind, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets |
 | `guardPrototypePollution(reaction)`                                                      | `/setup`                      | Name the test that left a key on `Object.prototype` — it stops later files collecting ([details](#test-run-hygiene))                                                                                  |
 | `installPerTest(install)`                                                                | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                                                                           |
 | `setupAngularTestEnv(opts)`                                                              | `/angular`                    | Zone and zoneless spec files in one worker, switching platforms per file                                                                                                                              |
@@ -2649,12 +2697,18 @@ onSave.calledWith(1).resolveWith();
 
 ### Console spies — `vitest-auto-spy/console`
 
-Importing the entry replaces `console.debug` / `error` / `info` / `log` / `time` / `timeEnd` /
-`trace` / `warn` with **silent, fully-typed spies** and exports each one ready to assert — no
-`vi.spyOn(console, 'info')` boilerplate in every suite, no log output polluting the test run:
+`installConsoleSpies()` replaces `console.debug` / `error` / `info` / `log` / `time` / `timeEnd` /
+`trace` / `warn` with **silent, fully-typed spies**, and the entry exports each one ready to assert —
+no `vi.spyOn(console, 'info')` boilerplate in every suite, no log output polluting the test run.
+Install them in a `beforeEach` and `restoreConsole()` in the `afterEach` (see
+[How to mock: the console](#how-to-mock-the-console)); importing the entry installs them too, but only
+once per worker, which under `isolate: false` silences every later file:
 
 ```ts
-import { consoleInfoSpy, consoleWarnSpy } from 'vitest-auto-spy/console';
+import { consoleInfoSpy, consoleWarnSpy, installConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
+
+beforeEach(() => installConsoleSpies());
+afterEach(() => restoreConsole());
 
 service.doWork();
 
@@ -2664,7 +2718,14 @@ expect(consoleWarnSpy).not.toHaveBeenCalled();
 
 Housekeeping: `resetConsoleSpies()` clears the recorded calls between tests (Vitest's
 `clearMocks: true` already does that automatically), `restoreConsole()` puts the original
-methods back, and `installConsoleSpies()` re-installs after a restore.
+methods back and keeps the spies, so the exports stay live, and `installConsoleSpies()` puts the same
+spies back on after a restore.
+
+Under `setupAutoSpy({ strayConsole })` importing the entry **installs nothing**: under
+`isolate: false` the import ran once per worker and left the spies silencing every later file, which
+is exactly the output the guard exists to see. Call `installConsoleSpies()` in a `beforeEach` (for
+each test) or at the top of the spec file (for the file); the guard takes them off again when that
+scope ends. See [How to mock: the console](#how-to-mock-the-console).
 
 > The spies use the registered `MockAdapter` — import your runtime entry
 > (`vitest-auto-spy/bun`, `…/node`) **before** `vitest-auto-spy/console` and the console spies
@@ -2874,7 +2935,26 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
     filter runs before either. A suite stays green with this broken — only the specs that touch
     storage fail — so it arrives as "CI moved to a new Node and eleven unrelated specs died". The
     repair decides by using the storage rather than looking at it, replaces only one that cannot
-    keep a value, and installs nothing at all in a `node` environment.
+    keep a value, and installs nothing at all in a `node` environment. The probe runs under
+    `withoutStrayTimerTracking`: jsdom answers every Web Storage write with a real
+    `setTimeout(…, 0)`, and `strayTimers` used to charge those to the file.
+12. **Console output nothing absorbed.** Opt-in, `strayConsole: 'throw'`. Any console call a test
+    made that nothing absorbed fails that test, quoting the method, the first lines written and the
+    first frame outside `node_modules`; output outside any test — while the file was imported, in a
+    `beforeAll` / `afterAll`, from a callback after its test ended — fails the file. Absorbed means it
+    never reached the console: a `vitest-auto-spy/console` spy installed for the test or the file, or
+    `vi.spyOn(console, m).mockImplementation(…)`; a bare `vi.spyOn` calls through and counts. Every
+    console method a test replaced is put back after it, so one file's silence cannot reach the next,
+    and the library's own warnings count like any other output. `allow: [...]` is the last resort,
+    for environment noise no spec can reach.
+13. **Every guard at its strictest — `preset: 'strict'`.** `duplicateCopies`, `propsOutsideHooks`,
+    `guardGlobals`, `prototypePollution`, `strayConsole` and `misconfiguration` to `'throw'`,
+    `strayTimers` on, `strayRejections` on where zone.js is loaded; an option passed alongside still
+    wins. Not in it: strict doubles (a semantic switch, not a grade), `blockNetwork`, `restoreMocks`,
+    and failing on stray-timer counts, which land on a file from `afterAll` and can charge it a
+    callback the previous file scheduled after its sweep. `misconfiguration: 'throw'` on its own
+    makes the library's misuse reports — an `onlyMethodsToSpyOn` typo, a `returns` key no spy answers
+    to, `injectSpy` handed a real instance — throw at the call site, every occurrence.
 
 | Option                | Default   | Notes                                                                                                                                                                                         |
 | --------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -2883,11 +2963,14 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
 | `propsOutsideHooks`   | `'warn'`  | Name a `mock*Prop` patch made in a `describe` body or `beforeAll` — it survives one test; `'throw'`, `'off'`. `reportPropsOutsideHooks(reaction)` sets the same dial without the setup helper |
 | `restoreMocks`        | `false`   | `vi.restoreAllMocks()` in a global `afterEach` — turn on for `isolate: false`                                                                                                                 |
 | `strayTimers`         | `false`   | Cancel timeouts, intervals and frames that outlive their file                                                                                                                                 |
-| `onStrayTimers`       | —         | Takes the per-file count the sweep cancelled — see the note on `--detect-async-leaks`                                                                                                         |
+| `onStrayTimers`       | —         | Takes the per-file count and each stray's origin (file, frames) — see `--detect-async-leaks`                                                                                                  |
 | `strayRejections`     | `false`   | Fail the test a rejection zone.js swallowed surfaced in — needs zone.js                                                                                                                       |
 | `blockNetwork`        | `false`   | Close every network channel the environment has — `true`, or a narrowing object                                                                                                               |
 | `guardGlobals`        | `'off'`   | Report a test that redefines a global property as non-configurable                                                                                                                            |
 | `prototypePollution`  | `'throw'` | Sweep and report an enumerable key a test left on a built-in prototype                                                                                                                        |
+| `strayConsole`        | `'off'`   | Fail a test (or a file) whose console output nothing absorbed — `'warn'`, `'throw'`, or `{ reaction, allow }`                                                                                  |
+| `misconfiguration`    | `'warn'`  | `'throw'` fails the library's own misuse reports at the call site, every occurrence                                                                                                            |
+| `preset`              | —         | `'strict'` starts every guard above at its strictest grade; explicit options still win                                                                                                        |
 | `globalFakeTimers`    | `false`   | Fake timers for every test **and between them** — Jest's `enableGlobally`                                                                                                                     |
 | `restoreTimerGlobals` | `true`    | Put back timer globals that uninstalling the fakes deleted                                                                                                                                    |
 | `restoreWebStorage`   | `true`    | Give the run a `localStorage` / `sessionStorage` that work                                                                                                                                    |
@@ -3127,6 +3210,9 @@ export can never be.
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                               |
 | `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                       |
 | `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                          |
+| `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 |
+| `no-import-time-console-spies`    |   `error`   | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and, under `isolate: false`, silences every later file |
 | `jasmine-namespace-without-entry` |   `error`   | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compatibility layer nowhere                                                                                                               |
 | `no-jasmine-globals`              |   `error`   | —                 | `jasmine.*`, `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(` — none of them exist under Vitest                                                                              |
 | `no-save-arguments-by-value`      |   `error`   | —                 | `spy.calls.saveArgumentsByValue()`, which is a no-op here → take the copy at call time                                                                                                                                 |
@@ -3136,7 +3222,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.
 
-**Three of the twenty-five fix on their own, eight offer suggestions**, and the split is not about how hard
+**Three of the twenty-eight fix on their own, nine 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
@@ -3240,7 +3326,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 twenty-five rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the twenty-eight rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3257,7 +3343,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 twenty-five rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of twenty-eight rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -3369,6 +3455,8 @@ another, and the next one is in that same file.
 | `flushEventLoopUntil(isDone, opts?)`                                                                                                        | Real event-loop turns until a condition holds, with a budget instead of a hang                                                                                                                                                                                                |
 | `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 |
+| `describeStrayTimers()` _(`/setup`)_                                                                                                        | Each pending timer with the spec file and frames that scheduled it — for a suite that sweeps by hand |
 | `guardPrototypePollution(reaction)` _(`/setup`)_                                                                                            | Name the test that left a key on `Object.prototype`, before the next file fails to collect                                                                                                                                                                                    |
 | `consoleDebugSpy` … `consoleWarnSpy` _(`/console`)_                                                                                         | Silent typed spies replacing the global `console` methods on import                                                                                                                                                                                                           |
 | `installConsoleSpies()` / `resetConsoleSpies()` / `restoreConsole()`                                                                        | Install / clear / undo the console spies                                                                                                                                                                                                                                      |

package/dist/angular-http.d.ts

@@ -77,9 +77,10 @@ interface RequestExpectation {
  * TestBed.configureTestingModule({ providers: [...provideHttpTesting(), provideAutoSpy(Analytics)] });
  * ```
  *
- * It is `provideHttpClient()` + `provideHttpClientTesting()` and deliberately nothing more: a suite
- * whose interceptors are the thing under test keeps its own `provideHttpClient(withInterceptors([…]))`
- * and adds `provideHttpClientTesting()` after it.
+ * It is `provideHttpClient()` + `provideHttpClientTesting()`, plus — unless `verifyOnTeardown` is
+ * `false` — the environment initializer that arms the end-of-test check: a suite whose interceptors
+ * are the thing under test keeps its own `provideHttpClient(withInterceptors([…]))` and adds
+ * `provideHttpClientTesting()` after it.
  */
 declare function provideHttpTesting(options?: HttpTestingOptions): (EnvironmentProviders | Provider)[];
 /**