vitest-auto-spy 5.1.0 → 5.2.0

package/AGENTS.md

@@ -634,6 +634,31 @@ Also true, and worth not re-deriving:
   mapping = createSpyFromClass(MgwMappingService); // no second type argument here
   ```
 
+  **The symptom that leads here says nothing about overloads**, which is why the option is hard to
+  find from the error. A stub of the real response shape is rejected on the spec's own line —
+  `TS2345: Argument of type 'Page' is not assignable to parameter of type 'HttpEvent<Page>'` — on
+  `nextWith(body)`, `resolveWith(body)`, `calledWith(…).returnValue(body)` or
+  `mockReturnValue(of(body))` against a generated `observe` client. Neither the double nor the stub
+  is wrong; both are being checked against the signature nobody calls. Reach for `overload`, never
+  for `@ts-expect-error`: one migration wrote sixty of those across twenty-five files before anyone
+  found this option, and each one stops checking the response shape that line exists to describe.
+
+  **Name the method rather than the whole double.** `'first'` on the type moves *every* overloaded
+  member, and on a wide type that breaks the ones nobody was fixing — `Spy<Response, { overload:
+  'first' }>` for one method collected five `TS2769`s on `download`. `overload` also takes a map:
+
+  ```ts
+  let perf: Spy<Performance, { overload: { getEntriesByType: 'first' } }>;
+  ```
+
+  A name the type does not have never matches, so a rename leaves a dead entry rather than a red
+  build. The default stays `'last'` because "the useful signature" is not decidable from the type: on
+  a generated `observe` client it is the first, on a four-overload `api-mgw` client the last, and both
+  live in one suite. And **overload order is not always the author's** — `declare global` in a
+  third-party package appends to a global interface (`web-vitals` does exactly this to
+  `Performance.getEntriesByType`), so which signature is last depends on which packages are in the
+  program and can move on a dependency bump.
+
 **A getter that returns a `Signal<T>` goes in `instanceMethodsToSpyOn`**, not in `gettersToSpyOn`.
 `get isKidMode(): Signal<boolean> { return this._isKidMode.asReadonly(); }` is read as a property
 and called as a function, and the accessor route makes you write
@@ -643,6 +668,29 @@ class prototype, so nothing is being shadowed), and
 `service.isKidMode.mockReturnValue(false)` reads like every other member. `mockSignalProp` is the
 other answer when the value has to change during the test.
 
+### The composition belongs to the class — `registerAutoSpyDefaults`
+
+A class is doubled the same way in every file that doubles it, so register that once instead of
+repeating it:
+
+```ts
+// vitest.setup.ts, once
+registerAutoSpyDefaults(Router, { observablePropsToSpyOn: ['events'], gettersToSpyOn: ['url'] });
+
+// every spec, from then on
+provideAutoSpy(Router);
+provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] }); // ADDS to the registration
+```
+
+The call site is **merged** into the registration, not substituted for it: lists unioned
+(registration first, no repeats), `returns` / `overrides` merged key by key with the call site
+winning, scalars decided by the call site when it names the key. The bare-array form counts as
+`{ methodsToSpyOn: [...] }`. Registration is by class identity, so a subclass inherits nothing —
+walking the prototype chain would let one registration change doubles in files nobody was looking at.
+A second registration for the same class replaces the first, because two of them in one suite is the
+drift this removes rather than a merge to perform. `clearAutoSpyDefaults(Class)` drops one,
+`clearAutoSpyDefaults()` the lot.
+
 ### `strict` — a method nobody configured throws instead of answering `undefined`
 
 ```ts
