vitest-auto-spy 5.56.0 → 5.58.0

package/AGENTS.md

@@ -284,7 +284,9 @@ new ProfileFacade(asInstance(users)); // Spy<T> → T, for an API typed against
 const cart = asSpy(TestBed.inject(CartService)); // T → Spy<T>, for the helpers
 ```
 
-Both are the same object at runtime. `injectSpy(X)` already returns `Spy<X>`. Do **not** patch the
+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
 mismatch with `as any`, `as unknown as T` or `@ts-expect-error`.
 
 | Compiler message | Direction | Fix |

package/CHANGELOG.md

@@ -10,6 +10,51 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.58.0] - 2026-09-30
+
+### Added
+
+- **`returnsClass` takes a pair, `{ method: [Class, options] }`.** `options` is the
+  `createSpyFromClass` configuration for the inner double, typed against that class. A factory method
+  whose result has a `void` method under `strict`
+  (`returnsClass: { openFromComponent: [MatSnackBarRef, { returnsUndefined: ['dismiss'] }] }`) now
+  moves to `returnsClass` too, instead of staying on `returns: { m: asInstance(ref) }`.
+- **`innerDouble(double, 'method')` returns the double a `returnsClass` method answers, without
+  calling the method.** A spec that asserts `toHaveBeenCalledExactlyOnceWith` on the factory method,
+  or configures the inner double before the code under test runs, no longer needs the two-step
+  `createSpyFromClass` + `returns` form. It throws when the method has no `returnsClass` entry.
+
+### Fixed
+
+- **`no-inline-test-data` no longer sends a value repeated only as an expected value to a
+  `*.mock.ts` file.** When every copy is the argument of an equality matcher (`toEqual`,
+  `toMatchObject`, `toHaveBeenCalledWith`…, through `.resolves` / `.rejects` / `.not`), the rule asks
+  for a spec-local `const` instead; a short expected object of up to three plain keys, such as
+  `{ name: 'HttpErrorResponse', status: 401 }`, is not reported at all.
+- **`no-inline-test-data` names a smaller part of a long expected value.** It now names the smallest
+  nested part whose move alone brings the expectation under `maxLines`, a list of plain values or a
+  template string first. In a rule-config expectation it names the word list, not the
+  `['error', {...}]` tuple under test.
+- **`shared-env-without-restore` reads frozen options and notes the ones it cannot read.**
+  `export const OPTS = Object.freeze({ restoreMocks: false, … }); setupAutoSpy(OPTS)` (or
+  `{ ...OPTS }`) used to pass silently. `Object.freeze(…)`, `as const`, `satisfies` and parentheses
+  are now read through, and a switch that stays unreadable (a call, a condition, an import from a
+  package) gets a note naming the file and the switches instead of a silent pass.
+- **`tsconfig-ships-mock-file` reports a library build config with no `exclude`.** A `tsc`-built
+  library whose `tsconfig.lib.json` has only `"include": ["src/**/*.ts"]` ships its specs and
+  `*.mock.ts` files, yet got no warning until an `exclude` naming the specs was added. Suggested
+  globs now follow the existing excludes or the `include` directory (`src/**/*.mock.ts` beside
+  `src/**/*.spec.ts`) instead of always `**/*.mock.ts`.
+
+### Size
+
+The root entry **29.99 → 30.27 kB** min+gzip (+0.28 kB, +0.9 %), and every runtime entry that carries
+the core by about the same: the `returnsClass` pair and the per-double registry `innerDouble` reads.
+`/eslint-plugin` 53.20 → 53.45 kB (+0.25 kB, +0.5 %) for the expected-value handling in
+`no-inline-test-data`; a lint-time entry no test run imports.
+
+## [5.57.0] - 2026-09-30
+
 ## [5.56.0] - 2026-09-30
 
 ### Fixed
@@ -6748,7 +6793,9 @@ 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.56.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.58.0...HEAD
+[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
 [5.55.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.54.0...v5.55.0
 [5.54.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.53.0...v5.54.0

package/README.md

@@ -15,7 +15,7 @@ replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spie
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-30.0%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-30.3%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -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 }`: the method answers one spy of that class per double, reached as `asSpy(double.create())`        |
-| `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 |
+| `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/checklist.md

@@ -85,10 +85,11 @@ Angular suites: `angular-testbed-split` (an Analog config without `server.deps.i
 which gives `/angular` a second `TestBed`), `angular-cache-off-in-ci` (the builder cache never reaches
 CI: +33 % per run on a 700-file suite), `shared-env-without-restore` (a shared environment without
 the `setupAutoSpy` restore options; each setup file is judged on its own calls, an options object declared,
-imported or spread counts, and a value it cannot read is never called off) and `mock-registry-capture-drops-sentinel` (a hand-rolled registry
+imported, spread or wrapped in `Object.freeze` counts, and a value it cannot read is never called off but gets a "not statically readable" note) and `mock-registry-capture-drops-sentinel` (a hand-rolled registry
 pruner that can drop the `clearAllMocks` sweep). `tsconfig-ships-mock-file` warns about a build
 tsconfig whose `exclude` leaves out the specs but not the `*.mock.ts` / `*.fixtures.ts` / `__mocks__/`
-files beside them, so they ship in the package. The `tsconfig` checks do not judge a `../` entry,
+files beside them, so they ship in the package, and about a `tsconfig.lib.json` / `tsconfig.build.json`
+with no `exclude` at all, which ships the specs too. The `tsconfig` checks do not judge a `../` entry,
 a missing generated `.d.ts` in `files`, or `include` on a scan that hit its cap, and the import graph
 ignores specifiers in comments and strings and follows tsconfig `paths` / `baseUrl` through `extends`.
 It is worth one run after any large edit to a test suite — especially after a codemod, which is where

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 }` — the method answers a spy of that class, built once per double (`asSpy(double.m())` reaches it; that read 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 }` 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. |
 
 ### `instanceMethodsToSpyOn` for members discovery cannot see
 

package/agent-docs/eslint.md

@@ -100,7 +100,7 @@ export default [
 | `no-outer-binding-in-mock-factory` | `error` | — | a `vi.mock(path, factory)` factory reading a top-level `const` / `let` / `var` / `class` declared outside `vi.hoisted` — the factory is hoisted above it, so the read is `Cannot access 'x' before initialization` → `const { user } = vi.hoisted(() => ({ user: … }))`. Only reads made while the factory runs count; function declarations, imports, type positions and `vi.doMock` are not reported |
 | `no-relative-mock-under-builder` | `error` | — | `vi.mock` / `doMock` / `importMock` / `unmock` / `doUnmock` with a specifier starting `.` or `/` in a spec `@angular/build:unit-test` runs — the builder throws on it → `provideAutoSpy(X)`, or `overrideComponentProvider` for a component's own provider. **Silent until** an `@angular/build:unit-test` / `@nx/angular:unit-test` target serving the file is found (the `no-redundant-mock-reset` search) or `{ builder: 'unit-test' }` says so; a tsconfig path alias to a workspace file is reported too (the builder bundles it, so the mock silently does nothing) unless every run's `buildTarget` lists it in `externalDependencies` |
 | `no-real-wait-in-test` | `warn` | — | a sleep on the real clock — `new Promise((r) => setTimeout(r, N))` in any spelling where `resolve` reaches the timer, `setTimeout(N)` from `node:timers/promises`; a `sleep(ms)` helper once, at its definition; a missing or `0` delay is left alone → `setupFakeTimers()` + `await advanceTimers(N)`, or wait for the outcome (`vi.waitFor`, `fixture.whenStable()`) |
-| `no-inline-test-data` | `warn` | — | test data inline in a spec — a data literal over `maxLines` (20) lines, or the same literal `repeats` (3) times in one file with at least `minValues` (2) values, one spelled out → export it once from `<name>.mock.ts` next to the spec (a `tsc`-built library must add `**/*.mock.ts` to its build tsconfig's `exclude`). A copy that reads a name the spec declares → a spec-local `const` instead. A long expected value (`toEqual`, `toMatchObject`, `toHaveBeenCalledWith`…) → keep its shape inline, move the largest part the message names. Never reported: module wiring (`providers`, `imports`…), `it.each` tables, `vi.mock` factories, literals holding a function, short tuples (`[1, 5]`, `['0', '1']`) and flag bags (≤ 3 boolean keys) as repeats, and files named `*.mock.ts` / `*.fixture.ts` / under `__mocks__/` |
+| `no-inline-test-data` | `warn` | — | test data inline in a spec — a data literal over `maxLines` (20) lines, or the same literal `repeats` (3) times in one file with at least `minValues` (2) values, one spelled out → export it once from `<name>.mock.ts` next to the spec (a `tsc`-built library must add `**/*.mock.ts` to its build tsconfig's `exclude`). A copy that reads a name the spec declares → a spec-local `const` instead. A long expected value (`toEqual`, `toMatchObject`, `toHaveBeenCalledWith`…) → keep its shape inline, move the part the message names (the smallest one that gets it under `maxLines`, a plain-value list or template string first). A literal repeated only as an expected value (`.resolves` / `.rejects` / `.not` included) → a spec-local `const`; a short expected object (≤ 3 keys, plain values) is not a repeat. Never reported: module wiring (`providers`, `imports`…), `it.each` tables, `vi.mock` factories, literals holding a function, short tuples (`[1, 5]`, `['0', '1']`) and flag bags (≤ 3 boolean keys) as repeats, and files named `*.mock.ts` / `*.fixture.ts` / under `__mocks__/` |
 | `no-disabled-testbed-teardown` | `error` | — | `destroyAfterEach: false`, in `initTestEnvironment` or one `configureTestingModule` — every fixture outlives its test, `ngOnDestroy` never runs → delete it (Angular's default since v13) and fix the test that then fails. A config scoped to `**/*.spec.ts` must add the setup file to `files` |
 | `no-redundant-mock-reset` | `error` | `--fix` / suggest | a mock reset the runner already performs between tests — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — standing where nothing the file wrote ran since the runner's own: the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear as the last statement of an `afterEach` → delete it, and the hook with it where that is all it held. A restore or reset in `afterEach` / `afterAll` is never reported: after the last test it is what takes a spy off before the `afterAll` hooks. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` (or `{ configFile }` naming the runner config) first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text; a config that leaves `clearMocks` out counts it on from Vitest 5 (its default). Where an `@angular/build:unit-test` / `@nx/angular:unit-test` target (found in `angular.json` / `project.json` above the file) also serves the spec, a config flag counts only if that target's `runnerConfig` applies it too — without `runnerConfig` the builder runs Vitest's defaults, so `restoreMocks` / `mockReset` from `vitest.config.ts` do not make a reset dead there, while a clear stays reported on Vitest 5; the rule's inline flags are not narrowed. A config built by a factory or `mergeConfig` from another module is not read through — name its flags as `{ configFile, configFlags: { clearMocks: true } }`, read as if the file set them, so the builder narrowing still applies (`configFlags` needs `configFile`; `doctor` notes the case as `mock-reset-config-unread`). `setupAutoSpy({ restoreMocks: true })` is not the runner's `restoreMocks` (it restores in an `afterEach`, after the test) — never pass the rule a flag only the setup file sets. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only in a file whose only before-hook it is; a suggestion otherwise; never inside a test body |
 | `no-unasserted-argument` | `warn` | — | a bare `expect(spy).toHaveBeenCalled()` on evidence from the file: the same subject asserted with `toHaveBeenCalledWith(…)` in another test, or a title containing `with` over a body whose every assertion is a bare call → `toHaveBeenCalledWith(…)` / `mustBeCalledWith(…)`. `not.toHaveBeenCalled()` and the counting matchers are never reported |

