vitest-auto-spy 5.42.0 → 5.43.0

package/CHANGELOG.md

@@ -10,6 +10,49 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.43.0] - 2026-09-27
+
+### Added
+
+- **`trackInjections(...).names({ clean: true })`.** `names()` returns each token's `Function.name`
+  as is, so under esbuild a decorated `FeatureFlagService` came back as `_FeatureFlagService` while
+  `get()` and every message printed the clean name. The option takes the rename off (the leading `_`,
+  Rollup's `$1`); without it the result is unchanged.
+- **`toHaveSignalValue(expected, { strict: true })`.** The matcher compares the way `toEqual` does, so
+  `signal({ color: undefined })` passed against `{}` and a class instance against a plain object; a
+  spec on `expect(sig()).toStrictEqual(x)` lost precision by moving to it. `strict` counts
+  `undefined` properties, array holes and the object's class, as `toStrictEqual` does. The options
+  type is exported from `/angular/matchers` as `SignalValueOptions`. `/angular/matchers` is +137 B
+  min+gzip (2662 → 2799 B, +5.1 %) and +0.6 kB to import (22349 → 22906 B): the strict comparison,
+  its class tester, and the structural-directive message below.
+
+### Changed
+
+- **`angular-build-istanbul-module-cache` puts its −46 % in range.** A second suite, 862 spec files on
+  `@angular/build` 22.2 and Vitest 5.0.2, gained −19 % from the cache (48 → 39 s), while switching it
+  to v8 ran in 19–22 s, about twice as fast as istanbul with the cache, on 7.5–8 GB RSS against
+  10–11 GB. The finding now gives −46 % as "up to", adds that data point, says the cache pays off on
+  CI only when CI keeps `node_modules/.vitest-cache`, and its fix offers `coverage.provider: 'v8'` as
+  the alternative. Still an info.
+
+### Fixed
+
+- **`toHaveDirectiveApplied(Structural, selector)` no longer sends a structural directive to
+  `detectChanges()`.** When the directive rendered nothing the selector names, the failure said no
+  element matches and to run `fixture.detectChanges()`, which changes nothing. It now says the
+  directive is on a template anchor, that the element exists only in a view the directive chose to
+  render, and to assert without a selector.
+- **Docs that disagreed with 5.41–5.42.** The performance table and README called the
+  `lazySpies: true` path "the default" (a class of 8+ methods now gets `'proxy'`) and said lazy spies
+  change no behaviour; the width is now defined as the methods the double spies, after
+  `onlyMethodsToSpyOn` / `methodsToSpyOn`. The Russian Angular page carried the pre-4.1 speed table.
+  The strict-mode and control-helper pages now say a delegating `mockImplementation` and `vi.when` are
+  not reported, and a `vi.when` over a `mockReturnValue` is. The CLI page counts `ng-test` among the
+  commands, says it exits with `ng`'s code, lists its exit-2 cases, that `--related` takes a
+  comma-separated list and that the builder compiles only included specs from `@angular/build` 22.2
+  (also in `--help`); the Russian CLI page gains the exit-code table. `RouteResources` is `never` up
+  to router 22.1, not only on 20 and 21.
+
 ## [5.42.0] - 2026-09-27
 
 ### Added
@@ -5692,7 +5735,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.42.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.43.0...HEAD
+[5.43.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.42.0...v5.43.0
 [5.42.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.41.0...v5.42.0
 [5.41.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.40.1...v5.41.0
 [5.40.1]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.40.0...v5.40.1

package/README.md

@@ -83,7 +83,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
 - 📏 Lint rules and one-line test-run hygiene — forty-nine rules in `vitest-auto-spy/eslint-plugin` (six `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
-- 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-and-init) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
+- 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-init-and-ng-test) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
 - 🚚 [`npx vitest-auto-spy codemod`](#codemod--migrating-a-suite-off-jest-auto-spies) — thirteen transforms that move a suite off `jest-auto-spies` and Jest, or off `jasmine-auto-spies` and jasmine (`--from jasmine`), dry-run by default, with a `--verify` pass that also checks a file somebody edited by hand
 - 🔇 Console spies — `import { consoleInfoSpy } from 'vitest-auto-spy/console'` silences `console` and asserts its calls; [`setupAutoSpy({ strayConsole: 'throw' })`](#how-to-mock-the-console) fails any test whose console output nothing absorbed
@@ -126,7 +126,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
   - [A jasmine suite mid-migration](#how-to-mock-a-jasmine-suite-mid-migration)
 - [New in 5](#new-in-5)
 - [New in 4](#new-in-4)
-- [The CLI — `doctor`, `perf`, `codemod` and `init`](#the-cli--doctor-perf-codemod-and-init)
+- [The CLI — `doctor`, `perf`, `codemod`, `init` and `ng-test`](#the-cli--doctor-perf-codemod-init-and-ng-test)
   - [`doctor` — defects that never fail](#doctor--defects-that-never-fail)
   - [`perf` — where the CPU time actually goes](#perf--where-the-cpu-time-actually-goes)
   - [`codemod` — migrating a suite off `jest-auto-spies`](#codemod--migrating-a-suite-off-jest-auto-spies)
@@ -989,7 +989,7 @@ a `.d.ts` your `tsconfig` includes — that one import is what keeps `returnSubj
 own `Subject<T>`. From `@angular/build:unit-test` 22.2.0 the test program is the specs, the setup
 files and the `.d.ts` files, so a plain `.ts` listed only in the spec `tsconfig`'s `include` is out.
 
-## The CLI — `doctor`, `perf`, `codemod` and `init`
+## The CLI — `doctor`, `perf`, `codemod`, `init` and `ng-test`
 
 The package ships one executable, with no dependencies and nothing to configure:
 
@@ -1007,7 +1007,7 @@ passes neither Vitest's `--shard` nor its `--changed` through, so it picks the s
 them to the builder as `--include` paths.
 
 **Exit `0` means "ran, nothing to report"; `1` means "ran, and here is the finding"; `2` means
-"there was nothing to judge".** The third one is the reason to read this line: an unknown flag for a
+"there was nothing to judge".** (`ng-test` passes `ng`'s own exit code through once it runs.) The third one is the reason to read this line: an unknown flag for a
 known command is an error and **nothing runs** — `init --dryrun` used to write the files and
 `perf --gat` used to pass with no gate at all, which is a typo that reads as a clean CI step. A path
 that matches no file is the same kind of error, because _Nothing left to migrate_ off a tree nobody
@@ -1055,7 +1055,7 @@ error  tsconfig-glob-matches-nothing libs/users/tsconfig.spec.json
 | `analog-behind-angular-build`         | `@analogjs/vite-plugin-angular` below 2.7.5 next to `@angular/build` 22.2+ — `TypeError: cache.has is not a function` at startup                                                     |
 | `analog-fast-compile-ctor-injection`  | Analog `fastCompile` in JIT mode with an `@Injectable` whose constructor parameter is known only by its type — NG0202 at injection                                                   |
 | `analog-module-cache-inline-styles`   | `fsModuleCache` on under the Analog plugin with a component that has inline `styles` — the warm run fails on `virtual:angular:jit:style:inline`                                      |
-| `angular-build-istanbul-module-cache` | istanbul coverage under the unit-test builder (not in `browsers`) without `fsModuleCache` — −46 % on a 700-file Angular 22.2 suite. Info                                             |
+| `angular-build-istanbul-module-cache` | istanbul coverage under the unit-test builder (not in `browsers`) without `fsModuleCache` — up to −46 %; v8 beat istanbul with the cache ~2x. Info                                   |
 | `angular-build-happy-dom`             | jsdom only because `happy-dom` is not installed; the builder picks it by itself from 21 — −4.6 % wall, −6 % RSS. Info                                                                |
 | `coverage-all-removed`                | `coverage.all` in a config, on a Vitest that stopped reading the key                                                                                                                 |
 | `coverage-include-misses-bundle`      | A `coverage.include` of sources only, in a runner config over a bundle                                                                                                               |
@@ -2422,7 +2422,9 @@ expect(() => myService.getName(2)).toThrow();
 install an implementation on the host mock, and the dispatch that reads a `calledWith` chain **is**
 the implementation they replace — so the one written later wins outright and the other decides
 nothing, in either order, without failing. Both orders are now reported as a misconfiguration (a
-warning, a throw under the `strict` preset). Where both are wanted, the fallback goes in the spy's
+warning, a throw under the `strict` preset) — except a wrapper that delegates, `vi.when(spy)` on
+Vitest 5 or a `mockImplementation` built from `spy.getMockImplementation()`, which the chain still
+answers through. Where both are wanted, the fallback goes in the spy's
 own container, which a chain still wins over: the `returns` option where the double is built, or
 `resolveWith` / `nextWith` / `failWith`. The report comes from this library's own spy engine — so
 Vitest and Rstest, not Bun or `node:test`, and not under `setSpyEngine('runner')` — and the `Once`
@@ -2656,11 +2658,12 @@ beforeEach(() => {
 > `@angular/build` 22.2 or newer, both `@analogjs` packages need 2.7.5 or newer — older ones crash at
 > startup with `TypeError: cache.has is not a function`.
 
-> **Lazy by default, everywhere.** Every factory builds each method spy on first access
+> **Lazy by default.** `createSpyFromClass` and `provideAutoSpy` build each method spy on first access
 > (accessor placeholders below 8 methods, a `Proxy` from 8), since Angular tests typically spy a wide service but call
 > only a few of its methods — and the margin widens as the class does: **1.4×** on a ten-method
-> class a test calls twice, **1.9×** on a forty-method one it calls three times. Behaviour is
-> unchanged; pass `{ lazySpies: false }` to build every spy eagerly.
+> class a test calls twice, **1.9×** on a forty-method one it calls three times. Calls, `Object.keys`,
+> spread and snapshots behave the same; a wide class's double is a `Proxy`, so pass
+> `{ lazySpies: true }` for a plain object, or `{ lazySpies: false }` to build every spy eagerly.
 
 #### Signal / readonly property mocking (bonus)
 
@@ -2930,8 +2933,9 @@ expect(component.items).toHaveSignalValue([{ id: 1 }]);
 ```
 
 `expect(component.total).toBeTruthy()` passes for every signal ever created — a signal is a
-function. The matcher reads it, deep-compares, and rejects anything that is not a zero-argument
-getter, so the missing-parentheses mistake fails instead of quietly passing.
+function. The matcher reads it, deep-compares (as `toEqual` does; `{ strict: true }` as
+`toStrictEqual` does), and rejects anything that is not a zero-argument getter, so the
+missing-parentheses mistake fails instead of quietly passing.
 
 #### Where a spec spends its time
 
@@ -3032,7 +3036,7 @@ collaborators.get(FeatureFlagService).isOn.mockReturnValue(true);
 
 TestBed.inject(CheckoutFacade).start();
 
-expect(collaborators.names()).toEqual(['FeatureFlagService']); // analytics was never asked for
+expect(collaborators.names({ clean: true })).toEqual(['FeatureFlagService']); // analytics was never asked for
 ```
 
 The assertion behind most `vi.mock('@app/services')` calls is not "this module was replaced" — it is
@@ -3061,7 +3065,8 @@ injectActivatedRoute().setParams({ id: '8' }); // params and paramMap emit; snap
 has neither, and a hand-written `useValue` usually has one half — the component that reads the other
 gets `undefined`, or a spec tests a route no navigation can produce. The double here is Angular's own
 `ActivatedRoute` over one record: `params`, `queryParams`, `data`, `fragment`, `url`, both
-`ParamMap`s and `snapshot` come from the same values, and each setter (`setParams`,
+`ParamMap`s and `snapshot` come from the same values (plus `title`, `children` and, on Angular 22.2+,
+the `resources` record), and each setter (`setParams`,
 `setQueryParams`, `setData`, `setFragment`, `setUrl`, or `set({ … })` for several at once) rebuilds
 the snapshot first and then emits what changed, in the router's order and with its equality. It is a
 real route to the real `Router` too: `relativeTo` resolves against its `url`. `createActivatedRoute()`

package/agent-docs/angular.md

@@ -538,8 +538,9 @@ Four things to know:
 - **List it after `provideRouter()`** — the later provider of `ActivatedRoute` wins, and
   `injectActivatedRoute()` throws naming the one that did. With the real router present, the double
   still works as `relativeTo` for `router.createUrlTree`.
-- **One node, no tree.** `root` is the route itself, `parent` / `firstChild` are `null`. For
-  `route.parent.params` patch that member with `mockReadonlyProp`, or use `RouterTestingHarness`.
+- **No parent above it.** `root` is the route itself and `parent` is `null`; below it there are only
+  the routes passed as `children`. For `route.parent.params` patch that member with
+  `mockReadonlyProp`, or use `RouterTestingHarness`.
 - **`title` is given, not resolved; no navigation, no input binding.** `provideActivatedRoute({
 title: 'Product 7' })` answers `route.snapshot.title` — the double puts the string under the
   router's own `RouteTitleKey`, read off the installed router, and does not run a `title: () => …`
@@ -857,10 +858,11 @@ collaborators.get(FeatureFlagService).isOn.mockReturnValue(true);
 
 TestBed.inject(CheckoutFacade).start();
 
-expect(collaborators.names()).toEqual(['FeatureFlagService']); // analytics was never asked for
+expect(collaborators.names({ clean: true })).toEqual(['FeatureFlagService']); // analytics was never asked for
 ```
 
-`providers`, `injectedTokens()` (in factory-run order), `names()`, `wasInjected(token)`,
+`providers`, `injectedTokens()` (in factory-run order), `names()` (raw `Function.name`, so `_Service`
+under esbuild; `names({ clean: true })` strips the rename), `wasInjected(token)`,
 `get<D>(token)` → `Spy<D>`, `reset()` (the record only — the doubles survive). A class token gets a
 class spy, anything else a `createAutoMock()`; pass `{ double: () => … }` when a collaborator has to
 be a real object. Doubles are built eagerly, so stub before the entry point runs; a factory runs once
@@ -1025,7 +1027,7 @@ expect(products.reload).toHaveBeenCalled(); // reload is spied, answers true, an
 
 // signal assertions
 registerSignalMatchers(); // once, in the setup file — /angular/matchers
-expect(component.total).toHaveSignalValue(3);
+expect(component.total).toHaveSignalValue(3); // toEqual semantics; { strict: true } for toStrictEqual's
 
 // resource assertions — value AND status, which is the whole point
 registerResourceMatchers(); // once, in the setup file — /angular/matchers

package/agent-docs/checklist.md

@@ -52,7 +52,9 @@ a unit-test target, Analog below 2.7.5, `vite` below 6.4, or Node below 22.12 in
 honours (`experimental.fsModuleCache`, `browser.isolate`, `cache.dir`, …) are left to Vitest's own
 deprecation line. Four more cover the Angular unit-test builder and Analog:
 `angular-build-istanbul-module-cache` notes an istanbul run under `@angular/build:unit-test` 21+ on
-Vitest 5 without `fsModuleCache` in the target's runner config (−46 % measured), and
+Vitest 5 without `fsModuleCache` in the target's runner config (up to −46 %, −19 % on another suite;
+v8 was about 2x faster than istanbul with the cache there, and the cache pays off on CI only when
+`node_modules/.vitest-cache` is kept), and
 `analog-module-cache-inline-styles` warns that `fsModuleCache` under the Analog plugin breaks the
 warm run of any spec reaching a component with inline `styles`. `angular-build-happy-dom` notes a
 builder target on jsdom only because `happy-dom` is not installed.
@@ -141,7 +143,7 @@ totals are CPU time summed across every worker, not wall clock** — a report sh
 time` under `986ms wall clock` is not a bug, it is the work spread over workers.
 
 Under `@angular/build:unit-test`, `ng test` takes no Vitest flag. Shard or run only what a change
-reaches with `npx vitest-auto-spy ng-test --shard 1/4` / `--changed [ref]` / `--related <files>`
+reaches with `npx vitest-auto-spy ng-test --shard 1/4` / `--changed [ref]` / `--related a.ts,b.ts`
 (`@angular/build` 21+; everything after `--` goes to `ng`); `test.repeats` in the runner config
 reaches Vitest as it is. `vitest doctor` does not work there — use `perf --command`.
 

package/agent-docs/configuration.md

@@ -28,7 +28,7 @@ createSpyFromClass(MyService, {
 | `onlyMethodsToSpyOn` | **Exhaustive whitelist.** Skips discovery; anything not listed is absent. |
 | `instanceMethodsToSpyOn` | **Additive.** The name to prefer in new code (see below). |
 | `autoSpyAccessors` | Merged with the explicit getter/setter lists. |
-| `lazySpies` | Unset: `true` (accessor placeholders) below 8 methods, `'proxy'` (a `Proxy`, lighter once touched) from 8. Explicit `true` / `false` / `'proxy'` apply at any width. Calls, `Object.keys`, spread and snapshots behave the same in every mode. |
+| `lazySpies` | Unset: `true` (accessor placeholders) below 8 methods, `'proxy'` (a `Proxy`, lighter once touched) from 8, counting the methods the double spies (after `onlyMethodsToSpyOn` / `methodsToSpyOn`). Explicit `true` / `false` / `'proxy'` apply at any width. Calls, `Object.keys`, spread and snapshots behave the same in every mode. |
 | `strict` | Throw on a method nobody configured, instead of answering `undefined` (below). |
 | `onUnstubbedCall` | The general form of `strict`; its return value becomes the call's return value. |
 | `selfReturning` | The named methods answer the double itself — a default like `returns`; a name in both answers `returns`. |
@@ -251,7 +251,8 @@ Precedence, first one set wins: the double's `onUnstubbedCall` → the double's
   double is built, or `resolveWith` / `nextWith` / `failWith` — which a `calledWith` still wins over.
   The report is this library's own spy engine's, so Vitest and Rstest have it; Bun, `node:test` and
   `setSpyEngine('runner')` do not. The `Once` family is never reported.
-  `vi.when(spy)` (Vitest 5) is not reported either: it wraps the dispatch rather than replacing it,
+  `vi.when(spy)` (Vitest 5) is not reported either, nor any `mockImplementation` built from
+  `spy.getMockImplementation()`: it wraps the dispatch rather than replacing it,
   so a `calledWith` on the same method still answers every call `vi.when` has no row for. A
   `vi.when` over a `mockReturnValue` still is.
 - **A throw something swallowed still fails the test.** Under `setupAutoSpy({ strict: true })` every

package/dist/angular-doubles.d.ts

@@ -1,5 +1,5 @@
 import { InjectionToken, AbstractType, Injector, ValueProvider, FactoryProvider, ProviderToken } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes } from './types-CyRUgJVd.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-CaGn5uvo.js';
 import 'vitest';
 
 /**

package/dist/angular-matchers.d.ts

@@ -76,11 +76,19 @@ type SignalLike<T> = () => T;
 declare global {
     namespace Chai {
         interface Assertion {
-            /** Read the signal under test and deep-compare its current value. */
-            toHaveSignalValue(expected: unknown): void;
+            /**
+             * Read the signal under test and deep-compare its current value, with `toEqual` semantics;
+             * `{ strict: true }` compares the way `toStrictEqual` does.
+             */
+            toHaveSignalValue(expected: unknown, options?: SignalValueOptions): void;
         }
     }
 }
+/** How {@link registerSignalMatchers}' `toHaveSignalValue` compares. */
+interface SignalValueOptions {
+    /** Count `undefined` properties, array holes and the object's class, as `toStrictEqual` does. */
+    readonly strict?: boolean;
+}
 /**
  * Register {@link toHaveSignalValue} with the runner. Call once, from your setup file.
  *
@@ -93,4 +101,4 @@ declare global {
  */
 declare function registerSignalMatchers(): void;
 
-export { type ResourceLike, type SignalLike, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers };
+export { type ResourceLike, type SignalLike, type SignalValueOptions, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers };

package/dist/angular-matchers.js

@@ -102,17 +102,18 @@ function diagnose(directive, selector, root, withDirective) {
   const elements = selector === void 0 ? [] : matching(root, By.css(selector));
   const where = selector === void 0 ? "" : ` on '${selector}'`;
   const prefix = `[vitest-auto-spy] expected ${name} to be applied${where}`;
-  if (selector !== void 0 && elements.length === 0) {
+  if (selector !== void 0 && withDirective.some(isAnchor)) {
+    const unrendered = elements.length === 0 ? ", and the element that selector names exists only in a view the directive chose to render" : "";
     return withDocs(
-      `${prefix}, but no element matches that selector.
-Run fixture.detectChanges() before asserting, and check the selector against the template.`,
+      `${prefix}, but it is on a template anchor, not on an element \u2014 a structural directive sits on the comment Angular leaves in place of its template${unrendered}.
+Assert it without a selector: expect(fixture).toHaveDirectiveApplied(${name}).`,
       angularDirectiveApplied
     );
   }
-  if (selector !== void 0 && withDirective.some(isAnchor)) {
+  if (selector !== void 0 && elements.length === 0) {
     return withDocs(
-      `${prefix}, but it is on a template anchor, not on an element \u2014 a structural directive sits on the comment Angular leaves in place of its template.
-Assert it without a selector: expect(fixture).toHaveDirectiveApplied(${name}).`,
+      `${prefix}, but no element matches that selector.
+Run fixture.detectChanges() before asserting, and check the selector against the template.`,
       angularDirectiveApplied
     );
   }
@@ -242,9 +243,15 @@ function registerResourceMatchers() {
 function isSpy(received) {
   return "mock" in received || "calls" in received;
 }
+function sameClass(a, b) {
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) && Array.isArray(b)) {
+    return void 0;
+  }
+  return Object.getPrototypeOf(a) === Object.getPrototypeOf(b) ? void 0 : false;
+}
 function registerSignalMatchers() {
   expect.extend({
-    toHaveSignalValue(received, expected) {
+    toHaveSignalValue(received, expected, { strict = false } = {}) {
       if (typeof received !== "function") {
         throw new Error(`expected a signal (a zero-argument getter), received ${this.utils.printReceived(received)}`);
       }
@@ -254,12 +261,12 @@ function registerSignalMatchers() {
         );
       }
       const actual = received();
-      const pass = this.equals(actual, expected);
+      const pass = strict ? this.equals(actual, expected, [...this.customTesters, sameClass], true) : this.equals(actual, expected);
       return {
         pass,
         actual,
         expected,
-        message: () => `expected signal ${pass ? "not " : ""}to have value ${this.utils.printExpected(expected)}, got ${this.utils.printReceived(actual)}`
+        message: () => `expected signal ${pass ? "not " : ""}to have ${strict ? "strictly equal " : ""}value ${this.utils.printExpected(expected)}, got ${this.utils.printReceived(actual)}`
       };
     }
   });

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-CyRUgJVd.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-CaGn5uvo.js';
 import { SpyLocation } from '@angular/common/testing';
 import 'vitest';
 
@@ -40,7 +40,7 @@ interface ActivatedRouteChange {
 }
 /**
  * `ActivatedRoute.resources` where the installed `@angular/router` has it (22.2 on), `never` before —
- * so the init key stays harmless on 20 and 21.
+ * so on 20 through 22.1 the init key cannot be passed.
  */
 type RouteResources = NonNullable<ActivatedRoute[Extract<'resources', keyof ActivatedRoute>]>;
 /** The route a spec starts from: what a navigation moves, plus what stays fixed for the route's life. */

package/dist/angular.d.ts

@@ -1,12 +1,12 @@
-export { u as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, v as provideAutoSpyForToken, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-bs2umXNE.js';
-import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, s as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-CyRUgJVd.js';
-export { H as SubjectOf } from './types-CyRUgJVd.js';
+export { u as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, v as provideAutoSpyForToken, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-B3noexlc.js';
+import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, s as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-CaGn5uvo.js';
+export { H as SubjectOf } from './types-CaGn5uvo.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
-import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-D273986K.js';
-export { C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, s as setEmissionTimeout } from './expect-emission-D273986K.js';
+import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-D7DaPI5H.js';
+export { C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
 import { TestAPI } from 'vitest';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BTJKOqWz.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-Cz0yKWEP.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CkVuJHr_.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-e7qpfqY1.js';
 import '@angular/core/testing';
 
 /**

package/dist/angular.js

@@ -462,7 +462,7 @@ function trackInjections(tokens, options = {}) {
   return {
     providers,
     injectedTokens: () => [...injected],
-    names: () => injected.map(tokenName),
+    names: ({ clean = false } = {}) => injected.map(clean ? messageName : tokenName),
     wasInjected: (token) => injected.includes(token),
     get: (token) => {
       if (!doubles.has(token)) {

package/dist/bun-angular.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-bs2umXNE.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-B3noexlc.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,4 +1,4 @@
-import { createSpyForToken } from './chunk-25QOHNGU.js';
+import { createSpyForToken } from './chunk-XXAGPAZR.js';
 export { injectSpy, provideAutoSpy } from './chunk-MHN6GMXP.js';
 import { stable, flushEffects } from './chunk-UH3KWLVL.js';
 export { flushEffects, stable } from './chunk-UH3KWLVL.js';

package/dist/bun.d.ts

@@ -1,8 +1,8 @@
-import { z as SpyOptions, C as ClassType, m as ClassSpyConfiguration, s as OnlyMethodKeysOf, S as Spy, I as InstanceSpyConfiguration, o as DeepPartial, D as DeepMockProxy, F as Func, h as AddSpyMethodsByReturnTypes } from './types-CyRUgJVd.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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, y as SpyDisposable, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+import { z as SpyOptions, C as ClassType, m as ClassSpyConfiguration, s as OnlyMethodKeysOf, S as Spy, I as InstanceSpyConfiguration, o as DeepPartial, D as DeepMockProxy, F as Func, h as AddSpyMethodsByReturnTypes } from './types-CaGn5uvo.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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, y as SpyDisposable, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
 import { Mock, MockInstance } from 'vitest';
 
 /**

package/dist/{chunk-25QOHNGU.js → chunk-XXAGPAZR.js}

@@ -31,7 +31,7 @@ function trackInjections(tokens, options = {}) {
   return {
     providers,
     injectedTokens: () => [...injected],
-    names: () => injected.map(tokenName),
+    names: ({ clean = false } = {}) => injected.map(clean ? messageName : tokenName),
     wasInjected: (token) => injected.includes(token),
     get: (token) => {
       if (!doubles.has(token)) {

package/dist/cli.js

@@ -3593,7 +3593,8 @@ function istanbulBecause(profile, { config, keys, browsers }) {
   return istanbul && !v8 ? "only `@vitest/coverage-istanbul` is installed, so the builder picks istanbul" : void 0;
 }
 var hasModuleCache = ({ keys }) => keys.some((key) => isKey(key, "fsModuleCache") && isTrue(key));
-var ISTANBUL_MEASURED = "On an Angular 22.2 suite of 700 spec files on Vitest 5, the module cache took an istanbul coverage run under the builder from 24.55 s to 13.20 s (\u221246 %), and from 27.01 s to 15.85 s (\u221241 %) with the builder cache off, as it is on CI; with v8 it gained nothing, since the builder has already bundled the code.";
+var ISTANBUL_MEASURED = "The module cache took an istanbul coverage run under the builder from 24.55 s to 13.20 s (up to \u221246 %) on an Angular 22.2 suite of 700 spec files on Vitest 5, and from 27.01 s to 15.85 s (\u221241 %) with the builder cache off, as it is on CI; on an 862-spec suite it took 48 s to 39 s (\u221219 %). Switching that suite to v8 beat istanbul with the cache about 2x: 19\u201322 s, where the cache gained nothing, since the builder has already bundled the code. The cache pays off on CI only when CI keeps `node_modules/.vitest-cache` between runs.";
+var V8_INSTEAD = " Or switch the target to `coverage.provider: 'v8'`, with `@vitest/coverage-v8` installed: it needs no cache, and the coverage thresholds are worth one run to confirm after the switch.";
 function moduleCacheFinding(profile, { first, why, targets: group3 }) {
   const where2 = namedTargets(group3.map(({ target }) => target));
   const ci = ciConfigs(profile);
@@ -3604,7 +3605,7 @@ function moduleCacheFinding(profile, { first, why, targets: group3 }) {
     severity: "info",
     file: first.config ?? first.target.file,
     message: `${where2} collects coverage with istanbul through \`${first.target.builder}\` (${why}), and no runner config of it turns on \`fsModuleCache\`: every run instruments every file again. ${ISTANBUL_MEASURED}`,
-    fix: `${turnOn}${persist}`
+    fix: `${turnOn}${persist}${V8_INSTEAD}`
   };
 }
 function checkIstanbulModuleCache(profile, targets) {
@@ -3862,7 +3863,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.41.0";
+var EXPORT_MAP_VERSION = "5.42.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",
@@ -4220,6 +4221,7 @@ var EXPORTED_BY = {
   setupFakeTimers: "23",
   ShallowRender: "2 12",
   SignalLike: "15",
+  SignalValueOptions: "15",
   SpecTiming: "13",
   SpiedFixtures: "12",
   Spy: "0 1 2 3 4 9 12 20 21 22",
@@ -5203,7 +5205,8 @@ Commands
             does not pass through: a shard, or the specs a change reaches.
             Lists the target's specs with --list-tests (@angular/build 21+),
             picks the ones this run gets and hands them to the builder as
-            --include paths, so it compiles only those. Exits with ng's code.
+            --include paths, so from @angular/build 22.2 it compiles only
+            those. Exits with ng's code.
 
   init      Write a pointer to node_modules/vitest-auto-spy/AGENTS.md into the
             instruction files the agents in this repository actually read, and

package/dist/console.d.ts

@@ -1,4 +1,4 @@
-import { F as Func, h as AddSpyMethodsByReturnTypes } from './types-CyRUgJVd.js';
+import { F as Func, h as AddSpyMethodsByReturnTypes } from './types-CaGn5uvo.js';
 import 'vitest';
 
 /** The call shape shared by every spied console method. */

package/dist/dom-stubs.d.ts

@@ -1,6 +1,6 @@
-import { F as Func } from './types-CyRUgJVd.js';
+import { F as Func } from './types-CaGn5uvo.js';
 export { W as WebStorageKey, a as WebStorageStub, b as WebStorageStubOptions, s as stubWebStorage } from './web-storage-dwQ9E7Lm.js';
-import { R as RestoreProp } from './prop-mock-Cz0yKWEP.js';
+import { R as RestoreProp } from './prop-mock-e7qpfqY1.js';
 import 'vitest';
 
 /**

package/dist/{expect-emission-D273986K.d.ts → expect-emission-D7DaPI5H.d.ts}

@@ -1,4 +1,4 @@
-import { B as StrictSpyConfiguration, t as OnlyObservablePropsOf, M as MethodReturns, s as OnlyMethodKeysOf, S as Spy, o as DeepPartial, z as SpyOptions, C as ClassType, m as ClassSpyConfiguration } from './types-CyRUgJVd.js';
+import { B as StrictSpyConfiguration, t as OnlyObservablePropsOf, M as MethodReturns, s as OnlyMethodKeysOf, S as Spy, o as DeepPartial, z as SpyOptions, C as ClassType, m as ClassSpyConfiguration } from './types-CaGn5uvo.js';
 
 /**
  * Create a fully-typed auto-mock of `T` from its type alone (no class).

package/dist/index.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
 import 'vitest';

package/dist/jasmine-compat.d.ts

@@ -1,5 +1,5 @@
 import { Mock } from 'vitest';
-import { F as Func, h as AddSpyMethodsByReturnTypes, g as AddPromiseSpyMethods, O as ObservableLike, f as AddObservableSpyMethods, y as SpyDisposable } from './types-CyRUgJVd.js';
+import { F as Func, h as AddSpyMethodsByReturnTypes, g as AddPromiseSpyMethods, O as ObservableLike, f as AddObservableSpyMethods, y as SpyDisposable } from './types-CaGn5uvo.js';
 
 /**
  * Install the `.and`, `.calls` and `.withArgs` namespaces on every spy built afterwards.

package/dist/jasmine.d.ts

@@ -1,7 +1,7 @@
 import { JasmineSpy, JasmineMethodSpy } from './jasmine-compat.js';
 export { JasmineAccessorSpies, JasmineAccessorSpy, JasmineAnd, JasmineCallInfo, JasmineCalls, JasmineNamespaces, JasmineStrategies, JasmineWithArgsAnd, JasmineWithArgsSync, enableJasmineCompat } from './jasmine-compat.js';
-import { C as ClassType, m as ClassSpyConfiguration, s as OnlyMethodKeysOf, F as Func } from './types-CyRUgJVd.js';
-export { t as OnlyObservablePropsOf, u as OnlyPropsOf } from './types-CyRUgJVd.js';
+import { C as ClassType, m as ClassSpyConfiguration, s as OnlyMethodKeysOf, F as Func } from './types-CaGn5uvo.js';
+export { t as OnlyObservablePropsOf, u as OnlyPropsOf } from './types-CaGn5uvo.js';
 import { expect } from 'vitest';
 
 /**

package/dist/nestjs.d.ts

@@ -1,5 +1,5 @@
-import { C as ClassType, S as Spy, m as ClassSpyConfiguration, s as OnlyMethodKeysOf } from './types-CyRUgJVd.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BTJKOqWz.js';
+import { C as ClassType, S as Spy, m as ClassSpyConfiguration, s as OnlyMethodKeysOf } from './types-CaGn5uvo.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CkVuJHr_.js';
 import 'vitest';
 
 /** `{ provide, useValue }` shape consumed by NestJS's `providers`. */

package/dist/nestjs.js

@@ -1,5 +1,5 @@
-import { createSpyForToken } from './chunk-25QOHNGU.js';
-export { trackInjections } from './chunk-25QOHNGU.js';
+import { createSpyForToken } from './chunk-XXAGPAZR.js';
+export { trackInjections } from './chunk-XXAGPAZR.js';
 import { createSpyFromClass } from './chunk-EYXARTWD.js';
 import { useVitestAdapter } from './chunk-J4IJCTHT.js';
 import './chunk-J2C3KRTC.js';

package/dist/node.d.ts

@@ -1,8 +1,8 @@
-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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
 import 'vitest';
 
 /**

package/dist/{package-identity-BnqwTQIn.d.ts → package-identity-C362z4w-.d.ts}

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

package/dist/{prop-mock-Cz0yKWEP.d.ts → prop-mock-e7qpfqY1.d.ts}

@@ -1,4 +1,4 @@
-import { P as PropStubValue } from './types-CyRUgJVd.js';
+import { P as PropStubValue } from './types-CaGn5uvo.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,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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
 import 'vitest';

package/dist/rstest.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
 import 'vitest';

package/dist/rxjs.d.ts

@@ -1,6 +1,6 @@
 import { Observable, ReplaySubject, Subject } from 'rxjs';
-import { V as ValueConfig } from './types-CyRUgJVd.js';
-export { f as AddObservableSpyMethods, n as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, Q as ValueConfigPerCall } from './types-CyRUgJVd.js';
+import { V as ValueConfig } from './types-CaGn5uvo.js';
+export { f as AddObservableSpyMethods, n as CompleteValueConfig, E as ErrorValueConfig, N as NextValueConfig, Q as ValueConfigPerCall } from './types-CaGn5uvo.js';
 import 'vitest';
 
 /**

package/dist/setup.d.ts

@@ -1,7 +1,7 @@
 import { vi } from 'vitest';
-import { O as OutsideHookReaction, R as RestoreProp } from './prop-mock-Cz0yKWEP.js';
-import { J as UnstubbedCallHandler, L as UnstubbedReadHandler } from './types-CyRUgJVd.js';
-export { d as describeDuplicateCopies, g as getPackageCopies, t as takeStrictViolations } from './package-identity-BnqwTQIn.js';
+import { O as OutsideHookReaction, R as RestoreProp } from './prop-mock-e7qpfqY1.js';
+import { J as UnstubbedCallHandler, L as UnstubbedReadHandler } from './types-CaGn5uvo.js';
+export { d as describeDuplicateCopies, g as getPackageCopies, t as takeStrictViolations } from './package-identity-C362z4w-.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,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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.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, m as ClassSpyConfiguration, C 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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, s as OnlyMethodKeysOf, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, S as Spy, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.js';
 import 'vitest';

package/dist/{track-injections-BTJKOqWz.d.ts → track-injections-CkVuJHr_.d.ts}

@@ -1,4 +1,4 @@
-import { C as ClassType, S as Spy } from './types-CyRUgJVd.js';
+import { C as ClassType, S as Spy } from './types-CaGn5uvo.js';
 
 /**
  * The provider shape Angular and NestJS agree on: `{ provide, useFactory }`, with the dependency
@@ -23,8 +23,14 @@ interface InjectionLog {
     readonly providers: TrackedProvider[];
     /** The tokens DI asked for, in the order their factories ran. A copy — mutating it changes nothing. */
     injectedTokens(): unknown[];
-    /** The same list as names, which is what makes a failing `toEqual` readable. */
-    names(): string[];
+    /**
+     * The same list as names, which is what makes a failing `toEqual` readable. Each is the token's own
+     * `name`, so esbuild's `_Service` stays as it is; `{ clean: true }` takes a bundler's rename off,
+     * the way every failure message prints it.
+     */
+    names(options?: {
+        readonly clean?: boolean;
+    }): string[];
     /** Whether DI ever constructed `token`. */
     wasInjected(token: unknown): boolean;
     /** The double registered for `token`, typed as a spy. Throws when the token was never tracked. */
@@ -44,7 +50,7 @@ interface InjectionLog {
  *
  * TestBed.inject(CheckoutFacade).start();
  *
- * expect(collaborators.names()).toEqual(['FeatureFlagService']); // analytics was never asked for
+ * expect(collaborators.names({ clean: true })).toEqual(['FeatureFlagService']); // analytics was never asked for
  * ```
  *
  * The doubles are built up front, so a spec can stub one before the entry point runs; the *record*

package/dist/{track-signal-runs-bs2umXNE.d.ts → track-signal-runs-B3noexlc.d.ts}

@@ -1,7 +1,7 @@
 import { InjectionToken, Injector, ProviderToken, Provider, Type, InputSignalWithTransform, InputSignal, ModelSignal, EnvironmentProviders, EffectRef, Signal } from '@angular/core';
-import { A as AutoMockConfiguration } from './expect-emission-D273986K.js';
-import { S as Spy, C as ClassType, z as SpyOptions, m as ClassSpyConfiguration, s as OnlyMethodKeysOf, o as DeepPartial } from './types-CyRUgJVd.js';
-import './prop-mock-Cz0yKWEP.js';
+import { A as AutoMockConfiguration } from './expect-emission-D7DaPI5H.js';
+import { S as Spy, C as ClassType, z as SpyOptions, m as ClassSpyConfiguration, s as OnlyMethodKeysOf, o as DeepPartial } from './types-CaGn5uvo.js';
+import './prop-mock-e7qpfqY1.js';
 import { ComponentFixture } from '@angular/core/testing';
 
 /**

package/dist/{types-CyRUgJVd.d.ts → types-CaGn5uvo.d.ts}

@@ -952,7 +952,8 @@ interface ClassSpyConfiguration<T> extends StrictSpyConfiguration {
      * and defines nothing until a method is read. The accessor path's first read drops the double into a
      * property dictionary as wide as the class; the proxy never does, so at 8–16 methods it is ~1.4 kB
      * against ~2.1 kB with one method called, and at 45 methods ~1.4 kB against ~4.4 kB, built 2–6×
-     * faster.
+     * faster. The width is the number of methods the double spies, after `onlyMethodsToSpyOn` narrows
+     * it and `methodsToSpyOn` / `instanceMethodsToSpyOn` add to it.
      *
      * What a wide class's proxy double changes, and the reason to pass `lazySpies: true`: every read of
      * a member pays a trap (~20 ns); `util.types.isProxy` is `true`; `console.log` shows only the

package/dist/vue.d.ts

@@ -1,9 +1,9 @@
-import { S as Spy, C as ClassType, m as ClassSpyConfiguration, s as OnlyMethodKeysOf } from './types-CyRUgJVd.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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CyRUgJVd.js';
+import { S as Spy, C as ClassType, m as ClassSpyConfiguration, s as OnlyMethodKeysOf } from './types-CaGn5uvo.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 Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, y as SpyDisposable, z as SpyOptions, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-CaGn5uvo.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 './bun.js';
-export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D273986K.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-BnqwTQIn.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-Cz0yKWEP.js';
+export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-D7DaPI5H.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-C362z4w-.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-e7qpfqY1.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.42.0",
+  "version": "5.43.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

@@ -358,7 +358,9 @@ it('loads', async () => {
   The family that installs an implementation (`mockImplementation`, `mockReturnValue`,
   `mockReturnThis`, `mockThrow`, `mockResolvedValue`, `mockRejectedValue`) replaces the very dispatch
   a chain is read by, so one of the two silently decides nothing and the spec goes green on a branch
-  nobody configured. Both orders are reported (warn, or throw under the `strict` preset). Want a
+  nobody configured. Both orders are reported (warn, or throw under the `strict` preset) — except a
+  wrapper that delegates: `vi.when(spy)` (Vitest 5), or a `mockImplementation` built from
+  `spy.getMockImplementation()`, since the chain still answers every call it passes through. Want a
   fallback **and** a per-argument value? Put the fallback in the container — `returns:` where the
   double is built, or `resolveWith` / `nextWith` / `failWith` — which a `calledWith` still wins over.
 - **`calledWith(x);` on its own is a stub, not an assertion.** It configures "answer `undefined`
@@ -372,7 +374,8 @@ it('loads', async () => {
   it took to stderr, with where the first three were scheduled; `onStrayTimers` receives every one's
   file and frames in `timers` instead of the warning.
 - **Never assert a signal with `toBeTruthy()`** — every signal is truthy. Use
-  `toHaveSignalValue(v)` after `registerSignalMatchers()` from `vitest-auto-spy/angular/matchers`.
+  `toHaveSignalValue(v)` after `registerSignalMatchers()` from `vitest-auto-spy/angular/matchers`
+  (`toEqual` semantics; `toHaveSignalValue(v, { strict: true })` for `toStrictEqual`'s).
 - **Never assert a resource with `expect(r.value()).toEqual(...)` alone** — an unresolved resource
   still holds its _default_, so that passes while proving nothing. `toHaveResourceValue(v)` after
   `registerResourceMatchers()`, from the same `/angular/matchers` entry, fails unless the resource