@@ -752,6 +800,23 @@ const config = asSpy<FeatureFlagService>(TestBed.inject(FeatureFlagService)); //
 const config = injectSpy<FeatureFlagService>(FeatureFlagService);             // ✅
 ```
 
+**A declared default now reaches the double, and used not to.** `class RemoteConfigService<T =
+RemoteConfigDefaults>` handed to `createSpyFromClass` / `injectSpy` inferred `T` as `unknown`, so
+every member typed against it read as `unknown` on a class that had said exactly what it should be.
+Two shapes caused it, both fixed: the `& { [key: string]: any }` intersection `ClassType<T>` used to
+carry (an index signature makes inference drop the default) and the union in `injectSpy`'s token
+parameter (a union does too — a class now matches a bare construct-signature overload first).
+Spelling the argument out still works and is still the answer when the class has **no** default.
+
+**A generic *method* is a different thing, and it does collapse.** `show<T, U>(component: Type<T>,
+data: U)` on a modal or factory service reaches `Spy<T>` through `Parameters` / `ReturnType`, which
+instantiate the method's own type parameters — so the double types as `show(component: Type<unknown>,
+data: unknown)`. No mapped type in TypeScript can preserve a generic signature, so this is a limit
+rather than a defect, and it is usually harmless: `unknown` accepts every argument and every seeded
+return, so `spy.show.calledWith(MyModal, data).mockReturnValue(ref)` compiles. It bites only where
+the instantiated type appears in a **contravariant** position; there, name the shape on a declaration
+of your own and assign the factory's result to it.
+
 ---
 
 ## 7. Resetting
@@ -1016,6 +1081,12 @@ and a template error about a null profile appeared in a different `describe`. Th
 properties back and warns with the count and the cause. `countMockedProps()` is exported if you
 would rather assert it: `afterEach(() => expect(countMockedProps()).toBe(0))`.
 
+**A `mock*Prop` patch written in a `describe` body or a `beforeAll` is reported**, because the sweep
+undoes it after the test it was applied during and nothing puts it back: the first test passes and
+every one after it reads the real member. `propsOutsideHooks` grades that — `'warn'` (default),
+`'throw'`, `'off'` — and `reportPropsOutsideHooks(reaction)` sets the same dial for a suite that
+wires its own hooks. Move the call into `beforeEach`.
+
 **The one that only bites at scale:** with `isolate: false`, a `setTimeout` or
 `requestAnimationFrame` a component schedules and never clears keeps running after its file is done,
 and fires while the **next** file is mid-test. It is reported against that innocent file, as
@@ -1900,11 +1971,13 @@ enableAngularDiagnostics(); // { ngModuleScopes, deadSchemas, unspiedProviders,
 | `deadSchemas`      | `schemas` sit next to a standalone component (`declarations` empty) — a no-op    |
 | `unspiedProviders` | `injectSpy` got a real instance; a `console.warn` alone, a throw under the group |
 | `pendingRequests`  | the test ended with unflushed `HttpTestingController` requests, named one by one |
+| `shadowedProviders` | a double on the testing module loses to the component's own `providers`         |
 
 Every member defaults to `true`, takes `false` to opt out, and a second call **replaces** the
 selection (safe from anywhere, including inside a test). `disableAngularDiagnostics()` turns the
-group off and leaves the TestBed timing instrumentation alone. `assertNoPendingRequests()` is the
-HTTP check on its own, for use mid-test — reading takes the requests, so the group will not
+group off and leaves the TestBed timing instrumentation alone. `assertNoShadowedProviders(Component, fixture)`
+and `assertNoPendingRequests()` are the same checks on their own, for a spec that renders through a
+helper of its own or wants the HTTP one mid-test — reading takes the requests, so the group will not
 re-report what you inspected.
 
 Nothing here imports `@angular/common/http/testing`: the token is read out of the spec's own
@@ -2407,17 +2480,21 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-floating-assertion`           | `error` | —                 | `expect()` in a `.then()` nobody awaits → `expect(await promise)`                                                                         |
 | `no-bare-called-with`             | `error` | —                 | `spy.m.calledWith(1);` as a statement — a stub nobody continued, asserting nothing; chai's `expect(fn).to.have.been.calledWith()` exempt  |
 | `no-overridden-provider`          | `error` | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                 |
