vitest-auto-spy 4.2.0 → 4.3.0

package/dist/angular.js

@@ -1,5 +1,5 @@
-import { guardAccessorSpies, registerMockAdapter, getMockAdapter, getObservableSupport, getJasmineSupport, requireObservableSupport } from './shared-state.js';
-export { expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, setEmissionTimeout } from './shared-state.js';
+import { guardAccessorSpies, registerMockAdapter, getMockAdapter, getObservableSupport, getJasmineSupport, emissionTimeout, requireObservableSupport } from './shared-state.js';
+export { setEmissionTimeout } from './shared-state.js';
 import { vi, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
 import { TestBed, getTestBed } from '@angular/core/testing';
 import { isStandalone, Component, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, ApplicationRef, signal, computed, ɵSIGNAL as _SIGNAL, InjectionToken } from '@angular/core';
@@ -629,6 +629,28 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /**
+   * Every configured argument list as a {@link ConfiguredEntry} — the same lists {@link configured}
+   * returns, each carrying its own position and its own predicate.
+   *
+   * The order is the order a lookup consults them (exact configs first, then the asymmetric ones in
+   * registration order), so the first entry whose `matches` holds is the config `get` would have
+   * answered from. That is what lets a reader be told "call 3 hit config 2" instead of a list of
+   * configs and a list of calls with nothing joining them.
+   */
+  configuredEntries() {
+    const exact = Object.keys(this.#map).map((key, position) => ({
+      index: position + 1,
+      args: key,
+      matches: (actualArgs) => this.#serialize(actualArgs) === key
+    }));
+    const asymmetric = this.#matcherConfigs.map((config, position) => ({
+      index: exact.length + position + 1,
+      args: `[${config.described.join(",")}]`,
+      matches: (actualArgs) => this.#argsMatch(config, actualArgs)
+    }));
+    return [...exact, ...asymmetric];
+  }
   /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
   #buildMatcherConfig(key, value) {
     const serialized = [];
