vitest-auto-spy 3.17.0 → 3.18.0

package/AGENTS.md

@@ -2020,6 +2020,56 @@ and type the value against the member's **own** type. For a signal-valued member
 `mockSignalProp(service, 'state', initial)` over `gettersToSpyOn`: a spied getter returns `undefined`
 until configured, a real signal keeps everything downstream reactive.
 
+**A spec importing `@ngneat/spectator`** is on a package whose repository is a 404 and which does not
+resolve on Angular 22 (it imports `@angular/platform-browser-dynamic/testing` without declaring it).
+`createSpyObject` → `createSpyFromClass`, `mockProvider` → `provideAutoSpy`, `spectator.inject` →
+`injectSpy`, `SpyObject<T>` → `Spy<T>`, `createComponentFactory` → `renderShallow`. There is no
+replacement here for `spectator.query`, the event helpers or the DOM matchers — leave those on
+`@testing-library/angular` rather than inventing an equivalent. Full mapping:
+[Migrating from @ngneat/spectator](https://asdalexey.github.io/vitest-auto-spy/migrating-spectator).
+
+A suite coming off [`@suites/unit`](https://github.com/suites-dev/suites) maps one to one:
+`TestBed.solitary(S).compile()` → `createNestUnit(S)`, `TestBed.sociable(S).expose(D).compile()` →
+`createNestUnit(S, { expose: [D] })`, `unitRef.get` → `spies.get`, `.final(v)` →
+`{ provide, useValue }`, and the `await` goes away because the graph is built synchronously. The one
+thing to check by hand after the swap: Suites' double answers every property name, so a spec that
+stubbed a since-renamed method was passing over nothing and will now fail. Full mapping:
+<https://asdalexey.github.io/vitest-auto-spy/migrating-suites>.
+
+- **`renderShallow` has no single speed number, and quoting one is a bug.** Per render it ranges
+  from 1.2× (no children) to 16.2× (400 child instances) — `docs-site/core/performance.md`,
+  measured 2026-08-26. Per spec file, where imports and the `TestBed` module are also on the clock,
+  the published conversion is 1.7× over three specs with one of them a 0.8× regression. The two are
+  not interchangeable: the per-render ratio is the upper bound on what a file can gain. Any surface
+  that mentions the helper's speed quotes the range and links to
+  `/core/performance#_2-rendering-the-child-subtree`. A figure of **4.1×** appears in
+  `PRIORITIES.md` and is backed by nothing in this repository — do not publish it until someone
+  produces the measurement.
+- **Competitor defects are quoted from the published tarball, with a file, a line and a date.** The
+  `@testing-library/angular` `createMock` claims in `docs-site/comparison.md` are pinned to
+  `fesm2022/testing-library-angular-vitest-utils.mjs` lines 14 and 18 at 19.4.2. Re-`npm pack` and
+  re-read before restating them against a new version; the "Where the numbers come from" box records
+  each re-verification date rather than replacing the previous one.
+
+`node:test` keeps every `mock.fn()` in one process-wide `MockTracker` for the life of the process.
+On a long suite that is real memory — 20 000 spies of a 10-method class retained 124.5 MB on
+Node v24.19.0. `trackNodeMocks()` puts this library's spies on a tracker it owns and replaces it per
+test: 5.9 MB for the same run, against a 5.4 MB baseline.
+
+\```ts
+import { before } from 'node:test';
+import { trackNodeMocks } from 'vitest-auto-spy/node';
+
+before(() => trackNodeMocks()); // opt-in, idempotent, returns the undo
+
+// by hand, for a concurrent suite: pruneNodeMocks() → how many were dropped; countNodeMocks() → how many are held
+\```
+
+It never calls `mock.reset()` — that would restore and forget the `mock.fn()` the spec made itself —
+and it never throws: the class is reached through the undocumented `mock.constructor`, so the
+constructed tracker is probed first and any failure leaves spies on `node:test`'s own tracker.
+Spies created **before** the call stay there too. `mock.reset()` in `afterEach` is the fallback.
+
 ---
 
 ## 14. `fakeAsync` needs `vitest-auto-spy/zone`

package/README.md

@@ -49,13 +49,19 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 - 🎯 Return-type-aware helpers — sync, `Promise`, and `Observable` all get the right API
 - 🔀 `calledWith` / `mustBeCalledWith` argument dispatch
 - 📡 First-class RxJS `Observable` spying (`nextWith`, `nextWithValues`, `throwWith`, …)
-- ⚙️ Getter / setter spies via `accessorSpies`
+- ⚙️ Getter / setter spies via `accessorSpies` — **including on Bun**, where `bun:test`'s own `spyOn(obj, 'prop', 'get')` throws _"does not support accessor properties yet"_ (verified on Bun 1.4.0); no library that generates a double from a class or a type has accessor spies on any runner
 - 🧰 DI & mocking utilities — `provideAutoSpy` / `injectSpy` (Angular, NestJS, Vue), `createFunctionSpy`, `mockReadonlyProp` for signals
-- ⚡ Angular speed & zoneless helpers — `renderShallow` (**1.7×** on real component specs), `createWithAutoSpies`, `stable` / `flushEffects`, `settleResource` for `httpResource()`, `toHaveSignalValue`, per-file `TestBed` timings
+- ⚡ Angular speed & zoneless helpers — `renderShallow` (**1.7×** across three converted specs of a real suite; per render, **1.2×** on a childless leaf up to **16.2×** on a 400-child tree — [both measurements below](#shallow-component-rendering)), `createWithAutoSpies`, `stable` / `flushEffects`, `settleResource` for `httpResource()`, `toHaveSignalValue`, per-file `TestBed` timings
+- **`node:test` stops retaining every spy.** Node's built-in runner keeps every `mock.fn()` in one
+  process-wide `MockTracker` and has no way to drop a single entry, so a long suite accumulates every
+  spy it ever made along with every argument they recorded. `trackNodeMocks()` gives this library a
+  tracker of its own and replaces it after each test — 124.5 MB retained down to 5.9 MB on 20 000
+  spies of a 10-method class (Node v24.19.0, `--expose-gc`, 5.4 MB baseline). It never calls
+  `mock.reset()`, so a `mock.fn()` your spec made by hand is untouched.
 - 🌐 `httpResource()` and `HttpClient` in two lines — `provideHttpTesting()` + `await expectRequest(url).flush(body)` does the tick, the controller, the `expectOne`, the flush **and the settling**, so `resource.value()` reads on the next line; `@angular/common` stays an optional peer, confined to the `/angular-http` entry
 - 🪆 NestJS units from their own DI metadata — `createNestUnit(Target, { expose, providers })`, the solitary / sociable model of `@suites/unit` with the real prototype behind every spy and no `@nestjs` dependency
 - 🧱 The providers a testing module cannot reach — `overrideComponentProvider` (which verifies the override actually applied), `provideAutoSpyForToken`, `assertNgModuleScopes`, `assertComponentDefIntact`, `createDirectiveHost`
-- 🚨 Failures that used to be silence — `enableAngularDiagnostics()` for dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests; `trackInjections` for which collaborators the code actually asked for
+- 🚨 Failures that used to be silence — `enableAngularDiagnostics()` for dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests; `trackInjections` for which collaborators the code actually asked for. `injectSpy` already warns once per token when DI handed back a real instance, naming the token and the missing `provideAutoSpy` — where Spectator's `inject<T>(token): SpyObject<T>` types **every** token as a spy whether it was mocked or not, so the compiler hides the same mistake
 - 🔒 [Strict doubles](#strict-doubles--fail-on-a-method-nobody-configured) — `strict: true` / `onUnstubbedCall` fail on a method nobody configured, naming the class, the method and the arguments instead of answering `undefined`
 - ♻️ `using spy = createSpyFromClass(X)` — every double carries `[Symbol.dispose]`, so the `afterEach` that only reset one spy can go
 - 📡 Observable assertions that fail on silence — `expectEmission` / `expectEmissions` / `expectNoEmission` / `expectCompletion` / `expectError`, no rxjs required, Angular `output()` included
@@ -112,8 +118,10 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
   - [Runtimes](#runtimes)
 - [Angular on Bun (`bun:test`)](#angular-on-bun-buntest)
 - [Comparison](#comparison)
+  - [@testing-library/angular /vitest-utils](#testing-libraryangular-vitest-utils)
 - [Migrating from jest-auto-spies](#migrating-from-jest-auto-spies)
 - [Migrating from jasmine-auto-spies](#migrating-from-jasmine-auto-spies)
+- [Migrating from @ngneat/spectator](https://asdalexey.github.io/vitest-auto-spy/migrating-spectator)
 - [Configuration](#configuration)
   - [Spying instance-assigned callables (`signal()`, arrow props, `signalStore()`)](#spying-instance-assigned-callables-signal-arrow-props-signalstore)
   - [Strict doubles — fail on a method nobody configured](#strict-doubles--fail-on-a-method-nobody-configured)
@@ -929,7 +937,7 @@ Node / Bun / React / Vue project pulls **neither rxjs nor Angular into its runti
 | `vitest-auto-spy/angular-http`   | `provideHttpTesting`, `expectRequest`, `expectNoRequest`, `verifyNoPendingRequests` — the `httpResource()` / `HttpClient` recipe in two lines, settling included                                               | `@angular/common`           |   ✅   |
 | `vitest-auto-spy/bun`            | the same core, driven by Bun's `bun:test` mocks                                                                                                                                                                | `bun:test`                  |   ✅   |
 | `vitest-auto-spy/bun-angular`    | Angular's `TestBed` under `bun test` — DOM, JIT `templateUrl` resolution and a zoneless environment, from one preload                                                                                          | `bun:test`, `@angular/core` |   ✅   |
-| `vitest-auto-spy/node`           | the same core, driven by `node:test`'s `mock.fn()`                                                                                                                                                             | `node:test`                 |   ✅   |
+| `vitest-auto-spy/node`           | the same core, driven by `node:test`'s `mock.fn()`, plus `trackNodeMocks()` — a private `MockTracker` so dropped spies are actually freed                                                                      | `node:test`                 |   ✅   |
 | `vitest-auto-spy/nestjs`         | `provideAutoSpy`, `injectSpy` for `Test.createTestingModule`                                                                                                                                                   | — (your `@nestjs/*`)        |   ✅   |
 | `vitest-auto-spy/react`          | the core, with a natural import for React Testing Library suites                                                                                                                                               | — (your `react`)            |   ✅   |
 | `vitest-auto-spy/vue`            | `provideAutoSpy` for `global.provide` + Pinia store spying                                                                                                                                                     | — (your `vue`/`pinia`)      |   ✅   |
@@ -1070,6 +1078,7 @@ Full recipe, including building your own preload:
 | [@bugsplat/vitest-auto-spies](https://www.npmjs.com/package/@bugsplat/vitest-auto-spies) |       ✅       |             ✅             | Vitest only              | Same class-based API **plus** Bun & `node:test`, [type-only `createAutoMock`](#auto-mock-by-type-no-class-needed), framework recipes (Angular/NestJS/React/Vue/Svelte), console spies, and **zero runtime deps** (it depends on `@hirez_io/auto-spies-core`) |
 | [vitest-mock-extended](https://www.npmjs.com/package/vitest-mock-extended)               |   ❌ (Proxy)   |             ❌             | Vitest                   | Return-type ergonomics **and** reading a real class (we also ship a Proxy mode: [`createAutoMock`](#auto-mock-by-type-no-class-needed))                                                                                                                      |
 | [@golevelup/ts-vitest](https://www.npmjs.com/package/@golevelup/ts-vitest)               |    partial     |             ❌             | Vitest                   | Typed `Promise`/`Observable` helpers + explicit class→spy + `mustBeCalledWith`                                                                                                                                                                               |
+| [@testing-library/angular](https://www.npmjs.com/package/@testing-library/angular)       |       ✅       |             ❌             | Vitest · Jest            | Its `/vitest-utils` `createMock` is the same eager prototype walk, minus two things — verified in the 19.4.2 tarball on 2026-09-02, [below](#testing-libraryangular-vitest-utils)                                                                            |
 | [sinon](https://www.npmjs.com/package/sinon)                                             |  ❌ (manual)   |             ❌             | Any                      | Auto-generated + fully typed vs. manual + loosely typed                                                                                                                                                                                                      |
 
 **The pitch:** the only auto-spy library that reads a **class** and gives a **fully-typed** spy of
@@ -1079,6 +1088,26 @@ across any Vitest-compatible runtime and framework.
 Feature-by-feature breakdown, and where another library is the better answer:
 [Comparison](https://asdalexey.github.io/vitest-auto-spy/comparison).
 
+### @testing-library/angular /vitest-utils
+
+Usually filed as complementary — its rendering API genuinely is a different discipline — but its
+`/vitest-utils` entry point exports `createMock` / `provideMock`, which do the same job as
+`createSpyFromClass` / `provideAutoSpy`. Reading the published 19.4.2 tarball on **2026-09-02**,
+`fesm2022/testing-library-angular-vitest-utils.mjs`:
+
+- **Accessors are skipped silently** (line 14): the walk assigns a mock only when
+  `typeof descriptor?.value === 'function'`, and a getter's descriptor has no `value`. So a
+  service's `get isLoggedIn()` is simply absent from the double, while its `Mock<T>` type —
+  `T & { [K in keyof T]: T[K] & Mock }` — types it as callable anyway.
+- **No `Object.prototype` guard** (line 18): `mockFunctions(Object.getPrototypeOf(proto))` recurses
+  until the prototype is `null`, so `hasOwnProperty`, `toString`, `valueOf` and `isPrototypeOf` end
+  up as `vi.fn()` on the double.
+
+It is also the only library in this field with **zoneless support** — a `./zoneless` entry point
+since 19.2.0 (2026-03-17), present in the tarball's `exports` map. That is a real point in its
+favour. Full write-up, including ng-mocks and Spectator:
+[Comparison → Angular](https://asdalexey.github.io/vitest-auto-spy/comparison#angular).
+
 ## Migrating from jest-auto-spies
 
 The public API is intentionally identical. In most projects the migration is a
@@ -1188,6 +1217,19 @@ arrives with a `{ get: vi.fn(), post: vi.fn() }` literal per double and up to th
 [After Angular's refactor-jasmine-vitest](https://asdalexey.github.io/vitest-auto-spy/migrating-angular-schematic),
 with the schematic's real output beside `createSpyFromClass(Api)`.
 
+A suite coming off [`@ngneat/spectator`](https://www.npmjs.com/package/@ngneat/spectator) — 739 852
+downloads a month on a package whose repository returns 404 and which fails to resolve on a clean
+Angular 22 install — has its own page,
+[Migrating from @ngneat/spectator](https://asdalexey.github.io/vitest-auto-spy/migrating-spectator),
+with the `createSpyObject` → `createSpyFromClass` and `mockProvider` → `provideAutoSpy` mapping, and
+an honest account of the component-rendering half this library does not replace.
+
+Coming from [`@suites/unit`](https://github.com/suites-dev/suites)? `TestBed.solitary(S).compile()`
+is `createNestUnit(S)` and `TestBed.sociable(S).expose(D).compile()` is
+`createNestUnit(S, { expose: [D] })`, minus the `await` — the whole mapping, including what each side
+refuses, is in
+[Migrating from @suites/unit](https://asdalexey.github.io/vitest-auto-spy/migrating-suites).
+
 ## Configuration
 
 ```ts
@@ -1662,6 +1704,26 @@ pays where there is a real child tree to skip** — the seven untouched files in
 by ±10%, which is this suite's run-to-run noise, so the two wins are outside it and the one
 regression is only just outside.
 
+**Why 1.7× and not more.** That row is a whole spec file's wall clock — imports, the `TestBed`
+module, the assertions — of which rendering is only a part. Isolated to the render itself, the
+saving tracks the size of the subtree removed, measured on 2026-08-26 on a component holding two
+`@for` tables whose row count is varied:
+
+| Child instances | `TestBed.createComponent` | `renderShallow` | Ratio |
+| --------------: | ------------------------: | --------------: | ----: |
+|               0 |                   0.65 ms |         0.55 ms |  1.2× |
+|              10 |                   1.00 ms |         0.55 ms |  1.8× |
+|             100 |                   2.72 ms |         0.48 ms |  5.7× |
+|             400 |                   8.52 ms |         0.53 ms | 16.2× |
+
+`renderShallow` is flat at ~0.5 ms because it never builds the subtree; `createComponent` scales
+linearly with it. So there is no single "renderShallow is N× faster" number — a leaf component has
+nothing to save, and a table or a dashboard is an order of magnitude. Treat the ratios as the
+result, not the absolute times, and pick files to convert with the diagnostics below rather than by
+guessing. `keepTemplate: true` is the middle rung — the component's own template with an empty
+subtree, 1.933 ms → 1.074 ms (1.8×), measured 2026-08-30. Full write-up:
+[Performance](https://asdalexey.github.io/vitest-auto-spy/core/performance#_2-rendering-the-child-subtree).
+
 Use [the diagnostics](#where-a-spec-spends-its-time) to find the files worth converting rather than
 guessing: across those ten files `TestBed` accounted for 820 ms of 3231 ms (25%), but per file the
 share ranged from 13% to 66%.
@@ -2118,6 +2180,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `setupAngularTestEnv(opts)`                                                              | `/angular`                    | Zone and zoneless spec files in one worker, switching platforms per file                                                                                                                              |
 | `restoreTimerGlobals()`                                                                  | `/setup`                      | Put back timer globals that uninstalling the fakes deleted rather than restored                                                                                                                       |
 | `trackMockRegistry()` / `keepMockRegistered(mock)` / `restoreLongLivedImplementations()` | `/setup`                      | Keep @vitest/spy's mock registry to the mocks that outlive a file; mark one the split would miss; put back an implementation a cross-file `vi.resetAllMocks()` dropped ([details](#test-run-hygiene)) |
+| `trackNodeMocks()` / `pruneNodeMocks()` / `countNodeMocks()`                             | `/node`                       | Give this library its own `node:test` `MockTracker` so a dropped spy is freed — 21× less retained heap; sweep by hand, and read the count back                                                        |
 | `errorHandler`                                                                           | core                          | The `mustBeCalledWith` argument-mismatch reporter — swap it to customize failure output                                                                                                               |
 
 A taste of the DI pair — provide the spy, inject it back fully typed:
@@ -2339,6 +2402,30 @@ grows by hundreds of megabytes with no plateau, the first evaluation writes one
 naming the version, both exits and the opt-out (`angularBuildHint: false`) — see
 [the Angular page](https://asdalexey.github.io/vitest-auto-spy/adapters/angular#when-the-unit-test-build-has-code-splitting-off).
 
+#### `node:test` retains every mock
+
+Node's runner registers every `mock.fn()` in a module-level `MockTracker` and keeps it for the life
+of the process; nothing removes one entry, and `mock.reset()` — the only thing that empties the list
+— restores and forgets the mocks your spec made by hand along with the library's.
+
+`trackNodeMocks()` sidesteps that. The library creates its spies on a `MockTracker` it owns and
+replaces that tracker after every test, so the retired one is collected with everything in it.
+Measured on Node v24.19.0, 20 000 spies of a 10-method class across 20 tests: **124.5 MB → 5.9 MB**
+(5.4 MB baseline). It is opt-in, idempotent, reversible, and a no-op on any runtime that will not
+give up the class — spies keep going where they go today.
+
+```js
+import { before } from 'node:test';
+import { trackNodeMocks } from 'vitest-auto-spy/node';
+
+before(() => {
+  trackNodeMocks();
+});
+```
+
+`mock.reset()` in `afterEach` remains the fallback for a suite that would rather not call anything.
+Vitest and Bun drop their own registries between files, so none of this applies to them.
+
 ## Fake timers
 
 ```ts

package/dist/angular.d.ts

@@ -1,10 +1,10 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-T3bgwkwb.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-D_hHdObW.js';
 import { InjectionToken, Provider, Type, Signal, WritableSignal } from '@angular/core';
 import { TestAPI } from 'vitest';
-import { C as ClassType, S as Spy, c as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-jaazRXzU.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-B3FT649L.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
-export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
+import { C as ClassType, S as Spy, j as ClassSpyConfiguration, O as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-BvbrSBUX.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CzzXQwTl.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
+export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
 import '@angular/core/testing';
 import 'rxjs';
 

package/dist/bun-angular.d.ts

@@ -1,9 +1,9 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, c as ClassSpyConfiguration, C as ClassType, a as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as ClassSpyConfiguration, C as ClassType, k as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-T3bgwkwb.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-D_hHdObW.js';
 import 'rxjs';
 import 'vitest';
 import '@angular/core';

package/dist/bun.d.ts

@@ -1,7 +1,7 @@
-import { t as SpyOptions, C as ClassType, c as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, m as DeepPartial, D as DeepMockProxy, F as Func, v as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-jaazRXzU.js';
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, k as AddThrowHelper, l as AddVoidReturnHelpers, a as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, n as Mutable, N as NextValueConfig, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, s as SpyDisposable, u as StrictSpyConfiguration, U as UnstubbedCall, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+import { s as SpyOptions, C as ClassType, j as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, l as DeepPartial, D as DeepMockProxy, F as Func, u as UnstubbedCallHandler, g as AddSpyMethodsByReturnTypes } from './types-BvbrSBUX.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, h as AddThrowHelper, i as AddVoidReturnHelpers, k as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, m as Mutable, N as NextValueConfig, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, r as SpyDisposable, t as StrictSpyConfiguration, U as UnstubbedCall, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import { Mock } from 'vitest';
 import 'rxjs';

package/dist/console.d.ts

@@ -1,4 +1,4 @@
-import { j as AddSpyMethodsByReturnTypes } from './types-jaazRXzU.js';
+import { g as AddSpyMethodsByReturnTypes } from './types-BvbrSBUX.js';
 import 'rxjs';
 import 'vitest';
 

package/dist/{expect-emission-CQkhGiYJ.d.ts → expect-emission-C-IjL1J2.d.ts}

@@ -1,4 +1,4 @@
-import { u as StrictSpyConfiguration, o as OnlyObservablePropsOf, M as MethodReturns, m as DeepPartial, S as Spy, t as SpyOptions } from './types-jaazRXzU.js';
+import { t as StrictSpyConfiguration, n as OnlyObservablePropsOf, M as MethodReturns, l as DeepPartial, S as Spy, s as SpyOptions } from './types-BvbrSBUX.js';
 
 /**
  * Create a fully-typed auto-mock of `T` from its type alone (no class).

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, c as ClassSpyConfiguration, C as ClassType, a as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as ClassSpyConfiguration, C as ClassType, k as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/jasmine-compat.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { Mock } from 'vitest';
-import { F as Func, j as AddSpyMethodsByReturnTypes, i as AddPromiseSpyMethods, A as AddObservableSpyMethods, s as SpyDisposable } from './types-jaazRXzU.js';
+import { F as Func, g as AddSpyMethodsByReturnTypes, f as AddPromiseSpyMethods, e as AddObservableSpyMethods, r as SpyDisposable } from './types-BvbrSBUX.js';
 
 /**
  * Install the `.and`, `.calls` and `.withArgs` namespaces on every spy built afterwards.

package/dist/jasmine.d.ts

@@ -1,7 +1,7 @@
 import { JasmineSpy, JasmineMethodSpy } from './jasmine-compat.js';
 export { JasmineAccessorSpies, JasmineAccessorSpy, JasmineAnd, JasmineCallInfo, JasmineCalls, JasmineNamespaces, JasmineStrategies, JasmineWithArgsAnd, JasmineWithArgsSync, enableJasmineCompat } from './jasmine-compat.js';
-import { C as ClassType, c as ClassSpyConfiguration, O as OnlyMethodKeysOf, F as Func } from './types-jaazRXzU.js';
-export { o as OnlyObservablePropsOf, p as OnlyPropsOf } from './types-jaazRXzU.js';
+import { C as ClassType, j as ClassSpyConfiguration, O as OnlyMethodKeysOf, F as Func } from './types-BvbrSBUX.js';
+export { n as OnlyObservablePropsOf, o as OnlyPropsOf } from './types-BvbrSBUX.js';
 import { expect } from 'vitest';
 import 'rxjs';
 

package/dist/nestjs.d.ts

@@ -1,5 +1,5 @@
-import { C as ClassType, S as Spy, c as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-jaazRXzU.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-B3FT649L.js';
+import { C as ClassType, S as Spy, j as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-BvbrSBUX.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CzzXQwTl.js';
 import 'rxjs';
 import 'vitest';
 

package/dist/node.cjs

@@ -214,6 +214,99 @@ function createNodeMockAdapter(nodeTest) {
   );
 }
 
+// src/lib/node-mock-tracker.ts
+var host;
+var owned;
+var created = 0;
+var sweepInstalled = false;
+function asNodeTestApi(tracker) {
+  return tracker;
+}
+function probeTracker(candidate) {
+  const create = Reflect.get(candidate, "fn");
+  if (typeof create !== "function") {
+    return void 0;
+  }
+  const probe = Reflect.apply(create, candidate, []);
+  if (typeof probe !== "function") {
+    return void 0;
+  }
+  probe();
+  const calls = Reflect.get(Object(Reflect.get(probe, "mock")), "calls");
+  return Array.isArray(calls) && calls.length === 1 ? asNodeTestApi(candidate) : void 0;
+}
+function constructPrivateTracker() {
+  const runtime = host;
+  if (runtime === void 0) {
+    return void 0;
+  }
+  try {
+    const Tracker = Reflect.get(runtime.mock, "constructor");
+    return typeof Tracker === "function" ? probeTracker(Object(Reflect.construct(Tracker, []))) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var stopTracking = () => {
+  owned = void 0;
+  created = 0;
+};
+var stopNothing = () => void 0;
+function installSweep() {
+  const runtime = host;
+  if (sweepInstalled || runtime?.afterEach === void 0) {
+    return;
+  }
+  sweepInstalled = true;
+  runtime.afterEach(() => {
+    pruneNodeMocks();
+  });
+}
+function createSwappableNodeTracker(nodeTest) {
+  host = nodeTest;
+  owned = void 0;
+  created = 0;
+  return {
+    fn: (implementation) => {
+      const tracker = owned;
+      if (tracker === void 0) {
+        return nodeTest.mock.fn(implementation);
+      }
+      created += 1;
+      return tracker.fn(implementation);
+    }
+  };
+}
+function pruneNodeMocks() {
+  if (owned === void 0) {
+    return 0;
+  }
+  const fresh = constructPrivateTracker();
+  if (fresh === void 0) {
+    return 0;
+  }
+  const dropped = created;
+  owned = fresh;
+  created = 0;
+  return dropped;
+}
+function trackNodeMocks() {
+  if (owned !== void 0) {
+    return stopTracking;
+  }
+  const tracker = constructPrivateTracker();
+  if (tracker === void 0) {
+    return stopNothing;
+  }
+  owned = tracker;
+  created = 0;
+  installSweep();
+  return stopTracking;
+}
+function countNodeMocks() {
+  return owned === void 0 ? 0 : created;
+}
+
 // src/lib/spy-mark.ts
 var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
 var DEEP_CHILDREN = /* @__PURE__ */ Symbol.for("vitest-auto-spy.deepChildren");
@@ -278,13 +371,13 @@ function createAccessorsSpies(autoSpy, gettersToSpyOn, settersToSpyOn) {
 
 // src/lib/dispose-symbol.ts
 var NODE_DISPOSE_KEY = "nodejs.dispose";
-function installDisposeSymbol(host) {
-  const existing = Reflect.get(host, "dispose");
+function installDisposeSymbol(host2) {
+  const existing = Reflect.get(host2, "dispose");
   if (typeof existing === "symbol") {
     return existing;
   }
   const shim = Symbol.for(NODE_DISPOSE_KEY);
-  Object.defineProperty(host, "dispose", { value: shim, enumerable: false, configurable: true, writable: false });
+  Object.defineProperty(host2, "dispose", { value: shim, enumerable: false, configurable: true, writable: false });
   return shim;
 }
 var DISPOSE = installDisposeSymbol(Symbol);
@@ -538,8 +631,8 @@ function readDefiner(candidate) {
   }
   return define;
 }
-function findHelperDefiner(host) {
-  const index = Reflect.get(host, "__vitest_index__");
+function findHelperDefiner(host2) {
+  const index = Reflect.get(host2, "__vitest_index__");
   const namespace = typeof index === "object" && index !== null ? Reflect.get(index, "vi") : void 0;
   return readDefiner(namespace);
 }
@@ -783,15 +876,15 @@ function ensureCalledWithObject(state, chain) {
   if (existing) {
     return existing;
   }
-  const created = { argsToValuesMap: new ArgsMap() };
-  state[chain] = created;
-  return created;
+  const created2 = { argsToValuesMap: new ArgsMap() };
+  state[chain] = created2;
+  return created2;
 }
 var FunctionSpyInternals = class {
-  constructor(state, valueContainer, host, dispatch, recorder) {
+  constructor(state, valueContainer, host2, dispatch, recorder) {
     this.state = state;
     this.valueContainer = valueContainer;
-    this.host = host;
+    this.host = host2;
     this.dispatch = dispatch;
     this.recorder = recorder;
     this.observable = void 0;
@@ -2270,9 +2363,9 @@ function stateOf(element, duration) {
   if (existing) {
     return existing;
   }
-  const created = { ...DEFAULT_STATE, duration };
-  states.set(element, created);
-  return created;
+  const created2 = { ...DEFAULT_STATE, duration };
+  states.set(element, created2);
+  return created2;
 }
 var ANNOUNCEMENTS = [
   (next) => next.duration === void 0 ? void 0 : "durationchange",
@@ -2527,7 +2620,7 @@ function resizeEntry(target, rect = {}) {
 }
 
 // src/node.ts
-registerMockAdapter(createNodeMockAdapter(node_test.mock));
+registerMockAdapter(createNodeMockAdapter(createSwappableNodeTracker({ mock: node_test.mock, afterEach: node_test.afterEach })));
 
 exports.asInstance = asInstance;
 exports.asInstances = asInstances;
@@ -2538,6 +2631,7 @@ exports.captureArg = captureArg;
 exports.clearAutoSpy = clearAutoSpy;
 exports.compareTestRuns = compareTestRuns;
 exports.countMockedProps = countMockedProps;
+exports.countNodeMocks = countNodeMocks;
 exports.createAutoMock = createAutoMock;
 exports.createFixture = createFixture;
 exports.createFixtureFactory = createFixtureFactory;
@@ -2567,6 +2661,7 @@ exports.mockValueProp = mockValueProp;
 exports.moduleNamespace = moduleNamespace;
 exports.mutationRecord = mutationRecord;
 exports.narrow = narrow;
+exports.pruneNodeMocks = pruneNodeMocks;
 exports.resetAutoSpy = resetAutoSpy;
 exports.resizeEntry = resizeEntry;
 exports.restoreMockedProps = restoreMockedProps;
@@ -2580,4 +2675,5 @@ exports.stubMutationObserver = stubMutationObserver;
 exports.stubObserver = stubObserver;
 exports.stubResizeObserver = stubResizeObserver;
 exports.summarizeTestRun = summarizeTestRun;
+exports.trackNodeMocks = trackNodeMocks;
 exports.withOverrides = withOverrides;

package/dist/node.d.cts

@@ -17,6 +17,7 @@ export declare const captureArg: typeof Entry.captureArg;
 export declare const clearAutoSpy: typeof Entry.clearAutoSpy;
 export declare const compareTestRuns: typeof Entry.compareTestRuns;
 export declare const countMockedProps: typeof Entry.countMockedProps;
+export declare const countNodeMocks: typeof Entry.countNodeMocks;
 export declare const createAutoMock: typeof Entry.createAutoMock;
 export declare const createFixture: typeof Entry.createFixture;
 export declare const createFixtureFactory: typeof Entry.createFixtureFactory;
@@ -46,6 +47,7 @@ export declare const mockValueProp: typeof Entry.mockValueProp;
 export declare const moduleNamespace: typeof Entry.moduleNamespace;
 export declare const mutationRecord: typeof Entry.mutationRecord;
 export declare const narrow: typeof Entry.narrow;
+export declare const pruneNodeMocks: typeof Entry.pruneNodeMocks;
 export declare const resetAutoSpy: typeof Entry.resetAutoSpy;
 export declare const resizeEntry: typeof Entry.resizeEntry;
 export declare const restoreMockedProps: typeof Entry.restoreMockedProps;
@@ -59,4 +61,5 @@ export declare const stubMutationObserver: typeof Entry.stubMutationObserver;
 export declare const stubObserver: typeof Entry.stubObserver;
 export declare const stubResizeObserver: typeof Entry.stubResizeObserver;
 export declare const summarizeTestRun: typeof Entry.summarizeTestRun;
+export declare const trackNodeMocks: typeof Entry.trackNodeMocks;
 export declare const withOverrides: typeof Entry.withOverrides;

package/dist/node.d.ts

@@ -1,7 +1,101 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, c as ClassSpyConfiguration, C as ClassType, a as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as ClassSpyConfiguration, C as ClassType, k as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';
+
+/**
+ * Keeping `node:test`'s process-wide `MockTracker` from holding every spy the library ever made.
+ *
+ * `node:test` exports one lazily-built `MockTracker` as `mock`, and every `mock.fn()` is pushed onto
+ * its private `#mocks` array so that `mock.reset()` can restore them later. Nothing is ever spliced
+ * out: `restoreAll()` walks the array without emptying it, `reset()` is the only line that assigns
+ * `#mocks = []`, and there is no per-entry removal. So a spy stays reachable from a module-level
+ * object for the life of the process even after the spec that made it is gone, and with it
+ * everything the spy closed over — its recorded arguments, and through them whole object graphs.
+ * Measured on Node v24.19.0: 200 000 spies created and dropped, then forced collections, held
+ * **148.5 MB**.
+ *
+ * The registry cannot be pruned the way {@link ../lib/mock-registry} prunes `@vitest/spy`'s. That
+ * one works because `vi.clearAllMocks()` iterates a plain `Set` and `Set.prototype.forEach` hands
+ * the set to its callback; `#mocks` is a hard private field appended through the **primordial**
+ * `ArrayPrototypePush`, which ignores prototype patches, and no public method removes one entry.
+ *
+ * What is available instead is a boundary. `MockTracker` is an ordinary class — `mock.constructor`
+ * **is** it — and `createNodeMockAdapter()` already takes the tracker as a parameter, so the library
+ * can own an instance the user never shares and simply let go of it. That is the whole mechanism:
+ * spies are created on a private tracker, and per test the tracker is **replaced** with a fresh one.
+ * The retired instance and its array become garbage together. Measured the same way, on the same
+ * machine: 600 000 spies routed through private trackers left **4.7 MB** against a 4.4 MB baseline.
+ *
+ * **Replace rather than `reset()`, and that is the point of the design.** `MockTracker#reset()`
+ * always runs `restoreAll()` first — the two cannot be separated through the public surface — so a
+ * `mockImplementation()` a spec applied to a spy that is still in use would be undone underneath it.
+ * Dropping the tracker instead touches no spy at all: a `node:test` mock keeps recording calls and
+ * keeps its implementation after its tracker is gone, because the tracker exists only for
+ * restore/reset. That is also why none of `mock-registry.ts`'s long-lived classification is needed
+ * here — there is no way for a dropped spy to start misbehaving, so there is nothing to exempt.
+ *
+ * **Why it is opt-in, and why every step is guarded.** `mock.constructor` is the constructor of a
+ * value a public API returns, not documented API. It has been `MockTracker` at v22.21.0, v24.19.0
+ * and v26.8.1, but it is not a contract, and this module is reached by every `vitest-auto-spy/node`
+ * consumer on import. So a tracker is constructed only when {@link trackNodeMocks} asks for one, the
+ * construction is probed before a single spy is routed at it, and every failure — a constructor that
+ * is not one, a throw, a runtime that is not `node:test` at all — leaves spies going to the
+ * runtime's own `mock` exactly as they do today. A slower run beats a broken one.
+ */
+
+/** Undo {@link trackNodeMocks}: spies go back to the runtime's own tracker from the next one on. */
+type StopTrackingNodeMocks = () => void;
+/**
+ * Drop the private tracker and start a fresh one, and report how many spies went with it.
+ *
+ * Answers `0` when tracking is off, and when a replacement could not be built — in which case the
+ * current tracker is kept, because a tracker that grows is better than no tracker at all.
+ *
+ * Installed on `afterEach` by {@link trackNodeMocks}; call it directly to sweep at some other
+ * moment, such as the end of a file in a suite that runs its tests concurrently.
+ */
+declare function pruneNodeMocks(): number;
+/**
+ * Give this library a `MockTracker` of its own, so its spies never enter the process-wide one.
+ *
+ * Opt-in: a `node:test` suite that does nothing keeps today's behaviour exactly. Idempotent — a
+ * second call installs nothing further and hands back the same stop — and reversible, which is the
+ * shape `trackStrayTimers()` and `trackMockRegistry()` already use.
+ *
+ * Spies created **before** this call stay on the runtime's tracker; call it once, as early as the
+ * file's imports allow.
+ *
+ * If the runtime will not give up its `MockTracker` class, this is a no-op that reports itself as
+ * one by handing back a stop that does nothing — spies keep going to `node:test`'s own tracker, and
+ * `mock.reset()` keeps freeing them.
+ *
+ * @returns The undo. Spies created after it go back to the runtime's tracker.
+ *
+ * @example
+ * ```js
+ * import { before, describe } from 'node:test';
+ * import { trackNodeMocks } from 'vitest-auto-spy/node';
+ *
+ * before(() => {
+ *   trackNodeMocks();
+ * });
+ * ```
+ */
+declare function trackNodeMocks(): StopTrackingNodeMocks;
+/**
+ * How many spies the private tracker is currently holding, or `0` when tracking is off.
+ *
+ * For diagnostics and for a suite that wants the sweep to fail loudly rather than quietly — the
+ * number `pruneNodeMocks()` is about to return.
+ *
+ * It counts spy *functions*, not spy objects, and a `createSpyFromClass()` spy materialises its
+ * methods on first access — so a spy whose methods a test never touched contributes nothing, which
+ * is also why it costs nothing.
+ */
+declare function countNodeMocks(): number;
+
+export { type StopTrackingNodeMocks, countNodeMocks, pruneNodeMocks, trackNodeMocks };

package/dist/node.js

@@ -6,7 +6,7 @@ import './chunk-PC3FAZT3.js';
 export { createFunctionSpy, errorHandler } from './chunk-3QJUFL2N.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';
-import { mock } from 'node:test';
+import { afterEach, mock } from 'node:test';
 import { registerMockAdapter, guardAccessorSpies } from './shared-state.js';
 
 function asNodeMock(mockFn) {
@@ -32,5 +32,100 @@ function createNodeMockAdapter(nodeTest) {
   );
 }
 
+// src/lib/node-mock-tracker.ts
+var host;
+var owned;
+var created = 0;
+var sweepInstalled = false;
+function asNodeTestApi(tracker) {
+  return tracker;
+}
+function probeTracker(candidate) {
+  const create = Reflect.get(candidate, "fn");
+  if (typeof create !== "function") {
+    return void 0;
+  }
+  const probe = Reflect.apply(create, candidate, []);
+  if (typeof probe !== "function") {
+    return void 0;
+  }
+  probe();
+  const calls = Reflect.get(Object(Reflect.get(probe, "mock")), "calls");
+  return Array.isArray(calls) && calls.length === 1 ? asNodeTestApi(candidate) : void 0;
+}
+function constructPrivateTracker() {
+  const runtime = host;
+  if (runtime === void 0) {
+    return void 0;
+  }
+  try {
+    const Tracker = Reflect.get(runtime.mock, "constructor");
+    return typeof Tracker === "function" ? probeTracker(Object(Reflect.construct(Tracker, []))) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var stopTracking = () => {
+  owned = void 0;
+  created = 0;
+};
+var stopNothing = () => void 0;
+function installSweep() {
+  const runtime = host;
+  if (sweepInstalled || runtime?.afterEach === void 0) {
+    return;
+  }
+  sweepInstalled = true;
+  runtime.afterEach(() => {
+    pruneNodeMocks();
+  });
+}
+function createSwappableNodeTracker(nodeTest) {
+  host = nodeTest;
+  owned = void 0;
+  created = 0;
+  return {
+    fn: (implementation) => {
+      const tracker = owned;
+      if (tracker === void 0) {
+        return nodeTest.mock.fn(implementation);
+      }
+      created += 1;
+      return tracker.fn(implementation);
+    }
+  };
+}
+function pruneNodeMocks() {
+  if (owned === void 0) {
+    return 0;
+  }
+  const fresh = constructPrivateTracker();
+  if (fresh === void 0) {
+    return 0;
+  }
+  const dropped = created;
+  owned = fresh;
+  created = 0;
+  return dropped;
+}
+function trackNodeMocks() {
+  if (owned !== void 0) {
+    return stopTracking;
+  }
+  const tracker = constructPrivateTracker();
+  if (tracker === void 0) {
+    return stopNothing;
+  }
+  owned = tracker;
+  created = 0;
+  installSweep();
+  return stopTracking;
+}
+function countNodeMocks() {
+  return owned === void 0 ? 0 : created;
+}
+
 // src/node.ts
-registerMockAdapter(createNodeMockAdapter(mock));
+registerMockAdapter(createNodeMockAdapter(createSwappableNodeTracker({ mock, afterEach })));
+
+export { countNodeMocks, pruneNodeMocks, trackNodeMocks };

package/dist/{prop-mock-BMs7lihn.d.ts → prop-mock-DDtfdw9e.d.ts}

@@ -1,4 +1,4 @@
-import { P as PropStubValue } from './types-jaazRXzU.js';
+import { P as PropStubValue } from './types-BvbrSBUX.js';
 
 /** Undoes a single `mock*Prop` patch; calling it more than once is a no-op. */
 type RestoreProp = () => void;

package/dist/react.d.ts

@@ -1,7 +1,7 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, c as ClassSpyConfiguration, C as ClassType, a as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as ClassSpyConfiguration, C as ClassType, k as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/rxjs.d.ts

@@ -1,6 +1,6 @@
 import { Observable, ReplaySubject } from 'rxjs';
-import { V as ValueConfig } from './types-jaazRXzU.js';
-export { A as AddObservableSpyMethods, a as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, b as ValueConfigPerCall } from './types-jaazRXzU.js';
+import { V as ValueConfig } from './types-BvbrSBUX.js';
+export { e as AddObservableSpyMethods, k as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, v as ValueConfigPerCall } from './types-BvbrSBUX.js';
 import 'vitest';
 
 /**

package/dist/setup.d.ts

@@ -1,6 +1,6 @@
 import { vi } from 'vitest';
-import { v as UnstubbedCallHandler } from './types-jaazRXzU.js';
-import { R as RestoreProp } from './prop-mock-BMs7lihn.js';
+import { u as UnstubbedCallHandler } from './types-BvbrSBUX.js';
+import { R as RestoreProp } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 

package/dist/svelte.d.ts

@@ -1,7 +1,7 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, c as ClassSpyConfiguration, C as ClassType, a as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as ClassSpyConfiguration, C as ClassType, k as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, S as Spy, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/{track-injections-B3FT649L.d.ts → track-injections-CzzXQwTl.d.ts}

@@ -1,4 +1,4 @@
-import { C as ClassType, S as Spy } from './types-jaazRXzU.js';
+import { C as ClassType, S as Spy } from './types-BvbrSBUX.js';
 
 /**
  * The provider shape Angular and NestJS agree on: `{ provide, useFactory }`, with the dependency

package/dist/{types-jaazRXzU.d.ts → types-BvbrSBUX.d.ts}

@@ -630,4 +630,4 @@ interface ClassSpyConfiguration<T> extends StrictSpyConfiguration {
     lazySpies?: boolean | 'proxy';
 }
 
-export type { AddObservableSpyMethods as A, ClassType as C, DeepMockProxy as D, ErrorValueConfig as E, Func as F, MethodReturns as M, NextValueConfig as N, OnlyMethodKeysOf as O, PropStubValue as P, Spy as S, UnstubbedCall as U, ValueConfig as V, WithMockReturnValue as W, CompleteValueConfig as a, ValueConfigPerCall as b, ClassSpyConfiguration as c, AccessorKeysOf as d, AddAccessorsSpies as e, AddCalledWithObservable as f, AddCalledWithPromise as g, AddCalledWithSpyMethods as h, AddPromiseSpyMethods as i, AddSpyMethodsByReturnTypes as j, AddThrowHelper as k, AddVoidReturnHelpers as l, DeepPartial as m, Mutable as n, OnlyObservablePropsOf as o, OnlyPropsOf as p, Overload as q, Overloads as r, SpyDisposable as s, SpyOptions as t, StrictSpyConfiguration as u, UnstubbedCallHandler as v };
+export type { AccessorKeysOf as A, ClassType as C, DeepMockProxy as D, ErrorValueConfig as E, Func as F, MethodReturns as M, NextValueConfig as N, OnlyMethodKeysOf as O, PropStubValue as P, Spy as S, UnstubbedCall as U, ValueConfig as V, WithMockReturnValue as W, AddAccessorsSpies as a, AddCalledWithObservable as b, AddCalledWithPromise as c, AddCalledWithSpyMethods as d, AddObservableSpyMethods as e, AddPromiseSpyMethods as f, AddSpyMethodsByReturnTypes as g, AddThrowHelper as h, AddVoidReturnHelpers as i, ClassSpyConfiguration as j, CompleteValueConfig as k, DeepPartial as l, Mutable as m, OnlyObservablePropsOf as n, OnlyPropsOf as o, Overload as p, Overloads as q, SpyDisposable as r, SpyOptions as s, StrictSpyConfiguration as t, UnstubbedCallHandler as u, ValueConfigPerCall as v };

package/dist/vue.d.ts

@@ -1,8 +1,8 @@
-import { S as Spy, C as ClassType, c as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-jaazRXzU.js';
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, a as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, b as ValueConfigPerCall, W as WithMockReturnValue } from './types-jaazRXzU.js';
+import { S as Spy, C as ClassType, j as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-BvbrSBUX.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, k as CompleteValueConfig, D as DeepMockProxy, l as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, m as Mutable, N as NextValueConfig, n as OnlyObservablePropsOf, o as OnlyPropsOf, p as Overload, q as Overloads, P as PropStubValue, r as SpyDisposable, s as SpyOptions, t as StrictSpyConfiguration, U as UnstubbedCall, u as UnstubbedCallHandler, V as ValueConfig, v as ValueConfigPerCall, W as WithMockReturnValue } from './types-BvbrSBUX.js';
 export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, IntersectionObserverStubOptions, MediaElementState, MediaElementStub, MediaElementStubOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, MutationRecordInit, ObserverGlobal, ObserverInstance, ObserverStub, ObserverStubOptions, ResizeEntryRect, TestRunComparison, TestRunReport, TestRunSummary, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, compareTestRuns, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, diffByField, errorHandler, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resetAutoSpy, resizeEntry, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CQkhGiYJ.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-BMs7lihn.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C-IjL1J2.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DDtfdw9e.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/{zoneless-T3bgwkwb.d.ts → zoneless-D_hHdObW.d.ts}

@@ -1,7 +1,7 @@
 import { InjectionToken, Injector, ProviderToken, Provider, Type, InputSignalWithTransform, InputSignal, ModelSignal, EnvironmentProviders, EffectRef } from '@angular/core';
-import { A as AutoMockConfiguration } from './expect-emission-CQkhGiYJ.js';
-import { S as Spy, C as ClassType, t as SpyOptions, c as ClassSpyConfiguration, O as OnlyMethodKeysOf, m as DeepPartial } from './types-jaazRXzU.js';
-import './prop-mock-BMs7lihn.js';
+import { A as AutoMockConfiguration } from './expect-emission-C-IjL1J2.js';
+import { S as Spy, C as ClassType, s as SpyOptions, j as ClassSpyConfiguration, O as OnlyMethodKeysOf, l as DeepPartial } from './types-BvbrSBUX.js';
+import './prop-mock-DDtfdw9e.js';
 import { ComponentFixture } from '@angular/core/testing';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "3.17.0",
+  "version": "3.18.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun and node:test, 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

@@ -1,6 +1,6 @@
 ---
 name: vitest-auto-spy
-description: Write or fix tests that use vitest-auto-spy — typed spies from a class or a type on Vitest, bun:test and node:test. Use when a spec imports `vitest-auto-spy` or any of its subpaths (`/angular`, `/angular-http`, `/bun-angular`, `/bun`, `/node`, `/rxjs`, `/nestjs`, `/jasmine`, `/jasmine-compat`, `/observer-spy`, `/setup`, `/zone`, `/eslint-plugin`), when the user mentions createSpyFromClass, createAutoMock, createMock, mockDeep, createFunctionSpy, createSpyObj, enableJasmineCompat, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, createDirectiveHost, overrideComponentProvider, enableAngularDiagnostics, assertNgModuleScopes, trackInjections, runEffect, settleResource, httpResource, mockResourceProp, mockSignalProp, mockReadonlyProp, captureArg, expectEmission, expectError, setupAutoSpy, stubIntersectionObserver, assertMocked, Spy<T>, calledWith, mustBeCalledWith, onlyMethodsToSpyOn, instanceMethodsToSpyOn, observablePropsToSpyOn, strict, onUnstubbedCall, resolveWith or nextWith, when migrating a suite off jest-auto-spies or jasmine-auto-spies (`npx vitest-auto-spy codemod --from jasmine`), or when a test fails with "No mock adapter registered", "Observable spies require rxjs", "not found on the class prototype", "strict mode is on", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController" or "Spy<T> is not assignable".
+description: Write or fix tests that use vitest-auto-spy — typed spies from a class or a type on Vitest, bun:test and node:test. Use when a spec imports `vitest-auto-spy` or any of its subpaths (`/angular`, `/angular-http`, `/bun-angular`, `/bun`, `/node`, `/rxjs`, `/nestjs`, `/jasmine`, `/jasmine-compat`, `/observer-spy`, `/setup`, `/zone`, `/eslint-plugin`), when the user mentions createSpyFromClass, createAutoMock, createMock, mockDeep, createFunctionSpy, createSpyObj, enableJasmineCompat, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, createDirectiveHost, overrideComponentProvider, enableAngularDiagnostics, assertNgModuleScopes, trackInjections, runEffect, settleResource, httpResource, mockResourceProp, mockSignalProp, mockReadonlyProp, captureArg, expectEmission, expectError, setupAutoSpy, assertMocked, Spy<T>, calledWith, mustBeCalledWith, onlyMethodsToSpyOn, strict, onUnstubbedCall, resolveWith or nextWith, when migrating a suite off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator (createSpyObject, mockProvider, SpectatorService) (`npx vitest-auto-spy codemod --from jasmine`), or when a test fails with "No mock adapter registered", "Observable spies require rxjs", "not found on the class prototype", "strict mode is on", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController" or "Spy<T> is not assignable".
 ---
 
 # vitest-auto-spy
@@ -127,6 +127,7 @@ it('loads', async () => {
 | a `signal()` / `computed()` field on the class under test               | `mockSignalProp(obj, prop, initial)` — returns the writable                                          |
 | a resource field, when the HTTP round trip is not the point             | `mockResourceProp(obj, prop, initial)` — `set` / `fail` / `loading`                                  |
 | the HTTP round trip _is_ the point                                      | `expectRequest(url).flush(body)` — `/angular-http`, settling included                                |
+| a node:test suite whose heap grows all run                              | `trackNodeMocks()` — `/node`, a private MockTracker                                                  |
 | a Nest provider whose constructor keeps changing                        | `createNestUnit(Target, { expose })` — built from its DI metadata                                    |
 | asserting a resource's value _and_ status together                      | `registerResourceMatchers()` → `toHaveResourceValue` / `toBeLoading`                                 |
 | a callback or config object the code under test built                   | `captureArg<T>()` in the assertion, then read `.value`                                               |