vitest-auto-spy 5.46.0 → 5.48.0

package/AGENTS.md

@@ -81,7 +81,7 @@ Add-ons, orthogonal to the runner:
 | --- | --- | --- |
 | Observable spies | `import 'vitest-auto-spy/rxjs'` | `nextWith` & friends. **Side-effect import, once**, in a setup file, a spec, or a `.d.ts` 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` — `installConsoleSpies()` per test, `restoreConsole()` after; `consoleOutput()` is everything logged, keyed by channel |
+| Console spies | `vitest-auto-spy/console` | silent typed spies over the global `console` — `useConsoleSpies()` in the `describe` (or `installConsoleSpies()` per test, `restoreConsole()` after); `consoleOutput()` is everything logged, keyed by channel |
 | DOM stubs | `vitest-auto-spy/dom-stubs` | `stubIntersectionObserver` / `stubResizeObserver` / `stubMutationObserver` / `stubObserver`, `stubMediaElement`, `stubAbortController`, `stubWebStorage` (§12), `stubAnimationFrame`, `stubElementRect`, `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 |
@@ -534,7 +534,7 @@ In [`agent-docs/adapters.md`](./agent-docs/adapters.md). Read it for NestJS, Vue
 
 ## 16. ESLint plugin (flat config only)
 
-In [`agent-docs/eslint.md`](./agent-docs/eslint.md). Read it when configuring `vitest-auto-spy/eslint-plugin` or fixing one of its reports.
+In [`agent-docs/eslint.md`](./agent-docs/eslint.md). Read it when configuring `vitest-auto-spy/eslint-plugin` or fixing one of its reports. For `vitest/require-hook`, spread `autoSpy.hookRegisteringHelpers` into `allowedFunctionCalls` rather than keeping the names by hand.
 
 <!-- agents-outline: agent-docs/eslint.md -->
 <!-- /agents-outline -->

package/CHANGELOG.md

