vitest-auto-spy 3.15.0 → 3.16.0

package/AGENTS.md

@@ -265,6 +265,14 @@ across two thousand tests is under a tenth of a second. Call the factory in `bef
 `provideAutoSpy` defaults to, and `autoSpyAccessors: true` walks the prototype chain uncached on
 every call — name the accessors instead.
 
+Memory is the exception, and only on classes wide enough for it to matter. `lazySpies: true` still
+defines one accessor per method, and that placeholder is nearly all of what an untouched double
+retains: 101.6 kB on a 400-method class against 11.8 kB with `lazySpies: 'proxy'`, which answers
+every method from a single trap object instead (25 B per method against 253 B). It is opt-in because
+a `Proxy` cannot remove itself — +30 ns per read and +43 ns per call, forever — and it loses on a
+five-method service. Reach for it on generated API clients and ngrx facades under `isolate: false`,
+where the doubles of a whole file are alive at once; leave the default everywhere else.
+
 ---
 
 ## 3. The 90% recipe
@@ -468,21 +476,21 @@ createSpyFromClass(MyService, {
   gettersToSpyOn: ['userName'],
   settersToSpyOn: ['userName'],
   autoSpyAccessors: true, // discover every accessor on the prototype chain
-  lazySpies: true, // build each method spy on first access
+  lazySpies: true, // build each method spy on first access ('proxy' for very wide classes)
   returns: { getProducts: of([]) }, // what a spied METHOD answers
   overrides: { products$: subject }, // a member that is not a method result
 });
 ```
 
-| Key                      | Semantics                                                                          |
-| ------------------------ | ---------------------------------------------------------------------------------- |
-| `methodsToSpyOn`         | **Additive**, as in `jest-auto-spies`. Same behaviour as `instanceMethodsToSpyOn`. |
-| `onlyMethodsToSpyOn`     | **Exhaustive whitelist.** Skips discovery; anything not listed is absent.          |
-| `instanceMethodsToSpyOn` | **Additive.** The name to prefer in new code (see below).                          |
-| `autoSpyAccessors`       | Merged with the explicit getter/setter lists.                                      |
-| `lazySpies`              | Behaviour-identical; only changes _when_ each spy is built.                        |
-| `strict`                 | Throw on a method nobody configured, instead of answering `undefined` (below).     |
-| `onUnstubbedCall`        | The general form of `strict`; its return value becomes the call's return value.    |
+| Key                      | Semantics                                                                                                 |
+| ------------------------ | --------------------------------------------------------------------------------------------------------- |
+| `methodsToSpyOn`         | **Additive**, as in `jest-auto-spies`. Same behaviour as `instanceMethodsToSpyOn`.                        |
+| `onlyMethodsToSpyOn`     | **Exhaustive whitelist.** Skips discovery; anything not listed is absent.                                 |
+| `instanceMethodsToSpyOn` | **Additive.** The name to prefer in new code (see below).                                                 |
+| `autoSpyAccessors`       | Merged with the explicit getter/setter lists.                                                             |
+| `lazySpies`              | Behaviour-identical; only changes _when_ each spy is built. `'proxy'` also changes _what holds the name_. |
+| `strict`                 | Throw on a method nobody configured, instead of answering `undefined` (below).                            |
+| `onUnstubbedCall`        | The general form of `strict`; its return value becomes the call's return value.                           |
 
 **`instanceMethodsToSpyOn` is not an edge case — it is a top-5 option** (103 of ~370 spec files in
 the reference suite). Method discovery walks the _prototype chain_; a callable assigned to an
@@ -2334,7 +2342,11 @@ suite that runs green but does not type-check is not done.
 `doctor` is read-only and finds what a green run cannot: a `tsconfig` `include` pattern that
 matches no file (so it type-checks nothing while `tsc --noEmit` still reports success), a
 production module importing a `*.spec.ts`, a spec importing another spec, a `@jest-environment`
