vitest-auto-spy 3.3.0 → 3.4.0

package/AGENTS.md

@@ -456,6 +456,34 @@ undo), `flushStrayRejections()` (takes what was captured and starts again from e
 `countStrayRejections()`. The `no-floating-assertion` lint rule catches the commonest shape before
 it ever runs (§16).
 
+**The one that gets slower the longer the run goes on:** every `vi.fn()` and `vi.spyOn()` is added
+to one `Set` inside `@vitest/spy`, because that is what `vi.clearAllMocks()` walks, and nothing takes
+anything out of it again. With `isolate: false` the set is created once per worker and only grows:
+`clearMocks: true` then walks every mock of every file already run **before every single test**, and
+the worker holds all of them at once — their recorded arguments included, and through those whole
+component trees.
+
+```ts
+setupAutoSpy({ pruneMockRegistry: true }); // keep only the mocks that outlive a file
+```
+
+The part to understand before turning it on is what must **not** be pruned. Dropping a mock from that
+set means `clearMocks` can no longer see it, so its calls accumulate silently — harmless for a mock
+that dies with its file, a bug for the module-level `vi.fn()` in a shared `*.mock.ts` that six spec
+files import. The first file to import it creates it; drop it when that file ends and the file that
+happens to run **second** fails on calls its predecessor made, which reads as flakiness because which
+file is first is the runner's choice. So the split is drawn where it is observable: what is already in
+the registry when a file's hooks start was created while the module graph was being evaluated and is
+kept; everything added after that belongs to the file and goes when it ends. One case lands on the
+wrong side — a module first loaded by a dynamic `import()` inside a test — and says so explicitly:
+
+```ts
+export const navigation = { setFocus: keepMockRegistered(vi.fn()) };
+```
+
+`trackMockRegistry()` installs the pair of hooks on its own, `pruneMockRegistry()` is the one-shot
+sweep (it returns how many went) and `getMockRegistrySize()` reports what is left.
+
 Two more switches, both about the environment rather than the spies:
 
 ```ts

package/README.md

@@ -1295,6 +1295,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `installPerTest(install)`                                                            | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                           |
 | `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)`                                    | `/setup`                      | Keep @vitest/spy's mock registry to the mocks that outlive a file; mark one the split would miss ([details](#test-run-hygiene))                        |
 | `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:
@@ -1426,6 +1427,15 @@ expensive to diagnose when it is missing. The first three are on by default:
    migrated Angular monorepo — 1688 spec files, 11 587 tests, green, exit 0 — was hiding six defects
    of exactly that shape, two of them assertions that were simply false and one a `TypeError` thrown
    by production code.
+8. **The mock registry, which nothing empties.** Opt-in. Every `vi.fn()` and `vi.spyOn()` is added to
+   one `Set` inside `@vitest/spy` so that `vi.clearAllMocks()` has something to walk, and no API takes
+   anything out of it again. With `isolate: false` that set is created once per worker and only
+   grows, so `clearMocks: true` walks every mock of every file already run before each test, and the
+   worker holds all of them at once — with their recorded arguments, and through those whole
+   component trees. Pruning it is easy to get wrong in one specific way: drop the module-level
+   `vi.fn()` that six spec files import from a shared `*.mock.ts` and nothing clears it any more, so
+   its calls accumulate and the file that happens to run second fails on calls its predecessor made.
+   `pruneMockRegistry` keeps what a file inherited and drops only what it added.
 
 | Option                | Default   | Notes                                                                         |
 | --------------------- | --------- | ----------------------------------------------------------------------------- |
@@ -1438,6 +1448,7 @@ expensive to diagnose when it is missing. The first three are on by default:
 | `guardGlobals`        | `'off'`   | Report a test that redefines a global property as non-configurable            |
 | `globalFakeTimers`    | `false`   | Fake timers for every test **and between them** — Jest's `enableGlobally`     |
 | `restoreTimerGlobals` | `true`    | Put back timer globals that uninstalling the fakes deleted                    |
+| `pruneMockRegistry`   | `false`   | Keep @vitest/spy's ever-growing mock registry to the mocks that outlive a file |
 
 `restoreMocks` is off by default because it also drops `vi.spyOn` stubs a suite installed in
 `beforeAll`; it is the knob to reach for when the run shares one environment across files.

package/dist/setup.d.ts