-| `no-inject-before-override`       | `error` | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                     |
+| `no-inject-before-override`       | `error` | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                     |
+| `no-private-member-access`        | `error` | —                 | `instance['privateMember']`, `(instance as any).privateMember` (and `as unknown as`, and a decoy type), `vi.spyOn(Object.getPrototypeOf(x), 'm')` → drive the member through the public API. **Type-aware**: silent without `parserOptions.project`, and silent on an index signature |
+| `no-dead-schemas`                 | `error` | —                 | `schemas` on a testing module with no `declarations` — the schema applies to nothing; the file decides, so a `declarations` in another `configureTestingModule` call silences it |
 | `no-import-time-spread`           | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                   |
 | `no-unregistered-inject-spy`      | `error` | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                  |
 | `prefer-render-shallow`           | `error` | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children          |
+| `prefer-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo |
 | `jasmine-namespace-without-entry` | `error` | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compat layer nowhere — option: `{ setupModules: […] }`       |
 | `no-jasmine-globals`              | `error` | —                 | `jasmine.*`, bare `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(`                              |
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                    |
 | `prefer-native-spy-api`           | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim                         |
 
-Nineteen rules, **every one an `error` since 4.0.0**; three fix on their own, seven offer
-suggestions. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
+Twenty-three rules, **every one an `error` since 4.0.0**; three fix on their own, eight offer
+suggestions. Twenty-two are syntactic; `no-private-member-access` is the one that reads types, and it
+reports nothing at all without `parserOptions.project` / `projectService` rather than guessing. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. Three of
 them can report on a _correct_ project, and only one has an option:
 `jasmine-namespace-without-entry` takes `['error', { setupModules: ['./test-setup'] }]`, naming the

package/README.md

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![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-15.1%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-15.8%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)
@@ -76,7 +76,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
 - 🚚 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 — twenty rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eight suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
+- 📏 Lint rules and one-line test-run hygiene — twenty-three rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eight suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()`
 - 🩺 [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 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
@@ -1662,6 +1662,27 @@ createSpyFromClass(MyService, {
 });
 ```
 
+### The composition belongs to the class — `registerAutoSpyDefaults`
+
+A spy's composition is a fact about the class rather than about the spec: `Router` needs `events`
+spied as an Observable property and `url` as a getter wherever it is doubled. Register it once and
+every call site starts from it.
+
+```ts
+// vitest-setup.ts, once
+registerAutoSpyDefaults(Router, { observablePropsToSpyOn: ['events'], gettersToSpyOn: ['url'] });
+
+// every spec, from then on
+provideAutoSpy(Router);
+provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] }); // adds, does not replace
+```
+
+The call site is **merged** into the registration rather than replacing it: lists unioned,
+`returns` / `overrides` merged key by key, scalars decided by the call site when it names the key.
+Registration is by class identity — a subclass inherits nothing — and a second registration for one
+class replaces the first, because two of them in one suite is the drift this removes.
+`clearAutoSpyDefaults(Class)` drops one, `clearAutoSpyDefaults()` the lot.
+
 ### Spying instance-assigned callables (`signal()`, arrow props, `signalStore()`)
 
 `createSpyFromClass` discovers methods by walking the **prototype**, so a callable assigned on the
@@ -2834,6 +2855,7 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
 | --------------------- | --------- | ------------------------------------------------------------------------------------- |
 | `duplicateCopies`     | `'throw'` | `'warn'` to report without failing, `'off'` to skip the check                         |
 | `restoreProps`        | `true`    | `restoreMockedProps()` in a global `afterEach`                                        |
+| `propsOutsideHooks`   | `'warn'`  | Name a `mock*Prop` patch made in a `describe` body or `beforeAll` — it survives one test; `'throw'`, `'off'`. `reportPropsOutsideHooks(reaction)` sets the same dial without the setup helper |
 | `restoreMocks`        | `false`   | `vi.restoreAllMocks()` in a global `afterEach` — turn on for `isolate: false`         |
 | `strayTimers`         | `false`   | Cancel timeouts, intervals and frames that outlive their file                         |
 | `onStrayTimers`       | —         | Takes the per-file count the sweep cancelled — see the note on `--detect-async-leaks` |
@@ -3048,10 +3070,13 @@ export can never be.
 | `no-floating-assertion`           |   `error`   | —                 | `expect()` in a `.then()` nobody awaits → `expect(await promise)`                                                                          |
 | `no-bare-called-with`             |   `error`   | —                 | `spy.m.calledWith(1);` as a statement of its own — a stub nobody continued, asserting nothing                                              |
 | `no-overridden-provider`          |   `error`   | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                  |
-| `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` in a hook, in a suite that still calls `override*`                                                                      |
+| `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                      |
+| `no-private-member-access`        |   `error`   | —                 | `instance['privateMember']`, `(instance as any).privateMember` and `vi.spyOn(Object.getPrototypeOf(x), 'm')` — the three spellings that get past `private`; **type-aware**, and silent without `parserOptions.project` |
+| `no-dead-schemas`                 |   `error`   | —                 | `schemas` on a testing module that declares nothing — a charm protecting nobody, and one that starts working the day `declarations` arrive                                                                            |
 | `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                    |
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                   |
 | `prefer-render-shallow`           |   `error`   | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children           |
+| `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                        |
 | `jasmine-namespace-without-entry` |   `error`   | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compatibility layer nowhere                                   |
 | `no-jasmine-globals`              |   `error`   | —                 | `jasmine.*`, `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(` — none of them exist under Vitest  |
 | `no-save-arguments-by-value`      |   `error`   | —                 | `spy.calls.saveArgumentsByValue()`, which is a no-op here → take the copy at call time                                                     |
@@ -3061,7 +3086,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Three of the twenty fix on their own, eight offer suggestions**, and the split is not about how hard
+**Three of the twenty-three fix on their own, eight offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -3165,7 +3190,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the twenty rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the twenty-three rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3182,7 +3207,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of twenty rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of twenty-three rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -3273,9 +3298,10 @@ another, and the next one is in that same file.
 | `mockSystemTime` / `withSystemTime` / `mockNow` / `useCountingClock` _(`/setup`)_                                 | Clock control that survives fake timers being re-installed per test                                                                                   |
 | `registerFocusMatchers()` _(`/setup`)_                                                                            | Adds `expect(el).toHaveFocus()`                                                                                                                       |
 | `overrideAutoSpy` / `overrideComponentProvider` / `assertNgModuleScopes` / `assertComponentDefIntact` _(Angular)_ | Override a component-level provider — and verify on the next fixture that the override applied; diagnose an NgModule with an empty runtime scope      |
-| `enableAngularDiagnostics(opts?)` / `disableAngularDiagnostics()` / `assertNoPendingRequests()` _(Angular)_       | Dead NgModule imports, dead `schemas`, an unspied provider and unflushed HTTP requests, as failures                                                   |
+| `enableAngularDiagnostics(opts?)` / `disableAngularDiagnostics()` / `assertNoPendingRequests()` / `assertNoShadowedProviders()` _(Angular)_ | `ngModuleScopes`, `deadSchemas`, `unspiedProviders`, `shadowedProviders` and `pendingRequests`: a dead NgModule import, `schemas` that can never apply, an unspied provider, a double the component's own `providers` shadow, and unflushed HTTP requests — each as a failure |
 | `trackInjections(tokens, opts?)` _(Angular, NestJS)_                                                              | Providers that record which collaborators DI constructed, with an auto-spy behind each token                                                          |
 | `setupAutoSpy(opts?)` _(`/setup`)_                                                                                | Property restore + duplicate-copy detection + mock-registry hygiene, in one call                                                                      |
+| `registerAutoSpyDefaults(Class, config)` / `clearAutoSpyDefaults(Class?)`                                         | A class's spy composition registered once, merged into every `createSpyFromClass(X)` / `provideAutoSpy(X)` from then on                               |
 | `setupFakeTimers(config?)` / `advanceTimers(ms?)` _(`/setup`)_                                                    | Paired fake-timer install/restore, and an advance that also settles queued microtasks                                                                 |
 | `describeDuplicateCopies()` / `getPackageCopies()`                                                                | The duplicate-install report, and the copies behind it                                                                                                |
 | `renderShallow(Component, opts?)` _(Angular)_                                                                     | `TestBed` component, minus its children and (by default) its template                                                                                 |

