vitest-auto-spy 5.58.0 → 5.59.0

package/AGENTS.md

@@ -286,7 +286,8 @@ const cart = asSpy(TestBed.inject(CartService)); // T → Spy<T>, for the helper
 
 Both are the same object at runtime. `injectSpy(X)` already returns `Spy<X>`. The double a
 `returnsClass` method answers is `innerDouble(outer, 'create')`, typed `Spy<Report>` and read
-without recording a call on `create`. Do **not** patch the
+without recording a call on `create`; for a generic method name the type,
+`innerDouble<DialogRef<Comp>>(dialog, 'open')`. Do **not** patch the
 mismatch with `as any`, `as unknown as T` or `@ts-expect-error`.
 
 | Compiler message | Direction | Fix |

package/CHANGELOG.md

@@ -10,6 +10,32 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.59.0] - 2026-09-30
+
+### Added
+
+- **`returnsClass` takes a builder, `{ method: { build: () => double } }`.** A factory method whose
+  result is a preset rather than a plain spy of the class, such as
+  `returnsClass: { open: { build: () => createMatDialogRef(MatDialogRef, { closedWith: 'ok' }).ref } }`,
+  moves to `returnsClass` too. `build` runs once per outer double, and `innerDouble` returns what it
+  built. It throws when `build` returns something other than an object.
+- **`innerDouble<R>(double, 'method')` names the type of a generic method's inner double.** A method
+  such as `openFromComponent<C>(…): SnackBarRef<C>` read back as `Spy<SnackBarRef<unknown>>`, which a
+  `Spy<SnackBarRef<Comp>>` variable does not accept (TS2322).
+  `innerDouble<SnackBarRef<Comp>>(snackBar, 'openFromComponent')` returns `Spy<SnackBarRef<Comp>>`.
+  Like a cast, the named type is not checked against the method.
+
+### Fixed
+
+- **`no-inline-test-data` asks for a spec-local `const` when the part of a long expected value it
+  names is written only once.** It used to send that part to a `*.mock.ts` file, a file of its own
+  for a value one test uses. A part the file writes again still goes to the mock file.
+- **`angular-cache-off-in-ci` and `fs-module-cache-not-persisted` no longer judge CI configs that only
+  include jobs from another repository.** A `.gitlab-ci.yml` holding nothing but
+  `include: - project: …` (or `remote:`, `component:`, `template:`) got the note on every run,
+  whatever the shared jobs cache. Such a config is now skipped. A local `cli.cache.environment` is
+  still reported, because it comes from `angular.json`.
+
 ## [5.58.0] - 2026-09-30
 
 ### Added