@@ -270,6 +270,18 @@ interface SetupAutoSpyOptions {
      * installed on purpose. See {@link restoreTimerGlobals}.
      */
     restoreTimerGlobals?: boolean;
+    /**
+     * Keep `@vitest/spy`'s registry of every mock ever created down to the mocks that outlive a file.
+     * Default `false`, because it reaches into a set the runner does not expose.
+     *
+     * The registry exists so `vi.clearAllMocks()` has something to walk. With `isolate: false` it is
+     * created once per worker and only grows: `clearMocks: true` then walks every mock of every file
+     * already run before each test, and the heap holds all of them — with their recorded arguments,
+     * and through those whole component trees. Turning this on prunes what each file added once the
+     * file is over, and keeps what the file inherited. See {@link trackMockRegistry}, and
+     * {@link keepMockRegistered} for the one case the split gets wrong on its own.
+     */
+    pruneMockRegistry?: boolean;
     /**
      * Clear the `vitest-auto-spy/console` spies after every test. Default `true`.
      *
@@ -415,6 +427,69 @@ declare module 'vitest' {
  */
 declare function registerFocusMatchers(): void;
 
+/**
+ * Capture `@vitest/spy`'s mock registry, or return `undefined` if this runner does not expose one
+ * the probe can confirm.
+ *
+ * Called once per worker: a second call hands back the first result, including a failed one.
+ *
+ * The capture clears every mock's recorded calls as a side effect, because `vi.clearAllMocks()` is
+ * what makes the set iterate. That is why {@link trackMockRegistry} does it in `beforeAll`, where
+ * no test has recorded anything yet.
+ */
+declare function captureMockRegistry(): Set<unknown> | undefined;
+/**
+ * Mark `mock` as one that outlives the file it was created in, so pruning never drops it.
+ *
+ * Needed only for a mock created inside a test or a hook and then shared with later files — a
+ * module loaded by a dynamic `import()` in a test, or a fixture cached in a module-level variable
+ * on first use. A `vi.fn()` at the top level of a module is kept without being told.
+ *
+ * @example
+ * ```ts
+ * // fixtures/navigation.mock.ts — imported by six spec files
+ * export const navigation = { setFocus: keepMockRegistered(vi.fn()) };
+ * ```
+ */
+declare function keepMockRegistered<T>(mock: T): T;
+/**
+ * Mark everything currently in the registry as long-lived.
+ *
+ * Run at the start of a file, this is the whole classification: what exists now was created while
+ * the modules were being evaluated, and everything added afterwards belongs to this file.
+ */
+declare function keepRegisteredMocks(): void;
+/**
+ * Drop every mock that is not marked long-lived from the registry, and report how many went.
+ *
+ * Safe to call without a capture, and safe to call twice — the second call finds nothing to do.
+ */
+declare function pruneMockRegistry(): number;
+/**
+ * Keep the registry to the mocks that outlive a file: capture it, mark what each file inherits, and
+ * prune what the file added once it is over.
+ *
+ * ```ts
+ * // vitest.setup.ts
+ * import { trackMockRegistry } from 'vitest-auto-spy/setup';
+ *
+ * trackMockRegistry();
+ * ```
+ *
+ * This is what `setupAutoSpy({ pruneMockRegistry: true })` installs; call it directly to have it
+ * without the rest.
+ */
+declare function trackMockRegistry(): void;
+/** How many mocks the registry holds, or `undefined` if it was never captured. For diagnostics. */
+declare function getMockRegistrySize(): number | undefined;
+/**
+ * Forget the capture and every long-lived mark.
+ *
+ * A worker never needs this — the registry it captured is the one it keeps. This module's own spec
+ * does, because it has to exercise both a successful and a failed capture in one process.
+ */
+declare function resetMockRegistryTracking(): void;
+
 /**
  * The callback half of a scheduler call, spelled out so a wrapper can pass it along and — for a
  * one-shot scheduler — call it itself.
@@ -561,4 +636,4 @@ declare const BLOCKED_FETCH_MESSAGE = "[vitest-auto-spy] fetch is stubbed in uni
  */
 declare function blockNetwork(): void;
 
-export { BLOCKED_FETCH_MESSAGE, type CountingClock, type CountingClockOptions, type DuplicateCopiesReaction, type FakeTimersConfig, type GlobalPatchReaction, type PerTestHandle, type RejectionHost, type SchedulerHost, type SetupAutoSpyOptions, type StopTrackingRejections, type StopTrackingTimers, type StrayRejection, type SystemTime, advanceTimers, blockNetwork, cancelStrayTimers, countStrayRejections, countStrayTimers, flushStrayRejections, getWatchedTimerGlobals, guardGlobalPatches, installPerTest, mockNow, mockSystemTime, registerFocusMatchers, restoreTimerGlobals, setupAutoSpy, setupFakeTimers, trackStrayRejections, trackStrayTimers, useCountingClock, withSystemTime };
+export { BLOCKED_FETCH_MESSAGE, type CountingClock, type CountingClockOptions, type DuplicateCopiesReaction, type FakeTimersConfig, type GlobalPatchReaction, type PerTestHandle, type RejectionHost, type SchedulerHost, type SetupAutoSpyOptions, type StopTrackingRejections, type StopTrackingTimers, type StrayRejection, type SystemTime, advanceTimers, blockNetwork, cancelStrayTimers, captureMockRegistry, countStrayRejections, countStrayTimers, flushStrayRejections, getMockRegistrySize, getWatchedTimerGlobals, guardGlobalPatches, installPerTest, keepMockRegistered, keepRegisteredMocks, mockNow, mockSystemTime, pruneMockRegistry, registerFocusMatchers, resetMockRegistryTracking, restoreTimerGlobals, setupAutoSpy, setupFakeTimers, trackMockRegistry, trackStrayRejections, trackStrayTimers, useCountingClock, withSystemTime };

package/dist/setup.js

@@ -136,6 +136,80 @@ function guardGlobalPatches(reaction) {
     checkSealedAdditions(watched, reaction);
   });
 }
