vitest-auto-spy 5.36.0 → 5.38.0

package/CHANGELOG.md

@@ -10,6 +10,115 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.38.0] - 2026-09-26
+
+### Added
+
+- **`doctor` notes `mock-reset-config-unread`.** A `no-redundant-mock-reset` entry whose options name
+  a `configFile` and no flag beside it, where that file's default export is a call to anything but
+  `defineConfig` / `defineProject` — a project factory such as `createProjectConfig({ alias })`, or
+  `mergeConfig(base, …)`. The rule reads the file as text, so it never sees the flags that call sets:
+  up to Vitest 4 it stays silent on every redundant reset, from Vitest 5 it assumes `clearMocks` on
+  even where the factory turns it off, and nothing says so. The note names the callee and the fix —
+  write the flags beside `configFile`, which win over the file. Only a literal `configFile` is read,
+  resolved against the repository root. The rule itself still reports nothing about its config.
+
+### Changed
+
+- **The block `init` writes into `AGENTS.md` / `CLAUDE.md` / `GEMINI.md` follows the 5.35.0 split.**
+  It called the package's `AGENTS.md` "the authoritative reference"; since 5.35.0 that file is a short
+  map and the reference is `agent-docs/*.md`. The block now says what the skill stub already did: read
+  the map whole, then only the topic files it names, and look a failure up with
+  `grep -n -F '<error text>' node_modules/vitest-auto-spy/agent-docs/errors.md`. The rxjs line names
+  the setup file "or a module / `.d.ts` it loads", since under `@angular/build:unit-test` 22.2 the
+  import may sit in a shared module the setup file reaches and the types in a `.d.ts`. Both land in
+  one change, so the block's `sha=` moves once: **`init --check` reports the root stubs as changed
+  until `npx vitest-auto-spy init` runs again**, and that run rewrites only the block. The pointer in
+  the glob-scoped rule files and the skill stub are unchanged. The hand-written snippets on the agents
+  page and in the README say the same as the block.
+
+### Fixed
+
+- **`createSpyFromInstance` recognises happy-dom's `MediaQueryList` as a live DOM/BOM object.** What
+  `matchMedia()` returns belongs to a class no global names, built on happy-dom's private
+  `EventTarget`, so discovery ran unrestricted over it without the warning that asks for
+  `onlyMethodsToSpyOn`. An event target built on the `EventTarget` the engine built `Node` on now
+  counts too; a user class over the global `EventTarget`, or over a polyfill's, still does not.
+
+### Docs
+
+- **`no-redundant-mock-reset`: only the runner's flags count.** `AGENTS.md` §16, the README and the
+  skill now say what the rule reference already did: `setupAutoSpy({ restoreMocks: true })` restores
+  in an `afterEach`, after the test, and is not the runner's `restoreMocks`, so it is never a reason
+  to pass the rule `{ restoreMocks: true }`. The README also names the factory / `mergeConfig` case,
+  and the Russian rule page gains both paragraphs.
+- **`TestBed.createDirective` on the Angular page.** The zoneless-waiting, `hostElement` and
+  directive-host sections say that `stable`, `hostElement` and `toHaveDirectiveApplied` take Angular
+  22.2's `DirectiveFixture`, and the `toHaveDirectiveApplied` section that the fixture's root element
+  is searched too, so a `hostDirectives` entry of the component under test counts. `AGENTS.md` §13
+  already said so; the site did not.
+- **What `vitest-auto-spy/angular` re-exports from the core.** The Angular page, `AGENTS.md` §13, the
+  skill and the README say it outright: the `Spy<T>` type (5.35.0), the `mock*Prop` helpers with
+  `restoreMockedProps` / `countMockedProps`, the `expectEmission` family and `registerAutoSpyDefaults`
+  / `clearAutoSpyDefaults` — and nothing else. `createSpyFromClass`, `createMock`, `createAutoMock`,
+  `spyOnVoidMethod`, `spyOnOwnMethod`, `stubConstructor`, `asInstance` and the rest stay on
+  `vitest-auto-spy`, so a spec that needs one keeps a second import line rather than folding it into
+  the `/angular` one. The `/angular-http` pages no longer say every other subpath re-exports the core.
+- **`toHaveDirectiveApplied` as the guard for a `hostDirectives` attribute.** `AGENTS.md` §13 and the
+  Angular page (English and Russian) show the matcher asserting the host directive itself, with no
+  selector, next to the attribute check that stays green when the entry is dropped and the attribute
+  is also written statically — and that it exists only after `registerDirectiveMatchers()` from
+  `vitest-auto-spy/angular/matchers` runs in the setup file.
+- **The `createSpyFromInstance` refusal of a non-configurable, non-enumerable member** (`AGENTS.md`
+  §17) says that members the same call replaced before it stay spied until `restoreSpiedInstance` or
+  the `setupAutoSpy()` sweep puts them back.
+
+## [5.37.0] - 2026-09-26
+
+### Added
+
+- **`stable()` takes Angular 22.2's `TestBed.createDirective` fixture.** It only ever awaited
+  `whenStable()`, but was typed on `ComponentFixture`, so `await stable(TestBed.createDirective(Dir,
+  { tagName }))` failed with `TS2345` and specs fell back to `detectChanges()`, which flushes no
+  effects. It now accepts any fixture with `whenStable()`; nothing in the signature names
+  `DirectiveFixture`, so Angular 20 and 21 compile as before.
+
+### Fixed
+
+- **`toHaveDirectiveApplied` finds a directive on the element a fixture is rooted at.** It searched
+  with `queryAll`, which never returns the root, so on a `TestBed.createDirective` fixture — rooted at
+  the element that carries the directive — it failed with `it is not on any element of this fixture`
+  and advised `createDirectiveHost`. The root is searched too; on a `ComponentFixture` that also counts
+  a `hostDirectives` entry of the component under test.
+- **`vitest-auto-spy/eslint-plugin` is assignable to ESLint's own `Plugin` and flat-config types.**
+  `plugins: { 'vitest-auto-spy': autoSpy }` in a typed `eslint.config.ts`, or in
+  `new Linter().verify(code, [...])`, failed with `TS2322` / `TS2769`: `configs.*.plugins` was
+  `Record<string, unknown>` and each rule's `create` was typed on the library's own context. The
+  configs now name the plugin type, and a published rule is typed the way ESLint calls it. The plugin
+  still imports nothing from ESLint.
+- **`strayListeners` no longer blames a spec file for jsdom's own wiring, and no longer strips it.**
+  Under Vitest 5, assigning a window global in jsdom or happy-dom also writes it to the environment's
+  real window, so the tracking wrapper sat where jsdom's internals call it too. The first
+  `querySelectorAll`, `matches` or `getComputedStyle` on a document makes jsdom's selector engine
+  register nine focus, keyboard and mouse listeners on the window, once; the file that happened to
+  run it failed under `onStrayListeners: 'throw'` with `left 9 window/document listeners attached`,
+  and the sweep took them off, which broke `:focus` and `:hover` matching for every later file in
+  the worker. The same held under a VM pool (`vmThreads`, the Analog default) on any Vitest version.
+  A registration whose first caller frame is inside `jsdom`, `happy-dom` or `@asamuzakjp/*` is now
+  the environment's and is neither counted nor swept — which also covers the `resize` listener
+  happy-dom's `matchMedia` adds per `change` listener. A `document.querySelectorAll('*')` warm-up
+  placed before `setupAutoSpy()` to work around this can go.
+- **Stray timer and listener reports quote the caller instead of `__VITEST_HELPER__`.** When every
+  frame of a registration was inside dependencies, the first one shown was the `vi.defineHelper`
+  wrapper around the tracker. It is now skipped like the library's own frames.
+
+### Docs
+
+- **`no-redundant-mock-reset` says what it cannot read.** A runner config assembled by a factory or
+  a `mergeConfig` from another module sets `clearMocks` in a file the rule never opens; the docs now
+  say to write the flag beside `configFile`. The Vitest 5 default for a config that leaves it out
+  arrived in 5.35.0.
+
 ## [5.36.0] - 2026-09-26
 
 **Why upgrade.** Eleven entries that crashed on import under `bun:test` load now, and every spec