@@ -10,6 +10,82 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.48.0] - 2026-09-28
+
+### Added
+
+- **`hookRegisteringHelpers` on `vitest-auto-spy/eslint-plugin`** — the frozen list of the
+  library's public helpers that register `beforeEach` / `afterEach` / `beforeAll` / `afterAll` when
+  called (`useConsoleSpies`, `setupAutoSpy`, `setupFakeTimers`, `useCountingClock`, `mockNow`, the
+  `guard*` family, …), for `vitest/require-hook`'s `allowedFunctionCalls`:
+  `allowedFunctionCalls: [...autoSpy.hookRegisteringHelpers]`. A bare `useConsoleSpies();` in a
+  `describe` body no longer needs a hand-kept list; a spec walks the call graph of every public entry
+  and fails when a hook-registering export is missing from it. It is a property of the plugin
+  object, so `require()` and `import` both reach it. `vitest-auto-spy/eslint-plugin` is +0.42 kB
+  min+gzip (+1.0 %) for the list and the two rule changes.
+- **`prefer-to-have-signal-value`** also reports `expect(sig()).toBeNull()` and `.toBeUndefined()`
+  on a signal read, `.not` included, and fixes them to `toHaveSignalValue(null)` /
+  `toHaveSignalValue(undefined)`.
+
+### Fixed
+
+- **`prefer-to-have-signal-value`** no longer rewrites an identity check. `expect(list.items()).toBe(items)`
+  asserts the signal holds that very array, and the fix turned it into `toHaveSignalValue(items)`,
+  which compares deeply and passes for any equal copy. A `toBe` is now reported only when the
+  expected value is a primitive literal or the signal's type is primitive (`any` does not count);
+  `toEqual` and `toStrictEqual` are unchanged.
+- **Docs**: `vitest-auto-spy/console` imports `vitest` itself (the fallback adapter and the
+  `useConsoleSpies()` hooks), so on `node:test` and Rstest it loads only where the `vitest` package
+  resolves; the console page, the README and `agent-docs/adapters.md` now say so. The README API
+  table and `agent-docs/angular.md` list `registerSignalMatchers({ strict })`, and the types list of
+  `/angular/matchers` names `RegisterSignalMatchersOptions`.
+
+## [5.47.0] - 2026-09-28
+
+### Added
+
+- **`prefer-to-have-signal-value`** (ESLint plugin, `warn`, type-aware, autofix) rewrites
+  `expect(component.total()).toBe(3)` into `expect(component.total).toHaveSignalValue(3)`:
+  the matcher keeps the signal's name in the failure output and refuses a value that is not a
+  signal. `toEqual` maps the same way, `toStrictEqual` keeps its comparison through
+  `{ strict: true }`. The signal is recognised by its type — callable and branded with Angular's
+  signal brand, spelled `__@SIGNAL@…` by the checker — so methods, plain functions and getters stay
+  unreported, and without parser services the rule says nothing. Safe to autofix since 5.46.0, which
+  made `toHaveSignalValue` compare nested `Set` and `Map` values.
+- **`registerSignalMatchers({ strict: true })`** flips the default of one registration: every
+  `toHaveSignalValue` of the suite compares like `toStrictEqual` without repeating the option per
+  assertion, and a single assertion can still pass `{ strict: false }`.
+- **`expectUnhandledObservableErrors([...])` from `vitest-auto-spy/setup`** asserts the rxjs errors
+  nothing handled are exactly the ones a test deliberately left — each expected entry the error
+  itself, its class, or a message (a string or a pattern), compared in order — and hands the
+  flushed entries back. Zero-argument form asserts none were left.
+- **`prepareShallow(Component, options).create(overrides)` from `vitest-auto-spy/angular`** binds a
+  component and the options every test of a suite repeats; `create()` runs the `renderShallow`
+  sequence with the overrides applied per key — `inputs` for an `it.each`, `providers` for a
+  one-off. One instance per test: the runner resets the TestBed between tests, and two `create()`
+  calls inside a single test need a manual `TestBed.resetTestingModule()`.
+- **`useConsoleSpies()` from `vitest-auto-spy/console`** registers `beforeEach(installConsoleSpies)`
+  and `afterEach(restoreConsole)` in the enclosing `describe` and returns the spies, replacing the
+  hook pair every console-asserting spec wrote by hand. It registers Vitest hooks (Bun resolves them
+  to its own); on `node:test` and Rstest the pair stays manual. `no-import-time-console-spies`
+  accepts it as the file's install, and the stray-console report and docs recommend it.
+
+### Fixed
+
+- **An app error in `expectRequest` / `expectNoRequest`'s tick under `provideDocumentDouble()` is no
+  longer blamed on the double.** 5.46.0 rewrapped every tick failure whenever `DOCUMENT` was not the
+  real document, so an effect that threw under the library's own double read as "a partial double
+  does not have" the members Angular reads, and pointed at `{ tick: false }`, which hides the error.
+  The message is now kept for a `DOCUMENT` that is not a document, or whose `body` has no
+  `querySelector`; any other failure is rethrown as it is.
+
+### Documentation
+
+- **`provideDocumentDouble()` needs no `{ tick: false }`**, and a JSON error body is
+  `flush(body, { status })` — `.error(status, { error })` takes a `ProgressEvent`, as Angular's
+  `TestRequest.error()` does. The HTTP page, `agent-docs/angular.md` and `agent-docs/errors.md` say so.
+- **The README's `SubjectLike` member list gains `unsubscribe`**, as `agent-docs` did in 5.46.0.
+
 ## [5.46.0] - 2026-09-27
 
 ### Added