@@ -1506,7 +1528,12 @@ function resolveAccessors(prototype, config) {
   };
 }
 function resolveMethodNames(ObjectClass, config) {
-  const base = config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getAllMethodNames(ObjectClass.prototype);
+  return mergeMethodNames(
+    config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getAllMethodNames(ObjectClass.prototype),
+    config
+  );
+}
+function mergeMethodNames(base, config) {
   if (config.methodsToSpyOn.length === 0 && config.instanceMethodsToSpyOn.length === 0) {
     return base;
   }
@@ -1545,7 +1572,7 @@ function warnOnAccessorNamingAMethod(ObjectClass, config) {
 function isCallable2(value) {
   return typeof value === "function";
 }
-function applyReturns(autoSpy, ObjectClass, returns) {
+function applyReturns(autoSpy, factory, returns) {
   const entries = Object.entries(returns);
   if (entries.length === 0) {
     return;
@@ -1556,7 +1583,7 @@ function applyReturns(autoSpy, ObjectClass, returns) {
     if (!isCallable2(spy)) {
       console.warn(
         withDocs(
-          `[vitest-auto-spy] createSpyFromClass(${ObjectClass.name}): returns names '${name}', which is not a spied method of the spy. Check the spelling, and check that a restricting onlyMethodsToSpyOn list did not leave it out \u2014 a value configured for a method that is not there is silently never returned.`,
+          `[vitest-auto-spy] ${factory}: returns names '${name}', which is not a spied method of the spy. Check the spelling, and check that a restricting onlyMethodsToSpyOn list did not leave it out \u2014 a value configured for a method that is not there is silently never returned.`,
           DOCS_LINKS.createSpyFromClass
         )
       );
@@ -1608,7 +1635,7 @@ function resolveConfiguration(methodsToSpyOnOrConfig) {
 function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
   const config = resolveConfiguration(methodsToSpyOnOrConfig);
   const autoSpy = assembleSpy(ObjectClass, config);
-  applyReturns(autoSpy, ObjectClass, config.returns);
+  applyReturns(autoSpy, `createSpyFromClass(${ObjectClass.name})`, config.returns);
   applyOverrides(autoSpy, config.overrides);
   return autoSpy;
 }
@@ -2737,6 +2764,248 @@ function registerSignalMatchers() {
     }
   });
 }
+
+// src/lib/error-anchor.ts
+var OWN_FAILURE = /* @__PURE__ */ Symbol("vitest-auto-spy.own-failure");
+function ownFailure(message, options) {
+  const error = new Error(message, options);
+  Object.defineProperty(error, OWN_FAILURE, { value: true });
+  return error;
+}
+function anchorOf(stack, boundaryName) {
+  const frames = framesAfter(frameLines(stack), boundaryName);
+  return (error) => anchor(frames, error);
+}
+function captureAnchor(boundary, host = Error) {
+  const holder = new Error();
+  const capture = host.captureStackTrace;
+  if (capture) {
+    capture(holder, boundary);
+    return anchorOf(holder.stack, "");
+  }
+  return anchorOf(holder.stack, boundary.name);
+}
+function anchor(frames, error) {
+  if (frames.length === 0 || Reflect.get(error, OWN_FAILURE) !== true) {
+    return error;
+  }
+  error.stack = [`${error.name}: ${error.message}`, ...frames].join("\n");
+  return error;
+}
+function frameLines(stack) {
+  const lines = String(stack).split("\n");
+  const first = lines.findIndex(isFrame);
+  return first < 0 ? [] : lines.slice(first);
+}
+function isFrame(line) {
+  return /^\s*at\s/.test(line) || /^\S*@/.test(line);
+}
+function framesAfter(frames, boundaryName) {
+  const boundary = boundaryName === "" ? -1 : frames.findIndex((frame) => frame.includes(boundaryName));
+  return boundary < 0 ? frames : frames.slice(boundary + 1);
+}
+function subscribeToSource(source$, observer) {
+  if (isRxjsSource(source$)) {
+    return source$.subscribe(observer);
+  }
+  return source$.subscribe(asHybridObserver(observer));
+}
+function isRxjsSource(source$) {
+  return typeof Reflect.get(source$, "pipe") === "function";
+}
+function asHybridObserver(observer) {
+  const listener = (value) => observer.next(value);
+  return Object.assign(listener, observer);
+}
+var setTimer2 = globalThis.setTimeout.bind(globalThis);
+var clearTimer2 = globalThis.clearTimeout.bind(globalThis);
+function describeSource(options) {
+  return options?.label ?? "the observable";
+}
+function accepted(values, options) {
+  const past = options?.skip ? values.slice(options.skip) : values;
+  const until = options?.until;
+  return until ? past.filter((value) => until(value)) : past;
+}
+function describeExpectation(count, options) {
+  return options?.until ? `${count} matching` : String(count);
+}
+function subscribeAndCollect(source$, options, settle, handlers) {
+  const values = [];
+  let subscription = void 0;
+  let stopped = false;
+  const stop = () => {
+    stopped = true;
+    clearTimer2(timer);
+    subscription?.unsubscribe();
+  };
+  const timeout = options?.timeout ?? emissionTimeout();
+  const timer = timeout > 0 ? setTimer2(() => {
+    stop();
+    settle.reject(handlers.onTimeout(values, options, timeout));
+  }, timeout) : void 0;
+  subscription = subscribeToSource(source$, {
+    next: (value) => {
+      values.push(value);
+      if (handlers.isDone(values)) {
+        stop();
+        settle.resolve(values);
+      }
+    },
+    error: (error) => {
+      stop();
+      handlers.onError(error, options, settle);
+    },
+    complete: () => {
+      stop();
+      handlers.onComplete(values);
+    }
+  });
+  if (stopped) {
+    subscription.unsubscribe();
+  }
+  if (!stopped) {
+    options?.advance?.();
+  }
+  return { values, stop };
+}
+function anchoredRejecter(reject, anchor2) {
+  return (error) => reject(anchor2(error));
+}
+function timeoutError(values, options, waited) {
+  return ownFailure(
+    `${describeSource(options)} did not emit within ${waited} ms (${values.length} emission(s) received). Either the stream never fired \u2014 check the trigger and any provider spy feeding it \u2014 or it is slower than the timeout; raise it with \`{ timeout: \u2026 }\`. This wait is real time even under fake timers, on purpose: a virtual watchdog would race the timers your spec advances. Lower it with \`setEmissionTimeout(100)\` in the setup file rather than disabling it with \`{ timeout: 0 }\`, which leaves the next silent stream with no message at all.`
+  );
+}
+function rejectAsSourceError(error, options, settle) {
+  settle.reject(ownFailure(`${describeSource(options)} errored instead of emitting: ${String(error)}`, { cause: error }));
+}
+function completedError(values, expected, options) {
+  return ownFailure(
+    `${describeSource(options)} completed after ${values.length} emission(s), expected ${describeExpectation(expected, options)}. A completed-but-empty stream is the usual sign that the value was produced before the subscription.`
+  );
+}
+function expectEmission(source$, options) {
+  return collectEmissions(source$, 1, options, captureAnchor(expectEmission)).then((values) => firstOf(values));
+}
+function firstOf(values) {
+  return values[0];
+}
+function expectEmissions(source$, count, options) {
+  return collectEmissions(source$, count, options, captureAnchor(expectEmissions));
+}
+function collectEmissions(source$, count, options, anchor2) {
+  return new Promise((resolve, reject) => {
+    const fail = anchoredRejecter(reject, anchor2);
+    subscribeAndCollect(
+      source$,
+      options,
+      // Resolved with everything that arrived, then narrowed to the accepted ones: the collector's
+      // job is to record, and `skip` / `until` decide what the caller is handed.
+      { resolve: (values) => resolve(accepted(values, options).slice(0, count)), reject: fail },
+      {
+        isDone: (values) => accepted(values, options).length >= count,
+        onComplete: (values) => fail(completedError(values, count, options)),
+        onTimeout: timeoutError,
+        onError: rejectAsSourceError
+      }
+    );
+  });
+}
+function expectNoEmission(source$, options) {
+  const quietFor = options?.timeout ?? 0;
+  const anchor2 = captureAnchor(expectNoEmission);
+  let quietWindow = void 0;
+  return new Promise((resolve, reject) => {
+    const fail = anchoredRejecter(reject, anchor2);
+    const collector = subscribeAndCollect(
+      source$,
+      { ...options, timeout: 0 },
+      {
+        resolve: (emitted) => fail(unexpectedEmissionError(accepted(emitted, options), options)),
+        reject: fail
+      },
+      {
+        isDone: (values) => accepted(values, options).length > 0,
+        onComplete: () => void 0,
+        // Never reached — the watchdog is off (`timeout: 0`) and the quiet window below is this
+        // helper's own timer. Named rather than inlined so it is not an uncalled arrow.
+        onTimeout: timeoutError,
+        onError: rejectAsSourceError
+      }
+    );
+    quietWindow = setTimer2(() => {
+      collector.stop();
+      resolve();
+    }, quietFor);
+  }).finally(() => {
+    clearTimer2(quietWindow);
+  });
+}
+function expectCompletion(source$, options) {
+  const anchor2 = captureAnchor(expectCompletion);
+  return new Promise((resolve, reject) => {
+    subscribeAndCollect(
+      source$,
+      options,
+      { resolve, reject: anchoredRejecter(reject, anchor2) },
+      {
+        // Emissions are collected for the failure message, but only completion settles this.
+        isDone: staysOpen,
+        onComplete: resolve,
+        onTimeout: notCompletedError,
+        onError: rejectAsNotCompleted
+      }
+    );
+  }).then(() => void 0);
+}
+function staysOpen() {
+  return false;
+}
+function notCompletedError(values, options, waited) {
+  return ownFailure(
+    `${describeSource(options)} did not complete within ${waited} ms (${values.length} emission(s) received). A stream that keeps running usually means the completing operator never ran \u2014 check \`take\`, \`first\`, \`takeUntil\`, or a Subject nobody calls \`complete()\` on. The wait is real time even under fake timers; raise it with \`{ timeout: \u2026 }\`, or lower the suite default with \`setEmissionTimeout(\u2026)\`.`
+  );
+}
+function rejectAsNotCompleted(error, options, settle) {
+  settle.reject(ownFailure(`${describeSource(options)} errored instead of completing: ${String(error)}`, { cause: error }));
+}
+function expectError(source$, options) {
+  const anchor2 = captureAnchor(expectError);
+  return new Promise((resolve, reject) => {
+    const fail = anchoredRejecter(reject, anchor2);
+    subscribeAndCollect(
+      source$,
+      options,
+      { resolve, reject: fail },
+      {
+        // Only `error` settles this one: an emission is not the answer, and neither is completion.
+        isDone: staysOpen,
+        onComplete: (values) => fail(completedWithoutErrorError(values, options)),
+        onTimeout: notErroredError,
+        onError: resolveWithError
+      }
+    );
+  }).then((values) => firstOf(values));
+}
+function completedWithoutErrorError(values, options) {
+  return ownFailure(
+    `${describeSource(options)} completed after ${values.length} emission(s) without erroring, but an error was expected. Check that the failure path is the one the spec set up \u2014 a spy configured with \`resolveWith\`/\`nextWith\` rather than \`rejectWith\`/\`throwWith\` produces exactly this.`
+  );
+}
+function notErroredError(values, options, waited) {
+  return ownFailure(
+    `${describeSource(options)} did not error within ${waited} ms (${values.length} emission(s) received). The stream is still running: nothing failed, and nothing completed either.`
+  );
+}
+function resolveWithError(error, _options, settle) {
+  settle.resolve([error]);
+}
+function unexpectedEmissionError(values, options) {
+  return ownFailure(`${describeSource(options)} emitted ${serializeValue(values[0])} but was expected to stay silent.`);
+}
+
+// src/angular.ts
 useVitestAdapter();
 
-export { assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, countMockedProps, createDirectiveHost, createWithAutoSpies, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, extendWithAutoSpies, flushEffects, formatSpecTiming, getTestBedTiming, injectSpy, instrumentTestBed, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockResourceProp, mockSignalProp, mockValueProp, overrideAutoSpy, overrideComponentProvider, provideAutoSpy, provideAutoSpyForToken, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, renderShallow, reportSpecTiming, restoreMockedProps, runEffect, settleResource, setupAngularTestEnv, stable, trackInjections };
+export { assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, countMockedProps, createDirectiveHost, createWithAutoSpies, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, extendWithAutoSpies, flushEffects, formatSpecTiming, getTestBedTiming, injectSpy, instrumentTestBed, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockResourceProp, mockSignalProp, mockValueProp, overrideAutoSpy, overrideComponentProvider, provideAutoSpy, provideAutoSpyForToken, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, renderShallow, reportSpecTiming, restoreMockedProps, runEffect, settleResource, setupAngularTestEnv, stable, trackInjections };

package/dist/bun-angular.d.ts

@@ -1,9 +1,9 @@
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, S as Spy, t as SpyDisposable, u as SpyOptions, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, y as UnstubbedCallHandler, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.js';
-export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, settleDynamicImport, stubConstructor, 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-BDuFuqTb.js';
+export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, 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-Dy5CvsF2.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-Dp2ZMFqj.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-DGwkbWKm.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-LsBDcSNZ.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,13 +1,13 @@
 import { flushEffects } from './chunk-5BPM3BLI.js';
 export { flushEffects, stable } from './chunk-5BPM3BLI.js';
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-KEKKEIRG.js';
+import { createSpyForToken } from './chunk-Z4VRMCW2.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5URFSYDT.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DSIYS6Y5.js';
-import { createSpyFromClass } from './chunk-4KCYFAJX.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-4KCYFAJX.js';
-export { createFunctionSpy, errorHandler } from './chunk-4KK3ES4P.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-GAY6LNAM.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-D5LDT3W4.js';
+import { createSpyFromClass } from './chunk-FYFF67EN.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-FYFF67EN.js';
+export { createFunctionSpy, errorHandler } from './chunk-FFKN6QKI.js';
 import './chunk-PC3FAZT3.js';
 import { isAutoSpyLike } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';

package/dist/bun.d.ts

@@ -1,6 +1,6 @@
 import { u as SpyOptions, C as ClassType, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, S as Spy, m as DeepPartial, D as DeepMockProxy, F as Func, y as UnstubbedCallHandler, g as AddSpyMethodsByReturnTypes } from './types-CQLPjw8z.js';
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, l as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as Overloads, P as PropStubValue, t as SpyDisposable, v as StrictSpyConfiguration, w as SubjectLike, x as SubjectOf, U as UnstubbedCall, V as ValueConfig, z as ValueConfigPerCall, W as WithMockReturnValue } from './types-CQLPjw8z.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-BDuFuqTb.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-Dy5CvsF2.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-Dp2ZMFqj.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import { Mock } from 'vitest';
@@ -30,6 +30,48 @@ import { Mock } from 'vitest';
  */
 declare function createSpyFromClass<T, Options extends SpyOptions = SpyOptions>(ObjectClass: ClassType<T>, methodsToSpyOnOrConfig?: ClassSpyConfiguration<T> | OnlyMethodKeysOf<T>[]): Spy<T, Options>;
 
+/**
+ * Undo every {@link createSpyFromInstance} patch on `instance`, newest first. A no-op on an object
+ * that was never spied, or that has already been restored.
+ *
+ * `restoreMockedProps()` (and therefore `setupAutoSpy()`) undoes the same patches as part of its
+ * sweep — this is the targeted form, for an object that has to be real again inside the same test.
+ *
+ * @example
+ * ```ts
+ * restoreSpiedInstance(client); // client.send is the real method again
+ * ```
+ */
+declare function restoreSpiedInstance(instance: object): void;
+/**
+ * Replace an existing object's methods with this library's spies, in place, and hand it back typed
+ * as a double.
+ *
+ * @example
+ * ```ts
+ * const client = new PaymentsClient(config); // a real object the test already holds
+ * const spy = createSpyFromInstance(client);
+ *
+ * spy.charge.calledWith(100).resolveWith({ ok: true });
+ * await service.pay(); // the code under test still holds `client`, and sees the spy
+ *
+ * restoreSpiedInstance(client);
+ * ```
+ *
+ * @remarks
+ * Discovery takes the object's own function-valued fields *and* every prototype method up to but not
+ * including `Object.prototype`, so an arrow-function property needs no `instanceMethodsToSpyOn` here
+ * and `hasOwnProperty` is never replaced. The configuration is {@link createSpyFromClass}', minus
+ * the two options that describe a double being built rather than an object being patched:
+ * `lazySpies` (the members already exist, so there is nothing to defer) and `fillMissing` (an
+ * instance is not an erased `abstract` declaration).
+ *
+ * The returned value **is** the argument. `using spy = createSpyFromInstance(client)` restores the
+ * object at the end of the block rather than merely resetting it, which is the only sense `dispose`
+ * can have for an object the consumer owns.
+ */
+declare function createSpyFromInstance<T extends object, Options extends SpyOptions = SpyOptions>(instance: T, methodsToSpyOnOrConfig?: ClassSpyConfiguration<T> | OnlyMethodKeysOf<T>[]): Spy<T, Options>;
+
 /**
  * `createMock` — a typed stand-in built from the fields a test actually touches.
  *
@@ -324,6 +366,24 @@ declare function clearAutoSpy(spy: object): void;
  */
 declare function resetAutoSpy(spy: object): void;
 
+/**
+ * One registered config, addressable on its own.
+ *
+ * {@link ArgsMap.configured} renders every config as a string, which is all a failure message
+ * needs. Attributing an actual call to *which* config it hit needs a handle instead — re-rendering
+ * the text and comparing it is not one, because two chains can render the same list.
+ *
+ * Built on demand: nothing here is written by `set` or read by `get`, so the match path is
+ * untouched by the existence of this surface.
+ */
+interface ConfiguredEntry {
+    /** 1-based position in {@link ArgsMap.configuredEntries}, in the order a lookup consults them. */
+    readonly index: number;
+    /** The config's argument list, rendered the way {@link ArgsMap.configured} renders it. */
+    readonly args: string;
+    /** Whether an actual call's arguments hit this config. */
+    matches(actualArgs: unknown[]): boolean;
+}
 declare class ArgsMap {
     #private;
     set(key: unknown, value: unknown): void;
@@ -337,6 +397,16 @@ declare class ArgsMap {
      * assembling text it already has.
      */
     configured(): string[];
+    /**
+     * Every configured argument list as a {@link ConfiguredEntry} — the same lists {@link configured}
+     * returns, each carrying its own position and its own predicate.
+     *
+     * The order is the order a lookup consults them (exact configs first, then the asymmetric ones in
+     * registration order), so the first entry whose `matches` holds is the config `get` would have
+     * answered from. That is what lets a reader be told "call 3 hit config 2" instead of a list of
+     * configs and a list of calls with nothing joining them.
+     */
+    configuredEntries(): ConfiguredEntry[];
 }
 
 /**
@@ -829,4 +899,4 @@ type ModuleNamespace<T extends object> = T & {
  */
 declare function moduleNamespace<T extends object>(exports: T, options?: ModuleNamespaceOptions): ModuleNamespace<T>;
 
-export { AddSpyMethodsByReturnTypes, type ArgCaptor, type AsInstances, type AssertMockedOptions, ClassSpyConfiguration, ClassType, type ConstructorMock, type ConstructorSpy, DeepMockProxy, DeepPartial, type FixtureFactory, type FlushUntilOptions, Func, type MockDeepOptions, type ModuleNamespace, type ModuleNamespaceOptions, OnlyMethodKeysOf, Spy, SpyOptions, UnstubbedCallHandler, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, settleDynamicImport, stubConstructor, withOverrides };
+export { AddSpyMethodsByReturnTypes, type ArgCaptor, type AsInstances, type AssertMockedOptions, ClassSpyConfiguration, ClassType, type ConstructorMock, type ConstructorSpy, DeepMockProxy, DeepPartial, type FixtureFactory, type FlushUntilOptions, Func, type MockDeepOptions, type ModuleNamespace, type ModuleNamespaceOptions, OnlyMethodKeysOf, Spy, SpyOptions, UnstubbedCallHandler, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides };

package/dist/bun.js

@@ -1,9 +1,9 @@
 import './chunk-Y4YG7UOK.js';
 import './chunk-NQXXUJPS.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-5URFSYDT.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DSIYS6Y5.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-4KCYFAJX.js';
-export { createFunctionSpy, errorHandler } from './chunk-4KK3ES4P.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-GAY6LNAM.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-D5LDT3W4.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-FYFF67EN.js';
+export { createFunctionSpy, errorHandler } from './chunk-FFKN6QKI.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-XRVVZXOM.js';
 import './chunk-B45HLBA4.js';

package/dist/{chunk-DSIYS6Y5.js → chunk-D5LDT3W4.js}

@@ -122,4 +122,4 @@ function mockAccessorsProp(object, property, accessors) {
   });
 }
 
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps };
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, redefineFailure, restoreMockedProps };

package/dist/{chunk-2ZG27FVL.js → chunk-EMASXQDZ.js}

@@ -1,4 +1,4 @@
-import { vitestMockAdapter } from './chunk-WQZ2RKS7.js';
+import { vitestMockAdapter } from './chunk-KYAJCFUA.js';
 import { registerMockAdapter } from './shared-state.js';
 
 function useVitestAdapter() {

package/dist/{chunk-4KK3ES4P.js → chunk-FFKN6QKI.js}

@@ -247,6 +247,28 @@ var ArgsMap = class {
     const asymmetric = this.#matcherConfigs.map((config) => `[${config.described.join(",")}]`);
     return [...Object.keys(this.#map), ...asymmetric];
   }
+  /**
+   * Every configured argument list as a {@link ConfiguredEntry} — the same lists {@link configured}
+   * returns, each carrying its own position and its own predicate.
+   *
+   * The order is the order a lookup consults them (exact configs first, then the asymmetric ones in
+   * registration order), so the first entry whose `matches` holds is the config `get` would have
+   * answered from. That is what lets a reader be told "call 3 hit config 2" instead of a list of
+   * configs and a list of calls with nothing joining them.
+   */
+  configuredEntries() {
+    const exact = Object.keys(this.#map).map((key, position) => ({
+      index: position + 1,
+      args: key,
+      matches: (actualArgs) => this.#serialize(actualArgs) === key
+    }));
+    const asymmetric = this.#matcherConfigs.map((config, position) => ({
+      index: exact.length + position + 1,
+      args: `[${config.described.join(",")}]`,
+      matches: (actualArgs) => this.#argsMatch(config, actualArgs)
+    }));
+    return [...exact, ...asymmetric];
+  }
   /** Render one asymmetric config once, at registration time. See {@link MatcherConfig}. */
   #buildMatcherConfig(key, value) {
     const serialized = [];

