vitest-auto-spy 5.47.0 → 5.48.0

package/AGENTS.md

@@ -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,36 @@ 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
@@ -6046,7 +6076,8 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.47.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

package/README.md

@@ -890,7 +890,9 @@ it('reports a failed load', () => {
 `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. Do not
+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
@@ -2953,7 +2955,8 @@ 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`.
+— 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
 
@@ -4017,7 +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 }`. **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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
@@ -4360,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                                                                                                                                                                                                     |

package/agent-docs/adapters.md

@@ -39,7 +39,9 @@ expect(consoleInfoSpy).toHaveBeenCalledWith('done'); // the output is silenced,
 ```
 
 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.
+`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

package/agent-docs/angular.md

@@ -1063,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/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,7 +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 }`; 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 |
+| `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` |

package/dist/cli.js

@@ -3865,7 +3865,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.46.0";
+var EXPORT_MAP_VERSION = "5.47.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular/diagnostics vitest-auto-spy/angular/doubles vitest-auto-spy/angular/matchers vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin vitest-auto-spy/perf-reporter";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 20 21 22",

package/dist/eslint-plugin.cjs

@@ -3,6 +3,25 @@
 var node_fs = require('node:fs');
 var node_path = require('node:path');
 
+// src/lib/eslint/hook-registering-helpers.ts
+var hookRegisteringHelpers = Object.freeze([
+  "enableAngularDiagnostics",
+  "enableTestBedDiagnostics",
+  "guardDocumentPollution",
+  "guardGlobalPatches",
+  "guardPrototypePollution",
+  "guardStrayConsole",
+  "installPerTest",
+  "mockNow",
+  "setupAngularTestEnv",
+  "setupAutoSpy",
+  "setupFakeTimers",
+  "trackMockRegistry",
+  "trackNodeMocks",
+  "useConsoleSpies",
+  "useCountingClock"
+]);
+
 // src/lib/eslint/rule-types.ts
 function isCast(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
@@ -4138,11 +4157,15 @@ var preferRenderShallow = defineRule({
 
 // src/lib/eslint/prefer-to-have-signal-value.ts
 var MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var VALUE_MATCHERS = /* @__PURE__ */ new Map([
+  ["toBeNull", "null"],
+  ["toBeUndefined", "undefined"]
+]);
 var SIGNAL_BRAND = "\u0275SIGNAL";
 var SIGNAL_BRAND_PROPERTY = /^__@(?:SIGNAL|ɵSIGNAL|ɵWRITABLE_SIGNAL)@\d+$/;
 function signalAssertionOf(node) {
   const callee = node.callee;
-  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !MATCHERS.has(callee.property.name)) {
+  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !(MATCHERS.has(callee.property.name) || VALUE_MATCHERS.has(callee.property.name))) {
     return void 0;
   }
   let expected = callee.object;
@@ -4164,9 +4187,37 @@ function readsSignal(context, node) {
   const signatures = type.getCallSignatures();
   return type.getProperties().some((property) => property.getName() === SIGNAL_BRAND || SIGNAL_BRAND_PROPERTY.test(property.getName())) && signatures.length > 0;
 }
+function isPrimitiveLiteral(node) {
+  if (node === void 0) {
+    return false;
+  }
+  switch (node.type) {
+    case "Literal":
+      return Reflect.get(node, "regex") === void 0;
+    case "Identifier":
+      return isIdentifier(node) && node.name === "undefined";
+    case "UnaryExpression":
+      return isPrimitiveLiteral(Reflect.get(node, "argument"));
+    case "TemplateLiteral":
+      return Reflect.get(node, "expressions")?.length === 0;
+    default:
+      return false;
+  }
+}
+function primitiveValue({ checker, toTs }, received) {
+  const value = checker.getTypeAtLocation(toTs.get(received));
+  return checker.typeToString(value) !== "any" && isPrimitiveLike(checker, value);
+}
+function identityIsMoot(context, node, shape) {
+  if (shape.matcher.name !== "toBe" || isPrimitiveLiteral(node.arguments.at(0))) {
+    return true;
+  }
+  const services = checkerServices(context, PRIMITIVE_CHECKER_METHODS);
+  return services !== void 0 && askChecker(() => primitiveValue(services, shape.received)) === true;
+}
 var preferToHaveSignalValue = defineRule({
   name: "prefer-to-have-signal-value",
-  description: "Assert a signal with toHaveSignalValue instead of reading it inline into toBe/toEqual",
+  description: "Assert a signal with toHaveSignalValue instead of reading it inline into toBe/toEqual/toBeNull",
   messages: {
     preferToHaveSignalValue: "Assert the signal, not the value it happens to hold: `expect({{signal}}).toHaveSignalValue(\u2026)` keeps the signal's name in the failure output and refuses a value that is not a signal."
   },
@@ -4174,7 +4225,7 @@ var preferToHaveSignalValue = defineRule({
   create: (context) => ({
     CallExpression: (node) => {
       const shape = signalAssertionOf(node);
-      if (!shape || !readsSignal(context, shape.received.callee)) {
+      if (!shape || !readsSignal(context, shape.received.callee) || !identityIsMoot(context, node, shape)) {
         return;
       }
       context.report({
@@ -4183,9 +4234,10 @@ var preferToHaveSignalValue = defineRule({
         data: { signal: excerpt(context, shape.received.callee, 40) },
         ...shape.received.typeArguments === void 0 && {
           fix: (fixer) => {
+            const value = VALUE_MATCHERS.get(shape.matcher.name);
             const fixes = [
               fixer.replaceText(shape.received, context.sourceCode.getText(shape.received.callee)),
-              fixer.replaceText(shape.matcher, "toHaveSignalValue")
+              value === void 0 ? fixer.replaceText(shape.matcher, "toHaveSignalValue") : fixer.replaceTextRange([shape.matcher.range[0], node.range[1]], `toHaveSignalValue(${value})`)
             ];
             const last = node.arguments.at(-1);
             if (shape.strict && last !== void 0) {
@@ -5853,7 +5905,8 @@ var plugin = {
     recommended: { plugins: {}, rules: recommendedRules },
     strict: { plugins: {}, rules: strictRules },
     typeErrors: { plugins: {}, rules: typeErrorRules }
-  }
+  },
+  hookRegisteringHelpers
 };
 plugin.configs.recommended.plugins[PLUGIN_NAME] = plugin;
 plugin.configs.strict.plugins[PLUGIN_NAME] = plugin;

package/dist/eslint-plugin.d.ts

@@ -227,29 +227,6 @@ interface RuleModule {
     create(context: RuleContext): RuleListener;
 }
 
-/**
- * `vitest-auto-spy/eslint-plugin` — the lint rules that keep a suite on the library's API.
- *
- * ```js
- * // eslint.config.js (flat config)
- * import autoSpy from 'vitest-auto-spy/eslint-plugin';
- *
- * export default [
- *   { files: ['**\/*.spec.ts'], ...autoSpy.configs.recommended },
- * ];
- * ```
- *
- * Scope the config to spec files yourself: every rule here is about test code, and `Object.
- * defineProperty` or an object of `vi.fn()`s is perfectly reasonable in application code.
- *
- * `configs.strict` is `recommended` with every rule at `error`. `configs.typeErrors` is the subset whose
- * findings are compile errors — already `error` in `recommended` — to spread back over a blanket
- * downgrade while a large suite is being adopted.
- *
- * Flat config only. The legacy `.eslintrc` `plugins: ['…']` form resolves plugin names to
- * `eslint-plugin-*` packages, which a subpath export of this package can never be.
- */
-
 /** Severity map shared by the shipped configs. */
 type RuleSeverity = 'error' | 'off' | 'warn';
 /** A flat-config object: the plugin under its name, plus the rules it turns on. */
@@ -277,6 +254,11 @@ interface AutoSpyEslintPlugin {
         strict: FlatConfig;
         typeErrors: FlatConfig;
     };
+    /**
+     * The library's helpers that register `beforeEach` / `afterEach` / `beforeAll` / `afterAll` when
+     * called, for `vitest/require-hook`'s `allowedFunctionCalls`.
+     */
+    hookRegisteringHelpers: readonly string[];
 }
 declare const plugin: AutoSpyEslintPlugin;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.47.0",
+  "version": "5.48.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",

package/skills/vitest-auto-spy/SKILL.md

@@ -384,7 +384,9 @@ it('loads', async () => {
   `toHaveSignalValue(v)` after `registerSignalMatchers()` from `vitest-auto-spy/angular/matchers`
   (`toEqual` semantics; `toHaveSignalValue(v, { strict: true })` for `toStrictEqual`'s, or
   `registerSignalMatchers({ strict: true })` for the whole suite). The type-aware
-  `prefer-to-have-signal-value` lint rule rewrites `expect(sig()).toBe(v)` into the matcher.
+  `prefer-to-have-signal-value` lint rule rewrites `expect(sig()).toBe(v)`, `.toBeNull()` and
+  `.toBeUndefined()` into the matcher, except a `toBe` that checks an object's identity, which the
+  deep matcher cannot keep.
 - **Never assert a resource with `expect(r.value()).toEqual(...)` alone** — an unresolved resource
   still holds its _default_, so that passes while proving nothing. `toHaveResourceValue(v)` after
   `registerResourceMatchers()`, from the same `/angular/matchers` entry, fails unless the resource
@@ -492,6 +494,11 @@ evidence that the types still hold. Where it cannot prove the rename it downgrad
 accept those together with the repair at the creation site, usually `createAutoMock<T>()` in place of
 an object literal.
 
+**`vitest/require-hook` reports a bare `useConsoleSpies();` or `setupFakeTimers();`** in a
+`describe` body. Do not wrap it in a hook or disable the line: spread
+`autoSpy.hookRegisteringHelpers` from `vitest-auto-spy/eslint-plugin` into the rule's
+`allowedFunctionCalls`.
+
 **`no-private-member-access`, `no-mistyped-use-value` and `no-unknown-use-value-key` are the three
 rules here that need type information.** The first reports
 `instance['privateMember']` (bracket access, which TypeScript does not visibility-check),