@@ -6793,7 +6819,8 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.58.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.0...HEAD
+[5.59.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.58.0...v5.59.0
 [5.58.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.57.0...v5.58.0
 [5.57.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.56.0...v5.57.0
 [5.56.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.55.0...v5.56.0

package/README.md

@@ -3806,18 +3806,18 @@ Helpers on each spied member, by return type:
 
 `ClassSpyConfiguration`, the second argument of `createSpyFromClass` and `provideAutoSpy`:
 
-| Option                              | What it does                                                                                                                                                                      |
-| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `methodsToSpyOn`                    | adds names to the discovered methods                                                                                                                                              |
-| `onlyMethodsToSpyOn`                | spies only these; discovery is skipped                                                                                                                                            |
-| `instanceMethodsToSpyOn`            | same as `methodsToSpyOn`, for callables on the instance (`signal()` fields, arrow props, `signalStore()` methods)                                                                 |
-| `observablePropsToSpyOn`            | Observable properties to spy                                                                                                                                                      |
-| `returnsUndefined`                  | methods that answer `undefined`, counted as configured under `strict`                                                                                                             |
-| `returnsClass`                      | `{ create: Report }` or `{ create: [Report, options] }`: the method answers one spy of that class per double, reached as `innerDouble(double, 'create')` without recording a call |
-| `gettersToSpyOn` / `settersToSpyOn` | accessors to spy                                                                                                                                                                  |
-| `autoSpyAccessors`                  | spies every getter and setter on the prototype                                                                                                                                    |
-| `fillMissing`                       | answers a name the prototype never had with a spy (a partially abstract class)                                                                                                    |
-| `lazySpies`                         | unset: plain object below 8 methods, `'proxy'` from 8; `true` keeps a plain object; `false` builds every spy up front                                                             |
+| Option                              | What it does                                                                                                                                                                                                                                              |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `methodsToSpyOn`                    | adds names to the discovered methods                                                                                                                                                                                                                      |
+| `onlyMethodsToSpyOn`                | spies only these; discovery is skipped                                                                                                                                                                                                                    |
+| `instanceMethodsToSpyOn`            | same as `methodsToSpyOn`, for callables on the instance (`signal()` fields, arrow props, `signalStore()` methods)                                                                                                                                         |
+| `observablePropsToSpyOn`            | Observable properties to spy                                                                                                                                                                                                                              |
+| `returnsUndefined`                  | methods that answer `undefined`, counted as configured under `strict`                                                                                                                                                                                     |
+| `returnsClass`                      | `{ create: Report }` or `{ create: [Report, options] }`: the method answers one spy of that class per double, reached as `innerDouble(double, 'create')` without recording a call; `{ create: { build: () => preset } }` answers a double a preset builds |
+| `gettersToSpyOn` / `settersToSpyOn` | accessors to spy                                                                                                                                                                                                                                          |
+| `autoSpyAccessors`                  | spies every getter and setter on the prototype                                                                                                                                                                                                            |
+| `fillMissing`                       | answers a name the prototype never had with a spy (a partially abstract class)                                                                                                                                                                            |
+| `lazySpies`                         | unset: plain object below 8 methods, `'proxy'` from 8; `true` keeps a plain object; `false` builds every spy up front                                                                                                                                     |
 
 `ValueConfig` (for `nextWithValues`): `{ value, delay? }` | `{ errorValue, delay? }` | `{ complete?, delay? }`.
 

package/agent-docs/configuration.md

@@ -36,7 +36,7 @@ createSpyFromClass(MyService, {
 | `overrides` | Replaces **any member** with the value as written — a field, a signal, an `Observable` property. The member is no longer a spy, except a plain function seeded on a method (class factories only), which becomes its spy. Named in both, `overrides` wins. |
 | `selfReturning` | The named methods answer the double itself — a default like `returns`; a name in both answers `returns`. |
 | `returnsUndefined` | The list form of `returns: { m: undefined }` — `provideAutoSpy(CartStore, { strict: true, returnsUndefined: ['add', 'remove', 'clear'] })`; a name also in `returns` answers that. `createAutoMock`, `provideAutoSpyForToken` and `registerAutoSpyDefaults` take it too. |
-| `returnsClass` | `{ method: Class }` or `{ method: [Class, options] }` — the method answers a spy of that class, built once per double with those `createSpyFromClass` options (typed against `Class`). `innerDouble(double, 'm')` reaches it without recording a call; `asSpy(double.m())` is a call. The one-entry form of `returns: { m: asInstance(createSpyFromClass(Class)) }`; `returns` wins for the same name. Every factory that takes `returns` takes it. With nothing seeded, `createAutoMock<T>({ returnsUndefined: [...] })` takes the options first. |
+| `returnsClass` | `{ method: Class }`, `{ method: [Class, options] }` or `{ method: { build } }` — the method answers a spy of that class, built once per double with those `createSpyFromClass` options (typed against `Class`); `build` returns a double a preset made, such as `createMatDialogRef(MatDialogRef).ref`, called once per double. `innerDouble(double, 'm')` reaches it without recording a call; `asSpy(double.m())` is a call. The one-entry form of `returns: { m: asInstance(createSpyFromClass(Class)) }`; `returns` wins for the same name. Every factory that takes `returns` takes it. With nothing seeded, `createAutoMock<T>({ returnsUndefined: [...] })` takes the options first. |
 
 ### `instanceMethodsToSpyOn` for members discovery cannot see
 

package/agent-docs/factories.md

@@ -66,7 +66,10 @@ records no call, so a spec asserting `create`'s call count uses it too (`asSpy(f
 is a recorded call). `innerDouble` throws for a method with no `returnsClass` entry. When the inner
 double needs options of its own — a `void` method under `strict` — pass a pair:
 `returnsClass: { open: [SnackBarRef, { returnsUndefined: ['dismiss'] }] }`; the options are typed
-against `SnackBarRef`.
+against `SnackBarRef`. A preset double goes in as a builder, called once per outer double:
+`returnsClass: { open: { build: () => createMatDialogRef(MatDialogRef, { closedWith: 'ok' }).ref } }`.
+A generic method reads back with its type parameters as `unknown` (`Spy<MatDialogRef<unknown>>`);
+name the type, `innerDouble<MatDialogRef<SaveDialog>>(dialog, 'open')` — unchecked, like a cast.
 
 `createMock<T>()` is the one to reach for on data shapes — it returns a plain `T`, so it satisfies a
 `no-type-assertion` lint rule without an `eslint-disable` on every fixture. `createMock<T>(undefined)`

package/dist/angular-diagnostics.js

@@ -1,10 +1,10 @@
 import { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, HTTP_TESTING_BRAND, beforeTestBedReset, verifyOnTeardown } from './chunk-JCTHGJTY.js';
 export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-JCTHGJTY.js';
-import { failOnUnspiedProvider, onTestBedFileEnd, isLazyDoubleFactory } from './chunk-3457Z3JE.js';
+import { failOnUnspiedProvider, onTestBedFileEnd, isLazyDoubleFactory } from './chunk-OWZPZBJI.js';
 import './chunk-T5MQSNRX.js';
 import './chunk-4JY7KIJG.js';
 import './chunk-RQLUH6RE.js';
-import './chunk-IQVNZORF.js';
+import './chunk-BCT7C6DQ.js';
 import './chunk-F7UPX6YV.js';
 import './chunk-PC3FAZT3.js';
 import './chunk-UH2Q7RTQ.js';

package/dist/angular-doubles.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { InjectionToken, AbstractType, Injector, ValueProvider, FactoryProvider, ProviderToken, ChangeDetectorRef } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-CpBA3PjQ.js';
+import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-BdYUK_Zv.js';
 import { DomSanitizer } from '@angular/platform-browser';
 import 'vitest';
 

package/dist/angular-doubles.js

@@ -1,7 +1,7 @@
 import { useVitestAdapter } from './chunk-JFROAGGY.js';
 import { describeInstance } from './chunk-3OEYMUV3.js';
 import { angularInternalsError } from './chunk-4JY7KIJG.js';
-import { createSpyFromClass } from './chunk-IQVNZORF.js';
+import { createSpyFromClass } from './chunk-BCT7C6DQ.js';
 import './chunk-XZ5JUXKT.js';
 import './chunk-ZTT2QLMJ.js';
 import './chunk-YHDBRBGU.js';

package/dist/angular-router.d.ts

@@ -1,6 +1,6 @@
 import { Type, Injector, FactoryProvider, Provider } from '@angular/core';
 import { Params, Data, UrlSegment, ActivatedRoute, Route, ResolveData, Navigation, Router, Event } from '@angular/router';
-import { h as AddSpyMethodsByReturnTypes } from './types-CpBA3PjQ.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-BdYUK_Zv.js';
 import { SpyLocation } from '@angular/common/testing';
 
 /**

package/dist/angular.d.ts

@@ -1,13 +1,13 @@
 import './vitest-mock-types-B17-xaWt.js';
-export { w as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, x as provideAutoSpyForToken, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-Cw_x1b9n.js';
-import { o as DeepPartial, m as ClassType, C as ClassSpyConfiguration, S as Spy, u as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, s as NotAPublicKey } from './types-CpBA3PjQ.js';
-export { K as SubjectOf } from './types-CpBA3PjQ.js';
+export { w as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, x as provideAutoSpyForToken, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-D1Vr9BdG.js';
+import { o as DeepPartial, m as ClassType, C as ClassSpyConfiguration, S as Spy, u as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, s as NotAPublicKey } from './types-BdYUK_Zv.js';
+export { K as SubjectOf } from './types-BdYUK_Zv.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
-import { b as AutoMockConfiguration, D as DeepReadonly } from './emission-sync-Cv6VnggW.js';
-export { C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
+import { b as AutoMockConfiguration, D as DeepReadonly } from './emission-sync-ByzgYsbj.js';
+export { C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
 import { TestAPI } from 'vitest';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-xXSrGdpM.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-fmOmTK0q.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
 import '@angular/core/testing';
 
 /**

package/dist/bun-angular.d.ts

@@ -1,10 +1,10 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DG-qxd6Q.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-Cw_x1b9n.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
+export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DyDDZMOm.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-D1Vr9BdG.js';
 import '@angular/core';
 import '@angular/core/testing';
 

package/dist/bun-angular.js

@@ -1,17 +1,17 @@
-import { withTestBedSplitExplained } from './chunk-3457Z3JE.js';
-export { injectSpy, provideAutoSpy } from './chunk-3457Z3JE.js';
+import { withTestBedSplitExplained } from './chunk-OWZPZBJI.js';
+export { injectSpy, provideAutoSpy } from './chunk-OWZPZBJI.js';
 import { stable, flushEffects } from './chunk-RHGDQQNC.js';
 export { flushEffects, stable } from './chunk-RHGDQQNC.js';
 import { readSignalSymbol } from './chunk-T5MQSNRX.js';
 import { angularInternalsError } from './chunk-4JY7KIJG.js';
 import './chunk-VLEU3CWT.js';
-import { createSpyForToken } from './chunk-OL2J4K4Z.js';
-export { createNestUnit } from './chunk-OL2J4K4Z.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-7MDSR745.js';
+import { createSpyForToken } from './chunk-6KS7F4YM.js';
+export { createNestUnit } from './chunk-6KS7F4YM.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-YAAE5465.js';
 import { mockValueProp } from './chunk-RQLUH6RE.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
-import { closestName } from './chunk-IQVNZORF.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-IQVNZORF.js';
+import { closestName } from './chunk-BCT7C6DQ.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BCT7C6DQ.js';
 import { fakeClockBacklog } from './chunk-SF4GKKN4.js';
 import './chunk-SOROJD3W.js';
 import './chunk-75WPOZKE.js';

package/dist/bun.d.ts

@@ -1,6 +1,6 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DG-qxd6Q.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
+export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DyDDZMOm.js';

package/dist/bun.js

@@ -1,8 +1,8 @@
 import './chunk-VLEU3CWT.js';
-export { createNestUnit } from './chunk-OL2J4K4Z.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-7MDSR745.js';
+export { createNestUnit } from './chunk-6KS7F4YM.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-YAAE5465.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-IQVNZORF.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BCT7C6DQ.js';
 import './chunk-SF4GKKN4.js';
 import './chunk-SOROJD3W.js';
 import './chunk-75WPOZKE.js';

package/dist/{chunk-OL2J4K4Z.js → chunk-6KS7F4YM.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-IQVNZORF.js';
+import { createSpyFromClass, createAutoMock } from './chunk-BCT7C6DQ.js';
 import { sourceClassName } from './chunk-DYAS4OK4.js';
 import { trackInjectionsUntracked, nestUnitRefusals } from './chunk-IATDAQMO.js';
 import { withDocs } from './chunk-ENCEEH23.js';

package/dist/{chunk-IQVNZORF.js → chunk-BCT7C6DQ.js}

@@ -1063,10 +1063,25 @@ function withUndefinedReturns(returns, names) {
 function classDoubles(classes, answered) {
   return Object.fromEntries(
     Object.entries(classes ?? {}).flatMap(
-      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, typeof entry === "function" ? createSpyFromClass2(entry) : createSpyFromClass2(entry[0], entry[1])]]
+      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, classDouble(name, entry)]]
     )
   );
 }
+function classDouble(name, entry) {
+  if (typeof entry === "function") {
+    return createSpyFromClass2(entry);
+  }
+  if (!("build" in entry)) {
+    return createSpyFromClass2(entry[0], entry[1]);
+  }
+  const built = entry.build();
+  if ((typeof built !== "object" || built === null) && typeof built !== "function") {
+    throw new TypeError(
+      `[vitest-auto-spy] returnsClass: the build() of '${name}' returned ${String(built)}; it has to return the double the method answers. For a plain value use returns: { ${name}: value }.`
+    );
+  }
+  return built;
+}
 var warnedThenables = /* @__PURE__ */ new WeakSet();
 function warnOnHeldBackThen(ObjectClass, config) {
   if (config.onlyMethodsToSpyOn.length > 0 || config.methodsToSpyOn.includes("then") || config.instanceMethodsToSpyOn.includes("then") || Object.hasOwn(config.overrides, "then") || warnedThenables.has(ObjectClass) || !declaresThen(ObjectClass.prototype)) {

package/dist/{chunk-3457Z3JE.js → chunk-OWZPZBJI.js}

@@ -1,5 +1,5 @@
 import { currentSpecFile } from './chunk-RQLUH6RE.js';
-import { createSpyFromClass } from './chunk-IQVNZORF.js';
+import { createSpyFromClass } from './chunk-BCT7C6DQ.js';
 import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-TXC3L3FO.js';
 import { count, displayPath, sourceClassName } from './chunk-DYAS4OK4.js';
 import { setup, angularComponentStub, angularInjectSpyReal, angularTestBedCopies, installationVitest } from './chunk-IATDAQMO.js';

package/dist/{chunk-7MDSR745.js → chunk-YAAE5465.js}

@@ -1,5 +1,5 @@
 import { mockValueProp, mockAccessorsProp } from './chunk-RQLUH6RE.js';
-import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, recordInnerDoubles, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-IQVNZORF.js';
+import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, recordInnerDoubles, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-BCT7C6DQ.js';
 import { fakeClockAdvice, fakeClockBacklog } from './chunk-SF4GKKN4.js';
 import { unpatchedSetTimeout, unpatchedClearTimeout } from './chunk-SOROJD3W.js';
 import { redefineFailure } from './chunk-F7UPX6YV.js';

package/dist/cli.js

@@ -1036,6 +1036,14 @@ function cachesPath(text, path) {
 function persistedInCi(ci, path) {
   return ci.some(({ text }) => cachesPath(text, path));
 }
+var PIPELINE_KEYWORDS = /* @__PURE__ */ new Set(["include", "variables", "stages", "workflow", "default", "spec", "image", "services", "cache"]);
+var EXTERNAL_INCLUDE = /^\s*-?\s*(?:project|remote|component|template)\s*:/m;
+function ciJobsElsewhere(ci) {
+  return ci.length > 0 && ci.every(({ text }) => {
+    const keys = [...text.matchAll(/^([.A-Z_a-z][\w.-]*)\s*:/gm)].map(([, key]) => String(key));
+    return keys.includes("include") && keys.every((key) => PIPELINE_KEYWORDS.has(key)) && EXTERNAL_INCLUDE.test(text);
+  });
+}
 function persistFix(path) {
   return `Persist \`${path}\` between CI runs \u2014 for GitHub Actions an \`actions/cache\` step with that path and a key on the lockfile hash (\`cache: npm\` in \`setup-node\` stores only the npm download cache). \`npm ci\` deletes \`node_modules\` before it installs, so with it set \`fsModuleCachePath\` to a directory outside \`node_modules\` and cache that one.`;
 }
@@ -1058,7 +1066,7 @@ function checkModuleCachePersisted(profile, graph) {
     return [];
   }
   const setting = moduleCacheSetting(profile, graph, major);
-  if (setting === void 0 || persistedInCi(ci, setting.path)) {
+  if (setting === void 0 || persistedInCi(ci, setting.path) || ciJobsElsewhere(ci)) {
     return [];
   }
   const files = ci.map(({ file }) => file).join(", ");
@@ -1227,7 +1235,7 @@ function checkAngularCacheInCi(profile) {
       }
     ];
   }
-  if (settings.environment === "none" || persistedInCi(ci, settings.path)) {
+  if (settings.environment === "none" || persistedInCi(ci, settings.path) || ciJobsElsewhere(ci)) {
     return [];
   }
   return [
@@ -1654,7 +1662,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.57.0";
+var EXPORT_MAP_VERSION = "5.58.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular/diagnostics vitest-auto-spy/angular/doubles vitest-auto-spy/angular/matchers vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin vitest-auto-spy/perf-reporter";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 20 21 22",

package/dist/console.d.ts

@@ -1,4 +1,4 @@
-import { F as Func, h as AddSpyMethodsByReturnTypes } from './types-CpBA3PjQ.js';
+import { F as Func, h as AddSpyMethodsByReturnTypes } from './types-BdYUK_Zv.js';
 
 /** The call shape shared by every spied console method. */
 type ConsoleMethodFn = (...data: unknown[]) => void;

package/dist/core.d.ts

@@ -1,8 +1,8 @@
-import { G as SpyOptions, m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf, S as Spy, I as InstanceSpyConfiguration, o as DeepPartial, D as DeepMockProxy, F as Func, Y as Mock, h as AddSpyMethodsByReturnTypes, Z as MockInstance } from './types-CpBA3PjQ.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, E as ErrorValueConfig, p as FunctionSpy, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, B as SpyDisposable, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+import { G as SpyOptions, m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf, S as Spy, I as InstanceSpyConfiguration, o as DeepPartial, D as DeepMockProxy, F as Func, Y as Mock, h as AddSpyMethodsByReturnTypes, Z as MockInstance } from './types-BdYUK_Zv.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, E as ErrorValueConfig, p as FunctionSpy, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, B as SpyDisposable, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
 
 /**
  * Generate a fully-typed auto-spy from a class.
@@ -656,8 +656,13 @@ declare global {
  *
  * The same object every call of the method answers. Throws when the method has no `returnsClass`
  * entry on this double, or when `returns` answers it instead.
+ *
+ * A generic method reads back with its type parameters as `unknown`; name the type instead —
+ * `innerDouble<SnackBarRef<Comp>>(snackBar, 'openFromComponent')` — which, like a cast, is not
+ * checked against the method.
  */
 declare function innerDouble<T, K extends OnlyMethodKeysOf<T>>(outer: Spy<T>, method: K): Required<T>[K] extends Func ? Spy<ReturnType<Required<T>[K]>> : never;
+declare function innerDouble<R = never>(outer: [R] extends [never] ? never : object, method: string): Spy<R>;
 
 /** The branch of `T` that has `Key`, or `T` itself when the union has no such member to extract. */
 type WithKey<T, Key extends PropertyKey> = [Extract<T, Record<Key, unknown>>] extends [never] ? T : Extract<T, Record<Key, unknown>>;

package/dist/dom-stubs.d.ts

@@ -1,8 +1,8 @@
 import './vitest-mock-types-B17-xaWt.js';
-import { F as Func } from './types-CpBA3PjQ.js';
+import { F as Func } from './types-BdYUK_Zv.js';
 export { W as WebStorageKey, a as WebStorageStub, b as WebStorageStubOptions, s as stubWebStorage } from './web-storage-dwQ9E7Lm.js';
 import { Mock } from 'vitest';
-import { R as RestoreProp } from './prop-mock-CIWAmzz0.js';
+import { R as RestoreProp } from './prop-mock-424cOHvI.js';
 
 /**
  * A host-runner mock function: a callable spy (Vitest `vi.fn()`, Bun `mock()`,

package/dist/{emission-sync-Cv6VnggW.d.ts → emission-sync-ByzgYsbj.d.ts}

@@ -1,4 +1,4 @@
-import { H as StrictSpyConfiguration, v as OnlyObservablePropsOf, M as MethodReturns, u as OnlyMethodKeysOf, q as MethodReturnsClass, S as Spy, o as DeepPartial, G as SpyOptions, m as ClassType, C as ClassSpyConfiguration } from './types-CpBA3PjQ.js';
+import { H as StrictSpyConfiguration, v as OnlyObservablePropsOf, M as MethodReturns, u as OnlyMethodKeysOf, q as MethodReturnsClass, S as Spy, o as DeepPartial, G as SpyOptions, m as ClassType, C as ClassSpyConfiguration } from './types-BdYUK_Zv.js';
 
 /**
  * Create a fully-typed auto-mock of `T` from its type alone (no class).

package/dist/eslint-plugin.cjs

@@ -2910,7 +2910,8 @@ var within = (node, outer) => node.range[0] >= outer.range[0] && node.range[1] <
 function span(node) {
   return node.range[1] - node.range[0];
 }
-function reportLong(context, node, maxLines) {
+var sourceKey = (context, node) => context.sourceCode.getText(node).replace(/\s+/g, "");
+function reportLong(context, node, maxLines, copies) {
   const data = { lines: String(lineCount(node)), max: String(maxLines) };
   if (!isExpected(node)) {
     context.report({ node, messageId: "longLiteral", data });
@@ -2920,7 +2921,7 @@ function reportLong(context, node, maxLines) {
   if (part && lineCount(part) > 1) {
     context.report({
       node,
-      messageId: "longExpected",
+      messageId: copies(part) > 1 ? "longExpected" : "longExpectedOnce",
       data: { ...data, part: excerpt(context, part, 40), line: String(part.loc.start.line) }
     });
   } else {
@@ -2968,6 +2969,7 @@ var noInlineTestData = defineRule({
   messages: {
     longLiteral: "This literal spans {{lines}} lines of test data (the limit is {{max}}). Move it to a `*.mock.ts` file next to the spec and import it, so the test shows what it checks rather than the data it feeds in.",
     longExpected: "This expected value spans {{lines}} lines (the limit is {{max}}). It is what the test checks, so keep its shape inline and move `{{part}}` at line {{line}} to a `*.mock.ts` file next to the spec.",
+    longExpectedOnce: "This expected value spans {{lines}} lines (the limit is {{max}}). It is what the test checks, so keep its shape inline and move `{{part}}` at line {{line}} to a `const` in this spec; it is written only here, so it needs no `*.mock.ts` file.",
     longExpectedFlat: "This expected value spans {{lines}} lines (the limit is {{max}}). It is what the test checks, so check only the entries this test is about, or move it to a `*.mock.ts` file next to the spec under a name that says what the test expects.",
     repeatedLiteral: "`{{literal}}` is written {{count}} times in this file (first at line {{first}}). Export it once from a `*.mock.ts` file next to the spec and import it, so one edit reaches every test that uses it.",
     repeatedExpected: "`{{literal}}` is expected {{count}} times in this file (first at line {{first}}). It is what these tests check, so keep it in the spec: name it once in a `const` and reuse it, so one edit reaches every test that checks it.",
@@ -2979,11 +2981,18 @@ var noInlineTestData = defineRule({
     }
     const { maxLines, repeats, minValues } = limits(context);
     const seen = /* @__PURE__ */ new Map();
+    const written = /* @__PURE__ */ new Map();
+    const long = [];
+    const tally = (node) => {
+      const key = sourceKey(context, node);
+      written.set(key, (written.get(key) ?? 0) + 1);
+      return key;
+    };
     const collect = (node) => {
+      const key = tally(node);
       if (!isData(node) || !isRecord(node, minValues)) {
         return;
       }
-      const key = context.sourceCode.getText(node).replace(/\s+/g, "");
       const group = seen.get(key);
       if (group) {
         group.rest.push(node);
@@ -2994,11 +3003,15 @@ var noInlineTestData = defineRule({
     return {
       "ObjectExpression, ArrayExpression": (node) => {
         if (!isLiteral(container(node)) && isData(node) && lineCount(node) > maxLines) {
-          reportLong(context, node, maxLines);
+          long.push(node);
         }
         collect(node);
       },
+      TemplateLiteral: tally,
       "Program:exit": () => {
+        for (const node of long) {
+          reportLong(context, node, maxLines, (part) => Number(written.get(sourceKey(context, part))));
+        }
         reportRepeats(context, seen.values(), repeats);
       }
     };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import './vitest-mock-types-B17-xaWt.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
 import 'vitest';

package/dist/index.js

@@ -3299,10 +3299,25 @@ function withUndefinedReturns(returns, names) {
 function classDoubles(classes, answered) {
   return Object.fromEntries(
     Object.entries(classes ?? {}).flatMap(
-      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, typeof entry === "function" ? createSpyFromClass2(entry) : createSpyFromClass2(entry[0], entry[1])]]
+      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, classDouble(name, entry)]]
     )
   );
 }
+function classDouble(name, entry) {
+  if (typeof entry === "function") {
+    return createSpyFromClass2(entry);
+  }
+  if (!("build" in entry)) {
+    return createSpyFromClass2(entry[0], entry[1]);
+  }
+  const built = entry.build();
+  if ((typeof built !== "object" || built === null) && typeof built !== "function") {
+    throw new TypeError(
+      `[vitest-auto-spy] returnsClass: the build() of '${name}' returned ${String(built)}; it has to return the double the method answers. For a plain value use returns: { ${name}: value }.`
+    );
+  }
+  return built;
+}
 var warnedThenables = /* @__PURE__ */ new WeakSet();
 function warnOnHeldBackThen(ObjectClass, config) {
   if (config.onlyMethodsToSpyOn.length > 0 || config.methodsToSpyOn.includes("then") || config.instanceMethodsToSpyOn.includes("then") || Object.hasOwn(config.overrides, "then") || warnedThenables.has(ObjectClass) || !declaresThen(ObjectClass.prototype)) {

package/dist/jasmine-compat.d.ts

@@ -1,4 +1,4 @@
-import { Y as Mock, F as Func, h as AddSpyMethodsByReturnTypes, g as AddPromiseSpyMethods, O as ObservableLike, f as AddObservableSpyMethods, B as SpyDisposable, t as ObservablePropSpyMethods } from './types-CpBA3PjQ.js';
+import { Y as Mock, F as Func, h as AddSpyMethodsByReturnTypes, g as AddPromiseSpyMethods, O as ObservableLike, f as AddObservableSpyMethods, B as SpyDisposable, t as ObservablePropSpyMethods } from './types-BdYUK_Zv.js';
 
 /**
  * Install the `.and`, `.calls` and `.withArgs` namespaces on every spy built afterwards.

package/dist/jasmine.d.ts

@@ -1,8 +1,8 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { JasmineSpy, JasmineMethodSpy } from './jasmine-compat.js';
 export { JasmineAccessorSpies, JasmineAccessorSpy, JasmineAnd, JasmineCallInfo, JasmineCalls, JasmineNamespaces, JasmineStrategies, JasmineWithArgsAnd, JasmineWithArgsStrategies, JasmineWithArgsSync, enableJasmineCompat } from './jasmine-compat.js';
-import { m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf, F as Func } from './types-CpBA3PjQ.js';
-export { v as OnlyObservablePropsOf, w as OnlyPropsOf } from './types-CpBA3PjQ.js';
+import { m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf, F as Func } from './types-BdYUK_Zv.js';
+export { v as OnlyObservablePropsOf, w as OnlyPropsOf } from './types-BdYUK_Zv.js';
 import { expect } from 'vitest';
 
 /**

package/dist/jasmine.js

@@ -2,7 +2,7 @@ import { enableJasmineCompat } from './chunk-R43PMWFH.js';
 export { enableJasmineCompat } from './chunk-R43PMWFH.js';
 import { useVitestAdapter } from './chunk-JFROAGGY.js';
 import { looseEquals } from './chunk-B6JUBFBA.js';
-import { createSpyFromClass } from './chunk-IQVNZORF.js';
+import { createSpyFromClass } from './chunk-BCT7C6DQ.js';
 import './chunk-XZ5JUXKT.js';
 import './chunk-ZTT2QLMJ.js';
 import './chunk-YHDBRBGU.js';

package/dist/{nest-unit-DG-qxd6Q.d.ts → nest-unit-DyDDZMOm.d.ts}

@@ -1,4 +1,4 @@
-import { m as ClassType, S as Spy } from './types-CpBA3PjQ.js';
+import { m as ClassType, S as Spy } from './types-BdYUK_Zv.js';
 
 /** A class `new` accepts. An abstract class is not one, which is what keeps it out of `expose`. */
 type NestUnitClass<T = unknown> = new (...args: never[]) => T;

package/dist/nestjs.d.ts

@@ -1,6 +1,6 @@
-import { m as ClassType, S as Spy, C as ClassSpyConfiguration, u as OnlyMethodKeysOf } from './types-CpBA3PjQ.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DG-qxd6Q.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-xXSrGdpM.js';
+import { m as ClassType, S as Spy, C as ClassSpyConfiguration, u as OnlyMethodKeysOf } from './types-BdYUK_Zv.js';
+export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DyDDZMOm.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-fmOmTK0q.js';
 
 /** `{ provide, useValue }` shape consumed by NestJS's `providers`. */
 type NestValueProvider<T> = {

package/dist/nestjs.js

@@ -1,5 +1,5 @@
-export { createNestUnit, trackInjections } from './chunk-OL2J4K4Z.js';
-import { createSpyFromClass } from './chunk-IQVNZORF.js';
+export { createNestUnit, trackInjections } from './chunk-6KS7F4YM.js';
+import { createSpyFromClass } from './chunk-BCT7C6DQ.js';
 import { useRunnerAdapter } from './chunk-XZ5JUXKT.js';
 import './chunk-ZTT2QLMJ.js';
 import './chunk-YHDBRBGU.js';

package/dist/node.cjs

@@ -2758,10 +2758,25 @@ function withUndefinedReturns(returns, names) {
 function classDoubles(classes, answered) {
   return Object.fromEntries(
     Object.entries(classes ?? {}).flatMap(
-      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, typeof entry === "function" ? createSpyFromClass2(entry) : createSpyFromClass2(entry[0], entry[1])]]
+      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, classDouble(name, entry)]]
     )
   );
 }
+function classDouble(name, entry) {
+  if (typeof entry === "function") {
+    return createSpyFromClass2(entry);
+  }
+  if (!("build" in entry)) {
+    return createSpyFromClass2(entry[0], entry[1]);
+  }
+  const built = entry.build();
+  if ((typeof built !== "object" || built === null) && typeof built !== "function") {
+    throw new TypeError(
+      `[vitest-auto-spy] returnsClass: the build() of '${name}' returned ${String(built)}; it has to return the double the method answers. For a plain value use returns: { ${name}: value }.`
+    );
+  }
+  return built;
+}
 var warnedThenables = /* @__PURE__ */ new WeakSet();
 function warnOnHeldBackThen(ObjectClass, config) {
   if (config.onlyMethodsToSpyOn.length > 0 || config.methodsToSpyOn.includes("then") || config.instanceMethodsToSpyOn.includes("then") || Object.hasOwn(config.overrides, "then") || warnedThenables.has(ObjectClass) || !declaresThen(ObjectClass.prototype)) {

package/dist/node.d.ts

@@ -1,9 +1,9 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DG-qxd6Q.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
+export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DyDDZMOm.js';
 
 /**
  * Keeping `node:test`'s process-wide `MockTracker` from holding every spy the library ever made.

package/dist/node.js

@@ -2652,10 +2652,25 @@ function withUndefinedReturns(returns, names) {
 function classDoubles(classes, answered) {
   return Object.fromEntries(
     Object.entries(classes ?? {}).flatMap(
-      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, typeof entry === "function" ? createSpyFromClass2(entry) : createSpyFromClass2(entry[0], entry[1])]]
+      ([name, entry]) => entry === void 0 || answered(name) ? [] : [[name, classDouble(name, entry)]]
     )
   );
 }
+function classDouble(name, entry) {
+  if (typeof entry === "function") {
+    return createSpyFromClass2(entry);
+  }
+  if (!("build" in entry)) {
+    return createSpyFromClass2(entry[0], entry[1]);
+  }
+  const built = entry.build();
+  if ((typeof built !== "object" || built === null) && typeof built !== "function") {
+    throw new TypeError(
+      `[vitest-auto-spy] returnsClass: the build() of '${name}' returned ${String(built)}; it has to return the double the method answers. For a plain value use returns: { ${name}: value }.`
+    );
+  }
+  return built;
+}
 var warnedThenables = /* @__PURE__ */ new WeakSet();
 function warnOnHeldBackThen(ObjectClass, config) {
   if (config.onlyMethodsToSpyOn.length > 0 || config.methodsToSpyOn.includes("then") || config.instanceMethodsToSpyOn.includes("then") || Object.hasOwn(config.overrides, "then") || warnedThenables.has(ObjectClass) || !declaresThen(ObjectClass.prototype)) {

package/dist/observer-spy.d.ts

@@ -1,5 +1,5 @@
 import { Subscription, Observable } from 'rxjs';
-import { B as SpyDisposable } from './types-CpBA3PjQ.js';
+import { B as SpyDisposable } from './types-BdYUK_Zv.js';
 
 /**
  * The `Symbol.dispose` every double is keyed by — installed first when the realm does not have it.

package/dist/{package-identity-DM9vHPzU.d.ts → package-identity-xpq8sPYM.d.ts}

@@ -1,4 +1,4 @@
-import { L as UnstubbedCallHandler, F as Func, U as UnstubbedCall, h as AddSpyMethodsByReturnTypes } from './types-CpBA3PjQ.js';
+import { L as UnstubbedCallHandler, F as Func, U as UnstubbedCall, h as AddSpyMethodsByReturnTypes } from './types-BdYUK_Zv.js';
 
 /**
  * A spy's strict-mode guard: who owns it, and what to do about a call nobody configured.

package/dist/{prop-mock-CIWAmzz0.d.ts → prop-mock-424cOHvI.d.ts}

@@ -1,4 +1,4 @@
-import { P as PropStubValue } from './types-CpBA3PjQ.js';
+import { P as PropStubValue } from './types-BdYUK_Zv.js';
 
 /** Undoes a single `mock*Prop` patch; calling it more than once is a no-op. */
 type RestoreProp = () => void;

package/dist/react.d.ts

@@ -1,7 +1,7 @@
 import './vitest-mock-types-B17-xaWt.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
 import 'vitest';

package/dist/rstest.d.ts

@@ -1,5 +1,5 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';

package/dist/rstest.js

@@ -1,6 +1,6 @@
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-7MDSR745.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, expectNoEmissionSync, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-YAAE5465.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-IQVNZORF.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-BCT7C6DQ.js';
 import './chunk-SF4GKKN4.js';
 import './chunk-SOROJD3W.js';
 import { createRunnerMockAdapter } from './chunk-ZTT2QLMJ.js';

package/dist/rxjs.d.ts

@@ -1,6 +1,6 @@
 import { Observable, ReplaySubject, Subject } from 'rxjs';
-import { V as ValueConfig } from './types-CpBA3PjQ.js';
-export { f as AddObservableSpyMethods, n as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, t as ObservablePropSpyMethods, W as ValueConfigPerCall } from './types-CpBA3PjQ.js';
+import { V as ValueConfig } from './types-BdYUK_Zv.js';
+export { f as AddObservableSpyMethods, n as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, t as ObservablePropSpyMethods, W as ValueConfigPerCall } from './types-BdYUK_Zv.js';
 
 /**
  * Observable-returning spy helpers.
@@ -43,7 +43,7 @@ declare function createObservableWithValues<T>(valuesConfigs: ValueConfig<T>[],
  * cannot drift apart, because it is one import.
  */
 
-declare module './types-CpBA3PjQ.js' {
+declare module './types-BdYUK_Zv.js' {
   interface l<T> {
         subject: Subject<T>;
     }

package/dist/setup.d.ts

@@ -1,8 +1,8 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { vi } from 'vitest';
-import { O as OutsideHookReaction, R as RestoreProp } from './prop-mock-CIWAmzz0.js';
-import { L as UnstubbedCallHandler, T as UnstubbedReadHandler } from './types-CpBA3PjQ.js';
-export { d as describeDuplicateCopies, g as getPackageCopies, t as takeStrictViolations } from './package-identity-DM9vHPzU.js';
+import { O as OutsideHookReaction, R as RestoreProp } from './prop-mock-424cOHvI.js';
+import { L as UnstubbedCallHandler, T as UnstubbedReadHandler } from './types-BdYUK_Zv.js';
+export { d as describeDuplicateCopies, g as getPackageCopies, t as takeStrictViolations } from './package-identity-xpq8sPYM.js';
 export { R as RestoreWebStorageOptions, r as restoreWebStorage } from './web-storage-dwQ9E7Lm.js';
 
 /** How a per-test guard reacts to what it found: fail the test, only report it, or not run at all. */

package/dist/svelte.d.ts

@@ -1,7 +1,7 @@
 import './vitest-mock-types-B17-xaWt.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, C as ClassSpyConfiguration, m as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, u as OnlyMethodKeysOf, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, S as Spy, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
 import 'vitest';

package/dist/{track-injections-xXSrGdpM.d.ts → track-injections-fmOmTK0q.d.ts}

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

package/dist/{track-signal-runs-Cw_x1b9n.d.ts → track-signal-runs-D1Vr9BdG.d.ts}

@@ -1,7 +1,7 @@
 import { InjectionToken, Injector, ProviderToken, Provider, Type, InputSignalWithTransform, InputSignal, ModelSignal, EnvironmentProviders, EffectRef, Signal } from '@angular/core';
-import { b as AutoMockConfiguration } from './emission-sync-Cv6VnggW.js';
-import { S as Spy, m as ClassType, G as SpyOptions, C as ClassSpyConfiguration, u as OnlyMethodKeysOf, o as DeepPartial } from './types-CpBA3PjQ.js';
-import './prop-mock-CIWAmzz0.js';
+import { b as AutoMockConfiguration } from './emission-sync-ByzgYsbj.js';
+import { S as Spy, m as ClassType, G as SpyOptions, C as ClassSpyConfiguration, u as OnlyMethodKeysOf, o as DeepPartial } from './types-BdYUK_Zv.js';
+import './prop-mock-424cOHvI.js';
 import { TestModuleMetadata, ComponentFixture } from '@angular/core/testing';
 
 /**

package/dist/{types-CpBA3PjQ.d.ts → types-BdYUK_Zv.d.ts}

@@ -814,8 +814,13 @@ type MethodReturns<T> = {
 type MethodReturnsClass<T> = {
     [K in OnlyMethodKeysOf<T>]?: Required<T>[K] extends Func ? ReturnsClassEntry<ReturnType<Required<T>[K]>> : never;
 };
-/** One `returnsClass` entry: the class, or the class and the `createSpyFromClass` configuration for it. */
-type ReturnsClassEntry<R> = ClassType<R> | readonly [ClassType<R>, ClassSpyConfiguration<R>];
+/**
+ * One `returnsClass` entry: the class, the class and the `createSpyFromClass` configuration for it, or
+ * `{ build }` — a function that builds the double, such as a preset, called once per outer double.
+ */
+type ReturnsClassEntry<R> = ClassType<R> | readonly [ClassType<R>, ClassSpyConfiguration<R>] | {
+    readonly build: () => R;
+};
 type OptionalFunctionKeysOf<T> = Extract<{
     [K in keyof T]-?: [NonNullable<T[K]>] extends [never] ? never : [NonNullable<T[K]>] extends [Func] ? K : never;
 }[keyof T], string>;
@@ -1053,11 +1058,13 @@ interface ClassSpyConfiguration<T> extends StrictSpyConfiguration {
     /**
      * Methods that answer a spy of the named class — `returns: { m: asInstance(createSpyFromClass(C)) }`
      * in one entry. Every call answers the same double; reach it with `innerDouble(double, 'm')`, which
-     * records no call, or `asSpy(double.m())`. A `[C, config]` pair builds that spy with `config`.
+     * records no call, or `asSpy(double.m())`. A `[C, config]` pair builds that spy with `config`;
+     * `{ build: () => double }` answers what the function builds, called once per outer double.
      *
      * ```ts
      * provideAutoSpy(ReportFactory, { returnsClass: { create: Report } });
      * provideAutoSpy(SnackBar, { returnsClass: { open: [SnackBarRef, { returnsUndefined: ['dismiss'] }] } });
+     * provideAutoSpy(MatDialog, { returnsClass: { open: { build: () => createMatDialogRef(MatDialogRef).ref } } });
      * ```
      *
      * Counts as configured under `strict`; a method also named in `returns` answers that value.

package/dist/vue.d.ts

@@ -1,10 +1,10 @@
 import './vitest-mock-types-B17-xaWt.js';
-import { S as Spy, m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf } from './types-CpBA3PjQ.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-CpBA3PjQ.js';
+import { S as Spy, m as ClassType, C as ClassSpyConfiguration, u as OnlyMethodKeysOf } from './types-BdYUK_Zv.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, p as FunctionSpy, I as InstanceSpyConfiguration, M as MethodReturns, q as MethodReturnsClass, r as Mutable, N as NextValueConfig, s as NotAPublicKey, O as ObservableLike, t as ObservablePropSpyMethods, v as OnlyObservablePropsOf, w as OnlyPropsOf, x as Overload, y as OverloadChoice, z as Overloads, P as PropStubValue, R as ReturnsClassEntry, B as SpyDisposable, G as SpyOptions, H as StrictSpyConfiguration, J as SubjectLike, K as SubjectOf, U as UnstubbedCall, L as UnstubbedCallHandler, Q as UnstubbedRead, T as UnstubbedReadHandler, V as ValueConfig, W as ValueConfigPerCall, X as WithMockReturnValue } from './types-BdYUK_Zv.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, innerDouble, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './core.js';
-export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-Cv6VnggW.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-DM9vHPzU.js';
-export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CIWAmzz0.js';
+export { A as AutoMockConfigMarker, a as AutoMockConfigOnly, b as AutoMockConfiguration, c as AutoMocked, d as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, e as EmissionOptions, f as EmissionSource, S as SubscribableLike, g as autoMocked, h as clearAutoSpyDefaults, i as createAutoMock, j as expectAllEmissions, k as expectCompletion, l as expectEmission, m as expectEmissions, n as expectError, o as expectNoEmission, p as expectNoEmissionSync, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './emission-sync-ByzgYsbj.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-xpq8sPYM.js';
+export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-424cOHvI.js';
 import 'vitest';
 
 /** A Vue injection token: a plain string/symbol key, or a typed `InjectionKey<T>` (a branded `symbol`). */

package/package.json

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

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

@@ -609,7 +609,7 @@ to 'ClassType<unknown>'`), and `provideAutoSpyForToken(TOKEN)` merges its argume
 `selfReturning` names methods that answer the double itself — a default like `returns`, configured
 under `strict`, on every factory. `returnsClass: { create: Report }` makes a method answer one
 `Spy<Report>` per double, reached without a recorded call as `innerDouble(factory, 'create')`;
-`returnsClass: { open: [SnackBarRef, { returnsUndefined: ['dismiss'] }] }` configures that inner double. With nothing to seed, options go
+`returnsClass: { open: [SnackBarRef, { returnsUndefined: ['dismiss'] }] }` configures that inner double, `{ open: { build: () => preset } }` takes a preset's, and `innerDouble<Ref<C>>(dialog, 'open')` types a generic method's. With nothing to seed, options go
 first: `createAutoMock<T>({ returnsUndefined: ['close'] })`; `strict` / `name` / `returns` alone go
 second.
 Reach for it when the same class carries different configurations in different specs: