vitest-auto-spy 3.12.0 → 3.13.0

package/AGENTS.md

@@ -668,6 +668,14 @@ sub-tree). The key is non-enumerable, so a spread does not copy it, and there is
 `[Symbol.dispose]` on a host mock restores the original implementation instead — call
 `resetAutoSpy(spy)` there. If the project does not transpile `using`, call `spy[Symbol.dispose]()`.
 
+`src/lib/dispose-symbol.ts` installs `Symbol.dispose` when the realm has none, and `DISPOSE` — not
+`Symbol.dispose` — is what library code compares against. Node 22 has no explicit resource
+management in V8: it patches the symbol in itself, as `Symbol.for('nodejs.dispose')`, onto the main
+realm only, so under `jsdom` / `happy-dom` (a bare `vm` context) it is absent, the downlevelled
+`using` throws out of `tslib.__addDisposableResource`, and `spy[Symbol.dispose]` degrades into a
+property named `"undefined"`. The shim is the same registry symbol, so it is identical to Node's
+across realms.
+
 ---
 
 ## 8. Observable assertions (core entry — no rxjs needed)
@@ -950,8 +958,19 @@ by a dynamic `import()` inside a test — and says so explicitly:
 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.
+The mocks it keeps, it also guards. Staying registered means `vi.resetAllMocks()` reaches them too —
+it walks the same set and calls `mockReset()`, which puts an implementation back only when it was
+passed to `vi.fn(implementation)`; behaviour chained on with `.mockReturnValue(…)` or
+`.mockReturnThis()` is simply lost. Under `isolate: false` that surfaces in a *different* file later
+in the same worker, inside application code, as `Cannot read properties of undefined` against a
+shared double that spec never touched — and `vi.restoreAllMocks()` does not cause it (Vitest 4 walks
+`MOCK_RESTORE` there, which only `vi.spyOn` writes to), so probing with that one comes back green and
+sends the search the wrong way. The implementation a long-lived mock carried when it was classified
+is therefore remembered and put back, in `beforeEach`, but only when it has gone missing.
+
+`trackMockRegistry()` installs the hooks on its own, `pruneMockRegistry()` is the one-shot sweep (it
+returns how many went), `restoreLongLivedImplementations()` is that repair (it returns how many it
+put back) and `getMockRegistrySize()` reports what is left.
 
 Two more switches, both about the environment rather than the spies:
 

package/README.md

@@ -16,7 +16,7 @@ identical API, with **RxJS** spies and **Angular / NestJS / React / Vue·Pinia /
 [![npm version](https://img.shields.io/npm/v/vitest-auto-spy?color=brightgreen&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![npm downloads](https://img.shields.io/npm/dm/vitest-auto-spy?color=brightgreen&logo=npm)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-14.5%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-14.6%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -1336,10 +1336,14 @@ non-enumerable, so `{ ...spy }` does not carry it into a snapshot, and there is
 `[Symbol.asyncDispose]` — `resetAutoSpy` is synchronous, and `await using` falls back to `@@dispose`
 anyway.
 
-**The method is ours; the `using` declaration is your toolchain's.** `Symbol.dispose` exists on every
-runtime this package supports, so there is no feature detection; esbuild and `tsc` both downlevel the
-declaration. If your setup does not transpile, call `spy[Symbol.dispose]()` or `resetAutoSpy(spy)`
-directly. A standalone `createFunctionSpy` is **not** covered: it is a host-runner mock, and Vitest
+**The method is ours; the `using` declaration is your toolchain's.** esbuild and `tsc` both downlevel
+the declaration. If your setup does not transpile, call `spy[Symbol.dispose]()` or
+`resetAutoSpy(spy)` directly. On **Node 22** the package installs the missing `Symbol.dispose` when
+it loads: the downlevelled form reads the symbol off the global `Symbol`, and Node 22 patches it in
+only on its main realm — under Vitest's `jsdom` environment, whose globals come from a `vm` context,
+it is absent and `using` throws `TypeError: Symbol.dispose is not defined.`. The shim is
+`Symbol.for('nodejs.dispose')`, the same registry symbol Node uses, so the key is identical across
+realms; a runtime that already has the symbol (Node 24+, Bun) is left untouched. A standalone `createFunctionSpy` is **not** covered: it is a host-runner mock, and Vitest
 puts its own `[Symbol.dispose]` on those, which restores the original implementation rather than
 reverting this library's configuration.
 
@@ -1897,7 +1901,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))                               |
+| `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)) |
 | `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:
@@ -2061,7 +2065,12 @@ expensive to diagnose when it is missing. The first three are on by default:
    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.
+   `pruneMockRegistry` keeps what a file inherited and drops only what it added. Keeping a mock
+   registered also means `vi.resetAllMocks()` can reach it — `mockReset` drops an implementation
+   that came from a chained `.mockReturnValue(…)`, which under `isolate: false` kills a *later*
+   file's test on a double it never touched — so `trackMockRegistry()` remembers the implementation
+   each long-lived mock carried and puts it back before a test that has lost it
+   (`restoreLongLivedImplementations()` is that repair on its own, and returns how many it put back).
 9. **A hook that ran out of a budget nobody meant to give it.** On by default, because it only ever
    appends a sentence to a test that has already failed. Jest applies one `testTimeout` to a hook and
    to a test body alike; Vitest resolves `hookTimeout` separately and defaults it to 10 000 ms, so a
@@ -2391,6 +2400,7 @@ names are unfindable from these messages otherwise — no `TS2739` text contains
 | `TS2345: Argument of type 'Spy<X>' is not assignable to parameter of type 'X'`   | the same, in an argument                  | `asInstance(spy)`, or `asInstances(a, b, c)`        |
 | `TS2322: Type 'Spy<X>' is not assignable to type 'Mocked<X>' …`                  | the variable was declared `Mocked<T>`     | declare it `Spy<T>`                                 |
 | `'AddPromiseSpyMethods<unknown>' is missing … from type 'WithMockReturnValue<…>'` | a generic class inferred as `Service<any>` | `asSpy<Service>(…)` / `injectSpy<Service>(…)`      |
+| `TS2345` / `TS2554` **on a call to a spied method** (wrong arguments)            | the arguments the real method rejects — the double's call signature is the method's own; it used to accept anything | fix the call; don't re-widen the spy |
 | `TS2739 … 'Spy<X>' is missing …` **on a line with `injectSpy`**                  | the provider handed back the real object  | `provideAutoSpy(X)`, or an honest `TestBed.inject`  |
 
 Two notes that cost real time when they are missing.

package/dist/angular.d.ts

@@ -1,9 +1,9 @@
-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-BUNSBSIP.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-CEhs7o9p.js';
 import { Type, Signal, WritableSignal } from '@angular/core';
-import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-it6CnDkI.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BAzV5ITq.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-IgCwv_40.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-CuGjE0YR.js';
+import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-Br-Usge9.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BQndbppn.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-DyjtZVoA.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-DMx5uXie.js';
 import '@angular/core/testing';
 import 'rxjs';
 import 'vitest';

package/dist/angular.js

@@ -42,6 +42,19 @@ function useVitestAdapter() {
   registerMockAdapter(vitestMockAdapter);
 }
 
+// src/lib/dispose-symbol.ts
+var NODE_DISPOSE_KEY = "nodejs.dispose";
+function installDisposeSymbol(host) {
+  const existing = Reflect.get(host, "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 });
+  return shim;
+}
+var DISPOSE = installDisposeSymbol(Symbol);
+
 // src/lib/docs-links.ts
 var DOCS = "https://asdalexey.github.io/vitest-auto-spy";
 var DOCS_LINKS = {
@@ -692,7 +705,7 @@ function disposeAutoSpy() {
   resetAutoSpy(this);
 }
 function attachDispose(spy) {
-  Object.defineProperty(spy, Symbol.dispose, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
+  Object.defineProperty(spy, DISPOSE, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
 }
 
 // src/lib/auto-mock.ts
@@ -750,7 +763,7 @@ function createAutoMockHandler(seed, unstubbed) {
     defineProperty: (_target, key, descriptor) => storeDefinedProp(store, key, descriptor),
     deleteProperty: (_target, key) => dropStoredProp(store, key),
     has(_target, key) {
-      return key === AUTO_SPY_MARK || key === Symbol.dispose || hasStoredProp(store, key);
+      return key === AUTO_SPY_MARK || key === DISPOSE || hasStoredProp(store, key);
     },
     ownKeys() {
       return [.../* @__PURE__ */ new Set([...store.values.keys(), ...store.accessors.keys()])];
@@ -769,7 +782,7 @@ function readKey(store, key, receiver, unstubbed) {
   if (key === AUTO_SPY_MARK) {
     return true;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (typeof key === "symbol" || key === "then" || key === "constructor" || isProtocolKey(key) || isDeletedProp(store, key)) {
@@ -1783,7 +1796,14 @@ var AutoSpyInjector = class extends Injector {
   tokens() {
     return [...this.#spies.keys()];
   }
+  knows(token) {
+    return this.#spies.has(token);
+  }
 };
+function describeToken(token) {
+  const name = Reflect.get(Object(token), "name");
+  return typeof name === "string" ? name : String(token);
+}
 function factoryOf(target) {
   const factory = Reflect.get(target, "\u0275fac");
   return typeof factory === "function" ? factory : void 0;
@@ -1798,6 +1818,14 @@ function createWithAutoSpies(target, options = {}) {
     injector,
     spies: {
       get: (token) => {
+        if (!autoSpies.knows(token) && injector.get(token, null, { optional: true }) === null) {
+          throw new Error(
+            withDocs(
+              `[vitest-auto-spy] createWithAutoSpies(${describeToken(target)}).spies.get(${describeToken(token)}): the instance never asked for that token, and nothing in \`providers\` supplies it, so the spy you would get back is not the one it uses. Auto-spied tokens: ${autoSpies.tokens().map(describeToken).join(", ") || "(none)"}.`,
+              DOCS_LINKS.angular
+            )
+          );
+        }
         return injector.get(token);
       },
       autoSpiedTokens: () => autoSpies.tokens()

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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-CuGjE0YR.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-IgCwv_40.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-DMx5uXie.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-DyjtZVoA.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-BUNSBSIP.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-CEhs7o9p.js';
 import 'rxjs';
 import 'vitest';
 import '@angular/core';
@@ -72,6 +72,12 @@ declare function registerDomGlobals(options?: RegisterDomGlobalsOptions): Promis
  * implementation. A property the target refuses to accept is skipped rather than fatal — a locked
  * global is not worth failing a whole test run over.
  *
+ * Skipped, but **not** in silence when it is one of {@link FORCED_GLOBALS}: those are the five the
+ * DOM is useless without, so a refused `document` means the environment came up half-installed and
+ * the first spec that touches it reports `document is not defined` — naming neither this helper nor
+ * the property that refused. The rest stay quiet, because a host built-in keeping its own
+ * implementation is the documented outcome rather than a problem.
+ *
  * @example
  * ```ts
  * copyWindowGlobals(dom.window as unknown as Record<string, unknown>, globalThis as Record<string, unknown>);

package/dist/bun-angular.js

@@ -1,10 +1,10 @@
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-LVLSMH6T.js';
+import { createSpyForToken } from './chunk-JV5XRAS4.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass } from './chunk-B7PDIHEG.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
+import { createSpyFromClass } from './chunk-7YTPHYP7.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
 import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-3AWKPZCE.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';
@@ -160,6 +160,7 @@ ${failures.join("\n") || "  - (no registrars were configured)"}`,
 }
 function copyWindowGlobals(source, target) {
   const keys = [...FORCED_GLOBALS, ...Object.getOwnPropertyNames(source)];
+  const refused = [];
   for (const key of keys) {
     if (key.startsWith("_")) {
       continue;
@@ -170,9 +171,21 @@ function copyWindowGlobals(source, target) {
     }
     try {
       Object.defineProperty(target, key, { value, configurable: true, writable: true, enumerable: true });
-    } catch {
+    } catch (error) {
+      if (FORCED_GLOBALS.includes(key)) {
+        refused.push(`${key} (${describeError(error)})`);
+      }
     }
   }
+  if (refused.length === 0) {
+    return;
+  }
+  console.warn(
+    withDocs(
+      `[vitest-auto-spy] copyWindowGlobals: the host refused to redefine ${refused.join(", ")}. The DOM is only half-installed, and the failure will arrive later as "document is not defined" or an unrelated jsdom assertion, naming neither this helper nor the property. Something sealed that global before the preload ran.`,
+      DOCS_LINKS.bunAngular
+    )
+  );
 }
 function createJsdomRegistrar(options) {
   return {
@@ -237,7 +250,14 @@ var AutoSpyInjector = class extends Injector {
   tokens() {
     return [...this.#spies.keys()];
   }
+  knows(token) {
+    return this.#spies.has(token);
+  }
 };
+function describeToken(token) {
+  const name = Reflect.get(Object(token), "name");
+  return typeof name === "string" ? name : String(token);
+}
 function factoryOf(target) {
   const factory = Reflect.get(target, "\u0275fac");
   return typeof factory === "function" ? factory : void 0;
@@ -252,6 +272,14 @@ function createWithAutoSpies(target, options = {}) {
     injector,
     spies: {
       get: (token) => {
+        if (!autoSpies.knows(token) && injector.get(token, null, { optional: true }) === null) {
+          throw new Error(
+            withDocs(
+              `[vitest-auto-spy] createWithAutoSpies(${describeToken(target)}).spies.get(${describeToken(token)}): the instance never asked for that token, and nothing in \`providers\` supplies it, so the spy you would get back is not the one it uses. Auto-spied tokens: ${autoSpies.tokens().map(describeToken).join(", ") || "(none)"}.`,
+              DOCS_LINKS.angular
+            )
+          );
+        }
         return injector.get(token);
       },
       autoSpiedTokens: () => autoSpies.tokens()

package/dist/bun.d.ts

@@ -1,7 +1,7 @@
-import { s as SpyOptions, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, l as DeepPartial, D as DeepMockProxy, F as Func, u as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-it6CnDkI.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 AddVoidReturnHelpers, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.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-CuGjE0YR.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-IgCwv_40.js';
+import { s as SpyOptions, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, l as DeepPartial, D as DeepMockProxy, F as Func, u as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-Br-Usge9.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 AddVoidReturnHelpers, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-DMx5uXie.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-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import { Mock } from 'vitest';
 import 'rxjs';
@@ -790,6 +790,11 @@ interface AssertMockedOptions {
      *
      * Worth naming when the factory stubs part of a module and re-exports the rest: without a list,
      * a factory that lost the one export the test drives still looks mocked.
+     *
+     * An **empty** list is rejected rather than accepted: `exports: []` — which is what
+     * `Object.keys(stubs)` or a filtered constant produces when it comes out empty — used to take the
+     * named-exports branch, find nothing to check and return, so the one call in the file whose job
+     * is to prove the mock applied proved nothing.
      */
     exports?: readonly string[];
 }

package/dist/bun.js

@@ -1,7 +1,7 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';

package/dist/{chunk-B7PDIHEG.js → chunk-7YTPHYP7.js}

@@ -1,6 +1,18 @@
 import { runClearHook, runConfigReset, resolveUnstubbedGuard, withDocs, DOCS_LINKS, AUTO_SPY_MARK, createFunctionSpy, isMarkedMock, readDeepChildren, markAsMock } from './chunk-3AWKPZCE.js';
 import { getMockAdapter, requireObservableSupport } from './shared-state.js';
 
+// src/lib/dispose-symbol.ts
+var NODE_DISPOSE_KEY = "nodejs.dispose";
+function installDisposeSymbol(host) {
+  const existing = Reflect.get(host, "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 });
+  return shim;
+}
+var DISPOSE = installDisposeSymbol(Symbol);
 function isAccessorBag(value) {
   return typeof value === "object" && value !== null && "getters" in value && "setters" in value;
 }
@@ -61,7 +73,7 @@ function disposeAutoSpy() {
   resetAutoSpy(this);
 }
 function attachDispose(spy) {
-  Object.defineProperty(spy, Symbol.dispose, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
+  Object.defineProperty(spy, DISPOSE, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
 }
 
 // src/lib/proxy-props.ts
@@ -185,7 +197,7 @@ function createAutoMockHandler(seed, unstubbed) {
     defineProperty: (_target, key, descriptor) => storeDefinedProp(store, key, descriptor),
     deleteProperty: (_target, key) => dropStoredProp(store, key),
     has(_target, key) {
-      return key === AUTO_SPY_MARK || key === Symbol.dispose || hasStoredProp(store, key);
+      return key === AUTO_SPY_MARK || key === DISPOSE || hasStoredProp(store, key);
     },
     ownKeys() {
       return [.../* @__PURE__ */ new Set([...store.values.keys(), ...store.accessors.keys()])];
@@ -204,7 +216,7 @@ function readKey(store, key, receiver, unstubbed) {
   if (key === AUTO_SPY_MARK) {
     return true;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (typeof key === "symbol" || key === "then" || key === "constructor" || isProtocolKey(key) || isDeletedProp(store, key)) {
@@ -498,4 +510,4 @@ function hasNothingToRead(ObjectClass, accessors, config) {
   config.onlyMethodsToSpyOn.length === 0;
 }
 
-export { NOT_STORED, autoMocked, clearAutoSpy, createAutoMock, createProxyPropStore, createSpyFromClass, describeStoredProp, disposeAutoSpy, dropStoredProp, isDeletedProp, isProtocolKey, readStoredAccessor, resetAutoSpy, storeDefinedProp, writeStoredAccessor, writeStoredValue };
+export { DISPOSE, NOT_STORED, autoMocked, clearAutoSpy, createAutoMock, createProxyPropStore, createSpyFromClass, describeStoredProp, disposeAutoSpy, dropStoredProp, isDeletedProp, isProtocolKey, readStoredAccessor, resetAutoSpy, storeDefinedProp, writeStoredAccessor, writeStoredValue };

package/dist/{chunk-FKAXOKP5.js → chunk-IKH4OTMV.js}

@@ -1,5 +1,5 @@
 import { mockValueProp, mockReadonlyPropGetter } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-B7PDIHEG.js';
+import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, DISPOSE, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-7YTPHYP7.js';
 import { defineHelper, withDocs, DOCS_LINKS, serializeValue, createFunctionSpy, DEEP_CHILDREN } from './chunk-3AWKPZCE.js';
 import { getMockAdapter } from './shared-state.js';
 export { describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, getPackageCopies, setEmissionTimeout } from './shared-state.js';
@@ -97,7 +97,7 @@ function readNodeMember(state, target, key, receiver) {
   if (key === DEEP_CHILDREN) {
     return state.children;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (key === "then" || isProtocolKey(key)) {
@@ -442,6 +442,14 @@ var SILENT_NO_OP_CAUSES = "A `vi.mock()` that does not apply reports nothing: un
 var assertMocked = defineHelper((namespace, options = {}) => {
   const target = describeTarget(options.specifier);
   const required = options.exports;
+  if (required?.length === 0) {
+    throw new Error(
+      withDocs(
+        `[vitest-auto-spy] assertMocked(${target}): the \`exports\` list is empty, so this call cannot fail and proves nothing. Drop the option to check that at least one export is a mock, or name the exports the test drives.`,
+        DOCS_LINKS.moduleMocks
+      )
+    );
+  }
   if (required) {
     const real = required.filter((name) => !isRunnerMock(Reflect.get(namespace, name)));
     if (real.length > 0) {

package/dist/{chunk-LVLSMH6T.js → chunk-JV5XRAS4.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-B7PDIHEG.js';
+import { createSpyFromClass, createAutoMock } from './chunk-7YTPHYP7.js';
 import { withDocs, DOCS_LINKS } from './chunk-3AWKPZCE.js';
 
 // src/lib/track-injections.ts

package/dist/console.d.ts

@@ -1,4 +1,4 @@
-import { j as AddSpyMethodsByReturnTypes } from './types-it6CnDkI.js';
+import { j as AddSpyMethodsByReturnTypes } from './types-Br-Usge9.js';
 import 'rxjs';
 import 'vitest';
 

package/dist/{expect-emission-CuGjE0YR.d.ts → expect-emission-DMx5uXie.d.ts}

@@ -1,4 +1,4 @@
-import { t as StrictSpyConfiguration, n as OnlyObservablePropsOf, M as MethodReturns, l as DeepPartial, S as Spy, s as SpyOptions } from './types-it6CnDkI.js';
+import { t as StrictSpyConfiguration, n as OnlyObservablePropsOf, M as MethodReturns, l as DeepPartial, S as Spy, s as SpyOptions } from './types-Br-Usge9.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-CuGjE0YR.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-IgCwv_40.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-DMx5uXie.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-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/index.js

@@ -109,6 +109,19 @@ 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");
+  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 });
+  return shim;
+}
+var DISPOSE = installDisposeSymbol(Symbol);
+
 // src/lib/docs-links.ts
 var DOCS = "https://asdalexey.github.io/vitest-auto-spy";
 var DOCS_LINKS = {
@@ -708,7 +721,7 @@ function disposeAutoSpy() {
   resetAutoSpy(this);
 }
 function attachDispose(spy) {
-  Object.defineProperty(spy, Symbol.dispose, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
+  Object.defineProperty(spy, DISPOSE, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
 }
 
 // src/lib/auto-mock.ts
@@ -766,7 +779,7 @@ function createAutoMockHandler(seed, unstubbed) {
     defineProperty: (_target, key, descriptor) => storeDefinedProp(store, key, descriptor),
     deleteProperty: (_target, key) => dropStoredProp(store, key),
     has(_target, key) {
-      return key === AUTO_SPY_MARK || key === Symbol.dispose || hasStoredProp(store, key);
+      return key === AUTO_SPY_MARK || key === DISPOSE || hasStoredProp(store, key);
     },
     ownKeys() {
       return [.../* @__PURE__ */ new Set([...store.values.keys(), ...store.accessors.keys()])];
@@ -785,7 +798,7 @@ function readKey(store, key, receiver, unstubbed) {
   if (key === AUTO_SPY_MARK) {
     return true;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (typeof key === "symbol" || key === "then" || key === "constructor" || isProtocolKey(key) || isDeletedProp(store, key)) {
@@ -1142,7 +1155,7 @@ function readNodeMember(state, target, key, receiver) {
   if (key === DEEP_CHILDREN) {
     return state.children;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (key === "then" || isProtocolKey(key)) {
@@ -1608,6 +1621,14 @@ var SILENT_NO_OP_CAUSES = "A `vi.mock()` that does not apply reports nothing: un
 var assertMocked = defineHelper((namespace, options = {}) => {
   const target = describeTarget2(options.specifier);
   const required = options.exports;
+  if (required?.length === 0) {
+    throw new Error(
+      withDocs(
+        `[vitest-auto-spy] assertMocked(${target}): the \`exports\` list is empty, so this call cannot fail and proves nothing. Drop the option to check that at least one export is a mock, or name the exports the test drives.`,
+        DOCS_LINKS.moduleMocks
+      )
+    );
+  }
   if (required) {
     const real = required.filter((name) => !isRunnerMock(Reflect.get(namespace, name)));
     if (real.length > 0) {

package/dist/nestjs.d.ts

@@ -1,5 +1,5 @@
-import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-it6CnDkI.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BAzV5ITq.js';
+import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-Br-Usge9.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BQndbppn.js';
 import 'rxjs';
 import 'vitest';
 

package/dist/nestjs.js

@@ -1,6 +1,6 @@
-export { trackInjections } from './chunk-LVLSMH6T.js';
+export { trackInjections } from './chunk-JV5XRAS4.js';
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-import { createSpyFromClass } from './chunk-B7PDIHEG.js';
+import { createSpyFromClass } from './chunk-7YTPHYP7.js';
 import './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';

package/dist/node.cjs

@@ -289,6 +289,19 @@ 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");
+  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 });
+  return shim;
+}
+var DISPOSE = installDisposeSymbol(Symbol);
+
 // src/lib/serialize-args.ts
 function createContext() {
   return { seen: /* @__PURE__ */ new WeakSet(), cache: /* @__PURE__ */ new Map(), circularHits: 0 };
@@ -874,7 +887,7 @@ function disposeAutoSpy() {
   resetAutoSpy(this);
 }
 function attachDispose(spy) {
-  Object.defineProperty(spy, Symbol.dispose, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
+  Object.defineProperty(spy, DISPOSE, { value: disposeAutoSpy, enumerable: false, configurable: true, writable: true });
 }
 
 // src/lib/auto-mock.ts
@@ -932,7 +945,7 @@ function createAutoMockHandler(seed, unstubbed) {
     defineProperty: (_target, key, descriptor) => storeDefinedProp(store, key, descriptor),
     deleteProperty: (_target, key) => dropStoredProp(store, key),
     has(_target, key) {
-      return key === AUTO_SPY_MARK || key === Symbol.dispose || hasStoredProp(store, key);
+      return key === AUTO_SPY_MARK || key === DISPOSE || hasStoredProp(store, key);
     },
     ownKeys() {
       return [.../* @__PURE__ */ new Set([...store.values.keys(), ...store.accessors.keys()])];
@@ -951,7 +964,7 @@ function readKey(store, key, receiver, unstubbed) {
   if (key === AUTO_SPY_MARK) {
     return true;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (typeof key === "symbol" || key === "then" || key === "constructor" || isProtocolKey(key) || isDeletedProp(store, key)) {
@@ -1310,7 +1323,7 @@ function readNodeMember(state, target, key, receiver) {
   if (key === DEEP_CHILDREN) {
     return state.children;
   }
-  if (key === Symbol.dispose) {
+  if (key === DISPOSE) {
     return disposeAutoSpy;
   }
   if (key === "then" || isProtocolKey(key)) {
@@ -1948,6 +1961,14 @@ var SILENT_NO_OP_CAUSES = "A `vi.mock()` that does not apply reports nothing: un
 var assertMocked = defineHelper((namespace, options = {}) => {
   const target = describeTarget2(options.specifier);
   const required = options.exports;
+  if (required?.length === 0) {
+    throw new Error(
+      withDocs(
+        `[vitest-auto-spy] assertMocked(${target}): the \`exports\` list is empty, so this call cannot fail and proves nothing. Drop the option to check that at least one export is a mock, or name the exports the test drives.`,
+        DOCS_LINKS.moduleMocks
+      )
+    );
+  }
   if (required) {
     const real = required.filter((name) => !isRunnerMock(Reflect.get(namespace, name)));
     if (real.length > 0) {

package/dist/node.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-CuGjE0YR.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-IgCwv_40.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-DMx5uXie.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-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/node.js

@@ -1,7 +1,7 @@
 import { createRedefineMockAdapter } from './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';
 import { mock } from 'node:test';

package/dist/{prop-mock-IgCwv_40.d.ts → prop-mock-DyjtZVoA.d.ts}

@@ -1,4 +1,4 @@
-import { P as PropStubValue } from './types-it6CnDkI.js';
+import { P as PropStubValue } from './types-Br-Usge9.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-CuGjE0YR.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-IgCwv_40.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-DMx5uXie.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-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/react.js

@@ -1,7 +1,7 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';

package/dist/rxjs.d.ts

@@ -1,6 +1,6 @@
 import { Observable, ReplaySubject } from 'rxjs';
-import { V as ValueConfig } from './types-it6CnDkI.js';
-export { A as AddObservableSpyMethods, b as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, c as ValueConfigPerCall } from './types-it6CnDkI.js';
+import { V as ValueConfig } from './types-Br-Usge9.js';
+export { A as AddObservableSpyMethods, b as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, c as ValueConfigPerCall } from './types-Br-Usge9.js';
 import 'vitest';
 
 /**

package/dist/rxjs.js

@@ -40,11 +40,18 @@ function mergeSubjectWithDefaultValues(subject, valuesConfigs) {
       return true;
     }),
     // Map each remaining entry to its emission: a value, an error, or nothing.
+    //
+    // The guards test *presence* (`'value' in config`), and that is the whole check: an entry that
+    // carries the key is an emission whatever the value is. Adding `&& config.value` on top — which
+    // is what stood here — silently dropped `{ value: false }`, `{ value: 0 }`, `{ value: '' }` and
+    // `{ value: null }`, i.e. an ordinary boolean or counter stream. Nothing was emitted, nothing
+    // was reported, and the symptom arrived a test away as a timed-out `expectEmission` or as a
+    // component still holding its initial state.
     concatMap((config) => {
-      if (isNextValueConfig(config) && config.value) {
+      if (isNextValueConfig(config)) {
         return config.delay ? of(config.value).pipe(delay(config.delay)) : of(config.value);
       }
-      if (isErrorConfig(config) && config.errorValue) {
+      if (isErrorConfig(config)) {
         return config.delay ? timer(config.delay).pipe(switchMap(() => throwError(() => config.errorValue))) : throwError(() => config.errorValue);
       }
       return EMPTY;

package/dist/setup.d.ts

@@ -1,6 +1,6 @@
 import { vi } from 'vitest';
-import { u as UnstubbedCallHandler } from './types-it6CnDkI.js';
-import { R as RestoreProp } from './prop-mock-IgCwv_40.js';
+import { u as UnstubbedCallHandler } from './types-Br-Usge9.js';
+import { R as RestoreProp } from './prop-mock-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 
@@ -348,6 +348,14 @@ interface SetupAutoSpyOptions {
      * 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.
+     *
+     * It also guards the mocks it keeps. A registered mock is reachable by `vi.resetAllMocks()` as
+     * well as by `vi.clearAllMocks()`, and `mockReset` puts an implementation back only when it was
+     * passed to `vi.fn(implementation)` — a chained `.mockReturnValue(…)` or `.mockReturnThis()` is
+     * simply lost. With `isolate: false` that surfaces as a failure in a later file, inside
+     * application code, blaming a component for a shared double some other spec reset. The
+     * implementation each long-lived mock carried when it was classified is therefore remembered and
+     * put back before a test that has lost it. See {@link restoreLongLivedImplementations}.
      */
     pruneMockRegistry?: boolean;
     /**
@@ -573,6 +581,17 @@ declare function captureMockRegistry(): Set<unknown> | undefined;
  * ```
  */
 declare function keepMockRegistered<T>(mock: T): T;
+/**
+ * Put back the implementation of every long-lived mock that has lost one, and report how many.
+ *
+ * The repair for a `vi.resetAllMocks()` — or a `mockReset: true` — reaching across files: it walks
+ * only the mocks that carried an implementation when they were classified, and only replaces one
+ * that is now missing, so a mock a test deliberately re-implements is left as the test left it.
+ *
+ * Installed on `beforeEach` by {@link trackMockRegistry}; call it directly to repair at some other
+ * moment.
+ */
+declare function restoreLongLivedImplementations(): number;
 /**
  * Mark everything currently in the registry as long-lived.
  *
@@ -747,4 +766,4 @@ declare function restoreTimerGlobals(): void;
 /** The names this module watches — exported for the diagnostics that report what went missing. */
 declare function getWatchedTimerGlobals(): string[];
 
-export { BLOCKED_FETCH_MESSAGE, BLOCKED_XHR_MESSAGE, type BlockNetworkOptions, 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, type XhrBlockMode, 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 };
+export { BLOCKED_FETCH_MESSAGE, BLOCKED_XHR_MESSAGE, type BlockNetworkOptions, 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, type XhrBlockMode, advanceTimers, blockNetwork, cancelStrayTimers, captureMockRegistry, countStrayRejections, countStrayTimers, flushStrayRejections, getMockRegistrySize, getWatchedTimerGlobals, guardGlobalPatches, installPerTest, keepMockRegistered, keepRegisteredMocks, mockNow, mockSystemTime, pruneMockRegistry, registerFocusMatchers, resetMockRegistryTracking, restoreLongLivedImplementations, restoreTimerGlobals, setupAutoSpy, setupFakeTimers, trackMockRegistry, trackStrayRejections, trackStrayTimers, useCountingClock, withSystemTime };

package/dist/setup.js

@@ -205,9 +205,32 @@ ${describeHookTimeout(timeouts)}`);
 var registry;
 var captureAttempted = false;
 var longLived = /* @__PURE__ */ new WeakSet();
+var rememberedImplementations = [];
+var implementationsChecked = /* @__PURE__ */ new WeakSet();
 function isWeakKey(value) {
   return typeof value === "function" || typeof value === "object" && value !== null;
 }
+function isMockImplementation(value) {
+  return typeof value === "function";
+}
+function hasImplementationControls(value) {
+  const getter = Reflect.get(value, "getMockImplementation");
+  const setter = Reflect.get(value, "mockImplementation");
+  return typeof getter === "function" && typeof setter === "function";
+}
+function rememberImplementation(mock) {
+  if (implementationsChecked.has(mock)) {
+    return;
+  }
+  implementationsChecked.add(mock);
+  if (!hasImplementationControls(mock)) {
+    return;
+  }
+  const implementation = mock.getMockImplementation();
+  if (isMockImplementation(implementation)) {
+    rememberedImplementations.push({ mock, implementation });
+  }
+}
 function captureMockRegistry() {
   if (captureAttempted) {
     return registry;
@@ -238,9 +261,20 @@ function captureMockRegistry() {
 function keepMockRegistered(mock) {
   if (isWeakKey(mock)) {
     longLived.add(mock);
+    rememberImplementation(mock);
   }
   return mock;
 }
+function restoreLongLivedImplementations() {
+  let restored = 0;
+  for (const remembered of rememberedImplementations) {
+    if (remembered.mock.getMockImplementation() === void 0) {
+      remembered.mock.mockImplementation(remembered.implementation);
+      restored += 1;
+    }
+  }
+  return restored;
+}
 function keepRegisteredMocks() {
   registry?.forEach((mock) => {
     keepMockRegistered(mock);
@@ -264,6 +298,9 @@ function trackMockRegistry() {
     captureMockRegistry();
     keepRegisteredMocks();
   });
+  beforeEach(() => {
+    restoreLongLivedImplementations();
+  });
   afterAll(() => {
     pruneMockRegistry();
   });
@@ -275,6 +312,8 @@ function resetMockRegistryTracking() {
   registry = void 0;
   captureAttempted = false;
   longLived = /* @__PURE__ */ new WeakSet();
+  rememberedImplementations = [];
+  implementationsChecked = /* @__PURE__ */ new WeakSet();
 }
 
 // src/lib/network-stub.ts
@@ -829,4 +868,4 @@ function registerFocusMatchers() {
 }
 useVitestAdapter();
 
-export { BLOCKED_FETCH_MESSAGE, BLOCKED_XHR_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 };
+export { BLOCKED_FETCH_MESSAGE, BLOCKED_XHR_MESSAGE, advanceTimers, blockNetwork, cancelStrayTimers, captureMockRegistry, countStrayRejections, countStrayTimers, flushStrayRejections, getMockRegistrySize, getWatchedTimerGlobals, guardGlobalPatches, installPerTest, keepMockRegistered, keepRegisteredMocks, mockNow, mockSystemTime, pruneMockRegistry, registerFocusMatchers, resetMockRegistryTracking, restoreLongLivedImplementations, restoreTimerGlobals, setupAutoSpy, setupFakeTimers, trackMockRegistry, trackStrayRejections, trackStrayTimers, useCountingClock, withSystemTime };

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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.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 AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-CuGjE0YR.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-IgCwv_40.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-DMx5uXie.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-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/svelte.js

@@ -1,7 +1,7 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';

package/dist/{track-injections-BAzV5ITq.d.ts → track-injections-BQndbppn.d.ts}

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

package/dist/{types-it6CnDkI.d.ts → types-Br-Usge9.d.ts}

@@ -1,5 +1,5 @@
 import { Observable, Subject } from 'rxjs';
-import { Mock } from 'vitest';
+import { Mock, MockInstance } from 'vitest';
 
 /**
  * Public type surface (mirrors `@hirez_io/auto-spies-core`).
@@ -177,8 +177,19 @@ interface AddVoidReturnHelpers {
  *    `ReturnType extends Promise<…>` distributes over the `infer`-bound parameter, and distributing
  *    over `never` yields `never` — the same collapse by a different route, for a method whose
  *    return type does resolve, to `never`.
+ * 3. **The mock surface is `MockInstance`, not `Mock`.** `Mock` is `Mock<Procedure>` here, and
+ *    `Procedure` is `(...args: any[]) => any` — so it contributed a call signature that swallows
+ *    anything. An intersection accepts a call matching *either* member, so on a double of
+ *    `read(key: string)` all three of `read(1)`, `read('ok', 'extra')` and `read()` compiled, none
+ *    of them compiles on the real instance, and the spec stayed green while calling the double the
+ *    way production code never could. `MockInstance` is the same surface *without* the call and
+ *    construct signatures, so the only call signature left is `Method`'s own. Nothing about
+ *    configuring the double changed: `MockInstance` defaults to `Procedure` too, so
+ *    `mockReturnValue` / `mockImplementation` stay as lenient as they were. Side effect worth
+ *    knowing: with one call signature instead of two, `expectTypeOf(spy.method).parameters` and
+ *    `.returns` resolve instead of collapsing to `never`.
  */
-type AddSpyMethodsByReturnTypes<Method extends Func> = Method & Mock & (Method extends (...args: any[]) => infer ReturnType ? [ReturnType] extends [Promise<infer P>] ? AddCalledWithPromise<Method, P> & AddPromiseSpyMethods<P> : [ReturnType] extends [Observable<infer O>] ? AddCalledWithObservable<Method, O> & AddObservableSpyMethods<O> : [ReturnType] extends [void] ? AddCalledWithSpyMethods<Method> & AddVoidReturnHelpers : AddCalledWithSpyMethods<Method> : AddCalledWithSpyMethods<Method>);
+type AddSpyMethodsByReturnTypes<Method extends Func> = Method & MockInstance & (Method extends (...args: any[]) => infer ReturnType ? [ReturnType] extends [Promise<infer P>] ? AddCalledWithPromise<Method, P> & AddPromiseSpyMethods<P> : [ReturnType] extends [Observable<infer O>] ? AddCalledWithObservable<Method, O> & AddObservableSpyMethods<O> : [ReturnType] extends [void] ? AddCalledWithSpyMethods<Method> & AddVoidReturnHelpers : AddCalledWithSpyMethods<Method> : AddCalledWithSpyMethods<Method>);
 /**
  * Every call signature of `F`, in declaration order.
  *

package/dist/vue.d.ts

@@ -1,8 +1,8 @@
-import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-it6CnDkI.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 AddVoidReturnHelpers, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-it6CnDkI.js';
+import { S as Spy, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf } from './types-Br-Usge9.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 AddVoidReturnHelpers, b 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, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-Br-Usge9.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-CuGjE0YR.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-IgCwv_40.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-DMx5uXie.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-DyjtZVoA.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import 'rxjs';
 import 'vitest';

package/dist/vue.js

@@ -1,8 +1,8 @@
 import { vitestMockAdapter } from './chunk-MG5EAMZR.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-FKAXOKP5.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, compareTestRuns, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, diffByField, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, formatTestRunComparison, getPackageCopies, intersectionEntry, mockConstructor, mockDeep, moduleNamespace, mutationRecord, narrow, resizeEntry, setEmissionTimeout, settleDynamicImport, stubAbortController, stubConstructor, stubIntersectionObserver, stubMediaElement, stubMutationObserver, stubObserver, stubResizeObserver, summarizeTestRun, withOverrides } from './chunk-IKH4OTMV.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-R4EWAG7Y.js';
-import { createSpyFromClass } from './chunk-B7PDIHEG.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-B7PDIHEG.js';
+import { createSpyFromClass } from './chunk-7YTPHYP7.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-7YTPHYP7.js';
 export { createFunctionSpy, errorHandler } from './chunk-3AWKPZCE.js';
 import './chunk-J5O72UHX.js';
 import { registerMockAdapter } from './shared-state.js';

package/dist/{zoneless-BUNSBSIP.d.ts → zoneless-CEhs7o9p.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-CuGjE0YR.js';
-import { S as Spy, C as ClassType, s as SpyOptions, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, l as DeepPartial } from './types-it6CnDkI.js';
-import './prop-mock-IgCwv_40.js';
+import { A as AutoMockConfiguration } from './expect-emission-DMx5uXie.js';
+import { S as Spy, C as ClassType, s as SpyOptions, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, l as DeepPartial } from './types-Br-Usge9.js';
+import './prop-mock-DyjtZVoA.js';
 import { ComponentFixture } from '@angular/core/testing';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "3.12.0",
+  "version": "3.13.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.",
   "keywords": [
     "auto-mock",