package/dist/angular.d.ts

@@ -1,10 +1,10 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-C9ruGqto.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-BerZbxtu.js';
 import { InjectionToken, Provider, Type, Signal, WritableSignal } from '@angular/core';
 import { TestAPI } from 'vitest';
-import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-CroX5c53.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-CiYfR36E.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as restoreMockedProps } from './prop-mock-DkSaUWiQ.js';
-export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-BfCKHEzi.js';
+import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-DTi4dIeN.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-D4TuS8yk.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-DmM-rPcG.js';
+export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-DYtyyKM5.js';
 import '@angular/core/testing';
 
 /**
@@ -245,6 +245,11 @@ interface AngularDiagnosticsOptions {
     unspiedProviders?: boolean;
     /** Fail a test that ends with unflushed `HttpTestingController` requests. */
     pendingRequests?: boolean;
+    /**
+     * Fail when a double registered on the testing module loses to the component's own `providers`,
+     * so the component under test is running against the real service.
+     */
+    shadowedProviders?: boolean;
 }
 /**
  * Fail when the `HttpTestingController` this test configured is still holding requests.
@@ -263,6 +268,23 @@ interface AngularDiagnosticsOptions {
  * ```
  */
 declare function assertNoPendingRequests(): void;
+/**
+ * Fail when a double this test registered on the testing module never reached `component`.
+ *
+ * `shadowedProviders` calls this on every fixture; it is exported for the same reason
+ * {@link assertNoPendingRequests} is — a spec that builds its component through a helper of its own
+ * can ask directly, and a check that can only be reached through one code path is a check that
+ * stops running the day that path changes.
+ *
+ * A no-op when the fixture never rendered `component`, and when everything it resolved is a double.
+ *
+ * @example
+ * ```ts
+ * const fixture = renderThroughOurHelper(CartComponent);
+ * assertNoShadowedProviders(CartComponent, fixture); // the doubles really are the ones in play
+ * ```
+ */
+declare function assertNoShadowedProviders(component: unknown, fixture: unknown): void;
 /**
  * Turn the group on. Every member defaults to `true`; pass `false` to leave one out.
  *
@@ -709,4 +731,4 @@ declare function reportSpecTiming(timing: SpecTiming): void;
  */
 declare function enableTestBedDiagnostics(options?: TestBedDiagnosticsOptions): void;
 
-export { type AngularDiagnosticsOptions, type AngularTestEnvMode, type AngularTestEnvOptions, type AutoSpyFixture, type AutoSpyOverride, type DirectiveHostOptions, type ExtendWithAutoSpiesOptions, type MockedResource, type ResourceDouble, type ResourceDoubleStatus, type ResourceLike, type SignalLike, type SpecTiming, type SpiedFixtures, type TestBedDiagnosticsOptions, assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, createDirectiveHost, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, extendWithAutoSpies, formatSpecTiming, getTestBedTiming, instrumentTestBed, mockResourceProp, mockSignalProp, overrideAutoSpy, overrideComponentProvider, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, reportSpecTiming, setupAngularTestEnv };
+export { type AngularDiagnosticsOptions, type AngularTestEnvMode, type AngularTestEnvOptions, type AutoSpyFixture, type AutoSpyOverride, type DirectiveHostOptions, type ExtendWithAutoSpiesOptions, type MockedResource, type ResourceDouble, type ResourceDoubleStatus, type ResourceLike, type SignalLike, type SpecTiming, type SpiedFixtures, type TestBedDiagnosticsOptions, assertComponentDefIntact, assertNgModuleScopes, assertNoPendingRequests, assertNoShadowedProviders, createDirectiveHost, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, extendWithAutoSpies, formatSpecTiming, getTestBedTiming, instrumentTestBed, mockResourceProp, mockSignalProp, overrideAutoSpy, overrideComponentProvider, registerDirectiveMatchers, registerResourceMatchers, registerSignalMatchers, reportSpecTiming, setupAngularTestEnv };