vitest-auto-spy 5.36.0 → 5.37.0

package/CHANGELOG.md

@@ -10,6 +10,52 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [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 +5420,8 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.36.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.37.0...HEAD
+[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/agent-docs/angular.md

@@ -977,6 +977,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 +1178,11 @@ _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.
 
+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/errors.md

@@ -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`. 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-6VPSS4BA.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-6VPSS4BA.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-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-GAE5EGO7.js → chunk-6VPSS4BA.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';

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

@@ -3421,7 +3421,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.35.0";
+var EXPORT_MAP_VERSION = "5.36.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 +3701,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",

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);

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);

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);

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-6VPSS4BA.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.37.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

@@ -281,7 +281,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 +544,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 }`. 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.