vitest-auto-spy 3.15.1 → 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-15.1%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

@@ -949,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: [],
@@ -1162,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,10 +1,10 @@
 import './chunk-Y4YG7UOK.js';
-import { createSpyForToken } from './chunk-VPRUMHEL.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-IZO7U34R.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-GEXYXX4P.js';
-export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-GEXYXX4P.js';
+import { createSpyFromClass } from './chunk-3EHP3NKE.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3EHP3NKE.js';
 import './chunk-PC3FAZT3.js';
 export { createFunctionSpy, errorHandler } from './chunk-52DZMI55.js';
 import { withDocs, DOCS_LINKS, isAutoSpyLike } from './chunk-4K5F2NVN.js';

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-IZO7U34R.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-GEXYXX4P.js';
+export { autoMocked, clearAutoSpy, createAutoMock, createSpyFromClass, resetAutoSpy } from './chunk-3EHP3NKE.js';
 import './chunk-PC3FAZT3.js';
 export { createFunctionSpy, errorHandler } from './chunk-52DZMI55.js';
 import './chunk-4K5F2NVN.js';

package/dist/{chunk-GEXYXX4P.js → chunk-3EHP3NKE.js}

@@ -269,6 +269,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: [],
@@ -482,15 +563,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/{chunk-VPRUMHEL.js → chunk-BNZFNS42.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-GEXYXX4P.js';
+import { createSpyFromClass, createAutoMock } from './chunk-3EHP3NKE.js';
 import { withDocs, DOCS_LINKS } from './chunk-4K5F2NVN.js';
 
 // src/lib/track-injections.ts

package/dist/{chunk-IZO7U34R.js → chunk-YXHG5DXF.js}

@@ -1,5 +1,5 @@
 import { mockValueProp, mockReadonlyPropGetter } from './chunk-MMKKLL5J.js';
-import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-GEXYXX4P.js';
+import { createSpyFromClass, createProxyPropStore, describeStoredProp, dropStoredProp, storeDefinedProp, writeStoredAccessor, writeStoredValue, readStoredAccessor, NOT_STORED, disposeAutoSpy, isProtocolKey, isDeletedProp } from './chunk-3EHP3NKE.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
 import { defineHelper, serializeValue, createFunctionSpy } from './chunk-52DZMI55.js';
 import { withDocs, DOCS_LINKS, DEEP_CHILDREN } from './chunk-4K5F2NVN.js';

package/dist/cli.js

@@ -2081,6 +2081,7 @@ var CONFIG_CANDIDATES2 = [
 var WORKSPACE_FILE = /(^|\/)(?:angular|workspace|project)\.json$/;
 var UNIT_TEST_BUILDER = "@angular/build:unit-test";
 var ALL_REMOVED_IN = 4;
+var RECOMPILE_THRESHOLD = 50;
 function coverageBlock(text) {
   const opening = /coverage\s*:\s*{/.exec(text);
   if (opening === null) {
@@ -2116,10 +2117,13 @@ function ownKeysText(block) {
 function declaresKey(block, key) {
   return new RegExp(`(?:^|[\\s,])${key}\\s*:`).test(ownKeysText(block));
 }
-function includePatterns(block) {
-  const arrays = captures(ownKeysText(block), /(?:^|[\s,])include\s*:\s*\[([^\]]*)]/g);
+function arrayPatterns(block, key) {
+  const arrays = captures(ownKeysText(block), new RegExp(`(?:^|[\\s,])${key}\\s*:\\s*\\[([^\\]]*)]`, "g"));
   return arrays.flatMap((body) => captures(body, /["'`]([^"'`]+)["'`]/g));
 }
+function includePatterns(block) {
+  return arrayPatterns(block, "include");
+}
 function canMatchBundleChunk(pattern) {
   const segment = pattern.slice(pattern.lastIndexOf("/") + 1);
   if (!segment.includes(".")) {
@@ -2128,6 +2132,36 @@ function canMatchBundleChunk(pattern) {
   const extension = segment.slice(segment.lastIndexOf(".") + 1);
   return extension === "*" || /^[cm]?js$/.test(extension) || /^{[^}]*\b[cm]?js\b[^}]*}$/.test(extension);
 }
+function collectTargetScope(value, into) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectTargetScope(item, into);
+    }
+    return;
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  const options = value["options"];
+  if ((value["builder"] === UNIT_TEST_BUILDER || value["executor"] === UNIT_TEST_BUILDER) && isRecord(options)) {
+    for (const key of ["coverageInclude", "coverageExclude"]) {
+      const list = options[key];
+      if (Array.isArray(list)) {
+        into.patterns += list.length;
+      }
+    }
+  }
+  for (const nested of Object.values(value)) {
+    collectTargetScope(nested, into);
+  }
+}
+function targetScopeSize(profile) {
+  const total = { patterns: 0 };
+  for (const file of profile.files.filter((candidate) => WORKSPACE_FILE.test(candidate))) {
+    collectTargetScope(parseJsonc(readTextFile(join(profile.cwd, file)) ?? ""), total);
+  }
+  return total.patterns;
+}
 function collectRunnerConfigs(value, into) {
   if (Array.isArray(value)) {
     for (const item of value) {
@@ -2165,6 +2199,7 @@ function installedMajor(cwd, packageName) {
 }
 function checkCoverageConfig(profile) {
   const runnerConfigs = unitTestRunnerConfigs(profile);
+  const targetScope = targetScopeSize(profile);
   const major = installedMajor(profile.cwd, "vitest");
   const findings = [];
   for (const file of [.../* @__PURE__ */ new Set([...runnerConfigs, ...CONFIG_CANDIDATES2])]) {
@@ -2182,6 +2217,16 @@ function checkCoverageConfig(profile) {
         fix: "Delete `all` and declare `coverage.include` instead. Without an include the report has been covering only the files the run imported \u2014 which is what this config has been silently doing since the upgrade."
       });
     }
+    const scopeSize = arrayPatterns(block, "include").length + arrayPatterns(block, "exclude").length + targetScope;
+    if (scopeSize >= RECOMPILE_THRESHOLD) {
+      findings.push({
+        check: "coverage-include-recompiles-globs",
+        severity: "info",
+        file,
+        message: `The coverage scope here is ${scopeSize} globs, and \`@vitest/coverage-v8\` recompiles all of them for every filename: its \`globCache\` memoises the verdict, keyed by the file, and never the matcher. Nothing fails \u2014 the report is correct, it is just paid for once per file per pattern.`,
+        fix: 'Swap the provider for a wrapper that compiles the list once: `coverage.provider: "custom"` plus a `customProviderModule` that re-exports `@vitest/coverage-v8` and overwrites `isIncluded` in `getProvider()`. Measured on one 1 725-file suite: 229.59 s \u2192 22.88 s on a shard, with a byte-identical report. The recipe is in the docs \u2014 Adapters \u2192 Angular, "Coverage matching costs more than coverage".'
+      });
+    }
     const patterns = runnerConfigs.includes(file) ? includePatterns(block) : [];
     if (patterns.length > 0 && !patterns.some(canMatchBundleChunk)) {
       findings.push({

package/dist/console.d.ts

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

package/dist/{expect-emission-COcg6YzT.d.ts → expect-emission-BhGKIi7_.d.ts}

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

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { d as AccessorKeysOf, e as AddAccessorsSpies, f as AddCalledWithObservable, g as AddCalledWithPromise, h as AddCalledWithSpyMethods, A as AddObservableSpyMethods, i as AddPromiseSpyMethods, j as AddSpyMethodsByReturnTypes, k as AddThrowHelper, l as AddVoidReturnHelpers, 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';
 import 'rxjs';
 import 'vitest';