-pragma the runner never reads, and configuration left behind for a runner that is gone. It is
+pragma the runner never reads, and configuration left behind for a runner that is gone. Three of
+its checks are about coverage, where the run is green and the report is simply not the one the
+config describes — `coverage.all` on a Vitest that stopped reading the key, a source-only
+`coverage.include` in a runner config over a bundle, and a scope so large that `picomatch`
+recompiling it per file costs more than collecting the coverage does. It is
 worth one run after any large edit to a test suite — especially after a codemod, which is where
 the eaten glob below came from. Full reference:
 <https://asdalexey.github.io/vitest-auto-spy/utilities/cli>.

package/README.md

@@ -19,7 +19,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.9%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-15.5%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)
@@ -239,20 +239,21 @@ error  tsconfig-glob-matches-nothing libs/users/tsconfig.spec.json
 3 errors, 4 warnings, 1 note
 ```
 
-| Check                            | What it finds                                                                                                    |
-| -------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
-| `tsconfig-glob-matches-nothing`  | An `include` pattern that matches no file — so it type-checks nothing                                            |
-| `tsconfig-file-missing`          | A `files` entry naming a file that is gone                                                                       |
-| `spec-imported-by-non-spec`      | A production module importing a `*.spec.ts`                                                                      |
-| `spec-exports-fixture`           | A spec importing another spec, whose hooks then run in a foreign file                                            |
-| `foreign-runner-pragma`          | `@jest-environment` left in a spec, which Vitest never reads                                                     |
-| `dead-runner-config`             | `jest.config.*` / `karma.conf.*` for a runner that is not installed                                              |
-| `orphan-runner-file`             | A setup file only that dead config referenced                                                                    |
-| `angular-build-splitting-off`    | `@angular/build` in `[22.1.5, 22.1.7)` — the OOM under `--coverage`                                              |
-| `coverage-all-removed`           | `coverage.all` in a config, on a Vitest that stopped reading the key                                             |
-| `coverage-include-misses-bundle` | A `coverage.include` of sources only, in a runner config over a bundle                                           |
-| `jasmine-era-project`            | `jasmine-core`, `@types/jasmine`, `karma.conf.*` or `@hirez_io/observer-spy` still installed. Info, not an error |
-| `no-agent-instructions`          | No instruction file names the package. A note, not an error                                                      |
+| Check                               | What it finds                                                                                                    |
+| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `tsconfig-glob-matches-nothing`     | An `include` pattern that matches no file — so it type-checks nothing                                            |
+| `tsconfig-file-missing`             | A `files` entry naming a file that is gone                                                                       |
+| `spec-imported-by-non-spec`         | A production module importing a `*.spec.ts`                                                                      |
+| `spec-exports-fixture`              | A spec importing another spec, whose hooks then run in a foreign file                                            |
+| `foreign-runner-pragma`             | `@jest-environment` left in a spec, which Vitest never reads                                                     |
+| `dead-runner-config`                | `jest.config.*` / `karma.conf.*` for a runner that is not installed                                              |
+| `orphan-runner-file`                | A setup file only that dead config referenced                                                                    |
+| `angular-build-splitting-off`       | `@angular/build` in `[22.1.5, 22.1.7)` — the OOM under `--coverage`                                              |
+| `coverage-all-removed`              | `coverage.all` in a config, on a Vitest that stopped reading the key                                             |
+| `coverage-include-misses-bundle`    | A `coverage.include` of sources only, in a runner config over a bundle                                           |
+| `coverage-include-recompiles-globs` | A coverage scope large enough that `picomatch` recompiling it per file costs more than the coverage. Info        |
+| `jasmine-era-project`               | `jasmine-core`, `@types/jasmine`, `karma.conf.*` or `@hirez_io/observer-spy` still installed. Info, not an error |
+| `no-agent-instructions`             | No instruction file names the package. A note, not an error                                                      |
 
 The check that motivated the tool: a spec showing `Cannot find name 'vi'` in the editor while
 `tsc --noEmit` reported zero errors. A migration codemod editing `include` had eaten a `/**`,
@@ -2682,7 +2683,7 @@ as `methodsToSpyOn`, named for callables that live on the instance — `signal()
 `gettersToSpyOn`, `settersToSpyOn`, `autoSpyAccessors` (discover every getter/setter),
 `fillMissing` (answer a name the prototype never carried with a spy — for a **partially** abstract
 class, where `abstract` members are erased and the empty-prototype fallback no longer fires),
-`lazySpies` (materialize method spies on first access — cheaper for wide classes; the `provideAutoSpy` default on Angular)
+`lazySpies` (materialize method spies on first access — cheaper for wide classes; the `provideAutoSpy` default on Angular. `'proxy'` keeps the laziness and drops the per-method placeholder: 11.8 kB retained against 101.6 kB on a 400-method class, at +30 ns per read — opt-in, and worth it only above ~20 methods)
 
 `ValueConfig` (for `nextWithValues`): `{ value, delay? }` | `{ errorValue, delay? }` | `{ complete?, delay? }`.
 

package/dist/angular.d.ts

@@ -1,10 +1,10 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-DzUXGIYb.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-BxqMRfiJ.js';
 import { InjectionToken, Provider, Type, Signal, WritableSignal } from '@angular/core';
 import { TestAPI } from 'vitest';
-import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-W5kEgzND.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BU-WSjji.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-CEBKBA7k.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-COcg6YzT.js';
+import { C as ClassType, S as Spy, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, j as AddSpyMethodsByReturnTypes } from './types-d8Mdj_jK.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-DXoDu6sG.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-B5TLaKCg.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-BhGKIi7_.js';
 import '@angular/core/testing';
 import 'rxjs';
 

package/dist/angular.js

@@ -380,6 +380,14 @@ Actual: ${actualCall(functionName, actualArgs)}`;
 };
 
 // src/lib/spy-decoration.ts
+function detachedHelperError(helper) {
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] ${helper} was called off its spy: \`const { ${helper} } = spy.method\` loses the spy it configures. Call it as a method \u2014 spy.method.${helper}(\u2026) \u2014 or bind it first.`,
+      DOCS_LINKS.controlHelpers
+    )
+  );
+}
 function decorate(target, helpers) {
   return Object.assign(target, helpers);
 }
@@ -390,34 +398,35 @@ function toResolvedPerCallValues(valueConfigsPerCall) {
     wrappedValue: config.delay === void 0 ? Promise.resolve(config.value) : new Promise((resolve) => setTimeout(() => resolve(config.value), config.delay))
   }));
 }
-function addPromiseHelpers(target, store) {
-  decorate(target, {
-    resolveWith: (value) => {
-      store({ value: Promise.resolve(value) });
+function promiseHelpers(store) {
+  return {
+    resolveWith(value) {
+      store(this, { value: Promise.resolve(value) }, "resolveWith");
     },
-    rejectWith: (value) => {
-      store({ value, _isRejectedPromise: true });
+    rejectWith(value) {
+      store(this, { value, _isRejectedPromise: true }, "rejectWith");
     },
-    resolveWithPerCall: (valueConfigsPerCall) => {
+    resolveWithPerCall(valueConfigsPerCall) {
       if (valueConfigsPerCall.length === 0) {
         return;
       }
-      store({ value: void 0, valuesPerCalls: toResolvedPerCallValues(valueConfigsPerCall) });
+      store(this, { value: void 0, valuesPerCalls: toResolvedPerCallValues(valueConfigsPerCall) }, "resolveWithPerCall");
     }
-  });
+  };
 }
-function addPromiseHelpersToFunctionSpy(spyFunction, valueContainer) {
-  addPromiseHelpers(spyFunction, (container) => {
-    valueContainer.value = container.value;
-    valueContainer._isRejectedPromise = container._isRejectedPromise ?? false;
-    valueContainer._isThrown = false;
-    valueContainer.valuesPerCalls = container.valuesPerCalls ?? [];
-  });
+function storePromiseConfig(valueContainer, container) {
+  valueContainer.value = container.value;
+  valueContainer._isRejectedPromise = container._isRejectedPromise ?? false;
+  valueContainer._isThrown = false;
+  valueContainer.valuesPerCalls = container.valuesPerCalls ?? [];
 }
 function addPromiseHelpersToCalledWithObject(calledWithObject, calledWithArgs) {
-  addPromiseHelpers(calledWithObject, (container) => {
-    calledWithObject.argsToValuesMap.set(calledWithArgs, container);
-  });
+  decorate(
+    calledWithObject,
+    promiseHelpers((_self, container) => {
+      calledWithObject.argsToValuesMap.set(calledWithArgs, container);
+    })
+  );
 }
 
 // src/lib/settled-results.ts
@@ -467,11 +476,16 @@ function installSettledResultsPolyfill(mockFn) {
 
 // src/lib/spy-mark.ts
 var AUTO_SPY_MARK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.mock");
-var RESET_CONFIG = /* @__PURE__ */ Symbol.for("vitest-auto-spy.resetConfig");
-var CLEAR_HOOK = /* @__PURE__ */ Symbol.for("vitest-auto-spy.clearHook");
 var DEEP_CHILDREN = /* @__PURE__ */ Symbol.for("vitest-auto-spy.deepChildren");