@@ -6000,7 +6076,9 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.46.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.48.0...HEAD
+[5.48.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.47.0...v5.48.0
+[5.47.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.46.0...v5.47.0
 [5.46.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.45.0...v5.46.0
 [5.45.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.44.0...v5.45.0
 [5.44.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.43.0...v5.44.0

package/README.md

@@ -81,7 +81,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored; `moduleNamespace(await importOriginal(), { passthrough: true })` is Vitest's `{ spy: true }` with `calledWith` on top, on any runner
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`, and `outOfType()` for the fixture that is outside its type on purpose
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — forty-nine rules in `vitest-auto-spy/eslint-plugin` (six `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
+- 📏 Lint rules and one-line test-run hygiene — fifty rules in `vitest-auto-spy/eslint-plugin` (eight `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
 - 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-init-and-ng-test) — 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
@@ -876,24 +876,23 @@ since those statuses carry no body.
 A test that expects output absorbs it, and asserts on it:
 
 ```ts
-import { type ConsoleSpies, installConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
+import { useConsoleSpies } from 'vitest-auto-spy/console';
 
-let consoleSpies: ConsoleSpies;
-
-beforeEach(() => {
-  consoleSpies = installConsoleSpies();
-});
-
-afterEach(() => restoreConsole());
+const { consoleErrorSpy } = useConsoleSpies();
 
 it('reports a failed load', () => {
   service.load();
 
-  expect(consoleSpies.consoleErrorSpy).toHaveBeenCalledWith('load failed', expect.any(Error));
+  expect(consoleErrorSpy).toHaveBeenCalledWith('load failed', expect.any(Error));
 });
 ```
 
-The exported `consoleErrorSpy` is the same object, so `expect(consoleErrorSpy)` works too. Do not
+`useConsoleSpies()` registers `beforeEach(installConsoleSpies)` and `afterEach(restoreConsole)` in
+the enclosing `describe` (or the file) and returns the spies, which are the same objects in every
+test. It registers Vitest hooks, which Bun resolves to its own; on `node:test` and Rstest write that
+pair in the runner's hooks yourself — the entry imports `vitest` itself, so there it loads only where
+the `vitest` package resolves. Under `vitest/require-hook`, spread `autoSpy.hookRegisteringHelpers`
+from `vitest-auto-spy/eslint-plugin` into its `allowedFunctionCalls`. 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
@@ -2531,7 +2530,7 @@ subject.next([{ name: 'manual' }]);
 
 `returnSubject()` and `nextWithPerCall()` are typed `SubjectOf<T>`: rxjs's own `Subject<T>` wherever
 `import 'vitest-auto-spy/rxjs'` is in the TypeScript program, and the structural `SubjectLike<T>`
-(`next` / `error` / `complete` / `asObservable` / `closed`) where it is not. That is how the
+(`next` / `error` / `complete` / `unsubscribe` / `asObservable` / `closed`) where it is not. That is how the
 published declarations name no rxjs type while a suite that has rxjs keeps the exact type it had.
 The seam is one augmentable interface, `AutoSpyRxjsTypes<T>`, which the `/rxjs` entry fills in; what
 decides that a member _is_ an observable is the other new type, `ObservableLike<T>` — `subscribe`
@@ -2945,6 +2944,20 @@ function. The matcher reads it, deep-compares (as `toEqual` does; `{ strict: tru
 `toStrictEqual` does), and rejects anything that is not a zero-argument getter, so the
 missing-parentheses mistake fails instead of quietly passing.
 
+A suite that wants the strict comparison everywhere passes it once instead of per assertion;
+a single assertion can still opt back out:
+
+```ts
+registerSignalMatchers({ strict: true });
+
+expect(component.items).toHaveSignalValue(items); // compares like toStrictEqual
+expect(component.draft).toHaveSignalValue({}, { strict: false });
+```
+
+The `prefer-to-have-signal-value` lint rule rewrites the inline spellings — `expect(component.total()).toBe(3)`
+— into the matcher with a `--fix`. A `toBe` against an object-typed signal checks identity, which the
+deep matcher cannot keep, so the rule leaves it alone.
+
 #### Where a spec spends its time
 
 ```ts
@@ -3141,7 +3154,7 @@ and `flush()` / `error()` settle before they resolve, which is why the value rea
 Match by URL (either `url` or `urlWithParams`), by `RegExp`, or by a predicate over the request, with
 `{ method }` to tell a read from a write. `error(0)` is a network failure, and
 `error(status, { error })` sets the payload the `HttpErrorResponse` carries. `{ tick: false }` skips
-the tick, for a module whose partial `DOCUMENT` double the tick cannot run against. `provideHttpTesting()` fails, by default, any test that
+the tick, for a module whose partial `DOCUMENT` double the tick cannot run against (`provideDocumentDouble()` is not partial). `provideHttpTesting()` fails, by default, any test that
 ends holding a request nothing answered; `provideHttpTesting({ verifyOnTeardown: false })` turns that
 off, and `verifyNoPendingRequests()` runs the same check by hand. An interceptor under test goes in
 the same spread — `provideHttpTesting({ interceptors: [authInterceptor] })`, or
@@ -3342,6 +3355,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `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 and delay, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets. Blind to anything scheduled under fake timers — `vi.useFakeTimers()` assigns over the wrapper                                                                                                                                              |
 | `flushUnhandledObservableErrors()`                                                                          | `/setup`                      | Run rxjs's pending rethrows of Observable errors nothing handled, now, and return `{ error, test }` (or `outsideTest`) for each — the check `strayTimers` runs after every test, which fails the test with `Unhandled Observable error`                                                                                                                                                   |
+| `expectUnhandledObservableErrors(expected?)`                                                                | `/setup`                      | The same flush as an assertion: the errors nothing handled must be exactly the ones listed — each entry the error itself, its class, or a message (string or pattern) — or the test fails with the diff; no argument asserts none were left                                                                                                                                               |
 | `guardPrototypePollution(reaction)`                                                                         | `/setup`                      | Name the test that left a key on `Object.prototype` — it stops later files collecting ([details](#test-run-hygiene))                                                                                                                                                                                                                                                                      |
 | `guardDocumentPollution(option)`                                                                            | `/setup`                      | Name the test that left an attribute on `<html>` / `<body>`, and put it back ([details](#test-run-hygiene))                                                                                                                                                                                                                                                                               |
 | `installPerTest(install)`                                                                                   | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                                                                                                                                                                                                                                                               |
@@ -3377,15 +3391,14 @@ onSave.calledWith(1).resolveWith();
 `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:
+`useConsoleSpies()` installs them before each test of the block and restores the console after
+(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, installConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
+import { consoleInfoSpy, consoleWarnSpy, useConsoleSpies } from 'vitest-auto-spy/console';
 
-beforeEach(() => installConsoleSpies());
-afterEach(() => restoreConsole());
+useConsoleSpies();
 
 service.doWork();
 
@@ -3405,8 +3418,8 @@ the worker and every log from then on went nowhere.
 
 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
+is exactly the output the guard exists to see. Call `useConsoleSpies()` (or `installConsoleSpies()` in
+a `beforeEach`) for each test, or `installConsoleSpies()` 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
@@ -4007,6 +4020,7 @@ export can never be.
 | `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, while the bundle loads                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `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-to-have-signal-value`     |   `warn`    | `--fix`           | `expect(signal()).toBe(…)` → `expect(signal).toHaveSignalValue(…)`; the matcher names the signal in the failure and refuses a non-signal. `toStrictEqual` keeps `{ strict: true }`, `toBeNull()` / `toBeUndefined()` become `toHaveSignalValue(null)` / `(undefined)`. **Type-aware** — the callee must be callable and carry Angular's signal brand — and silent without `parserOptions.project`; safe to autofix since 5.46.0 fixed the `Set`/`Map` comparison. A `toBe` against an object-typed signal is an identity check and is left alone                                                                                                                                                                                                                                                                                                                  |
 | `prefer-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer that with `NG0101`                                                                                                                                                                                                                                                                                                                                                  |
 | `prefer-spy-on-own-method`        |   `warn`    | `--fix` / suggest | `createSpyFromInstance(x, { onlyMethodsToSpyOn: ['m'], passthrough: true })` read for `m` alone — `.m` on the call, `const { m } = …`, a bare statement, or a name read only as `v.m` → `spyOnOwnMethod(x, 'm')`; the same whitelist with `returns: { m: undefined }` → `spyOnVoidMethod(x, 'm')`. Both fix, import and all; a `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed is a suggestion, offered only on a real event or element — `new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement` — never on a double                                                                                                                                                                                                                                                                        |
 | `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
@@ -4015,7 +4029,7 @@ export can never be.
 | `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `no-import-time-console-spies`    |   `error`   | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` or `useConsoleSpies()` — the import installs once per worker and, under `isolate: false`, silences every later file                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `no-mistyped-use-value`           |   `error`   | —                 | `{ provide: TOKEN, useValue }` whose value is not assignable to the primitive `TOKEN` declares — `useValue` is `any`, so `{}` for an `InjectionToken<boolean>` compiles and is truthy; **type-aware**, and silent without `parserOptions.project`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `no-unknown-use-value-key`        |   `error`   | —                 | a key of an object `useValue` literal the provided type does not have — `T` of an `InjectionToken<T>`, or a class's instance; keys only, never the values; silent on `any` / `unknown`, an index signature, a spread and `multi: true`; **type-aware**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `no-instance-lifecycle-spy`       |   `warn`    | —                 | `vi.spyOn(component, 'ngOnInit')` and the other hooks a view reads off the prototype — Angular never calls the instance spy → spy on `Cls.prototype` before the component is created, or assert the hook's effect                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -4040,7 +4054,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.
 
-**Six of the forty-nine fix on their own, nineteen offer suggestions**, and the split is not about how hard
+**Eight of the fifty fix on their own, nineteen offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -4211,7 +4225,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the forty-nine rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the fifty rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -4228,7 +4242,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of forty-nine rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of fifty rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -4334,6 +4348,7 @@ another, and the next one is in that same file.
 | `setupFakeTimers(config?)` / `advanceTimers(ms?)` _(`/setup`)_                                                                              | Paired fake-timer install/restore, and an advance that also settles queued microtasks                                                                                                                                                                                                                                    |
 | `describeDuplicateCopies()` / `getPackageCopies()`                                                                                          | The duplicate-install report, and the copies behind it                                                                                                                                                                                                                                                                   |
 | `renderShallow(Component, opts?)` _(Angular)_                                                                                               | `TestBed` component, minus its children and (by default) its template                                                                                                                                                                                                                                                    |
+| `prepareShallow(Component, opts?)` _(Angular)_                                                                                              | `renderShallow` bound to shared options — `.create(overrides?)` per test, one instance each                                                                                                                                                                                                                              |
 | `setInputs(fixture, inputs, opts?)` _(Angular)_                                                                                             | Change an input after the first render — one `setInput` per name, checked against the compiled definition, then one wait                                                                                                                                                                                                 |
 | `createWithAutoSpies(Class, opts?)` _(Angular)_                                                                                             | Build a class through Angular DI with every unprovided token auto-spied                                                                                                                                                                                                                                                  |
 | `createNestUnit(Class, opts?)` _(NestJS)_                                                                                                   | Build a provider from its DI metadata with every unprovided token auto-spied; `expose` builds collaborators for real, `providers` wins over both                                                                                                                                                                         |
@@ -4348,7 +4363,7 @@ another, and the next one is in that same file.
 | `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)`                                                                                                                                                                                                                                                                              |
+| `registerSignalMatchers(opts?)` _(Angular)_                                                                                                 | Adds `expect(sig).toHaveSignalValue(value)`; `{ strict: true }` compares every assertion like `toStrictEqual`                                                                                                                                                                                                            |
 | `trackRecomputations(signal)` / `trackEffectRuns(effectRef)` _(Angular)_                                                                    | Count what the reactive graph re-ran — `{ count, stop() }`, undone by `restoreMockedProps()`                                                                                                                                                                                                                             |
 | `provideWindowDouble(token, overrides?)` / `provideDocumentDouble(overrides?)` _(Angular)_                                                  | A `window` / `document` merged over the real jsdom one; `createWindowDouble` / `createDocumentDouble` outside DI                                                                                                                                                                                                         |
 | `provideMatDialogData(token, data)` / `provideMatDialogRef(Ref, init?)` / `injectMatDialogRef(Ref)` _(Angular)_                             | The Material dialog trio — the token and the ref class are arguments; `createMatDialogRef` builds the ref outside DI                                                                                                                                                                                                     |
@@ -4366,6 +4381,7 @@ another, and the next one is in that same file.
 | `guardDocumentPollution(option)` _(`/setup`)_                                                                                               | Name the test that left an attribute on `<html>` / `<body>`, before a later file takes another branch on it                                                                                                                                                                                                              |
 | `consoleDebugSpy` … `consoleWarnSpy` _(`/console`)_                                                                                         | Silent typed spies replacing the global `console` methods on import                                                                                                                                                                                                                                                      |
 | `installConsoleSpies()` / `resetConsoleSpies()` / `restoreConsole()`                                                                        | Install / clear / undo the console spies                                                                                                                                                                                                                                                                                 |
+| `useConsoleSpies()` _(`/console`)_                                                                                                          | Install the console spies before each test of the block, restore after; returns the spies                                                                                                                                                                                                                                |
 | `consoleOutput()` _(`/console`)_                                                                                                            | Everything the console spies recorded, keyed by channel, only the channels written to — `toStrictEqual({})` is silence                                                                                                                                                                                                   |
 | `explainSpy(spy, method?)` _(`/diagnostics`)_                                                                                               | Every configured argument list next to every recorded call, attributed to the config it hit                                                                                                                                                                                                                              |
 | `errorHandler`                                                                                                                              | The `mustBeCalledWith` argument-mismatch error helper                                                                                                                                                                                                                                                                    |

package/agent-docs/adapters.md

@@ -28,21 +28,21 @@ import { createSpyFromClass } from 'vitest-auto-spy/react';
 
 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:
+and take them off after it — `useConsoleSpies()` registers exactly that pair in the enclosing `describe`:
 
 ```ts
-import { type ConsoleSpies, installConsoleSpies, restoreConsole } from 'vitest-auto-spy/console';
+import { useConsoleSpies } from 'vitest-auto-spy/console';
 
-let consoleSpies: ConsoleSpies;
+const { consoleInfoSpy } = useConsoleSpies();
 
-beforeEach(() => {
-  consoleSpies = installConsoleSpies();
-});
-afterEach(() => restoreConsole());
-
-expect(consoleSpies.consoleInfoSpy).toHaveBeenCalledWith('done'); // the output is silenced, not printed
+expect(consoleInfoSpy).toHaveBeenCalledWith('done'); // the output is silenced, not printed
 ```
 
+It registers Vitest hooks (Bun resolves them to its own); on `node:test` and Rstest write
+`installConsoleSpies()` in a `beforeEach` and `restoreConsole()` in an `afterEach` yourself. The entry
+imports `vitest` itself, so there it loads only where the `vitest` package resolves. Under
+`vitest/require-hook`, spread `autoSpy.hookRegisteringHelpers` into `allowedFunctionCalls` (§16).
+
 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

package/agent-docs/angular.md

@@ -203,7 +203,10 @@ replaced where nothing would notice it — the refusal now names `computed()` sp
 that driving the signal the computation reads is the way through. An `input()` is refused outright:
 Angular sets an input through the input node rather than the property, so a replaced one breaks the
 host's next write. Drive an input with `await setInputs(fixture, { … })`, or with
-`renderShallow(Component, { inputs: { … } })` for the value it starts at.
+`renderShallow(Component, { inputs: { … } })` for the value it starts at. When every test of a
+describe renders the same component with the same providers, `prepareShallow(Component, opts)` binds
+them once and each test calls `.create({ inputs: { … } })` — the overrides replace a key outright,
+one instance per test.
 
 ### Observers the component constructs itself
 
@@ -511,6 +514,8 @@ provided after it, so it wins over `withXhr()`.
 carries (default `new ProgressEvent('error')`). A module that provides a partial `DOCUMENT` double
 fails Angular's tick (`inject(...).body?.querySelector is not a function`, reported as a doubled
 `DOCUMENT`): pass `{ tick: false }` to `expectRequest` / `expectNoRequest` when the request is already out.
+`provideDocumentDouble()` is not partial and needs no option. A JSON error body is a response:
+`flush(body, { status: 409 })`; `{ error }` on `.error()` is a `ProgressEvent`.
 `flush()` and `error()` are `async` because settling requires letting a microtask run — `await` them,
 and the next line reads the settled value.
 
@@ -1058,8 +1063,8 @@ service.products.set([edited]); // the component's own optimistic write — stat
 expect(products.reload).toHaveBeenCalled(); // reload is spied, answers true, and re-issues nothing
 
 // signal assertions
-registerSignalMatchers(); // once, in the setup file — /angular/matchers
-expect(component.total).toHaveSignalValue(3); // toEqual semantics; { strict: true } for toStrictEqual's
+registerSignalMatchers(); // once, in the setup file — /angular/matchers; ({ strict: true }) makes the whole suite strict
+expect(component.total).toHaveSignalValue(3); // toEqual semantics; { strict: true } for toStrictEqual's, { strict: false } opts out
 
 // resource assertions — value AND status, which is the whole point
 registerResourceMatchers(); // once, in the setup file — /angular/matchers

package/agent-docs/anti-patterns.md

@@ -61,8 +61,9 @@ Part of the agent reference [`AGENTS.md`](../AGENTS.md), which maps every sectio
 | 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`, 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 second `vi.spyOn(console, 'error')` | `consoleErrorSpy` from `vitest-auto-spy/console`, installed with `useConsoleSpies()` |
+| `import { consoleErrorSpy } from 'vitest-auto-spy/console'` as the install | `useConsoleSpies()` in the `describe` (the `installConsoleSpies()` / `restoreConsole()` hook pair) — the import installs once per worker |
+| `beforeEach(installConsoleSpies)` with `afterEach(restoreConsole)` repeated per spec | `useConsoleSpies()` — registers both hooks and returns the spies |
 | 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/agent-docs/errors.md

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

package/agent-docs/eslint.md

@@ -32,6 +32,25 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 `autoSpy.configs.strict` is `recommended` with every rule at `error`, instead of mapping
 `Object.keys(autoSpy.rules)` by hand.
 
+`@vitest/eslint-plugin`'s `vitest/require-hook` reports a bare `useConsoleSpies();` or
+`setupFakeTimers();` in a `describe` body, since it cannot know the call registers hooks.
+`autoSpy.hookRegisteringHelpers` is the library's list of such helpers — every public function that
+calls `beforeEach` / `afterEach` / `beforeAll` / `afterAll` when it runs, kept in step with the
+source by a spec — so spread it instead of maintaining the names by hand. Calls that register no
+hook (`registerSignalMatchers()`, `trackStrayTimers()`) are not in it; add them yourself where a
+linted file calls them at the top level.
+
+```js
+export default [
+  {
+    files: ['**/*.spec.ts'],
+    rules: {
+      'vitest/require-hook': ['error', { allowedFunctionCalls: [...autoSpy.hookRegisteringHelpers] }],
+    },
+  },
+];
+```
+
 | Rule | Level | Fix | Flags |
 | --- | --- | --- | --- |
 | `no-expect-in-subscribe` | `error` | suggest | `expect()` inside `subscribe()` → `expectEmission` / `firstValueFrom` |
@@ -56,6 +75,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-unregistered-inject-spy` | `error` | — | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler |
 | `prefer-render-shallow` | `warn` | suggest | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children |
 | `prefer-set-inputs` | `warn` | suggest | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101` |
+| `prefer-to-have-signal-value` | `warn` | `--fix` | `expect(component.total()).toBe(3)` / `toEqual(…)` → `expect(component.total).toHaveSignalValue(3)`, `toStrictEqual` → `{ strict: true }`, `toBeNull()` / `toBeUndefined()` → `toHaveSignalValue(null)` / `(undefined)`; the matcher names the signal in the failure and refuses a value that is not one. **Type-aware**: the signal is recognised by Angular's brand on its type, so methods, functions and getters are never reported, and without `parserOptions.project` it reports nothing. A `toBe` against an object-typed signal (`expect(list.items()).toBe(items)`) is an identity check the deep matcher would lose, so it is reported only when the expected value is a primitive literal or the signal's type is primitive |
 | `prefer-spy-on-own-method` | `warn` | `--fix` / suggest | `createSpyFromInstance(x, { onlyMethodsToSpyOn: ['m'], passthrough: true })` read for `m` alone — `.m` on the call, `const { m } = …`, a bare statement, or a name read only as `v.m` → `spyOnOwnMethod(x, 'm')`; the same whitelist with `returns: { m: undefined }` → `spyOnVoidMethod(x, 'm')`. Both fix, import and all; a `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed is a suggestion, offered only on a real event or element — `new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement` — never on a double |
 | `prefer-observer-stub` | `error` | — | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo |
 | `no-hand-assigned-global` | `error` | `--fix` | 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, `stubWorker({ respond })` for `Worker`; the three observers stay with `prefer-observer-stub`; any value written into an imported object (`environment.production = true`) → `mockValueProp(environment, 'production', true)`, fixed in a test or `beforeEach` |
@@ -63,7 +83,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `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` |
-| `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` |
+| `no-import-time-console-spies` | `error` | — | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` or `useConsoleSpies()` — the import installs once per worker and silences every later file → `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` |
 | `no-mistyped-use-value` | `error` | — | `{ provide: TOKEN, useValue }` whose value is not assignable to the primitive `T` of `InjectionToken<T>` (string, number, boolean, bigint, enum, their literals, `null`, `undefined`) — `useValue` is `any`, so `{}` for a `boolean` token compiles and is truthy. **Type-aware**: silent without `parserOptions.project`; object-typed tokens are `no-unknown-use-value-key`'s |
 | `no-unknown-use-value-key` | `error` | — | a key of an object `useValue` literal the provided type does not have — `T` of `InjectionToken<T>`, or the instance type of a `provide:` class; `{ provide: ActivatedRoute, useValue: { queryParams$: … } }` compiles, since `useValue` is `any`. Keys only, never assignability (a partial fixture is fine). **Type-aware**; silent on `any` / `unknown` / `object`, an index signature, a spread's keys, `multi: true` |
 | `no-instance-lifecycle-spy` | `warn` | — | `vi.spyOn(instance, 'ngOnInit')` (and `ngOnDestroy`, `ngDoCheck`, `ngAfterContent*`, `ngAfterView*`) — a view calls the hook read off the prototype, so the instance spy is never called and its stub never runs → `vi.spyOn(Cls.prototype, …)` before `createComponent`, or assert the effect. `ngOnChanges` is exempt: Angular calls it through the instance |
@@ -84,14 +104,14 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-save-arguments-by-value` | `error` | — | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state |
 | `prefer-native-spy-api` | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim |
 
-Forty-nine rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+Fifty rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `prefer-create-mock`, `no-instance-lifecycle-spy`,
-`prefer-set-inputs`, `no-unasserted-argument` and `prefer-spy-on-own-method`**; six fix on their own, nineteen offer suggestions. Forty-six are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
-`no-unknown-use-value-key` read types, and all three report nothing at all without `parserOptions.project` / `projectService`
+`prefer-set-inputs`, `no-unasserted-argument`, `prefer-spy-on-own-method` and `prefer-to-have-signal-value`**; eight fix on their own, nineteen offer suggestions. Forty-six are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
+`no-unknown-use-value-key` and `prefer-to-have-signal-value` read types, and all four report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
 builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. The
-eight `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
+nine `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
 about the _kind_ of finding: every other rule names something wrong or dead, while this one names a
 file that could render more cheaply, and `renderShallow` is a migration a suite either takes or does
 not. At `error` the plugin would gate that migration — 491 findings across 398 of one consumer's

package/agent-docs/setup.md

@@ -94,7 +94,11 @@ nothing. Fix it where the stream is subscribed — an error callback or `catchEr
 error. `flushUnhandledObservableErrors()` is the same check by hand: it returns `{ error, test }` (or
 `{ error, outsideTest }`) for each rethrow that threw; assert the errors alone with
 `expect(flushUnhandledObservableErrors()).toMatchObject([{ error: new Error('502') }])` — it checks the
-count and ignores `test`, with no `.map(({ error }) => error)`.
+count and ignores `test`, with no `.map(({ error }) => error)`. A test that deliberately leaves the
+error unhandled asserts it in place instead: `expectUnhandledObservableErrors([{ message: /502/ }])`
+flushes and compares — each entry the error itself, its class, or a message (a string or a pattern),
+in order — and fails with a diff listing what was expected and what was found; no argument asserts
+nothing was left.
 
 **`countStrayTimers()` cannot see a timer scheduled under fake timers, and that does not compose
 away.** `vi.useFakeTimers()` assigns its own `setTimeout` over the tracking wrapper, so everything
@@ -722,7 +726,7 @@ frame outside `node_modules`, and naming the spy that absorbs it:
 [vitest-auto-spy] "CartService > reports a failed load" wrote to console.error 1 time and nothing absorbed it:
   - console.error: Error: load failed
       at CartService.load (src/app/cart.service.ts:41:15)
-Absorb what the test expects — installConsoleSpies() in a beforeEach, then assert consoleErrorSpy — or fix the code if the output is a defect.
+Absorb what the test expects — useConsoleSpies() in the describe, then assert consoleErrorSpy — or fix the code if the output is a defect.
 Docs: https://asdalexey.github.io/vitest-auto-spy/utilities/setup#_16-console-output-nothing-absorbed
 ```
 
@@ -748,7 +752,7 @@ Docs: https://asdalexey.github.io/vitest-auto-spy/utilities/setup#_16-console-ou
   `It is reported at the end of b.spec.ts: the file-end check of a.spec.ts did not run.`
 - 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
+  `useConsoleSpies()` in the `describe` (or `installConsoleSpies()` at the top of the file). Spies an import installed
   before the guard armed are taken off.
 - `strayConsole: { allow: ['…', /…/] }` is the last resort, for a line from a dependency no spec can
   reach — the import-time report offers it, with the pattern, only when the quoted frame is inside

package/dist/angular-http.d.ts

@@ -97,7 +97,7 @@ declare function provideHttpTesting(options?: HttpTestingOptions): (EnvironmentP
  * that was never sent rather than one that was sent wrongly.
  *
  * @param matcher The URL, a pattern for it, or a predicate over the request.
- * @param options `{ method }`, for a URL that is both read and written in the same test.
+ * @param options `{ method }`, for a URL that is both read and written in the same test; `{ tick: false }` for a doubled `DOCUMENT`.
  */
 declare function expectRequest(matcher: RequestMatcher, options?: ExpectRequestOptions): RequestExpectation;
 /**

package/dist/angular-http.js

@@ -175,11 +175,22 @@ async function settle(tick) {
     }
   }
 }
+function isPartialDocument(doc) {
+  const real = globalThis.document;
+  if (doc === real) {
+    return false;
+  }
+  if (Reflect.getPrototypeOf(Object(doc)) !== Reflect.getPrototypeOf(Object(real))) {
+    return true;
+  }
+  const body = Reflect.get(Object(doc), "body");
+  return typeof Reflect.get(Object(body), "querySelector") !== "function";
+}
 function tickApp(caller) {
   try {
     flushEffects();
   } catch (error) {
-    if (TestBed.inject(DOCUMENT) === globalThis.document) {
+    if (!isPartialDocument(TestBed.inject(DOCUMENT))) {
       throw error;
     }
     throw new Error(