+var registry;
+var captureAttempted = false;
+var longLived = /* @__PURE__ */ new WeakSet();
+function isWeakKey(value) {
+  return typeof value === "function" || typeof value === "object" && value !== null;
+}
+function captureMockRegistry() {
+  if (captureAttempted) {
+    return registry;
+  }
+  captureAttempted = true;
+  const probe = vi.fn();
+  const originalForEach = Set.prototype.forEach;
+  let captured;
+  const remember = (set) => {
+    captured ??= set;
+  };
+  Set.prototype.forEach = function patchedForEach(...args) {
+    remember(this);
+    originalForEach.apply(this, args);
+  };
+  try {
+    vi.clearAllMocks();
+  } finally {
+    Set.prototype.forEach = originalForEach;
+  }
+  if (!captured?.has(probe)) {
+    return void 0;
+  }
+  captured.delete(probe);
+  registry = captured;
+  return registry;
+}
+function keepMockRegistered(mock) {
+  if (isWeakKey(mock)) {
+    longLived.add(mock);
+  }
+  return mock;
+}
+function keepRegisteredMocks() {
+  registry?.forEach((mock) => {
+    keepMockRegistered(mock);
+  });
+}
+function pruneMockRegistry() {
+  if (!registry) {
+    return 0;
+  }
+  let pruned = 0;
+  for (const mock of registry) {
+    if (!isWeakKey(mock) || !longLived.has(mock)) {
+      registry.delete(mock);
+      pruned += 1;
+    }
+  }
+  return pruned;
+}
+function trackMockRegistry() {
+  beforeAll(() => {
+    captureMockRegistry();
+    keepRegisteredMocks();
+  });
+  afterAll(() => {
+    pruneMockRegistry();
+  });
+}
+function getMockRegistrySize() {
+  return registry?.size;
+}
+function resetMockRegistryTracking() {
+  registry = void 0;
+  captureAttempted = false;
+  longLived = /* @__PURE__ */ new WeakSet();
+}
 
 // src/lib/network-stub.ts
 var BLOCKED_FETCH_MESSAGE = "[vitest-auto-spy] fetch is stubbed in unit tests";
@@ -154,7 +228,7 @@ function describeTarget(input) {
 }
 var HANDLER_SLOT = "unhandledPromiseRejectionHandler";
 var MISSING_ZONE = "trackStrayRejections() found no zone.js on the host (`Zone.__symbol__` is not there), so there is no handler slot to claim. This module never imports zone.js \u2014 a zoneless project must not pull it in \u2014 which means the consumer loads it first: `import 'zone.js';` at the top of the setup file, or, under `@angular/build:unit-test`, the builder's own entry point does it. It throws rather than quietly doing nothing on purpose: without zone.js the global `Promise` is the platform one, whose unhandled rejections Vitest already reports and fails the run for, so a silent no-op here would read as \"the check is on\" while nothing was ever checked. Drop the option instead.";