@@ -5374,7 +5483,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.36.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.38.0...HEAD
+[5.38.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.37.0...v5.38.0
+[5.37.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.36.0...v5.37.0
 [5.36.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.35.0...v5.36.0
 [5.35.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.34.0...v5.35.0
 [5.34.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.33.0...v5.34.0

package/README.md

@@ -1035,29 +1035,30 @@ error  tsconfig-glob-matches-nothing libs/users/tsconfig.spec.json
 3 errors, 4 warnings, 1 note
 ```
 
-| Check                               | What it finds                                                                                                                                                             |
-| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `tsconfig-glob-matches-nothing`     | An `include` pattern that matches no file — so it type-checks nothing; `info` when nothing beside the config is there to miss yet                                         |
-| `tsconfig-file-missing`             | A `files` entry naming a file that is gone                                                                                                                                |
-| `spec-imported-by-non-spec`         | A production module importing a `*.spec.ts`                                                                                                                               |
-| `spec-exports-fixture`              | A spec importing another spec, whose hooks then run in a foreign file                                                                                                     |
-| `foreign-runner-pragma`             | `@jest-environment` left in a spec, which Vitest never reads                                                                                                              |
-| `dead-runner-config`                | `jest.config.*` / `karma.conf.*` for a runner that is not installed                                                                                                       |
-| `orphan-runner-file`                | A setup file only that dead config referenced                                                                                                                             |
-| `angular-build-splitting-off`       | `@angular/build` in `[22.1.5, 22.1.7)` — the OOM under `--coverage`                                                                                                       |
-| `analog-behind-angular-build`       | `@analogjs/vite-plugin-angular` below 2.7.5 next to `@angular/build` 22.2+ — `TypeError: cache.has is not a function` at startup                                          |
-| `coverage-all-removed`              | `coverage.all` in a config, on a Vitest that stopped reading the key                                                                                                      |
-| `coverage-include-misses-bundle`    | A `coverage.include` of sources only, in a runner config over a bundle                                                                                                    |
-| `coverage-include-recompiles-globs` | A coverage scope large enough that `picomatch` recompiling it per file costs more than the coverage. Info                                                                 |
-| `vitest-5-removed`                  | What Vitest 5 removed — `vitest/reporters`-style imports, `.sequential`, `--outputJson`/`--compare`; error on 5, note on 4. Also `poolOptions` (warning, ignored since 4) |
-| `vitest-5-deprecated`               | `experimental_clearCache` / `experimental_parseSpecifications` on Vitest 5, which nothing warns about at run time. Info                                                   |
-| `vitest-5-clear-mocks`              | `clearMocks: true` restating the Vitest 5 default, or a Vitest 4 suite that never decided and will have mocks cleared after the upgrade. Info                             |
-| `vitest-5-available`                | Vitest 4 with nothing holding back 5 — what it buys (−46 % v8 / −35.5 % istanbul on a 700-file Angular suite with coverage) — or what holds it back. Info                 |
-| `fs-module-cache-not-persisted`     | `fsModuleCache` on, and no CI config caches its directory — every CI run starts cold                                                                                      |
-| `jasmine-era-project`               | `jasmine-core`, `@types/jasmine`, `karma.conf.*` or `@hirez_io/observer-spy` still installed. Info, not an error                                                          |
-| `no-agent-instructions`             | No instruction file names the package. A note, not an error                                                                                                               |
-| `helper-from-wrong-entry`           | A named import taken from an entry that does not export it — `provideAutoSpy` from the root                                                                               |
-| `no-unawaited-helper`               | An `expectEmission` / `stable` / `flushEventLoop` call dropped as a bare statement, so nothing awaits it                                                                  |
+| Check                               | What it finds                                                                                                                                                                        |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `tsconfig-glob-matches-nothing`     | An `include` pattern that matches no file — so it type-checks nothing; `info` when nothing beside the config is there to miss yet                                                    |
+| `tsconfig-file-missing`             | A `files` entry naming a file that is gone                                                                                                                                           |
+| `spec-imported-by-non-spec`         | A production module importing a `*.spec.ts`                                                                                                                                          |
+| `spec-exports-fixture`              | A spec importing another spec, whose hooks then run in a foreign file                                                                                                                |
+| `foreign-runner-pragma`             | `@jest-environment` left in a spec, which Vitest never reads                                                                                                                         |
+| `dead-runner-config`                | `jest.config.*` / `karma.conf.*` for a runner that is not installed                                                                                                                  |
+| `orphan-runner-file`                | A setup file only that dead config referenced                                                                                                                                        |
+| `angular-build-splitting-off`       | `@angular/build` in `[22.1.5, 22.1.7)` — the OOM under `--coverage`                                                                                                                  |
+| `analog-behind-angular-build`       | `@analogjs/vite-plugin-angular` below 2.7.5 next to `@angular/build` 22.2+ — `TypeError: cache.has is not a function` at startup                                                     |
+| `coverage-all-removed`              | `coverage.all` in a config, on a Vitest that stopped reading the key                                                                                                                 |
+| `coverage-include-misses-bundle`    | A `coverage.include` of sources only, in a runner config over a bundle                                                                                                               |
+| `coverage-include-recompiles-globs` | A coverage scope large enough that `picomatch` recompiling it per file costs more than the coverage. Info                                                                            |
+| `vitest-5-removed`                  | What Vitest 5 removed — `vitest/reporters`-style imports, `.sequential`, `--outputJson`/`--compare`; error on 5, note on 4. Also `poolOptions` (warning, ignored since 4)            |
+| `vitest-5-deprecated`               | `experimental_clearCache` / `experimental_parseSpecifications` on Vitest 5, which nothing warns about at run time. Info                                                              |
+| `vitest-5-clear-mocks`              | `clearMocks: true` restating the Vitest 5 default, or a Vitest 4 suite that never decided and will have mocks cleared after the upgrade. Info                                        |
+| `mock-reset-config-unread`          | `no-redundant-mock-reset` given a `configFile` whose default export is a factory or `mergeConfig` call and no flag beside it — the rule reads none of the flags that call sets. Info |
+| `vitest-5-available`                | Vitest 4 with nothing holding back 5 — what it buys (−46 % v8 / −35.5 % istanbul on a 700-file Angular suite with coverage) — or what holds it back. Info                            |
+| `fs-module-cache-not-persisted`     | `fsModuleCache` on, and no CI config caches its directory — every CI run starts cold                                                                                                 |
+| `jasmine-era-project`               | `jasmine-core`, `@types/jasmine`, `karma.conf.*` or `@hirez_io/observer-spy` still installed. Info, not an error                                                                     |
+| `no-agent-instructions`             | No instruction file names the package. A note, not an error                                                                                                                          |
+| `helper-from-wrong-entry`           | A named import taken from an entry that does not export it — `provideAutoSpy` from the root                                                                                          |
+| `no-unawaited-helper`               | An `expectEmission` / `stable` / `flushEventLoop` call dropped as a bare statement, so nothing awaits it                                                                             |
 
 The check that motivated the tool: a spec showing `Cannot find name 'vi'` in the editor while
 `tsc --noEmit` reported zero errors. A migration codemod editing `include` had eaten a `/**`,
@@ -1293,8 +1294,8 @@ Add this to the instruction file your agent actually reads — the table below s
 
 ```md
 When writing or fixing tests that use `vitest-auto-spy`, first read
-`node_modules/vitest-auto-spy/AGENTS.md`. It is the authoritative reference for the API,
-the configuration semantics and the common mistakes.
+`node_modules/vitest-auto-spy/AGENTS.md` whole — a short map — then only the topic files in
+`agent-docs/` it names for the task.
 ```
 
 The text is the same everywhere; only the filename changes. **Two files cover the whole field: a
@@ -1344,8 +1345,8 @@ cat >> AGENTS.md <<'MD'
 ## Tests that use `vitest-auto-spy`
 
 When writing or fixing tests that use `vitest-auto-spy`, first read
-`node_modules/vitest-auto-spy/AGENTS.md`. It is the authoritative reference for the API,
-the configuration semantics and the common mistakes.
+`node_modules/vitest-auto-spy/AGENTS.md` whole — a short map — then only the topic files in
+`agent-docs/` it names for the task.
 MD
 
 # 2 — CLAUDE.md: Claude Code, and GLM / Kimi running inside it. One line, no second copy to maintain
@@ -1588,6 +1589,12 @@ Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runti
 > `@nestjs/*`, `react`, `vue`/`pinia` and `svelte` stay your own (already-present) dev dependencies and
 > never reach this package's runtime bundle.
 
+> **`vitest-auto-spy/angular` is a companion to the root, not a copy of it.** Of the core it
+> re-exports only the `Spy<T>` type, the `mock*Prop` helpers with `restoreMockedProps`, the
+> `expectEmission` family and `registerAutoSpyDefaults`. `createSpyFromClass`, `createMock`,
+> `createAutoMock`, `spyOnVoidMethod`, `spyOnOwnMethod`, `stubConstructor`, `asInstance` and the rest
+> stay on `vitest-auto-spy`, so an Angular spec that needs one imports from both.
+
 > **The two entries every suite loads are shipped as one module each.** Importing an entry costs
 > per-module loader work rather than per-byte work, and every consumer imports the root on every spec
 > file while every Angular consumer imports `/angular` alongside it. The root now reaches the loader
@@ -3097,7 +3104,7 @@ off, and `verifyNoPendingRequests()` runs the same check by hand.
 
 It is a separate entry because it is the only part of the package that imports `@angular/common` —
 an **optional** peer, so `vitest-auto-spy/angular` keeps loading in a project that does not have it.
-Like `/angular-router` and unlike every other subpath, it does not re-export the core; it is a companion to
+Like `/angular-router`, it does not re-export the core; it is a companion to
 `vitest-auto-spy/angular`, not a replacement.
 
 ### React (Testing Library)
@@ -3972,7 +3979,7 @@ export can never be.
 | `prefer-settle-dynamic-import`    |   `error`   | suggest           | `await import('./thing')` — or `import('./thing').then(…)` — written in a test body or a hook to settle a module the code under test lazy-loads → `await settleDynamicImport(() => import('./thing'))`. Awaiting the specifier waits for the **module**; the handler's own continuation, the lines after _its_ `await`, is still queued behind it, so the assertion reads the state one turn early. The suggestion wraps the `import()` and imports the helper. Reported only where the innermost enclosing function is the runner's own callback, which is what exempts a `vi.mock` factory, a lazy route's `loadComponent` and a callback the spec hands to production code                                                                                                                 |
 | `prefer-create-mock`              |   `warn`    | suggest           | an object literal under `as SomeType` — `{ id: '1', isOffline: false } as Device`, and the `<Device>{ … }` spelling → `createMock<Device>({ … })`, which takes a `DeepPartial<Device>` and answers a `Device`. A cast asks whether the two types overlap, so it passes a key the type does not declare **and** a required field the fixture never sets; both type gates stay silent and the fixture is then spread into an expected payload. Silent on `as const`, on `as unknown` / `as any` and the double cast built from them, on a cast of anything that is not a literal, and on a literal inside one of this library's own factories. `warn`, not `error`: the repair makes a drifted fixture red on the next type-check, which is the finding and also a migration taken file by file |
 | `no-mock-cast`                    |   `error`   | suggest           | `TestBed.inject(S).m as Mock` — a cast to Vitest's `Mock` / `MockInstance` over a **member access** → `injectSpy(S).m`, which the suggestion writes when the token is in view. `Mock` with no parameters is `Mock<any>`, so `mockReturnValue` takes anything and `toHaveBeenCalledWith` stops comparing arguments; the worse form, `(spy.m.mockReturnValue as Mock)(…)`, gets a message of its own because the cast sits on the member that installs the answer. The name has to resolve to a runner's import, so a domain `Mock` is never reported                                                                                                                                                                                                                                           |
-| `no-redundant-mock-reset`         |   `error`   | `--fix` / suggest | a mock reset **the runner already performs** — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — as the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear closing an `afterEach` → delete it. **Silent until** the flags are known: `['error', { clearMocks: true, restoreMocks: true, mockReset: true }]`, `{ configFile }` naming the runner config, or a `vitest.config.*` / `vite.config.*` found above the file. The flag has to match the call: `restoreMocks` alone does not make a `clearAllMocks()` dead, since it never reaches a plain `vi.fn()`. `--fix` only in a file whose only before-hook it is, a suggestion everywhere else, and **never** in a test body                     |
+| `no-redundant-mock-reset`         |   `error`   | `--fix` / suggest | a mock reset **the runner already performs** — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — first in a `beforeEach` no other `beforeEach` precedes, or a clear closing an `afterEach` → delete it. **Silent until** the runner's flags are known: `['error', { clearMocks: true }]` and siblings, `{ configFile }`, or a `vitest.config.*` / `vite.config.*` above the file, read as text; a factory or `mergeConfig` in another module is not read through, and `setupAutoSpy({ restoreMocks })` is not the runner's flag. The flag has to match the call: `restoreMocks` never reaches a plain `vi.fn()`. `--fix` only where it is the file's only before-hook, a suggestion elsewhere, **never** in a test body     |
 | `no-unasserted-argument`          |   `warn`    | —                 | a bare `expect(spy).toHaveBeenCalled()` where the file itself says the arguments are the point: the same subject is pinned with `toHaveBeenCalledWith(…)` in another test of the file, or the test's title says `with` and its body asserts nothing else → name the arguments. Narrower than `vitest/prefer-called-with` on purpose — 175 findings against its 1941 on the same suite                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `no-compile-components`           |   `error`   | suggest           | `compileComponents()` under a builder that inlines `templateUrl` / `styleUrls` — a promise already settled; **silent** until `{ builder: 'inline-resources' }` says so, because a JIT setup that loads resources at run time needs the call. One exception the rule cannot see: a component whose template holds a `@defer` block ships async class metadata, so the call stays load-bearing there                                                                                                                                                                                                                                                                                                                                                                                            |
 | `no-sync-testbed-await`           |   `error`   | suggest           | `await` on a TestBed call that answers the TestBed or a fixture — `configureTestingModule`, every `override*`, `resetTestingModule`, `createComponent`, `getLastFixture`; none of them is a promise, so the `await` waits for nothing and the `async` it forced on the hook awaits nothing either. The suggestion drops both. Reads no types, so it reports without `parserOptions.project`                                                                                                                                                                                                                                                                                                                                                                                                   |

package/agent-docs/angular.md

@@ -26,6 +26,14 @@ helper a suite names once in a setup file must not ride along with every `provid
 the diagnostics, doubles and matcher registrars left on that rule (`trackInjections` stays —
 `createWithAutoSpies` needs its module).
 
+**`/angular` is not a second copy of the core.** Of the root entry it re-exports only the `Spy<T>`
+type (5.35.0), the `mock*Prop` family with `restoreMockedProps` / `countMockedProps`, the
+`expectEmission` family and `registerAutoSpyDefaults` / `clearAutoSpyDefaults`. Every other runtime
+name — `createSpyFromClass`, `createMock`, `createAutoMock`, `createSpyFromInstance`,
+`spyOnVoidMethod`, `spyOnOwnMethod`, `stubConstructor`, `asInstance`, `asSpy` — stays on
+`vitest-auto-spy`, so a spec that needs one keeps a second import line; do not fold it into the
+`/angular` import. `/bun-angular` differs: a runner entry, it re-exports the whole core.
+
 ### The same thing as fixtures — `extendWithAutoSpies` (Vitest 4.1+)
 
 The block above, written once instead of once per dependency, with the types inferred rather than
@@ -476,7 +484,7 @@ and the next line reads the settled value.
 
 Three things to know before reaching for it:
 
-- **It does not re-export the core** — nor does `/angular-router`; every other subpath does. It is a
+- **It does not re-export the core** — nor does `/angular-router`, and `/angular` only a few names (§13). It is a
   companion to `vitest-auto-spy/angular`, which stays the import for spies, `TestBed` helpers and
   `settleResource`.
   Staying narrow is what keeps `@angular/common` — an **optional** peer — out of every other entry.
@@ -977,6 +985,7 @@ spies.get(PricingService).total.mockReturnValue(100);
 // zoneless waiting
 await stable(fixture); // flush effects, then await the fixture; fails at 2000 ms naming the cause
 await stable(fixture, { timeout: 5000, label: 'the products fixture' });
+await stable(TestBed.createDirective(TooltipDirective, { tagName: 'button' })); // any fixture with whenStable()
 flushEffects(); // the no-fixture half: services, stores, runInInjectionContext
 
 // resources — one wait for httpResource(), resource() and rxResource()
@@ -1177,6 +1186,27 @@ _is_ declared; `NG0304` calls a missing directive a missing component; a bare at
 nothing at all). `schemas: [NO_ERRORS_SCHEMA]` next to a standalone component is a dead entry —
 schemas apply to a testing module's `declarations` only.
 
+It is also the guard for an attribute a `hostDirectives` entry puts on the component under test. An
+assertion on the attribute alone stays green when the entry is dropped and the attribute is also
+written statically, or set by something else; the fixture's root element is searched, so the entry
+itself can be asserted with no selector:
+
+```ts
+import { registerDirectiveMatchers } from 'vitest-auto-spy/angular/matchers';
+
+registerDirectiveMatchers(); // once, in the setup file; nothing registers the matcher for you
+
+const fixture = TestBed.createComponent(CardComponent); // hostDirectives: [TestIdDirective]
+
+expect(fixture).toHaveDirectiveApplied(TestIdDirective);
+expect(hostElement(fixture).getAttribute('data-testid')).toBe('card');
+```
+
+Angular ≥ 22.2: when the directive needs no static host attribute, no `TemplateRef` (structural) and
+no sibling markup, `TestBed.createDirective(Dir, { tagName, bindings })` builds the host itself.
+`stable(fixture)`, `hostElement(fixture)` and `toHaveDirectiveApplied` take its `DirectiveFixture`;
+`setInputs` does not (no `componentRef`) — bind a signal with `inputBinding` and set it.
+
 ### A stand-in for a child — `createComponentStub`
 
 Do not hand-write `class MockChartComponent` with a copied selector: nothing checks the copy, so a

package/agent-docs/checklist.md

@@ -48,7 +48,9 @@ a unit-test target, Analog below 2.7.5, `vite` below 6.4, or Node below 22.12 in
 `.node-version`, CI or a private package's `engines`. `fs-module-cache-not-persisted` warns when
 `fsModuleCache` is on and no CI config caches its directory. Renamed config keys Vitest 5 still
 honours (`experimental.fsModuleCache`, `browser.isolate`, `cache.dir`, …) are left to Vitest's own
-deprecation line.
+deprecation line. `mock-reset-config-unread` notes a `no-redundant-mock-reset` whose `configFile` names
+a config built by a factory or `mergeConfig`, with no flag beside it: the rule cannot see the flags
+that call sets.
 It is worth one run after any large edit to a test suite — especially after a codemod, which is where
 the eaten glob below came from.
 

package/agent-docs/errors.md

@@ -47,9 +47,9 @@ Part of the agent reference [`AGENTS.md`](../AGENTS.md), which maps every sectio
 | `Cannot read properties of undefined (reading 'name')` on `value.constructor.name`, with `createAutoMock<T>()` | `constructor` answered `undefined` on an auto-mock | upgrade — it answers `Object`, as every other double does; or seed it: `createAutoMock<T>({ constructor: … })` |
 | `Cannot redefine property: …` from a library accessor spy | the target is an ES module namespace a bundler inlined | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that |
 | `Cannot spy on this instance in place: it is not extensible` | `createSpyFromInstance` was handed a frozen or sealed object | spy it before it is frozen, or build a separate double with `createSpyFromClass` (§2) |
-| `createSpyFromInstance(X): no onlyMethodsToSpyOn was given for a live DOM/BOM object` | discovery is about to walk the whole prototype chain of a live `Node`, `window` or other engine-provided event target (not a user class extending `EventTarget`), engine internals included — the bare-array shorthand does not avoid this, since it merges as `methodsToSpyOn`, not `onlyMethodsToSpyOn` | list the methods the test needs: `{ onlyMethodsToSpyOn: [...] }`; for one method on a node that must keep living a DOM life, `mockValueProp` / `spyOnVoidMethod` instead (§2, live DOM node) |
+| `createSpyFromInstance(X): no onlyMethodsToSpyOn was given for a live DOM/BOM object` | discovery is about to walk the whole prototype chain of a live `Node`, `window` or other engine-provided event target, happy-dom's `MediaQueryList` included (not a user class extending `EventTarget`), engine internals included — the bare-array shorthand does not avoid this, since it merges as `methodsToSpyOn`, not `onlyMethodsToSpyOn` | list the methods the test needs: `{ onlyMethodsToSpyOn: [...] }`; for one method on a node that must keep living a DOM life, `mockValueProp` / `spyOnVoidMethod` instead (§2, live DOM node) |
 | `Cannot mock the property 'X': it is not configurable` | the member was defined with `configurable: false`, so it cannot be redefined | members replaced before it are still restorable — `restoreSpiedInstance(instance)` or `restoreMockedProps()` |
-| `createSpyFromInstance`: `Cannot spy on 'X' in place: it is a non-configurable, non-enumerable own property` | the value can be rewritten but not made enumerable, so `resetAutoSpy` would never find the spy | spy it alone with `mockValueProp(instance, 'X', vi.fn())`, or build a double with `createSpyFromClass` |
+| `createSpyFromInstance`: `Cannot spy on 'X' in place: it is a non-configurable, non-enumerable own property` | the value can be rewritten but not made enumerable, so `resetAutoSpy` would never find the spy | spy it alone with `mockValueProp(instance, 'X', vi.fn())`, or build a double with `createSpyFromClass`; members the same call replaced before `X` stay spied until `restoreSpiedInstance(instance)` or the `setupAutoSpy()` sweep |
 | `overrideComponentProvider(…): the override did not apply — C resolved T to …` | the component injects a different token, or something configured the token again after the call; the message says whether the real service or a different double won | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures |
 | `.value() was read while the resource is in the error state: …` | `mockResourceProp`'s double after `fail(reason)`, as a real `ResourceRef` behaves; the reason is on `cause` | branch on `hasValue()` / `status()` first, or assert with `toHaveResourceError()` (§13) |
 | `@angular/core <version> no longer carries …, which this package reads` | an Angular internal this package reads has moved; checked once per worker | nothing is fixable from a spec — report the version in the message and pin the previous Angular until a release reads the new shape (§13) |
@@ -126,7 +126,7 @@ Part of the agent reference [`AGENTS.md`](../AGENTS.md), which maps every sectio
 | `flushEventLoopUntil` timing out on the **first** such test only, the rest green | a cold dynamic `import()` outran the turn budget; later tests hit the module cache | `await settleDynamicImport(() => import('…'))` — await the module, do not count turns |
 | `Expected to be running in 'ProxyZone', but it was not found` | `zone.js/testing` patches jasmine/mocha/jest, not Vitest | `import 'vitest-auto-spy/zone'` after zone.js, with `globals: true` (§14) |
 | `nextWith` demanding `HttpEvent<T>` on a generated API client | `Parameters`/`ReturnType` read the **last** overload | `asSpy<Client, { overload: 'first' }>(…)`, or `Overload<M, 0>` — never `@ts-expect-error`, which `no-ts-expect-error-on-double` reports (§16) |
-| `NG0303` / `NG0304` / nothing at all, from a directive spec | the host is `standalone: false`, or the module is in the TestBed | `createDirectiveHost({ template, scope: [Module] })` (§13) |
+| `NG0303` / `NG0304` / nothing at all, from a directive spec | the host is `standalone: false`, or the module is in the TestBed | `createDirectiveHost({ template, scope: [Module] })`; on Angular ≥ 22.2, for a directive with no static host attribute, `TemplateRef` or sibling markup, `TestBed.createDirective(Dir, { tagName, bindings })` (§13) |
 | `setInputs: … declares no input named …` (with a `Did you mean` for a near typo) | the key is not an input of that component — a typo, an input renamed since, or one of its own fields | take the suggestion, or set a name the message lists; a signal the component owns is moved through the signal (§13) |
 | `setInputs: X carries no ɵcmp, so there are no inputs to set` (or `the component class is undefined`, `X is a @Pipe`) | the fixture's `componentType` is not a compiled `@Component` — a `@Pipe`, a class Angular never compiled, or `undefined` from a barrel split across chunks | pass the `@Component` class the fixture was created from; call a pipe's `transform()` directly; for `undefined` import the class from its own file (§13) |
 | `TypeError: dependencies is not a function`, from `renderShallow({ keepTemplate: true })` | the compiled `ɵcmp.dependencies` is the flat array AOT emits when no cycle forced a factory, and the trim called it | upgrade — all three shapes (array, factory, `null`) are read; nothing to change in the spec |

package/agent-docs/eslint.md

@@ -75,7 +75,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-settle-dynamic-import` | `error` | suggest | `await import('./thing')` and `import('./thing').then(…)` inside an `it` / `test` body or a `beforeEach` / `beforeAll` / `afterEach` / `afterAll` hook (the `.only`, `.skip` and `.each` spellings included) → `await settleDynamicImport(() => import('./thing'))`, which is the same load plus `flushEventLoop(1)` and returns the namespace, so the destructured form keeps reading the same way. The bare `await` waits for the **module** and not for the continuation of the code that was loading it, so the assertion runs a turn early and the test is green only while that continuation is short. Syntax only. Silent wherever a function of its own sits between the runner's callback and the import — a `vi.mock` factory, a lazy route's `loadComponent` / `loadChildren`, a callback handed to production code, `settleDynamicImport`'s own `() => import(…)` — and, by the same reading, silent on a spec-local `const load = async () => { await import('…') }`, which is written identically whether the spec calls it or the code under test does |
 | `prefer-create-mock` | `warn` | suggest | an object literal under `as SomeType` — `{ id: '1', isOffline: false } as Device`, `<Device>{ … }` too → `createMock<Device>({ … })`. A cast asks whether the two types overlap rather than whether the value is one of them, so it passes a key the type does not declare (the excess-property check is skipped) **and** a required field the fixture never sets; both type gates stay silent, and the same object is then spread into the expected payload of a call assertion. Where the literal already sits in a typed slot the first repair is to delete the cast. Silent on `as const`, `as unknown` / `as any` and the double cast built from them, on a cast of anything but a literal, and on a literal inside one of this library's own factories. `warn`, because accepting the suggestion makes a drifted fixture red on the next type-check — the finding, and a migration taken file by file |
 | `no-mock-cast` | `error` | suggest | a cast to Vitest's `Mock` / `MockInstance` over a **member access** — `TestBed.inject(S).m as Mock` → `injectSpy(S).m`, which the suggestion writes whenever the token is in view (directly, or through a `const` the file settled with a `TestBed.inject`). `Mock` with no parameters is `Mock<any>`: `mockReturnValue` takes anything and `toHaveBeenCalledWith` stops comparing arguments. `(spy.m.mockReturnValue as Mock)(…)` gets its own message — the cast is on the member that installs the answer, so neither the value nor the method's return type is checked. The name must resolve to an import from `vitest` / `@rstest/core` / `bun:test` / `jest`, or to nothing at all, so a domain `Mock` is left alone |
-| `no-redundant-mock-reset` | `error` | `--fix` / suggest | a mock reset the runner already performs between tests — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — standing where nothing the file wrote ran since the runner's own: the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear as the last statement of an `afterEach` → delete it, and the hook with it where that is all it held. A restore or reset in `afterEach` / `afterAll` is never reported: after the last test it is what takes a spy off before the `afterAll` hooks. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` (or `{ configFile }` naming the runner config) first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only in a file whose only before-hook it is; a suggestion otherwise; never inside a test body |
+| `no-redundant-mock-reset` | `error` | `--fix` / suggest | a mock reset the runner already performs between tests — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — standing where nothing the file wrote ran since the runner's own: the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear as the last statement of an `afterEach` → delete it, and the hook with it where that is all it held. A restore or reset in `afterEach` / `afterAll` is never reported: after the last test it is what takes a spy off before the `afterAll` hooks. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` (or `{ configFile }` naming the runner config) first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text; a config that leaves `clearMocks` out counts it on from Vitest 5 (its default). A config built by a factory or `mergeConfig` from another module is not read through — write its flags beside `configFile` (`doctor` notes the case as `mock-reset-config-unread`). `setupAutoSpy({ restoreMocks: true })` is not the runner's `restoreMocks` (it restores in an `afterEach`, after the test) — never pass the rule a flag only the setup file sets. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only in a file whose only before-hook it is; a suggestion otherwise; never inside a test body |
 | `no-unasserted-argument` | `warn` | — | a bare `expect(spy).toHaveBeenCalled()` on evidence from the file: the same subject asserted with `toHaveBeenCalledWith(…)` in another test, or a title containing `with` over a body whose every assertion is a bare call → `toHaveBeenCalledWith(…)` / `mustBeCalledWith(…)`. `not.toHaveBeenCalled()` and the counting matchers are never reported |
 | `no-compile-components` | `error` | suggest | `compileComponents()` under a builder that inlines `templateUrl` / `styleUrls` — a promise already settled → delete it, and the `async` of a hook that awaits nothing else. **Silent until** `['error', { builder: 'inline-resources' }]`: under a JIT setup that loads resources at run time the call is load-bearing. **Keep the call for a component whose template holds a `@defer` block** — that ships async class metadata, which `TestBed` resolves in this very call whatever the builder did, and dropping it fails the test with `has unresolved metadata`; the rule cannot see another file's template, so list those classes in `{ ignoreComponents: ['CardComponent'] }` (a spec naming one is left alone) or keep a `// eslint-disable-next-line vitest-auto-spy/no-compile-components -- @defer: async class metadata` |
 | `no-sync-testbed-await` | `error` | suggest | `await` on a TestBed call that answers the TestBed or a fixture — `configureTestingModule`, `override*`, `resetTestingModule`, `createComponent`, `getLastFixture`, through `TestBed`, `getTestBed()`, a chain of those, or a name holding one → drop the `await`, and the `async` of a hook that then awaits nothing else; the suggestion does both. Reads **no types**, so it reports without `parserOptions.project`, where `@typescript-eslint/await-thenable` cannot. `inject` and `runInInjectionContext` are never reported: each answers whatever the token or the callback holds, which can be a promise |

package/agent-docs/setup.md

@@ -202,7 +202,9 @@ setupAutoSpy({ strayListeners: true }); // wrap addEventListener, sweep what the
 
 The split is the one `pruneMockRegistry` uses: a `beforeAll` marks the listeners already on
 `window`/`document` — registered while the module graph was evaluated, a framework's one-time
-initialisation — and the `afterAll` takes off everything added since. The pieces are exported too:
+initialisation — and the `afterAll` takes off everything added since. A registration jsdom or
+happy-dom makes itself (jsdom wires nine focus, keyboard and mouse listeners the first time a
+document is queried) is the environment's: neither counted nor swept. The pieces are exported too:
 `trackStrayListeners()` (idempotent, returns the undo), `baselineStrayListeners()`,
 `removeStrayListeners()` (returns how many), `countStrayListeners()` (throws before
 `trackStrayListeners()` has run, like the timer counter) and `describeStrayListeners()` — each

package/dist/angular-diagnostics.js

@@ -1,12 +1,12 @@
 import { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-GKSVYPZQ.js';
 export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-GKSVYPZQ.js';
-import { failOnUnspiedProvider } from './chunk-VWNFNWTG.js';
+import { failOnUnspiedProvider } from './chunk-2KBRDNIB.js';
 import './chunk-GG7BQKEK.js';
 import './chunk-FWXDSPZD.js';
-import './chunk-F4URI3UE.js';
+import './chunk-6KP5QMMV.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-LA2CMIPM.js';
+import './chunk-RYFF55PV.js';
 import { isAutoSpyLike } from './chunk-Q7L4AWI7.js';
 import { count, taskName } from './chunk-M3NTXLZG.js';
 import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-5FQZGJLJ.js';

package/dist/angular-doubles.js

@@ -1,11 +1,11 @@
 import { describeInstance } from './chunk-BS432KB2.js';
-import { useVitestAdapter } from './chunk-YWSOJH5C.js';
-import './chunk-GTDJ22IQ.js';
+import { useVitestAdapter } from './chunk-YNXQ2WFH.js';
+import './chunk-B6C3K27C.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-LA2CMIPM.js';
+import { createFunctionSpy } from './chunk-RYFF55PV.js';
 import './chunk-Q7L4AWI7.js';
 import './chunk-M3NTXLZG.js';
 import { angularDialog } from './chunk-5FQZGJLJ.js';

package/dist/angular-matchers.js

@@ -17,11 +17,14 @@ function rootOf(received) {
     candidate
   ) : void 0;
 }
+function matching(root, predicate) {
+  return predicate(root) ? [root, ...root.queryAll(predicate)] : root.queryAll(predicate);
+}
 function diagnose(directive, selector, root) {
-  const matching = selector === void 0 ? [] : root.queryAll(By.css(selector));
+  const elements = selector === void 0 ? [] : matching(root, By.css(selector));
   const where = selector === void 0 ? "" : ` on '${selector}'`;
   const prefix = `[vitest-auto-spy] expected ${directive.name} to be applied${where}`;
-  if (selector !== void 0 && matching.length === 0) {
+  if (selector !== void 0 && elements.length === 0) {
     return withDocs(
       `${prefix}, but no element matches that selector.
 Run fixture.detectChanges() before asserting, and check the selector against the template.`,
@@ -47,14 +50,14 @@ function directiveResult(received, directive, selector) {
   if (!root) {
     throw new Error(
       withDocs(
-        `[vitest-auto-spy] toHaveDirectiveApplied: expected a ComponentFixture or a DebugElement, received ${describeReceived(received)}.
+        `[vitest-auto-spy] toHaveDirectiveApplied: expected a ComponentFixture, a DirectiveFixture or a DebugElement, received ${describeReceived(received)}.
 Pass the fixture itself, or fixture.debugElement \u2014 not fixture.nativeElement.`,
         angularDirectiveApplied
       )
     );
   }
-  const withDirective = root.queryAll(By.directive(directive));
-  const applied = selector === void 0 ? withDirective.length > 0 : root.queryAll(By.css(selector)).some((element) => element.providerTokens.includes(directive));
+  const withDirective = matching(root, By.directive(directive));
+  const applied = selector === void 0 ? withDirective.length > 0 : matching(root, By.css(selector)).some((element) => element.providerTokens.includes(directive));
   return {
     pass: applied,
     message: () => applied ? `[vitest-auto-spy] expected ${directive.name} not to be applied, but it is on ${count(withDirective.length, "element")}.` : diagnose(directive, selector, root)

package/dist/angular-router.js

@@ -1,6 +1,6 @@
 import { describeInstance } from './chunk-BS432KB2.js';
 import { angularInternalsError } from './chunk-GG7BQKEK.js';
-import { createFunctionSpy } from './chunk-LA2CMIPM.js';
+import { createFunctionSpy } from './chunk-RYFF55PV.js';
 import './chunk-Q7L4AWI7.js';
 import { count } from './chunk-M3NTXLZG.js';
 import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-5FQZGJLJ.js';

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-export { u as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, v as provideAutoSpyForToken, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-BuJk_Yi8.js';
+export { u as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, v as provideAutoSpyForToken, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-C7SrW3Ub.js';
 import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, s as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-BVKEkhWj.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
 import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-wUaoy0NW.js';

package/dist/bun-angular.d.ts

@@ -3,7 +3,7 @@ export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOpti
 export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-wUaoy0NW.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-5pFBRWW9.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-8Ps9usRa.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-BuJk_Yi8.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-C7SrW3Ub.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,19 +1,19 @@
-import { createSpyForToken } from './chunk-464WKNEQ.js';
-export { injectSpy, provideAutoSpy } from './chunk-VWNFNWTG.js';
+import { createSpyForToken } from './chunk-2TZCJ3MM.js';
+export { injectSpy, provideAutoSpy } from './chunk-2KBRDNIB.js';
 import { stable, flushEffects } from './chunk-DBC6526L.js';
 export { flushEffects, stable } from './chunk-DBC6526L.js';
 import { angularInternalsError } from './chunk-GG7BQKEK.js';
 import './chunk-QDBRZQJO.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-GAE5EGO7.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-5TYNQH5Q.js';
 import { mockValueProp } from './chunk-FWXDSPZD.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-FWXDSPZD.js';
-import { closestName } from './chunk-F4URI3UE.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-F4URI3UE.js';
+import { closestName } from './chunk-6KP5QMMV.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-6KP5QMMV.js';
 import { fakeClockBacklog } from './chunk-W5EXSI22.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-LA2CMIPM.js';
+export { createFunctionSpy, errorHandler } from './chunk-RYFF55PV.js';
 import { libraryWarn } from './chunk-Q7L4AWI7.js';
 import { displayPath, count } from './chunk-M3NTXLZG.js';
 import { angularEffects, angularTrackRuns, bunAngular, angularUnreadResource, angularCreateWithAutoSpies, angularResources, angularTypedElements, angularInputs, angularKeepTemplate } from './chunk-5FQZGJLJ.js';

package/dist/bun.js

@@ -1,12 +1,12 @@
 import './chunk-QDBRZQJO.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-GAE5EGO7.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-5TYNQH5Q.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-FWXDSPZD.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-F4URI3UE.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-6KP5QMMV.js';
 import './chunk-W5EXSI22.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-LA2CMIPM.js';
+export { createFunctionSpy, errorHandler } from './chunk-RYFF55PV.js';
 import './chunk-Q7L4AWI7.js';
 import './chunk-M3NTXLZG.js';
 import './chunk-5FQZGJLJ.js';

package/dist/{chunk-VWNFNWTG.js → chunk-2KBRDNIB.js}

@@ -1,5 +1,5 @@
 import { currentSpecFile } from './chunk-FWXDSPZD.js';
-import { createSpyFromClass } from './chunk-F4URI3UE.js';
+import { createSpyFromClass } from './chunk-6KP5QMMV.js';
 import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-Q7L4AWI7.js';
 import { angularInjectSpyReal } from './chunk-5FQZGJLJ.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/{chunk-464WKNEQ.js → chunk-2TZCJ3MM.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-F4URI3UE.js';
+import { createSpyFromClass, createAutoMock } from './chunk-6KP5QMMV.js';
 import { trackInjectionsUntracked } from './chunk-5FQZGJLJ.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 

package/dist/{chunk-GAE5EGO7.js → chunk-5TYNQH5Q.js}

@@ -1,9 +1,9 @@
 import { mockValueProp, mockAccessorsProp } from './chunk-FWXDSPZD.js';
-import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-F4URI3UE.js';
+import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-6KP5QMMV.js';
 import { unpatchedSetTimeout, unpatchedClearTimeout, fakeClockAdvice, fakeClockBacklog } from './chunk-W5EXSI22.js';
 import { redefineFailure } from './chunk-FOL5RH22.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-LA2CMIPM.js';
+import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-RYFF55PV.js';
 import { isMarkedMock, reportMisconfiguration, DEEP_CHILDREN } from './chunk-Q7L4AWI7.js';
 import { count, displayPath } from './chunk-M3NTXLZG.js';
 import { moduleMocksAssert, moduleMocksNoOp, narrow, adoptMock, observableFailures, strictModePassthrough, createSpyFromClassReturns, captureArg, eventLoopUntil, mockConstructor, createSpyFromClassLiveDomNode } from './chunk-5FQZGJLJ.js';
@@ -79,12 +79,15 @@ function looksLikeLiveHostObject(instance) {
       continue;
     }
     if (constructor.name === "EventTarget") {
-      return engineLevel;
+      return engineLevel || isEnginePrivateEventTarget(constructor);
     }
     engineLevel ||= Reflect.get(globalThis, constructor.name) === constructor;
   }
   return false;
 }
+function isEnginePrivateEventTarget(constructor) {
+  return typeof Node !== "undefined" && constructor !== Reflect.get(globalThis, "EventTarget") && Reflect.getPrototypeOf(Node.prototype) === Reflect.get(constructor, "prototype");
+}
 function warnOnUndiscriminatedHostDiscovery(label, listedAdditions) {
   const additions = listedAdditions ? "The methods listed (a bare array is methodsToSpyOn) are spied in addition to that discovery, not instead of it. " : "";
   reportMisconfiguration(

package/dist/{chunk-F4URI3UE.js → chunk-6KP5QMMV.js}

@@ -1,5 +1,5 @@
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defaultStrict, resolveUnstubbedGuard, seedReturnValue, createFunctionSpy } from './chunk-LA2CMIPM.js';
+import { defaultStrict, resolveUnstubbedGuard, seedReturnValue, createFunctionSpy } from './chunk-RYFF55PV.js';
 import { runClearHook, runConfigReset, reportMisconfiguration, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-Q7L4AWI7.js';
 import { autoMockHeldBack, createSpyFromClassInstanceMethods, createSpyFromClassAccessors, createSpyFromClassReturns, createSpyFromClassLazySpies } from './chunk-5FQZGJLJ.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/{chunk-GTDJ22IQ.js → chunk-B6C3K27C.js}

@@ -1,6 +1,6 @@
 import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-TXDBDMIL.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-LA2CMIPM.js';
+import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-RYFF55PV.js';
 import { setSharedHelperSink, hooksOf } from './chunk-Q7L4AWI7.js';
 import { mockConstructor } from './chunk-5FQZGJLJ.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/{chunk-LA2CMIPM.js → chunk-RYFF55PV.js}

@@ -768,11 +768,15 @@ function installSettledResultsPolyfill(mockFn) {
 // src/lib/stack-frames.ts
 var FOREIGN_FRAME = /node_modules|node:internal|\(node:/;
 var LIBRARY_FRAME = /[/\\]vitest-auto-spy[/\\]dist[/\\]|[/\\]\.vite[/\\]deps[^/\\]*[/\\]vitest-auto-spy[^/\\]*\.js/;
+var HELPER_FRAME = /\b__VITEST_HELPER__\b/;
+function isLibraryFrame(frame) {
+  return LIBRARY_FRAME.test(frame) || HELPER_FRAME.test(frame);
+}
 function stackFrames(stack) {
   return String(stack).split("\n").filter((line) => /^\s*at\s/.test(line)).map((line) => line.trim());
 }
 function ownFrames(frames, limit) {
-  const outside = frames.filter((frame) => !LIBRARY_FRAME.test(frame));
+  const outside = frames.filter((frame) => !isLibraryFrame(frame));
   const own = outside.filter((frame) => !FOREIGN_FRAME.test(frame));
   const shown = [own, outside].find((candidates) => candidates.length > 0) ?? frames;
   return shown.slice(0, limit);

package/dist/{chunk-YWSOJH5C.js → chunk-YNXQ2WFH.js}

@@ -1,4 +1,4 @@
-import { createRunnerMockAdapter } from './chunk-GTDJ22IQ.js';
+import { createRunnerMockAdapter } from './chunk-B6C3K27C.js';
 import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
 import { hasMockAdapter, registerMockAdapter } from './shared-state.js';
 import { vi } from 'vitest';

package/dist/cli.js

@@ -536,6 +536,7 @@ var DOCTOR_CHECKS = [
   "fs-module-cache-not-persisted",
   "helper-from-wrong-entry",
   "jasmine-era-project",
+  "mock-reset-config-unread",
   "module-mock-leak",
   "no-agent-instructions",
   "no-unawaited-helper",
@@ -3421,7 +3422,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.35.0";
+var EXPORT_MAP_VERSION = "5.37.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",
@@ -3701,6 +3702,7 @@ var EXPORTED_BY = {
   PendingRequestsOptions: "13",
   PerTestHandle: "23",
   PlatformOverrides: "14",
+  PluginRule: "25",
   PropStubValue: "0 1 2 3 4 20 21 22",
   PrototypePollutionReaction: "23",
   provideActivatedRoute: "17",
@@ -4058,6 +4060,73 @@ function checkJasmineEra(profile) {
     }
   ];
 }
+var RULE_KEY = /["'][\w/@-]*\/no-redundant-mock-reset["']\s*:\s*\[/g;
+var CONFIG_FILE = /\bconfigFile\s*:\s*(["'`])([^"'`]+)\1/g;
+var OPTION_FLAG = /\b(?:clearMocks|mockReset|restoreMocks)\s*:/g;
+var ANY_FLAG = /\b(?:clearMocks|mockReset|restoreMocks)\b/;
+var DEFAULT_CALL = /\b(?:export\s+default|module\.exports\s*=)\s*([$A-Z_a-z][\w$.]*)\s*(?:<[^>]*>)?\s*\(/;
+var READABLE = /* @__PURE__ */ new Set(["defineConfig", "defineProject"]);
+function closingBracket(text, spans, open) {
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    const span = spans.find((candidate) => candidate.start === index);
+    if (span !== void 0) {
+      index = span.end - 1;
+      continue;
+    }
+    const char = text.charAt(index);
+    depth += char === "[" ? 1 : char === "]" ? -1 : 0;
+    if (depth === 0) {
+      return index + 1;
+    }
+  }
+  return text.length;
+}
+function inCode(spans, match, base) {
+  return !isInsideLiteral(spans, base + match.index);
+}
+function unflaggedConfigFiles(text) {
+  const spans = literalSpans(text);
+  const found = [];
+  for (const match of text.matchAll(RULE_KEY)) {
+    if (spans.find((span) => span.start <= match.index && match.index < span.end)?.start !== match.index) {
+      continue;
+    }
+    const open = match.index + match[0].length - 1;
+    const options = text.slice(open, closingBracket(text, spans, open));
+    const configFile = [...options.matchAll(CONFIG_FILE)].find((entry) => inCode(spans, entry, open))?.[2];
+    const flagged = [...options.matchAll(OPTION_FLAG)].some((entry) => inCode(spans, entry, open));
+    if (configFile !== void 0 && !flagged) {
+      found.push(configFile);
+    }
+  }
+  return found;
+}
+function unreadableCallee(configText) {
+  if (ANY_FLAG.test(configText)) {
+    return void 0;
+  }
+  const callee = DEFAULT_CALL.exec(configText)?.[1];
+  return callee === void 0 || READABLE.has(callee) ? void 0 : callee;
+}
+function checkMockResetConfig(profile, graph) {
+  const findings = [];
+  for (const [file, text] of graph.texts) {
+    for (const configFile of unflaggedConfigFiles(text)) {
+      const callee = unreadableCallee(readTextFile(resolve(profile.cwd, configFile)) ?? "");
+      if (callee !== void 0) {
+        findings.push({
+          check: "mock-reset-config-unread",
+          severity: "info",
+          file,
+          message: `\`no-redundant-mock-reset\` reads \`${configFile}\`, whose default export is a \`${callee}(\u2026)\` call: the rule reads the file as text, finds no \`clearMocks\` / \`mockReset\` / \`restoreMocks\`, and decides on the runner's defaults instead of what \`${callee}\` sets.`,
+          fix: "Write the flags that config ends up with beside `configFile` in the rule options, e.g. `{ configFile, clearMocks: true }`; a flag written there wins over the file."
+        });
+      }
+    }
+  }
+  return findings;
+}
 var BASE_CONFIGS2 = ["ts", "mts", "cts", "js", "mjs", "cjs"].map((extension) => `vitest-base.config.${extension}`);
 var SHARED_BY_DEFAULT_FROM = [21];
 var OPTION_WINS_FROM = [22, 1];
@@ -4760,6 +4829,7 @@ function runDoctor(profile) {
     ...checkHelperEntry(profile, graph),
     ...checkUnawaitedHelper(profile, graph),
     ...checkModuleMockLeak(profile, graph),
+    ...checkMockResetConfig(profile, graph),
     ...checkVitest5Removed(profile, graph),
     ...checkVitest5ClearMocks(profile, graph),
     ...checkVitest5Available(profile),
@@ -4978,23 +5048,24 @@ function rxjsBullet(profile, facts) {
   }
   const target = facts.setupFile ?? profile.setupFiles[0] ?? "the test setup file";
   return `- Observable spies (\`nextWith\`, \`observablePropsToSpyOn\`) need \`import 'vitest-auto-spy/rxjs'\` once, in
-  \`${target}\`. Without it they throw "Observable spies require rxjs".`;
+  \`${target}\` or a module / \`.d.ts\` it loads. Without it they throw "Observable spies require rxjs".`;
 }
 function companionsBullet(facts) {
   if (facts.companions.length === 0) {
     return void 0;
   }
   const list = facts.companions.map((entry) => `\`${entry}\``).join(", ");
-  return `- Setup helpers also come from ${list}, which since 5.21.0 are separate
-  entries and do not re-export the core.`;
+  return `- Setup helpers also come from ${list}, separate entries since
+  5.21.0 that do not re-export the core.`;
 }
 function renderBody(profile, facts = NO_FACTS) {
   const lines = [
     "## Tests that use `vitest-auto-spy`",
     "",
-    "Read `node_modules/vitest-auto-spy/AGENTS.md` before writing or fixing a spec that uses",
-    "`vitest-auto-spy` \u2014 it is the authoritative reference for the API, the configuration semantics",
-    "and the common mistakes. Where it and the code disagree, `dist/*.d.ts` wins.",
+    "For a spec that uses `vitest-auto-spy`, read the short map",
+    "`node_modules/vitest-auto-spy/AGENTS.md` whole, then only the `agent-docs/*.md` files it names.",
+    "On a failure: `grep -n -F '<error text>' node_modules/vitest-auto-spy/agent-docs/errors.md`.",
+    "Where docs and code disagree, `dist/*.d.ts` wins.",
     "",
     `- This repository imports from \`${profile.entry}\`. Each entry registers its mock adapter on`,
     "  import, so the wrong one leaves the wrong adapter installed and the spies fail at runtime.",
@@ -5002,8 +5073,7 @@ function renderBody(profile, facts = NO_FACTS) {
     companionsBullet(facts),
     rxjsBullet(profile, facts),
     "- `methodsToSpyOn` **adds** to the auto-discovered prototype methods; the exhaustive whitelist is",
-    "  `onlyMethodsToSpyOn`. For methods that live on the instance rather than the prototype, use",
-    "  `createAutoMock<T>()`.",
+    "  `onlyMethodsToSpyOn`. For methods on the instance, not the prototype, use `createAutoMock<T>()`.",
     "- `Spy<T>` is a mapped type and drops `#private` members, so it is not assignable to `T`. Declare",
     "  the variable as `Spy<T>`, or pass `asInstance(spy)` where the real type is required.",
     "- `npx vitest-auto-spy doctor` reports suite-level defects that never fail a run."
@@ -6211,7 +6281,7 @@ function nothingOverBudgetNote(gate = GATE_DEFAULTS, runFailed = false) {
   return `Nothing over budget: no file over its budget and no test body over ${formatMs(gate.maxTestMs)}. ${verdict}`;
 }
 var DOMINATES = 0.3;
-var CONFIG_FILE = /(?:^|\/)vite(?:st)?[\w.-]*\.config\.[cm]?[jt]s$/;
+var CONFIG_FILE2 = /(?:^|\/)vite(?:st)?[\w.-]*\.config\.[cm]?[jt]s$/;
 var NO_ISOLATION = /\bisolate\s*:\s*false/;
 var JSDOM = /\benvironment\s*:\s*["'`]jsdom["'`]/;
 var HAPPY_DOM = /happy-dom/;
@@ -6223,7 +6293,7 @@ var LARGE_RUN_MS = 6e4;
 function configCode(graph) {
   const configs = [];
   for (const [file, text] of graph.texts) {
-    if (!CONFIG_FILE.test(file)) {
+    if (!CONFIG_FILE2.test(file)) {
       continue;
     }
     configs.push([

package/dist/console.js

@@ -1,10 +1,10 @@
-import { useVitestAdapter } from './chunk-YWSOJH5C.js';
-import './chunk-GTDJ22IQ.js';
+import { useVitestAdapter } from './chunk-YNXQ2WFH.js';
+import './chunk-B6C3K27C.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-LA2CMIPM.js';
+import { createFunctionSpy } from './chunk-RYFF55PV.js';
 import './chunk-Q7L4AWI7.js';
 import './chunk-M3NTXLZG.js';
 import './chunk-5FQZGJLJ.js';

package/dist/eslint-plugin.d.cts

@@ -11,6 +11,7 @@ declare const plugin: Plugin.AutoSpyEslintPlugin;
 declare namespace plugin {
   export type AutoSpyEslintPlugin = Plugin.AutoSpyEslintPlugin;
   export type FlatConfig = Plugin.FlatConfig;
+  export type PluginRule = Plugin.PluginRule;
   export type RuleSeverity = Plugin.RuleSeverity;
 }
 

package/dist/eslint-plugin.d.ts

@@ -248,12 +248,24 @@ interface RuleModule {
 type RuleSeverity = 'error' | 'off' | 'warn';
 /** A flat-config object: the plugin under its name, plus the rules it turns on. */
 interface FlatConfig {
-    plugins: Record<string, unknown>;
+    plugins: Record<string, AutoSpyEslintPlugin>;
     rules: Record<string, RuleSeverity>;
 }
+/**
+ * One visitor of a published rule. A method signature is bivariant in its parameter, which lets a
+ * visitor typed on its selector's node fit ESLint's `(...args: any[]) => void`.
+ */
+type PluginRuleVisitor = {
+    visit(node: unknown): void;
+}['visit'];
+/** A rule as the plugin publishes it: ESLint calls `create`, so no caller needs its context type. */
+interface PluginRule {
+    meta: RuleModule['meta'];
+    create(context: never): Record<string, PluginRuleVisitor>;
+}
 /** The plugin object, as ESLint consumes it. */
 interface AutoSpyEslintPlugin {
-    rules: Record<string, RuleModule>;
+    rules: Record<string, PluginRule>;
     configs: {
         recommended: FlatConfig;
         strict: FlatConfig;
@@ -262,4 +274,4 @@ interface AutoSpyEslintPlugin {
 }
 declare const plugin: AutoSpyEslintPlugin;
 
-export { type AutoSpyEslintPlugin, type FlatConfig, type RuleSeverity, plugin as default };
+export { type AutoSpyEslintPlugin, type FlatConfig, type PluginRule, type RuleSeverity, plugin as default };

package/dist/index.js

@@ -1609,11 +1609,15 @@ function installSettledResultsPolyfill(mockFn) {
 // src/lib/stack-frames.ts
 var FOREIGN_FRAME = /node_modules|node:internal|\(node:/;
 var LIBRARY_FRAME = /[/\\]vitest-auto-spy[/\\]dist[/\\]|[/\\]\.vite[/\\]deps[^/\\]*[/\\]vitest-auto-spy[^/\\]*\.js/;
+var HELPER_FRAME = /\b__VITEST_HELPER__\b/;
+function isLibraryFrame(frame) {
+  return LIBRARY_FRAME.test(frame) || HELPER_FRAME.test(frame);
+}
 function stackFrames(stack) {
   return String(stack).split("\n").filter((line) => /^\s*at\s/.test(line)).map((line) => line.trim());
 }
 function ownFrames(frames, limit) {
-  const outside = frames.filter((frame) => !LIBRARY_FRAME.test(frame));
+  const outside = frames.filter((frame) => !isLibraryFrame(frame));
   const own = outside.filter((frame) => !FOREIGN_FRAME.test(frame));
   const shown = [own, outside].find((candidates) => candidates.length > 0) ?? frames;
   return shown.slice(0, limit);
@@ -3243,12 +3247,15 @@ function looksLikeLiveHostObject(instance) {
       continue;
     }
     if (constructor.name === "EventTarget") {
-      return engineLevel;
+      return engineLevel || isEnginePrivateEventTarget(constructor);
     }
     engineLevel ||= Reflect.get(globalThis, constructor.name) === constructor;
   }
   return false;
 }
+function isEnginePrivateEventTarget(constructor) {
+  return typeof Node !== "undefined" && constructor !== Reflect.get(globalThis, "EventTarget") && Reflect.getPrototypeOf(Node.prototype) === Reflect.get(constructor, "prototype");
+}
 function warnOnUndiscriminatedHostDiscovery(label, listedAdditions) {
   const additions = listedAdditions ? "The methods listed (a bare array is methodsToSpyOn) are spied in addition to that discovery, not instead of it. " : "";
   reportMisconfiguration(

package/dist/jasmine.js

@@ -1,13 +1,13 @@
 import { enableJasmineCompat } from './chunk-3ZBRBPOL.js';
 export { enableJasmineCompat } from './chunk-3ZBRBPOL.js';
-import { createSpyFromClass } from './chunk-F4URI3UE.js';
-import { useVitestAdapter } from './chunk-YWSOJH5C.js';
-import './chunk-GTDJ22IQ.js';
+import { createSpyFromClass } from './chunk-6KP5QMMV.js';
+import { useVitestAdapter } from './chunk-YNXQ2WFH.js';
+import './chunk-B6C3K27C.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-LA2CMIPM.js';
+import { createFunctionSpy } from './chunk-RYFF55PV.js';
 import { reportMisconfiguration, misconfigurationThrows } from './chunk-Q7L4AWI7.js';
 import './chunk-M3NTXLZG.js';
 import { jasmineGlobals, jasmineClock, jasmineAutoSpies, jasmineTimeout } from './chunk-5FQZGJLJ.js';

package/dist/nestjs.js

@@ -1,13 +1,13 @@
-import { createSpyForToken } from './chunk-464WKNEQ.js';
-export { trackInjections } from './chunk-464WKNEQ.js';
-import { createSpyFromClass } from './chunk-F4URI3UE.js';
-import { useVitestAdapter } from './chunk-YWSOJH5C.js';
-import './chunk-GTDJ22IQ.js';
+import { createSpyForToken } from './chunk-2TZCJ3MM.js';
+export { trackInjections } from './chunk-2TZCJ3MM.js';
+import { createSpyFromClass } from './chunk-6KP5QMMV.js';
+import { useVitestAdapter } from './chunk-YNXQ2WFH.js';
+import './chunk-B6C3K27C.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-LA2CMIPM.js';
+import './chunk-RYFF55PV.js';
 import './chunk-Q7L4AWI7.js';
 import './chunk-M3NTXLZG.js';
 import { nestUnitRefusals } from './chunk-5FQZGJLJ.js';

package/dist/node.cjs

@@ -1240,11 +1240,15 @@ function installSettledResultsPolyfill(mockFn) {
 // src/lib/stack-frames.ts
 var FOREIGN_FRAME = /node_modules|node:internal|\(node:/;
 var LIBRARY_FRAME = /[/\\]vitest-auto-spy[/\\]dist[/\\]|[/\\]\.vite[/\\]deps[^/\\]*[/\\]vitest-auto-spy[^/\\]*\.js/;
+var HELPER_FRAME = /\b__VITEST_HELPER__\b/;
+function isLibraryFrame(frame) {
+  return LIBRARY_FRAME.test(frame) || HELPER_FRAME.test(frame);
+}
 function stackFrames(stack) {
   return String(stack).split("\n").filter((line) => /^\s*at\s/.test(line)).map((line) => line.trim());
 }
 function ownFrames(frames, limit) {
-  const outside = frames.filter((frame) => !LIBRARY_FRAME.test(frame));
+  const outside = frames.filter((frame) => !isLibraryFrame(frame));
   const own = outside.filter((frame) => !FOREIGN_FRAME.test(frame));
   const shown = [own, outside].find((candidates) => candidates.length > 0) ?? frames;
   return shown.slice(0, limit);
@@ -2863,12 +2867,15 @@ function looksLikeLiveHostObject(instance) {
       continue;
     }
     if (constructor.name === "EventTarget") {
-      return engineLevel;
+      return engineLevel || isEnginePrivateEventTarget(constructor);
     }
     engineLevel ||= Reflect.get(globalThis, constructor.name) === constructor;
   }
   return false;
 }
+function isEnginePrivateEventTarget(constructor) {
+  return typeof Node !== "undefined" && constructor !== Reflect.get(globalThis, "EventTarget") && Reflect.getPrototypeOf(Node.prototype) === Reflect.get(constructor, "prototype");
+}
 function warnOnUndiscriminatedHostDiscovery(label, listedAdditions) {
   const additions = listedAdditions ? "The methods listed (a bare array is methodsToSpyOn) are spied in addition to that discovery, not instead of it. " : "";
   reportMisconfiguration(

package/dist/node.js

@@ -1129,11 +1129,15 @@ function installSettledResultsPolyfill(mockFn) {
 // src/lib/stack-frames.ts
 var FOREIGN_FRAME = /node_modules|node:internal|\(node:/;
 var LIBRARY_FRAME = /[/\\]vitest-auto-spy[/\\]dist[/\\]|[/\\]\.vite[/\\]deps[^/\\]*[/\\]vitest-auto-spy[^/\\]*\.js/;
+var HELPER_FRAME = /\b__VITEST_HELPER__\b/;
+function isLibraryFrame(frame) {
+  return LIBRARY_FRAME.test(frame) || HELPER_FRAME.test(frame);
+}
 function stackFrames(stack) {
   return String(stack).split("\n").filter((line) => /^\s*at\s/.test(line)).map((line) => line.trim());
 }
 function ownFrames(frames, limit) {
-  const outside = frames.filter((frame) => !LIBRARY_FRAME.test(frame));
+  const outside = frames.filter((frame) => !isLibraryFrame(frame));
   const own = outside.filter((frame) => !FOREIGN_FRAME.test(frame));
   const shown = [own, outside].find((candidates) => candidates.length > 0) ?? frames;
   return shown.slice(0, limit);
@@ -2757,12 +2761,15 @@ function looksLikeLiveHostObject(instance) {
       continue;
     }
     if (constructor.name === "EventTarget") {
-      return engineLevel;
+      return engineLevel || isEnginePrivateEventTarget(constructor);
     }
     engineLevel ||= Reflect.get(globalThis, constructor.name) === constructor;
   }
   return false;
 }
+function isEnginePrivateEventTarget(constructor) {
+  return typeof Node !== "undefined" && constructor !== Reflect.get(globalThis, "EventTarget") && Reflect.getPrototypeOf(Node.prototype) === Reflect.get(constructor, "prototype");
+}
 function warnOnUndiscriminatedHostDiscovery(label, listedAdditions) {
   const additions = listedAdditions ? "The methods listed (a bare array is methodsToSpyOn) are spied in addition to that discovery, not instead of it. " : "";
   reportMisconfiguration(

package/dist/rstest.js

@@ -1,12 +1,12 @@
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-GAE5EGO7.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-5TYNQH5Q.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-FWXDSPZD.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-F4URI3UE.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-6KP5QMMV.js';
 import './chunk-W5EXSI22.js';
-import { createRunnerMockAdapter } from './chunk-GTDJ22IQ.js';
+import { createRunnerMockAdapter } from './chunk-B6C3K27C.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-LA2CMIPM.js';
+export { createFunctionSpy, errorHandler } from './chunk-RYFF55PV.js';
 import './chunk-Q7L4AWI7.js';
 import './chunk-M3NTXLZG.js';
 import './chunk-5FQZGJLJ.js';

package/dist/setup.js

@@ -1245,11 +1245,15 @@ function storagePrototype() {
 // src/lib/stack-frames.ts
 var FOREIGN_FRAME = /node_modules|node:internal|\(node:/;
 var LIBRARY_FRAME = /[/\\]vitest-auto-spy[/\\]dist[/\\]|[/\\]\.vite[/\\]deps[^/\\]*[/\\]vitest-auto-spy[^/\\]*\.js/;
+var HELPER_FRAME = /\b__VITEST_HELPER__\b/;
+function isLibraryFrame(frame) {
+  return LIBRARY_FRAME.test(frame) || HELPER_FRAME.test(frame);
+}
 function stackFrames(stack) {
   return String(stack).split("\n").filter((line) => /^\s*at\s/.test(line)).map((line) => line.trim());
 }
 function ownFrames(frames, limit) {
-  const outside = frames.filter((frame) => !LIBRARY_FRAME.test(frame));
+  const outside = frames.filter((frame) => !isLibraryFrame(frame));
   const own = outside.filter((frame) => !FOREIGN_FRAME.test(frame));
   const shown = [own, outside].find((candidates) => candidates.length > 0) ?? frames;
   return shown.slice(0, limit);
@@ -1442,12 +1446,24 @@ function recordEntry(tracking, type, listener, options) {
 function forgetEntries(tracking, type, listener, capture) {
   tracking.entries = tracking.entries.filter((entry) => entry.type !== type || entry.listener !== listener || entry.capture !== capture);
 }
+var OWN_MODULE_FRAME = /stray-listeners\.[jt]s/;
+var ENVIRONMENT_FRAME = /[/\\]node_modules[/\\](?:jsdom|happy-dom|@asamuzakjp[/\\][^/\\]+)[/\\]/;
+var environmentVerdicts = /* @__PURE__ */ new WeakMap();
+function isEnvironmentEntry(entry) {
+  let verdict = environmentVerdicts.get(entry);
+  if (verdict === void 0) {
+    const caller = stackFrames(entry.trace.stack).find((frame) => !OWN_MODULE_FRAME.test(frame) && !isLibraryFrame(frame));
+    verdict = caller !== void 0 && ENVIRONMENT_FRAME.test(caller);
+    environmentVerdicts.set(entry, verdict);
+  }
+  return verdict;
+}
 function strayEntries(tracking) {
   const { baseline } = tracking;
   if (!baseline) {
     return [];
   }
-  return tracking.entries.filter((entry) => !baseline.has(entry));
+  return tracking.entries.filter((entry) => !baseline.has(entry) && !isEnvironmentEntry(entry));
 }
 function installTracking({ name, target }) {
   const host = target;
@@ -1549,7 +1565,6 @@ function countStrayListeners(targets) {
   }
   return total;
 }
-var OWN_MODULE_FRAME = /stray-listeners\.[jt]s/;
 function describeEntry(name, entry) {
   return { target: name, type: entry.type, ...describeOriginOf(entry, OWN_MODULE_FRAME) };
 }

package/dist/{track-signal-runs-BuJk_Yi8.d.ts → track-signal-runs-C7SrW3Ub.d.ts}

@@ -456,8 +456,10 @@ interface StableOptions {
  * one component. On expiry this throws the cause instead, and names the two things that produce it.
  *
  * Pass `{ label }` when a spec awaits more than one fixture, so the failure says which.
+ *
+ * Any fixture with `whenStable()` is taken — Angular 22.2's `TestBed.createDirective` fixture too.
  */
-declare function stable(fixture: ComponentFixture<unknown>, options?: StableOptions): Promise<void>;
+declare function stable(fixture: Pick<ComponentFixture<unknown>, 'whenStable'>, options?: StableOptions): Promise<void>;
 
 /**
  * `setInputs` — change a component's inputs after it is rendered, and let Angular catch up.

package/package.json

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

@@ -110,6 +110,12 @@ describe('TaskService', () => {
 });
 ```
 
+`type Spy`, `provideAutoSpy` and `injectSpy` come from `vitest-auto-spy/angular`. Of the core it
+re-exports only the `Spy<T>` type, the `mock*Prop` helpers and the `expectEmission` family;
+`createSpyFromClass`, `createMock`, `createAutoMock`, `spyOnVoidMethod`, `spyOnOwnMethod`,
+`stubConstructor` and `asInstance` stay on `vitest-auto-spy` — keep that second import line instead
+of folding the names into the `/angular` one.
+
 One `configureTestingModule` per `describe` — reconfiguring per `it()` recompiles the module every
 test. Use `mockSignalProp(service, 'count', 0)` for a signal on a collaborator — a member that already is
 a `signal()`, `model()`, `linkedSignal()` **or a `signal().asReadonly()` view** is written through rather
@@ -281,7 +287,7 @@ it('loads', async () => {
 | the same 100-line model literal copied into eight specs (`TS1117`)                                  | one `createFixtureFactory<T>(defaults)`; specs call it with what they change                                                                                                                      |
 | `'params' in link` ladders, or a cast, to pick a union branch                                       | `narrow.byKey(link, 'params')` / `narrow.observable(x)`                                                                                                                                           |
 | `{ ...modelInstance, flag: true }` losing every getter                                              | `withOverrides(modelInstance, { flag: true })`                                                                                                                                                    |
-| `NG0303` / `NG0304` / silence from a directive spec                                                 | `createDirectiveHost({ template, scope: [Module] })`                                                                                                                                              |
+| `NG0303` / `NG0304` / silence from a directive spec                                                 | `createDirectiveHost({ template, scope: [Module] })`; Angular ≥ 22.2, no host markup needed: `TestBed.createDirective(Dir, { tagName, bindings })`, which `stable` takes                          |
 | a hand-written `class MockChartComponent` restating a child's selector                              | `createComponentStub(ChartComponent)` (`/angular`) — selector, inputs, outputs read from `ɵcmp`                                                                                                   |
 | a `TestingStorage` class for `localStorage` / `sessionStorage`                                      | `stubWebStorage('localStorage', { items })` from `/dom-stubs` — `snapshot()` to assert                                                                                                            |
 | a hand-written `MockWorker` whose `addEventListener` sets `onmessage`                               | `stubWorker({ respond })` from `/dom-stubs` — `last.emit(data)`, `last.messages`                                                                                                                  |
@@ -544,7 +550,7 @@ from `vitest-auto-spy/angular-router` rather than at `provideAutoSpy`.
 
 **`no-self-called-spy` reports a test that calls the spied method itself and then asserts that it was called** — `vi.spyOn(obj, 'm')`, then `obj.m(…)` written by the test body after it, then a positive `toHaveBeenCalled*`. Such a test proves that `emit` calls `emit`: delete the template binding or subscription its title names and it stays green. Drive the real trigger instead and keep the assertion. Order decides it, so a call written **before** the spy is arrangement and is never reported; neither is a negated matcher or `toHaveBeenCalledTimes(0)`, a call whose record a `mockClear` / `vi.clearAllMocks()` drops before the assertion reads it, an assertion whose arguments the call did not pass, a spy installed in a hook, or a call made from inside a callback.
 
-**`no-redundant-mock-reset` reports a mock reset in a hook that the runner already performs** — `vi.clearAllMocks()` / `vi.resetAllMocks()` / `vi.restoreAllMocks()` and the per-mock `mockClear()` / `mockReset()` / `mockRestore()` — as the first statement of a `beforeEach` that no other `beforeEach` precedes, or a clear as the last statement of an `afterEach`. Vitest resets in `onBeforeTryTask`, ahead of every `beforeEach` chain and never after a test, so a reset that anything ran before, or a restore in `afterEach` / `afterAll` (the only thing that takes the last test's spies off before the `afterAll` hooks), is left alone. **It is silent until it knows the configuration**: options first — `['error', { clearMocks: true, restoreMocks: true }]`, or `{ configFile: 'path/to/runner.config.ts' }` for a runner config the search cannot find — then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text; with neither, it reports nothing. The flag has to match the call, not the family: `restoreMocks` walks only the spies `vi.spyOn` installed, so it makes a `vi.clearAllMocks()` dead only where the receiver is such a spy. `--fix` deletes the line only in a file whose only before-hook it is, and offers a suggestion everywhere else; a reset in the middle of a test body is never reported, because there it separates two arrangements inside one test.
+**`no-redundant-mock-reset` reports a mock reset in a hook that the runner already performs** — `vi.clearAllMocks()` / `vi.resetAllMocks()` / `vi.restoreAllMocks()` and the per-mock `mockClear()` / `mockReset()` / `mockRestore()` — as the first statement of a `beforeEach` that no other `beforeEach` precedes, or a clear as the last statement of an `afterEach`. Vitest resets in `onBeforeTryTask`, ahead of every `beforeEach` chain and never after a test, so a reset that anything ran before, or a restore in `afterEach` / `afterAll` (the only thing that takes the last test's spies off before the `afterAll` hooks), is left alone. **It is silent until it knows the configuration**: options first — `['error', { clearMocks: true, restoreMocks: true }]`, or `{ configFile: 'path/to/runner.config.ts' }` for a runner config the search cannot find — then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text; with neither, it reports nothing. A config that leaves `clearMocks` out counts it on from Vitest 5, whose default it is; a config a factory or `mergeConfig` assembles in another module is not read through, so write its flags beside it — `{ configFile: 'vitest.config.ts', clearMocks: true }`. Pass only what the runner config sets: `setupAutoSpy({ restoreMocks: true })` restores in an `afterEach`, after the test, which is not the runner's `restoreMocks`. The flag has to match the call, not the family: `restoreMocks` walks only the spies `vi.spyOn` installed, so it makes a `vi.clearAllMocks()` dead only where the receiver is such a spy. `--fix` deletes the line only in a file whose only before-hook it is, and offers a suggestion everywhere else; a reset in the middle of a test body is never reported, because there it separates two arrangements inside one test.
 
 **`no-unasserted-argument` reports a bare `expect(spy).toHaveBeenCalled()` where the file itself says the arguments are the point** — either the same subject is pinned with `toHaveBeenCalledWith(…)` in another test of the file, or the test's title says `with` and its body asserts nothing but bare calls. Narrower than `vitest/prefer-called-with` on purpose: on one 2032-file suite that reports 1941 times in 360 files and this one 175 in 90. `not.toHaveBeenCalled()` and the counting matchers are never reported. `warn` rather than `error`, because the repair is the argument list the test should have named — `toHaveBeenCalledWith(…)`, `toHaveBeenCalledExactlyOnceWith(…)`, or `mustBeCalledWith(…)` where the double is configured — and that is the one thing the rule cannot write.