-function markAsMock(mock) {
-  Object.defineProperty(mock, AUTO_SPY_MARK, { value: true, enumerable: false, configurable: true });
+function markAsMock(mock, mark = true) {
+  Object.defineProperty(mock, AUTO_SPY_MARK, { value: mark, enumerable: false, configurable: true });
+}
+function isMarkHooks(value) {
+  return typeof value === "object" && value !== null && "reset" in value && "clear" in value;
+}
+function hooksOf(mock) {
+  const mark = Reflect.get(mock, AUTO_SPY_MARK);
+  return isMarkHooks(mark) ? mark : void 0;
 }
 function isAutoSpyLike(value) {
   if (typeof value !== "object" || value === null) {
@@ -493,29 +507,11 @@ function readDeepChildren(value) {
   }
   return [...children.values()].filter(isMarkedMock);
 }
-function attachConfigReset(spy, reset2) {
-  Object.defineProperty(spy, RESET_CONFIG, { value: reset2, enumerable: false, configurable: true });
-}
 function runConfigReset(mock) {
-  if (!(RESET_CONFIG in mock)) {
-    return;
-  }
-  const reset2 = Reflect.get(mock, RESET_CONFIG);
-  if (typeof reset2 === "function") {
-    reset2();
-  }
-}
-function attachClearHook(spy, clear) {
-  Object.defineProperty(spy, CLEAR_HOOK, { value: clear, enumerable: false, configurable: true });
+  hooksOf(mock)?.reset();
 }
 function runClearHook(mock) {
-  if (!(CLEAR_HOOK in mock)) {
-    return;
-  }
-  const clear = Reflect.get(mock, CLEAR_HOOK);
-  if (typeof clear === "function") {
-    clear();
-  }
+  hooksOf(mock)?.clear();
 }
 
 // src/lib/function-spy.ts
@@ -610,6 +606,68 @@ function ensureCalledWithObject(state, chain) {
   state[chain] = created;
   return created;
 }
+var FunctionSpyInternals = class {
+  constructor(state, valueContainer, host, dispatch, recorder) {
+    this.state = state;
+    this.valueContainer = valueContainer;
+    this.host = host;
+    this.dispatch = dispatch;
+    this.recorder = recorder;
+    this.observable = void 0;
+  }
+  /**
+   * `resetAutoSpy` reverts this spy's configuration; the state lives here, where the host runner's
+   * own reset cannot reach it. Clearing the container in place keeps the reference the mock
+   * implementation closed over.
+   */
+  reset() {
+    const { state, valueContainer } = this;
+    delete state.calledWith;
+    delete state.mustBeCalledWith;
+    valueContainer.value = void 0;
+    delete valueContainer._isRejectedPromise;
+    delete valueContainer._isThrown;
+    delete valueContainer.valuesPerCalls;
+    this.observable?.reset();
+    getMockAdapter().restoreImplementation(this.host, this.dispatch);
+  }
+  /** Empties the polyfilled `settledResults` on `clearAutoSpy` / `resetAutoSpy` (a no-op on Vitest, where the host clears its native array). */
+  clear() {
+    this.recorder.clear();
+  }
+};
+function internalsOf(self, helper) {
+  const mark = typeof self === "function" || typeof self === "object" && self !== null ? Reflect.get(self, AUTO_SPY_MARK) : void 0;
+  if (mark instanceof FunctionSpyInternals) {
+    return mark;
+  }
+  throw detachedHelperError(helper);
+}
+var SPY_HELPERS = /* @__PURE__ */ Object.assign(
+  // The inner call carries its own mark: a pure annotation covers the call it precedes, not its
+  // arguments, and an unmarked argument call is evaluated — and everything it reaches kept.
+  /* @__PURE__ */ promiseHelpers((self, container, helper) => {
+    storePromiseConfig(internalsOf(self, helper).valueContainer, container);
+  }),
+  {
+    failWith(error) {
+      const { valueContainer } = internalsOf(this, "failWith");
+      valueContainer.value = error;
+      valueContainer._isThrown = true;
+      valueContainer._isRejectedPromise = false;
+      valueContainer.valuesPerCalls = [];
+    },
+    calledWith(...calledWithArgs) {
+      return addMethodsToCalledWith(ensureCalledWithObject(internalsOf(this, "calledWith").state, "calledWith"), calledWithArgs);
+    },
+    mustBeCalledWith(...calledWithArgs) {
+      return addMethodsToCalledWith(
+        ensureCalledWithObject(internalsOf(this, "mustBeCalledWith").state, "mustBeCalledWith"),
+        calledWithArgs
+      );
+    }
+  }
+);
 function createFunctionSpy(name, unstubbed) {
   const valueContainer = { value: void 0 };
   const state = { valueContainer };
@@ -621,46 +679,16 @@ function createFunctionSpy(name, unstubbed) {
   const functionSpy = getMockAdapter().createMockFn(dispatch, name);
   const recorder = installSettledResultsPolyfill(functionSpy);
   settledResultsRecorder = recorder;
-  addPromiseHelpersToFunctionSpy(functionSpy, valueContainer);
-  const resetObservableStream = getObservableSupport()?.addToFunctionSpy(functionSpy, valueContainer);
-  const spy = decorate(functionSpy, {
-    // The sync twin of `resolveWith` / `nextWith`, and the reason it is here rather than left to
-    // the runner: Vitest 4.1 grew `mockThrow`, but Bun and `node:test` have nothing like it, and
-    // no runtime has a way to make a *`calledWith` chain* throw — `mockImplementation` replaces the
-    // whole dispatch, which is the opposite of configuring one set of arguments.
-    //
-    // `failWith` and not `throwWith`, which is the name the shape asks for: `throwWith` is already
-    // the observable helper that *errors the stream*, it is attached to every spy at runtime (the
-    // return type that tells the two apart exists only in the types), and whichever is installed
-    // last wins. Sharing the name therefore breaks one of them on every spy in the run — which it
-    // did, loudly, the first time this was written that way.
-    failWith: (error) => {
-      valueContainer.value = error;
-      valueContainer._isThrown = true;
-      valueContainer._isRejectedPromise = false;
-      valueContainer.valuesPerCalls = [];
-    },
-    calledWith: (...calledWithArgs) => addMethodsToCalledWith(ensureCalledWithObject(state, "calledWith"), calledWithArgs),
-    mustBeCalledWith: (...calledWithArgs) => addMethodsToCalledWith(ensureCalledWithObject(state, "mustBeCalledWith"), calledWithArgs)
-  });
+  const internals = new FunctionSpyInternals(state, valueContainer, functionSpy, dispatch, recorder);
+  const spy = decorate(functionSpy, SPY_HELPERS);
+  internals.observable = getObservableSupport()?.addToFunctionSpy(spy, valueContainer);
   getJasmineSupport()?.addToFunctionSpy(spy, {
     name,
     restoreDispatch: () => {
       getMockAdapter().restoreImplementation(functionSpy, dispatch);
     }
   });
-  attachConfigReset(spy, () => {
-    delete state.calledWith;
-    delete state.mustBeCalledWith;
-    valueContainer.value = void 0;
-    delete valueContainer._isRejectedPromise;
-    delete valueContainer._isThrown;
-    delete valueContainer.valuesPerCalls;
-    resetObservableStream?.();
-    getMockAdapter().restoreImplementation(functionSpy, dispatch);
-  });
-  attachClearHook(spy, () => recorder.clear());
-  markAsMock(spy);
+  markAsMock(spy, internals);
   return exposeAsSpy(spy);
 }
 function exposeAsSpy(spy) {
@@ -921,6 +949,87 @@ function fillMissingMembers(autoSpy, unstubbed) {
     }
   });
 }
+
+// src/lib/lazy-spy-proxy.ts
+var hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+function defineSpy(target, key, value) {
+  Object.defineProperty(target, key, { configurable: true, enumerable: true, writable: true, value });
+}
+function materialize(target, state, key) {
+  const spy = createFunctionSpy(key, state.unstubbed);
+  defineSpy(target, key, spy);
+  return spy;
+}
+function pendingDescriptor(target, state, key) {
+  return {
+    configurable: true,
+    enumerable: true,
+    get: () => materialize(target, state, key),
+    set: (value) => defineSpy(target, key, value)
+  };
+}
+function orderedKeys(target, state) {
+  const own = Reflect.ownKeys(target);
+  if (!Reflect.isExtensible(target)) {
+    return own;
+  }
+  const ownStrings = own.filter((key) => typeof key === "string");
+  const present = new Set(ownStrings);
+  return [
+    ...state.preKeys.filter((key) => present.has(key)),
+    ...[...state.names].filter((key) => state.isPending(key) || present.has(key)),
+    ...ownStrings.filter((key) => !state.preSet.has(key) && !state.names.has(key)),
+    ...own.filter((key) => typeof key === "symbol")
+  ];
+}
+function createLazySpyProxy(autoSpy, methodNames, unstubbed) {
+  const preKeys = Reflect.ownKeys(autoSpy).filter((key) => typeof key === "string");
+  const state = {
+    // Insertion order doubles as declaration order for `ownKeys`, so no second array is retained.
+    names: new Set(methodNames),
+    // Only ever holds a name a caller explicitly deleted: without it, `delete spy.method` would leave
+    // the name pending again and the next read would resurrect it.
+    deleted: /* @__PURE__ */ new Set(),
+    preKeys,
+    preSet: new Set(preKeys),
+    unstubbed,
+    isPending: (key) => typeof key === "string" && state.names.has(key) && !state.deleted.has(key) && !hasOwn(autoSpy, key)
+  };
+  return new Proxy(autoSpy, {
+    get(target, key) {
+      return state.isPending(key) ? materialize(target, state, key) : Reflect.get(target, key);
+    },
+    set(target, key, value) {
+      if (state.isPending(key)) {
+        defineSpy(target, key, value);
+        return true;
+      }
+      return Reflect.set(target, key, value);
+    },
+    has(target, key) {
+      return state.isPending(key) || Reflect.has(target, key);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      return state.isPending(key) ? pendingDescriptor(target, state, key) : Reflect.getOwnPropertyDescriptor(target, key);
+    },
+    deleteProperty(target, key) {
+      const wasPending = state.isPending(key);
+      if (typeof key === "string" && state.names.has(key)) {
+        state.deleted.add(key);
+      }
+      return wasPending || Reflect.deleteProperty(target, key);
+    },
+    ownKeys: (target) => orderedKeys(target, state),
+    preventExtensions(target) {
+      state.names.forEach((key) => {
+        if (state.isPending(key)) {
+          materialize(target, state, key);
+        }
+      });
+      return Reflect.preventExtensions(target);
+    }
+  });
+}
 var EMPTY_CONFIGURATION = {
   methodsToSpyOn: [],
   onlyMethodsToSpyOn: [],
@@ -1134,15 +1243,18 @@ function assembleSpy(ObjectClass, config) {
   });
   warnOnAccessorNamingAMethod(ObjectClass, config);
   createAccessorsSpies(autoSpy, accessors.getters, accessors.setters);
-  methodNames.forEach((methodName) => {
-    if (config.lazySpies) {
-      defineLazyMethodSpy(autoSpy, methodName, unstubbed);
-    } else {
-      autoSpy[methodName] = createFunctionSpy(methodName, unstubbed);
-    }
-  });
+  if (config.lazySpies !== "proxy") {
+    methodNames.forEach((methodName) => {
+      if (config.lazySpies) {
+        defineLazyMethodSpy(autoSpy, methodName, unstubbed);
+      } else {
+        autoSpy[methodName] = createFunctionSpy(methodName, unstubbed);
+      }
+    });
+  }
   attachDispose(autoSpy);
-  return config.fillMissing ? fillMissingMembers(autoSpy, unstubbed) : autoSpy;
+  const assembled = config.lazySpies === "proxy" ? createLazySpyProxy(autoSpy, methodNames, unstubbed) : autoSpy;
+  return config.fillMissing ? fillMissingMembers(assembled, unstubbed) : assembled;
 }
 function hasNothingToRead(ObjectClass, accessors, config) {
   return getAllMethodNames(ObjectClass.prototype).length === 0 && accessors.getters.length === 0 && accessors.setters.length === 0 && config.observablePropsToSpyOn.length === 0 && // A *restricting* list asks for the opposite of what the proxy provides. `onlyMethodsToSpyOn`

package/dist/bun-angular.d.ts

@@ -1,9 +1,9 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-W5kEgzND.js';
+export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, a as ClassSpyConfiguration, C as ClassType, b as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as OnlyMethodKeysOf, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, S as Spy, s as SpyDisposable, t as SpyOptions, u as StrictSpyConfiguration, U as UnstubbedCall, v as UnstubbedCallHandler, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-d8Mdj_jK.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-COcg6YzT.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-CEBKBA7k.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-BhGKIi7_.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-B5TLaKCg.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-DzUXGIYb.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-BxqMRfiJ.js';
 import 'rxjs';
 import 'vitest';
 import '@angular/core';

package/dist/bun-angular.js

@@ -1,14 +1,13 @@
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-LIOV4WZK.js';
+import { createSpyForToken } from './chunk-BNZFNS42.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-CR5Q3YMQ.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DMOJ4NZH.js';
-import { createSpyFromClass } from './chunk-3OX44LME.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3OX44LME.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-YXHG5DXF.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-MMKKLL5J.js';
+import { createSpyFromClass } from './chunk-3EHP3NKE.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3EHP3NKE.js';
 import './chunk-PC3FAZT3.js';
-import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-AQSVZK2R.js';
-export { createFunctionSpy, errorHandler } from './chunk-AQSVZK2R.js';
-import './chunk-J5O72UHX.js';
+export { createFunctionSpy, errorHandler } from './chunk-52DZMI55.js';
+import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-4K5F2NVN.js';
 import '@angular/compiler';
 import { NgModule, provideZonelessChangeDetection, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, ApplicationRef, ɵSIGNAL as _SIGNAL } from '@angular/core';
 import { getTestBed, TestBed } from '@angular/core/testing';

package/dist/bun.d.ts

@@ -1,7 +1,7 @@
-import { t as SpyOptions, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, m as DeepPartial, D as DeepMockProxy, F as Func, v as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-W5kEgzND.js';
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, k as AddThrowHelper, l as AddVoidReturnHelpers, b as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, n as Mutable, N as NextValueConfig, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, s as SpyDisposable, u as StrictSpyConfiguration, U as UnstubbedCall, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-W5kEgzND.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-COcg6YzT.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-CEBKBA7k.js';
+import { t as SpyOptions, C as ClassType, a as ClassSpyConfiguration, O as OnlyMethodKeysOf, S as Spy, m as DeepPartial, D as DeepMockProxy, F as Func, v as UnstubbedCallHandler, j as AddSpyMethodsByReturnTypes } from './types-d8Mdj_jK.js';
+export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, k as AddThrowHelper, l as AddVoidReturnHelpers, b as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, n as Mutable, N as NextValueConfig, o as OnlyObservablePropsOf, p as OnlyPropsOf, q as Overload, r as Overloads, P as PropStubValue, s as SpyDisposable, u as StrictSpyConfiguration, U as UnstubbedCall, V as ValueConfig, c as ValueConfigPerCall, W as WithMockReturnValue } from './types-d8Mdj_jK.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-BhGKIi7_.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-B5TLaKCg.js';
 export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
 import { Mock } from 'vitest';
 import 'rxjs';

package/dist/bun.js

@@ -1,8 +1,8 @@
 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-CR5Q3YMQ.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-DMOJ4NZH.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3OX44LME.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-YXHG5DXF.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, restoreMockedProps } from './chunk-MMKKLL5J.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3EHP3NKE.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-AQSVZK2R.js';
-import './chunk-J5O72UHX.js';
+export { createFunctionSpy, errorHandler } from './chunk-52DZMI55.js';
+import './chunk-4K5F2NVN.js';