-function registry() {
+function registry2() {
   return globalThis.__vitestAutoSpyTrackedRejections__ ??= /* @__PURE__ */ new Map();
 }
 function defaultHost() {
@@ -182,7 +256,7 @@ function describeRejection(error) {
   return { reason, assertion: isAssertionFailure(reason), testName: expect.getState().currentTestName ?? "" };
 }
 function trackStrayRejections(host = defaultHost()) {
-  const tracked = registry().get(host);
+  const tracked = registry2().get(host);
   if (tracked) {
     return tracked.stop;
   }
@@ -202,25 +276,25 @@ function trackStrayRejections(host = defaultHost()) {
     } else {
       Reflect.deleteProperty(zone, slot);
     }
-    registry().delete(host);
+    registry2().delete(host);
   };
-  registry().set(host, { captured, stop });
+  registry2().set(host, { captured, stop });
   return stop;
 }
 function countStrayRejections(host = defaultHost()) {
-  const tracked = registry().get(host);
+  const tracked = registry2().get(host);
   if (!tracked) {
     throw new Error(withDocs("countStrayRejections() needs trackStrayRejections() to have run first.", DOCS_LINKS.setup));
   }
   return tracked.captured.length;
 }
 function flushStrayRejections(host = defaultHost()) {
-  const tracked = registry().get(host);
+  const tracked = registry2().get(host);
   return tracked ? tracked.captured.splice(0) : [];
 }
 
 // src/lib/stray-timers.ts
-function registry2() {
+function registry3() {
   return globalThis.__vitestAutoSpyTrackedSchedulers__ ??= /* @__PURE__ */ new Map();
 }
 function defaultHost2() {
@@ -278,7 +352,7 @@ function wrapFrameScheduler(host, frames) {
   };
 }
 function trackStrayTimers(host = defaultHost2()) {
-  const tracked = registry2().get(host);
+  const tracked = registry3().get(host);
   if (tracked) {
     return tracked.stop;
   }
@@ -294,13 +368,13 @@ function trackStrayTimers(host = defaultHost2()) {
   const stop = () => {
     cancelStrayTimers(host);
     undo.forEach((restore) => restore());
-    registry2().delete(host);
+    registry3().delete(host);
   };
-  registry2().set(host, { handles, frames, stop });
+  registry3().set(host, { handles, frames, stop });
   return stop;
 }
 function cancelStrayTimers(host = defaultHost2()) {
-  const tracked = registry2().get(host);
+  const tracked = registry3().get(host);
   if (!tracked) {
     return 0;
   }
@@ -318,7 +392,7 @@ function cancelStrayTimers(host = defaultHost2()) {
   return cancelled;
 }
 function countStrayTimers(host = defaultHost2()) {
-  const tracked = registry2().get(host);
+  const tracked = registry3().get(host);
   if (!tracked) {
     throw new Error(withDocs("countStrayTimers() needs trackStrayTimers() to have run first.", DOCS_LINKS.setup));
   }
@@ -408,6 +482,9 @@ function setupAutoSpy(options = {}) {
       cancelStrayTimers();
     });
   }
+  if (options.pruneMockRegistry ?? false) {
+    trackMockRegistry();
+  }
   if (options.globalFakeTimers) {
     setupFakeTimers(options.globalFakeTimers === true ? void 0 : options.globalFakeTimers, { betweenTests: true });
   }
@@ -552,4 +629,4 @@ function registerFocusMatchers() {
 // src/setup.ts
 useVitestAdapter();
 
-export { BLOCKED_FETCH_MESSAGE, advanceTimers, blockNetwork, cancelStrayTimers, countStrayRejections, countStrayTimers, flushStrayRejections, getWatchedTimerGlobals, guardGlobalPatches, installPerTest, mockNow, mockSystemTime, registerFocusMatchers, restoreTimerGlobals, setupAutoSpy, setupFakeTimers, trackStrayRejections, trackStrayTimers, useCountingClock, withSystemTime };
+export { BLOCKED_FETCH_MESSAGE, advanceTimers, blockNetwork, cancelStrayTimers, captureMockRegistry, countStrayRejections, countStrayTimers, flushStrayRejections, getMockRegistrySize, getWatchedTimerGlobals, guardGlobalPatches, installPerTest, keepMockRegistered, keepRegisteredMocks, mockNow, mockSystemTime, pruneMockRegistry, registerFocusMatchers, resetMockRegistryTracking, restoreTimerGlobals, setupAutoSpy, setupFakeTimers, trackMockRegistry, trackStrayRejections, trackStrayTimers, useCountingClock, withSystemTime };

package/package.json

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

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

@@ -104,6 +104,7 @@ it('loads', async () => {
 | a green run exiting 1 with `AbortError` under happy-dom            | `setupAutoSpy({ blockNetwork: true })`                             |
 | timers or frames from a previous file failing this one             | `setupAutoSpy({ strayTimers: true })`                              |
 | an assertion error in stderr, every test green and the run at 0    | `setupAutoSpy({ strayRejections: true })` — zone.js swallowed it   |
+| a run getting slower the longer it goes, on `isolate: false`       | `setupAutoSpy({ pruneMockRegistry: true })` — the mock registry    |
 | `Cannot read properties of undefined (reading 'now')`              | `restoreTimerGlobals` — on by default                              |
 | a spy handed to an API typed against the real class                | `asInstance()` / `asSpy()`                                         |
 | the code under test does `new X()` (a global, a vendor SDK)        | `mockConstructor(factory)` / `stubConstructor(obj, key, factory)`  |