package/agent-docs/factories.md

@@ -61,9 +61,12 @@ second argument (`{}` included) keeps the first a seed.
 
 **A method that returns another class's double is one entry:** `returnsClass: { create: Report }` on
 any factory that takes `returns` builds `createSpyFromClass(Report)` once per outer double and makes
-`create()` answer it. Reach it with `asSpy(factory.create('a'))` — typed `Spy<Report>`, but that read
-is a recorded call, so keep `const report = createSpyFromClass(Report)` +
-`returns: { create: asInstance(report) }` when the spec asserts `create`'s call count.
+`create()` answer it. Reach it with `innerDouble(factory, 'create')` — typed `Spy<Report>`, and it
+records no call, so a spec asserting `create`'s call count uses it too (`asSpy(factory.create('a'))`
+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`.
 
 `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-KHALREYP.js';
+import { failOnUnspiedProvider, onTestBedFileEnd, isLazyDoubleFactory } from './chunk-3457Z3JE.js';
 import './chunk-T5MQSNRX.js';
 import './chunk-4JY7KIJG.js';
 import './chunk-RQLUH6RE.js';
-import './chunk-LKXOKRTC.js';
+import './chunk-IQVNZORF.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-NphKNopY.js';
+import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-CpBA3PjQ.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-LKXOKRTC.js';
+import { createSpyFromClass } from './chunk-IQVNZORF.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-NphKNopY.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-CpBA3PjQ.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-BDQ6MqwO.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-NphKNopY.js';
-export { K as SubjectOf } from './types-NphKNopY.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';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
-import { b as AutoMockConfiguration, D as DeepReadonly } from './emission-sync-CNbHIKGX.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-CNbHIKGX.js';
+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 { TestAPI } from 'vitest';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BkGvSEzV.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-vydpb5c5.js';
+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';
 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, 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, R as UnstubbedReadHandler, V as ValueConfig, T as ValueConfigPerCall, W as WithMockReturnValue } from './types-NphKNopY.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, 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-CNbHIKGX.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-Dhlx2i2x.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-vydpb5c5.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DdJ251KZ.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-BDQ6MqwO.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 { 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';
 import '@angular/core';
 import '@angular/core/testing';
 

package/dist/bun-angular.js

@@ -1,17 +1,17 @@
-import { withTestBedSplitExplained } from './chunk-KHALREYP.js';
-export { injectSpy, provideAutoSpy } from './chunk-KHALREYP.js';
+import { withTestBedSplitExplained } from './chunk-3457Z3JE.js';
+export { injectSpy, provideAutoSpy } from './chunk-3457Z3JE.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-RAJTKMDV.js';
-export { createNestUnit } from './chunk-RAJTKMDV.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-3IINYLDB.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 { mockValueProp } from './chunk-RQLUH6RE.js';
 export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
-import { closestName } from './chunk-LKXOKRTC.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-LKXOKRTC.js';
+import { closestName } from './chunk-IQVNZORF.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-IQVNZORF.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, 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, R as UnstubbedReadHandler, V as ValueConfig, T as ValueConfigPerCall, W as WithMockReturnValue } from './types-NphKNopY.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, 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-CNbHIKGX.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-Dhlx2i2x.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-vydpb5c5.js';
-export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-DdJ251KZ.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 { 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';

package/dist/bun.js

@@ -1,8 +1,8 @@
 import './chunk-VLEU3CWT.js';
-export { createNestUnit } from './chunk-RAJTKMDV.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-3IINYLDB.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 { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-RQLUH6RE.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-LKXOKRTC.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, innerDouble, registerAutoSpyDefaults, resetAutoSpy } from './chunk-IQVNZORF.js';
 import './chunk-SF4GKKN4.js';
 import './chunk-SOROJD3W.js';
 import './chunk-75WPOZKE.js';

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

@@ -1,5 +1,5 @@
 import { currentSpecFile } from './chunk-RQLUH6RE.js';
-import { createSpyFromClass } from './chunk-LKXOKRTC.js';
+import { createSpyFromClass } from './chunk-IQVNZORF.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-3IINYLDB.js → chunk-7MDSR745.js}

@@ -1,5 +1,5 @@
 import { mockValueProp, mockAccessorsProp } from './chunk-RQLUH6RE.js';
-import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-LKXOKRTC.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 { fakeClockAdvice, fakeClockBacklog } from './chunk-SF4GKKN4.js';
 import { unpatchedSetTimeout, unpatchedClearTimeout } from './chunk-SOROJD3W.js';
 import { redefineFailure } from './chunk-F7UPX6YV.js';
@@ -48,6 +48,7 @@ function withoutRealMembers(instance, label, config) {
   return {
     ...config,
     returns: Object.fromEntries(Object.entries(config.returns).filter(([name]) => kept(name))),
+    classReturns: Object.fromEntries(Object.entries(config.classReturns).filter(([name]) => kept(name))),
     selfReturning: config.selfReturning.filter(kept)
   };
 }
@@ -203,7 +204,9 @@ function createSpyFromInstance(instance, methodsToSpyOnOrConfig) {
   config.observablePropsToSpyOn.forEach((name) => installMember(instance, name, createTrackedPropSpy(name, reads), restores));
   installAccessorSpies(instance, config, restores, reads);
   const label = `createSpyFromInstance(${className ?? "object"})`;
-  applyConfiguredReturns(instance, label, withoutRealMembers(instance, label, config), () => getCallableMemberNames(instance));
+  const applied = withoutRealMembers(instance, label, config);
+  applyConfiguredReturns(instance, label, applied, () => getCallableMemberNames(instance));
+  recordInnerDoubles(instance, applied.classReturns);
   for (const key of Reflect.ownKeys(config.overrides)) {
     installMember(instance, key, Reflect.get(config.overrides, key), restores);
   }

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

@@ -111,6 +111,26 @@ function mergeInto(defaults, written) {
   }
   return merged;
 }
+
+// src/lib/inner-double.ts
+function registry2() {
+  return globalThis.__vitestAutoSpyInnerDoubles__ ??= /* @__PURE__ */ new WeakMap();
+}
+function recordInnerDoubles(outer, doubles) {
+  const entries = Object.entries(doubles ?? {});
+  if (entries.length > 0) {
+    registry2().set(outer, new Map([...registry2().get(outer) ?? [], ...entries]));
+  }
+}
+function innerDouble(outer, method) {
+  const double = registry2().get(outer)?.get(method);
+  if (double === void 0) {
+    throw new Error(
+      `[vitest-auto-spy] innerDouble: '${method}' has no returnsClass entry on this double, so there is no inner double to read. Name it in the configuration, { returnsClass: { ${method}: SomeClass } }, or read what it answers with asSpy(double.${method}(\u2026)).`
+    );
+  }
+  return double;
+}
 function isAccessorBag(value) {
   return typeof value === "object" && value !== null && "getters" in value && "setters" in value;
 }
@@ -428,8 +448,10 @@ function buildAutoMock(overrides, config, boundary) {
     seeded,
     "returnsUndefined"
   );
-  applyMockReturns(mock, config?.returnsClass && withClassReturns({}, config.returnsClass), seeded, "returnsClass");
+  const inner = config?.returnsClass && classDoubles(config.returnsClass, (name) => seeded.has(name) || Object.hasOwn(config.returns ?? {}, name));
+  applyMockReturns(mock, inner, seeded, "returnsClass");
   applyMockReturns(mock, config?.returns, seeded);
+  recordInnerDoubles(mock, inner);
   return mock;
 }
 function applyObservableProps(mock, names, reads) {
@@ -842,6 +864,7 @@ var EMPTY_CONFIGURATION = {
   fillMissing: void 0,
   lazySpies: void 0,
   returns: {},
+  classReturns: {},
   selfReturning: [],
   overrides: {},
   strict: void 0,
@@ -1010,6 +1033,8 @@ function resolveConfiguration(methodsToSpyOnOrConfig) {
   if (Array.isArray(methodsToSpyOnOrConfig)) {
     return { ...EMPTY_CONFIGURATION, methodsToSpyOn: methodsToSpyOnOrConfig };
   }
+  const returns = methodsToSpyOnOrConfig.returns ?? {};
+  const classReturns = classDoubles(methodsToSpyOnOrConfig.returnsClass, (name) => Object.hasOwn(returns, name));
   return {
     methodsToSpyOn: methodsToSpyOnOrConfig.methodsToSpyOn ?? [],
     onlyMethodsToSpyOn: methodsToSpyOnOrConfig.onlyMethodsToSpyOn ?? [],
@@ -1021,9 +1046,10 @@ function resolveConfiguration(methodsToSpyOnOrConfig) {
     fillMissing: methodsToSpyOnOrConfig.fillMissing,
     lazySpies: methodsToSpyOnOrConfig.lazySpies,
     returns: withUndefinedReturns(
-      withClassReturns(methodsToSpyOnOrConfig.returns ?? {}, methodsToSpyOnOrConfig.returnsClass),
+      Object.keys(classReturns).length > 0 ? { ...classReturns, ...returns } : returns,
       methodsToSpyOnOrConfig.returnsUndefined
     ),
+    classReturns,
     selfReturning: methodsToSpyOnOrConfig.selfReturning ?? [],
     overrides: methodsToSpyOnOrConfig.overrides ?? {},
     strict: methodsToSpyOnOrConfig.strict,
@@ -1034,11 +1060,12 @@ function resolveConfiguration(methodsToSpyOnOrConfig) {
 function withUndefinedReturns(returns, names) {
   return names?.length ? { ...Object.fromEntries(names.map((name) => [name, void 0])), ...returns } : returns;
 }
-function withClassReturns(returns, classes) {
-  const built = Object.entries(classes ?? {}).flatMap(
-    ([name, ReturnedClass]) => ReturnedClass === void 0 || Object.hasOwn(returns, name) ? [] : [[name, createSpyFromClass2(ReturnedClass)]]
+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])]]
+    )
   );
-  return built.length > 0 ? { ...Object.fromEntries(built), ...returns } : returns;
 }
 var warnedThenables = /* @__PURE__ */ new WeakSet();
 function warnOnHeldBackThen(ObjectClass, config) {
@@ -1064,6 +1091,7 @@ function createSpyFromClass2(ObjectClass, methodsToSpyOnOrConfig) {
       config,
       () => getDeclaredMethodNames(ObjectClass.prototype)
     );
+    recordInnerDoubles(autoSpy, config.classReturns);
   }
   if (Reflect.ownKeys(config.overrides).length > 0) {
     applyOverrides(autoSpy, config.overrides, ObjectClass.name, (key) => answersWithMethodSpy(ObjectClass, config, key));
@@ -1165,4 +1193,4 @@ function hasNothingToRead(ObjectClass, accessors, config) {
   config.onlyMethodsToSpyOn.length === 0;
 }
 
-export { NOT_STORED, applyConfiguredReturns, autoMocked, clearAutoSpy, clearAutoSpyDefaults, closestName, createAccessorsSpies, createAutoMock, createProxyPropStore, createSpyFromClass2 as createSpyFromClass, createTrackedPropSpy, describeStoredProp, disposeAutoSpy, getCallableMemberNames, hasStoredProp, isDeletedProp, isProtocolKey, mergeAutoSpyDefaults, mergeMethodNames, ownerOf, readStoredAccessor, registerAutoSpyDefaults, resetAutoSpy, resolveAccessors, resolveConfiguration, resolveReadGuard, storeWriteTraps, warnOnAccessorNamingAMethod, warnOnUnknownMethods, writeStoredValue };
+export { NOT_STORED, applyConfiguredReturns, autoMocked, clearAutoSpy, clearAutoSpyDefaults, closestName, createAccessorsSpies, createAutoMock, createProxyPropStore, createSpyFromClass2 as createSpyFromClass, createTrackedPropSpy, describeStoredProp, disposeAutoSpy, getCallableMemberNames, hasStoredProp, innerDouble, isDeletedProp, isProtocolKey, mergeAutoSpyDefaults, mergeMethodNames, ownerOf, readStoredAccessor, recordInnerDoubles, registerAutoSpyDefaults, resetAutoSpy, resolveAccessors, resolveConfiguration, resolveReadGuard, storeWriteTraps, warnOnAccessorNamingAMethod, warnOnUnknownMethods, writeStoredValue };

package/dist/{chunk-RAJTKMDV.js → chunk-OL2J4K4Z.js}

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