package/dist/{chunk-4KCYFAJX.js → chunk-FYFF67EN.js}

@@ -1,6 +1,6 @@
-import { resolveUnstubbedGuard, createFunctionSpy } from './chunk-4KK3ES4P.js';
+import { resolveUnstubbedGuard, createFunctionSpy } from './chunk-FFKN6QKI.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { runClearHook, runConfigReset, AUTO_SPY_MARK, isMarkedMock, readDeepChildren, markAsMock } from './chunk-XRVVZXOM.js';
+import { runClearHook, runConfigReset, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-XRVVZXOM.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';
 import { getMockAdapter, requireObservableSupport, getJasmineSupport } from './shared-state.js';
 
@@ -380,6 +380,17 @@ function walkOwnPrototypes(prototype, visit) {
     current = parent;
   }
 }
+function getCallableMemberNames(target) {
+  const names = /* @__PURE__ */ new Set();
+  walkOwnPrototypes(target, (obj) => {
+    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(obj))) {
+      if (name !== "constructor" && typeof descriptor.value === "function") {
+        names.add(name);
+      }
+    }
+  });
+  return [...names];
+}
 var methodNamesCache = /* @__PURE__ */ new WeakMap();
 function getAllMethodNames(prototype) {
   const cached = methodNamesCache.get(prototype);
@@ -437,7 +448,12 @@ function resolveAccessors(prototype, config) {
   };
 }
 function resolveMethodNames(ObjectClass, config) {
-  const base = config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getAllMethodNames(ObjectClass.prototype);
+  return mergeMethodNames(
+    config.onlyMethodsToSpyOn.length > 0 ? config.onlyMethodsToSpyOn : getAllMethodNames(ObjectClass.prototype),
+    config
+  );
+}
+function mergeMethodNames(base, config) {
   if (config.methodsToSpyOn.length === 0 && config.instanceMethodsToSpyOn.length === 0) {
     return base;
   }
@@ -476,7 +492,7 @@ function warnOnAccessorNamingAMethod(ObjectClass, config) {
 function isCallable2(value) {
   return typeof value === "function";
 }
-function applyReturns(autoSpy, ObjectClass, returns) {
+function applyReturns(autoSpy, factory, returns) {
   const entries = Object.entries(returns);
   if (entries.length === 0) {
     return;
@@ -487,7 +503,7 @@ function applyReturns(autoSpy, ObjectClass, returns) {
     if (!isCallable2(spy)) {
       console.warn(
         withDocs(
-          `[vitest-auto-spy] createSpyFromClass(${ObjectClass.name}): returns names '${name}', which is not a spied method of the spy. Check the spelling, and check that a restricting onlyMethodsToSpyOn list did not leave it out \u2014 a value configured for a method that is not there is silently never returned.`,
+          `[vitest-auto-spy] ${factory}: returns names '${name}', which is not a spied method of the spy. Check the spelling, and check that a restricting onlyMethodsToSpyOn list did not leave it out \u2014 a value configured for a method that is not there is silently never returned.`,
           DOCS_LINKS.createSpyFromClass
         )
       );
@@ -539,7 +555,7 @@ function resolveConfiguration(methodsToSpyOnOrConfig) {
 function createSpyFromClass(ObjectClass, methodsToSpyOnOrConfig) {
   const config = resolveConfiguration(methodsToSpyOnOrConfig);
   const autoSpy = assembleSpy(ObjectClass, config);
-  applyReturns(autoSpy, ObjectClass, config.returns);
+  applyReturns(autoSpy, `createSpyFromClass(${ObjectClass.name})`, config.returns);
   applyOverrides(autoSpy, config.overrides);
   return autoSpy;
 }
@@ -586,4 +602,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 { NOT_STORED, applyReturns, autoMocked, clearAutoSpy, createAccessorsSpies, createAutoMock, createProxyPropStore, createSpyFromClass, describeStoredProp, disposeAutoSpy, dropStoredProp, getCallableMemberNames, isDeletedProp, isProtocolKey, mergeMethodNames, readStoredAccessor, resetAutoSpy, resolveAccessors, resolveConfiguration, storeDefinedProp, writeStoredAccessor, writeStoredValue };