vitest-auto-spy 5.59.1 → 5.62.0

package/AGENTS.md

@@ -455,6 +455,7 @@ In [`agent-docs/doubles.md`](./agent-docs/doubles.md). Read it when production c
 ## 13. Angular
 
 In [`agent-docs/angular.md`](./agent-docs/angular.md). Read it for any spec that uses `TestBed`, signals, Angular HTTP, the router or an Angular double.
+For selected void window methods, use `createWindowSpies` from `/angular/doubles`; the window recipe is in that file.
 
 <!-- agents-outline: agent-docs/angular.md -->
 

package/CHANGELOG.md

@@ -10,6 +10,37 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.62.0] - 2026-10-20
+
+### Fixed
+
+- **`prefer-settle-dynamic-import` recognises Angular provider setup in setup hooks.** A namespace
+  loaded for providers is allowed after logger or fixture preparation. Imports after application
+  actions remain checked. The English and Russian rule guides distinguish provider loading from
+  waiting for handlers, and clarify that `Promise.resolve()` does not take an event-loop turn.
+
+## [5.61.0] - 2026-10-07
+
+### Added
+
+- `createWindowSpies` in `/angular/doubles`: typed, configured no-op spies for selected void window methods, including `location.reload` and `parent.postMessage`, composable with existing window overrides.
+
+## [5.60.0] - 2026-10-06
+
+### Added
+
+- **`no-redundant-as-instance`** in `vitest-auto-spy/eslint-plugin`, `warn` in `recommended`:
+  `expect(service.open()).toBe(asInstance(ref))`. The three comparing matchers take their argument as
+  a free type parameter, so the unwrap buys nothing there — it keeps an import alive and reads as if
+  the types needed it. `--fix` drops the wrapper and, when that was the import's last use, the import
+  too. Slots typed against the real class are untouched: `toHaveBeenCalledWith(asInstance(cart))`
+  can be load-bearing, and so can a wrapper that is part of the argument (`[asInstance(x)]`,
+  `asInstance(x).id`). Three such call sites in two consumer suites (5.59.1). The plugin now ships
+  fifty-eight rules. `/eslint-plugin` is 53.45 → 53.84 kB (+0.39 kB, +0.7 %): the rule, minus the
+  matcher set that `no-constant-expect`, `prefer-to-have-signal-value` and
+  `no-vacuous-absence-assertion` each carried a copy of, and the `matcherOf` walk `no-constant-expect`
+  duplicated — both now shared out of `absence-assertion.ts`.
+
 ## [5.59.1] - 2026-09-30
 
 ## [5.59.0] - 2026-09-30
@@ -6825,7 +6856,10 @@ 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.59.1...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.62.0...HEAD
+[5.62.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.61.0...v5.62.0
+[5.61.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.60.0...v5.61.0
+[5.60.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.1...v5.60.0
 [5.59.1]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.59.0...v5.59.1
 [5.59.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.58.0...v5.59.0
 [5.58.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.57.0...v5.58.0

package/README.md

@@ -3125,6 +3125,7 @@ only the ones you need. Every helper, with its signature: [API](https://asdalexe
 | `provideLocationDouble()` / `injectLocationDouble()` / `createLocationDouble()`                             | `/angular-router`             | Angular's own `SpyLocation` and `MockLocationStrategy` in one call — a real history, the `urlChanges` journal, `simulateUrlPop()` / `simulateHashChange()` for the browser's half of the contract; `Location` is `providedIn: 'root'`, so a spec that forgets the provider silently drives the platform's real one                                                                        |
 | `createForm(model, schema?)` / `registerFormMatchers()`                                                     | `/signal-forms`               | A signal form built where `form()` can inject, and `expect(field).toHaveFieldErrors(['required'])` over what it produced                                                                                                                                                                                                                                                                  |
 | `provideWindowDouble(TOKEN, over?)` / `provideDocumentDouble(over?)`                                        | `/angular/doubles`            | A `window` / `document` merged **over** the real jsdom one, so members the spec never named still answer; the globals stay untouched                                                                                                                                                                                                                                                      |
+| `createWindowSpies(selection)`                                                                              | `/angular/doubles`            | Typed no-op spies for selected void window methods: `createWindowSpies({ location: ['reload'], parent: ['postMessage'] })`; pass them as window overrides.                                                                                                                                                                                                                                |
 | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(Ref, init?)`                                     | `/angular/doubles`            | The Material dialog trio without `@angular/material` as a dependency — the token and the ref class are arguments, `afterClosed()` still answers after the close                                                                                                                                                                                                                           |
 | `providePlatform(platform, flags?)`                                                                         | `/angular/doubles`            | `PLATFORM_ID` plus the app's own `isBrowser` / `isServer` tokens, always agreeing                                                                                                                                                                                                                                                                                                         |
 | `provideDomSanitizerDouble()` / `provideChangeDetectorRefDouble()`                                          | `/angular/doubles`            | A `DomSanitizer` whose bypass spies return Angular's real safe values; a `ChangeDetectorRef` of four spies answering `undefined` (`create…Double()` for the bare double)                                                                                                                                                                                                                  |
@@ -3596,6 +3597,7 @@ Rolling it out on a large suite, and the options each rule takes:
 | [`no-instance-lifecycle-spy`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-instance-lifecycle-spy)               |   `warn`    | —                 | Spy on an Angular lifecycle hook through the class prototype — Angular never calls the one on an instance                             |
 | [`no-ts-expect-error-on-double`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-ts-expect-error-on-double)         |   `error`   | —                 | Do not suppress a type error on a double's configuration — name the overload, or fix the fixture                                      |
 | [`no-constant-expect`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-constant-expect)                             |   `error`   | —                 | Assert on a value the code under test produced, not on one the spec spelled out                                                       |
+| [`no-redundant-as-instance`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-redundant-as-instance)                 |   `warn`    | `--fix`           | Drop asInstance() around a comparing matcher's argument — the unwrap buys nothing there and keeps an import alive                     |
 | [`no-redundant-smoke-test`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-redundant-smoke-test)                   |   `error`   | suggest           | Delete a test whose whole body asserts that the subject exists, where the block already has tests that use it                         |
 | [`no-self-called-spy`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-self-called-spy)                             |   `error`   | —                 | Do not assert a call the test made itself — drive the production path that should make it                                             |
 | [`no-vacuous-absence-assertion`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-vacuous-absence-assertion)         |   `error`   | —                 | Do not let a whole test rest on assertions that a stream which never emits already satisfies                                          |

package/agent-docs/angular.md

@@ -862,6 +862,32 @@ Five things to know:
   `win.Promise.resolve()`, `win.Object.keys(x)` and `new win.Event('x')` work, and
   `win.Event === window.Event` holds — which is what `instanceof` in production code needs.
 
+`createWindowSpies` creates typed spies for selected `void` methods, including nested window members.
+The spies return `undefined` without invoking browser methods.
+
+```ts
+import { InjectionToken } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { expect } from 'vitest';
+import { createWindowSpies, provideWindowDouble } from 'vitest-auto-spy/angular/doubles';
+
+const WINDOW = new InjectionToken<Window>('WINDOW');
+const spies = createWindowSpies({ location: ['reload'], parent: ['postMessage'] });
+TestBed.configureTestingModule({
+  providers: [provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'tv.kion.ru' } })],
+});
+const win = TestBed.inject(WINDOW);
+win.location.reload();
+win.parent.postMessage('ready', '*');
+expect(spies.location.reload).toHaveBeenCalledOnce();
+expect(spies.parent.postMessage).toHaveBeenCalledWith('ready', '*');
+```
+
+Pass an array for root methods: `createWindowSpies(['close', 'focus'])`. Each call builds fresh spies.
+The object returned by `createWindowSpies` contains only the selected methods. Their parameter types and spy helpers are preserved.
+For methods that return a value, use `createFunctionSpy` and configure that value explicitly.
+When adding location values, spread `spies.location` too; replacing it would discard the reload spy.
+
 ### The Material dialog trio — `provideMatDialogData` / `provideMatDialogRef`
 
 ```ts

package/agent-docs/eslint.md

@@ -91,6 +91,7 @@ export default [
 | `no-instance-lifecycle-spy` | `warn` | — | `vi.spyOn(instance, 'ngOnInit')` (and `ngOnDestroy`, `ngDoCheck`, `ngAfterContent*`, `ngAfterView*`) — a view calls the hook read off the prototype, so the instance spy is never called and its stub never runs → `vi.spyOn(Cls.prototype, …)` before `createComponent`, or assert the effect. `ngOnChanges` is exempt: Angular calls it through the instance |
 | `no-ts-expect-error-on-double` | `error` | — | `@ts-expect-error` / `@ts-ignore` above `nextWith`, `resolveWith`, `mockReturnValue`, `returnValue`, `calledWith(…)` and the other helpers that check a stub against the method's signature → an overloaded method takes `Spy<X, { overload: { m: 'first' } }>`; otherwise the fixture is the wrong shape, checked against `ReturnType<X['m']>`. A reason after the directive does not silence it; a deliberate out-of-type value keeps it under `eslint-disable-next-line … -- <why>` |
 | `no-constant-expect` | `error` | — | `expect(true).toBe(true)`, `expect({ … }).toBeDefined()` — a value the spec spelled out, under a matcher whose answer it already fixes (`toBe` / `toEqual` / `toStrictEqual` against a literal; `toBeTruthy`, `toBeDefined`, `toBeNull`… for any literal) → assert on what the code produced, or `expect.fail(…)` for an unreachable branch |
+| `no-redundant-as-instance` | `warn` | `--fix` | `expect(x).toBe(asInstance(ref))` → `.toBe(ref)`: the comparing matchers take their argument as a free type parameter, so the bridge buys nothing there; `--fix` drops the wrapper and the import once it is unused. `toHaveBeenCalledWith(asInstance(cart))` is left alone — that slot is typed against the real class and the unwrap can be load-bearing; so is a wrapper that is part of the argument (`[asInstance(x)]`, `asInstance(x).id`) |
 | `no-redundant-smoke-test` | `error` | suggest | `it('should create', () => expect(pipe).toBeTruthy())` — every statement of the body an `expect(x)` under `toBeTruthy` / `toBeDefined` / `toBeInstanceOf` (or their negated twins), weighed against the tests that run the same setup: the rest of the block, and everything the blocks nested in it declare → delete it; the suggestion removes the test and the blank line above it. Silent where that test is the block's only running one, and a skipped sibling does not count as proof |
 | `no-self-called-spy` | `error` | — | `vi.spyOn(obj, 'm')`, then `obj.m(…)` written by the test itself, then a positive `toHaveBeenCalled*` — the assertion is satisfied by the test's own line, so the test survives the deletion of the behaviour its title names. Order decides it: a call written **before** the spy is arrangement, and a `mockClear` between the call and the assertion, a negated matcher or arguments the call did not pass all silence it |
 | `no-vacuous-absence-assertion` | `error` | — | a test **all** of whose assertions are satisfied by the stream never emitting. The carrier is a `const` / `let` declared in the test whose every write outside the declaration sits in a `subscribe` callback of that test (the assignment and the `push` forms both count), or a `vi.fn()` the test hands to `subscribe` and never calls itself. Silence satisfies an equality matcher repeating the initialiser's source text, `toBeUndefined` / `not.toBeDefined` on a `let` holding `undefined`, `toBeNull` on one holding `null`, `toBeFalsy` / `not.toBeTruthy` on any falsy literal, `toHaveLength(0)` on `[]` or `''`, and `not.toHaveBeenCalled` / `not.toHaveBeenCalledWith` / `toHaveBeenCalledTimes(0)` on any subject — read literally, so `toBeNull()` on a `let` with no initialiser is **not** reported. One `expect()` a silent source could fail silences the rule, which is what exempts the "nothing yet, trigger, now the value" shape; a test asserting through a local helper is skipped entirely → `await expectNoEmission(source$)`, or `expect(await expectEmission(source$))` |
@@ -111,22 +112,24 @@ export default [
 | `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. The fix renames only the member (`and.returnValue` → `mockReturnValue`, `withArgs` → `calledWith`), so comments stay; a rewrite that would drop one is a suggestion |
 
-Fifty-seven rules, **every one an `error` except `prefer-render-shallow`,
+Fifty-eight rules, **every one an `error` except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `prefer-create-mock`, `no-instance-lifecycle-spy`,
 `prefer-set-inputs`, `no-unasserted-argument`, `prefer-spy-on-own-method`, `prefer-to-have-signal-value`,
-`no-unasserted-console-spy`, `no-real-wait-in-test` and `no-inline-test-data`**; eight fix on their own, nineteen offer suggestions. Fifty-three are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
+`no-unasserted-console-spy`, `no-real-wait-in-test`, `no-inline-test-data` and
+`no-redundant-as-instance`**; nine fix on their own, nineteen offer suggestions. Fifty-four are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
 `no-unknown-use-value-key` and `prefer-to-have-signal-value` read types, and all four report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
 builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it;
 `no-relative-mock-under-builder` waits for a builder target serving the file, or `{ builder: 'unit-test' }`.
 
-The twelve `warn`s do not rank findings by importance. Each names something other than a defect: a
+The thirteen `warn`s do not rank findings by importance. Each names something other than a defect: a
 cheaper render (`prefer-render-shallow`), a heuristic reading with no `provide:` to settle it
 (`no-stub-class-double`, `no-structural-double`, `no-instance-lifecycle-spy`), a repair that turns
 many files red at once (`prefer-create-mock`), a question only the author can answer
 (`no-unasserted-argument`, `no-unasserted-console-spy`, `no-real-wait-in-test`), a place data should
 live rather than a defect (`no-inline-test-data`), or a preferred spelling
-of working code (`prefer-spy-on-own-method`, `prefer-set-inputs`, `prefer-to-have-signal-value`). Set
+of working code (`prefer-spy-on-own-method`, `prefer-set-inputs`, `prefer-to-have-signal-value`,
+`no-redundant-as-instance`). Set
 any of the `warn`s to `'error'` once the batch is done.
 
 Three rules can report on a _correct_ project, and only one has an option:

package/agent-docs/waiting.md

@@ -22,6 +22,17 @@ fixture.debugElement.query(By.css('.open')).nativeElement.click(); // production
 await settleDynamicImport(() => import('./profile-select.modal'));
 ```
 
+**Loading provider classes is setup, not a wait for application work.** Keep
+`const { PremiumService } = await import('./premium.service')` when its exports configure Angular
+providers before creating the service under test. `settleDynamicImport` is useful after an action
+starts a lazy import; it adds no needed wait merely to read provider classes. Preserve dynamic
+imports when module evaluation order matters, including `vi.resetModules()` / `vi.doMock()` setup.
+The ESLint rule recognises provider setup in `beforeEach` / `beforeAll`. Earlier fixture factories
+must be imported functions whose bound results also supply providers. Member calls and other
+actions prevent this exemption, except recognised module-registry resets.
+
+`await Promise.resolve()` yields to microtasks; it is not equivalent to `flushEventLoop(1)`.
+
 Three rules worth stating outright, because each of them cost a day somewhere:
 
 - **`afterNextRender` does not run on `detectChanges()`.** A component that fills a form there is
@@ -30,9 +41,8 @@ Three rules worth stating outright, because each of them cost a day somewhere:
 - **`fixture.whenRenderingDone()` is not a stronger `whenStable()`.** With an animation renderer
   installed it degrades to `Promise.resolve()`. Use `stable(fixture)`.
 - **`fakeAsync` / `tick()` / `flushMicrotasks()` never reach the module loader.** Spinning
-  `await Promise.resolve()` ten times looks like it works and instead lands the continuation after
-  teardown — a green run with `NG0205: Injector has already been destroyed` in "Unhandled Errors"
-  and a non-zero exit code.
+  `await Promise.resolve()` ten times may leave a continuation until after teardown, causing
+  `NG0205: Injector has already been destroyed` in "Unhandled Errors" and a non-zero exit code.
 
 **`stable()` and `flushEffects()` are not zoneless-only, and their tick runs inside the `NgZone` so
 that they are not.** `TestBed.createComponent` builds the component inside `ngZone.run(…)`, so an

package/dist/angular-doubles.d.ts

@@ -1,6 +1,6 @@
 import './vitest-mock-types-B17-xaWt.js';
 import { InjectionToken, AbstractType, Injector, ValueProvider, FactoryProvider, ProviderToken, ChangeDetectorRef } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func } from './types-BdYUK_Zv.js';
+import { h as AddSpyMethodsByReturnTypes, S as Spy, F as Func, p as FunctionSpy } from './types-BdYUK_Zv.js';
 import { DomSanitizer } from '@angular/platform-browser';
 import 'vitest';
 
@@ -183,7 +183,7 @@ declare function injectMatDialogRef<Ref extends DialogRefLike>(RefClass: Abstrac
  */
 
 /** How many levels of slicing the type follows. Beyond it a member takes its whole type. */
-type Levels = [never, 0, 1, 2, 3];
+type Levels$1 = [never, 0, 1, 2, 3];
 /**
  * One member's override: the member's own type, or a slice of it wherever it is a plain-ish object.
  *
@@ -192,7 +192,7 @@ type Levels = [never, 0, 1, 2, 3];
  * array is matched whole too: slicing one by index describes nothing a spec means.
  */
 type PlatformOverride<V, Depth extends number> = V extends (...args: never[]) => unknown ? V : V extends readonly unknown[] ? V : V extends object ? Depth extends 0 ? V : V | {
-    [K in keyof V]?: PlatformOverride<V[K], Levels[Depth]>;
+    [K in keyof V]?: PlatformOverride<V[K], Levels$1[Depth]>;
 } : V;
 /**
  * What a spec says about a platform object: a value per member, and a **slice** wherever the member
@@ -470,4 +470,35 @@ declare function provideOverlayDouble<O extends OverlayLike>(OverlayClass: Abstr
  */
 declare function injectOverlayDouble<O extends OverlayLike>(OverlayClass: AbstractType<O>, injector?: Injector): OverlayDouble<O>;
 
-export { type AttachedComponent, type DialogComponent, type DialogDataOf, type DialogRefLike, type DialogResult, type MatDialogRefDouble, type MatDialogRefInit, type OverlayDouble, type OverlayDoubleInit, type OverlayLike, type OverlayRefDouble, type OverlayRefStub, type PlatformFlagTokens, type PlatformName, type PlatformOverrides, type PositionCall, createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };
+type Levels = [never, 0, 1, 2, 3];
+type VoidMethodKeys<T> = {
+    [K in keyof T]: T[K] extends (...args: never[]) => infer R ? (R extends void ? K : never) : never;
+}[keyof T];
+/** Select void methods at each object level; only named methods become spies. */
+type WindowSpySelection<T = Window, Depth extends number = 3> = readonly VoidMethodKeys<T>[] | (Depth extends 0 ? never : {
+    [K in keyof T as T[K] extends object ? (T[K] extends (...args: never[]) => unknown ? never : K) : never]?: WindowSpySelection<NonNullable<T[K]>, Levels[Depth]>;
+});
+/** The selected methods, with their original call signatures and the auto-spy helpers. */
+type WindowSpies<T, Selection> = Selection extends readonly (infer K)[] ? {
+    [P in Extract<K, keyof T>]: T[P] extends (...args: never[]) => unknown ? FunctionSpy<T[P]> : never;
+} : {
+    [P in keyof Selection & keyof T]: WindowSpies<NonNullable<T[P]>, Selection[P]>;
+};
+type ValidSelection<T, Selection> = Selection extends readonly unknown[] ? readonly VoidMethodKeys<T>[] : {
+    [K in keyof Selection]: K extends keyof T ? T[K] extends (...args: never[]) => unknown ? never : ValidSelection<NonNullable<T[K]>, Selection[K]> : never;
+};
+/**
+ * Build typed, already configured no-op spies for selected void window methods.
+ *
+ * ```ts
+ * const spies = createWindowSpies({ location: ['reload'], parent: ['postMessage'] });
+ * provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'tv.kion.ru' } });
+ * expect(spies.location.reload).toHaveBeenCalledOnce();
+ * ```
+ *
+ * No global is read or patched. Pass the result to `createWindowDouble` or `provideWindowDouble`;
+ * unnamed members still use the real window. Use `createFunctionSpy` for methods returning values.
+ */
+declare function createWindowSpies<const Selection extends WindowSpySelection>(selection: Selection & ValidSelection<Window, Selection>): WindowSpies<Window, Selection>;
+
+export { type AttachedComponent, type DialogComponent, type DialogDataOf, type DialogRefLike, type DialogResult, type MatDialogRefDouble, type MatDialogRefInit, type OverlayDouble, type OverlayDoubleInit, type OverlayLike, type OverlayRefDouble, type OverlayRefStub, type PlatformFlagTokens, type PlatformName, type PlatformOverrides, type PositionCall, type WindowSpies, type WindowSpySelection, createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, createWindowSpies, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };

package/dist/angular-doubles.js

@@ -464,7 +464,35 @@ function injectOverlayDouble(OverlayClass, injector) {
   return double;
 }
 
+// src/lib/window-spies.ts
+function buildSpies(selection, path) {
+  const result = {};
+  if (Array.isArray(selection)) {
+    for (const key of selection) {
+      Object.defineProperty(result, key, {
+        value: createFunctionSpy(`${path}.${String(key)}`).mockReturnValue(void 0),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  } else {
+    for (const key of Reflect.ownKeys(selection)) {
+      Object.defineProperty(result, key, {
+        value: buildSpies(Reflect.get(selection, key), `${path}.${String(key)}`),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  return result;
+}
+function createWindowSpies(selection) {
+  return buildSpies(selection, "window");
+}
+
 // src/angular-doubles.ts
 useVitestAdapter();
 
-export { createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };
+export { createChangeDetectorRefDouble, createDocumentDouble, createDomSanitizerDouble, createMatDialogRef, createOverlayDouble, createWindowDouble, createWindowSpies, injectMatDialogRef, injectOverlayDouble, provideChangeDetectorRefDouble, provideDocumentDouble, provideDomSanitizerDouble, provideMatDialogData, provideMatDialogRef, provideOverlayDouble, providePlatform, provideWindowDouble };

package/dist/cli.js

@@ -1667,7 +1667,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.59.0";
+var EXPORT_MAP_VERSION = "5.61.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",
@@ -1800,6 +1800,7 @@ var EXPORTED_BY = {
   createSpyFromInstance: "0 1 2 3 4 20 21 22",
   createSpyObj: "9",
   createWindowDouble: "14",
+  createWindowSpies: "14",
   createWithAutoSpies: "2 12",
   CreateWithAutoSpiesOptions: "2 12",
   DeepMockProxy: "0 1 2 3 4 20 21 22",
@@ -2158,6 +2159,8 @@ var EXPORTED_BY = {
   WebStorageKey: "7",
   WebStorageStub: "7",
   WebStorageStubOptions: "7",
+  WindowSpies: "14",
+  WindowSpySelection: "14",
   withFakeTimers: "23",
   WithMockReturnValue: "0 1 2 3 4 20 21 22",
   withoutStrayTimerTracking: "23",

package/dist/eslint-plugin.cjs

@@ -480,13 +480,13 @@ function runnerBehind(callee) {
   }
   return isCallExpression(callee) ? runnerBehind(callee.callee) : void 0;
 }
-function insideRunnerCallback(node) {
+function enclosingRunner(node) {
   const callback = enclosingFunction(node);
   if (!callback) {
-    return false;
+    return void 0;
   }
   const call = callback.parent;
-  return isCallExpression(call) && call.arguments.includes(callback) && runnerBehind(call.callee) !== void 0;
+  return isCallExpression(call) && call.arguments.includes(callback) ? runnerBehind(call.callee) : void 0;
 }
 function consumptionOf(node) {
   const { parent } = node;
@@ -518,6 +518,74 @@ function takesTheNamespaceFirst(node, bound) {
   const before2 = siblings2.slice(0, siblings2.indexOf(statement)).reverse().find((sibling) => !bound.has(sibling));
   return before2 === void 0 ? statement.parent === callback.body : resetsRegistry(before2);
 }
+function providerReference(context, reference, callback) {
+  if (enclosingFunction(reference) !== callback) {
+    return false;
+  }
+  let current = reference;
+  while (current !== callback) {
+    if (propertyName(current) === "providers") {
+      const configuration = current.parent;
+      const call = configuration.parent;
+      if (!isCallExpression(call) || !call.arguments.includes(configuration)) {
+        return false;
+      }
+      if (!isMemberExpression(call.callee) || memberName(call.callee) !== "configureTestingModule" || !isIdentifier(call.callee.object)) {
+        return false;
+      }
+      const receiver = call.callee.object;
+      const binding = findBinding(context.sourceCode.getScope(receiver), receiver.name);
+      const specifier = binding && importSpecifierOf(binding);
+      return specifier ? isIdentifier(specifier.imported) && specifier.imported.name === "TestBed" && specifier.parent.source.value === "@angular/core/testing" : binding === void 0 && receiver.name === "TestBed";
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function suppliesProvider(context, awaited, callback) {
+  const holder = awaited.parent;
+  const pattern = isVariableDeclarator(holder) ? holder.id : isAssignmentExpression(holder) ? holder.left : void 0;
+  return pattern !== void 0 && anyInSubtree(
+    context,
+    pattern,
+    (candidate) => {
+      if (!isIdentifier(candidate)) {
+        return false;
+      }
+      const binding = findBinding(context.sourceCode.getScope(candidate), candidate.name);
+      const writes = binding?.references.filter((reference) => reference.writeExpr) ?? [];
+      return writes.length === 1 && writes[0]?.writeExpr === awaited && binding?.references.some(
+        (reference) => reference.identifier.range[0] > awaited.range[1] && providerReference(context, reference.identifier, callback)
+      ) === true;
+    },
+    false
+  );
+}
+function preparesProvider(context, call, callback) {
+  if (!isCallExpression(call) || !isIdentifier(call.callee)) {
+    return false;
+  }
+  const binding = findBinding(context.sourceCode.getScope(call), call.callee.name);
+  return binding?.defs.some((definition) => definition.type === "ImportBinding") === true && suppliesProvider(context, call, callback);
+}
+function loadsProviderForSetup(context, node, runner) {
+  const callback = enclosingFunction(node);
+  const statement = bindingStatement(node.parent);
+  if (!callback || statement?.parent !== callback.body || !isBlockStatement(callback.body)) {
+    return false;
+  }
+  if (runner !== "beforeAll" && runner !== "beforeEach" || !suppliesProvider(context, node.parent, callback)) {
+    return false;
+  }
+  return callback.body.body.slice(0, callback.body.body.indexOf(statement)).every(
+    (before2) => (before2.type === "VariableDeclaration" || isExpressionStatement(before2)) && !anyInSubtree(
+      context,
+      before2,
+      (candidate) => isAssignmentExpression(candidate) && !isIdentifier(candidate.left) || candidate.type === "UnaryExpression" && Reflect.get(candidate, "operator") === "delete" || (isCallExpression(candidate) || candidate.type === "NewExpression" || candidate.type === "AwaitExpression" || candidate.type === "UpdateExpression") && !preparesProvider(context, candidate, callback) && !(candidate.type === "AwaitExpression" && suppliesProvider(context, candidate, callback) && anyInSubtree(context, candidate, (child) => child.type === "ImportExpression" && child.parent === candidate, false)) && !isRunnerCall(candidate, REGISTRY_RESETS),
+      false
+    )
+  );
+}
 function wrap(context, node) {
   const state = bindingState(context.sourceCode.getScope(node), HELPER);
   if (state === "taken") {
@@ -540,7 +608,7 @@ var preferSettleDynamicImport = defineRule({
   description: "Load a module the code under test lazy-loads with settleDynamicImport(), not a bare await import()",
   hasSuggestions: true,
   messages: {
-    awaitedDynamicImport: `\`await {{load}}\` waits for the module, not for the code under test that was loading it: its continuation after its own \`await\` has not run yet, so the assertions below read the state one turn early. ${REPAIR}`,
+    awaitedDynamicImport: `\`await {{load}}\` waits for the module, not for the code under test that was loading it: its continuation after its own \`await\` may still be pending, so the assertions below may read state too early. ${REPAIR}`,
     thenedDynamicImport: `\`{{load}}.then(\u2026)\` waits for the module, not for the code under test that was loading it, and its callback runs later still, after the test ends if nothing awaits it. ${REPAIR}`
   },
   create: (context) => {
@@ -548,7 +616,8 @@ var preferSettleDynamicImport = defineRule({
     return {
       ImportExpression: (node) => {
         const consumption = consumptionOf(node);
-        if (consumption === void 0 || !insideRunnerCallback(node) || consumption === "await" && takesTheNamespaceFirst(node, bound)) {
+        const runner = enclosingRunner(node);
+        if (consumption === void 0 || runner === void 0 || consumption === "await" && (takesTheNamespaceFirst(node, bound) || loadsProviderForSetup(context, node, runner))) {
           return;
         }
         const messageId = consumption === "await" ? "awaitedDynamicImport" : "thenedDynamicImport";
@@ -632,7 +701,7 @@ function repairFor(node, subscribeCall) {
 var TESTS = /* @__PURE__ */ new Set(["it", "test"]);
 var NEVER_CALLED = /* @__PURE__ */ new Set(["toHaveBeenCalled", "toHaveBeenCalledWith"]);
 var UNDEFINED_MATCHERS = /* @__PURE__ */ new Set(["toBeDefined", "toBeUndefined"]);
-var EQUALITY = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var FALSY = /* @__PURE__ */ new Set(["0", "''", '""', "``", "NaN", "false", "null", "undefined"]);
 var EMPTY = /* @__PURE__ */ new Set(["[]", "''", '""', "``"]);
 function testCallOf(fn) {
@@ -697,7 +766,7 @@ function satisfiedByHeldValue(context, held, matcher) {
   if (matcher.negated) {
     return UNDEFINED_MATCHERS.has(matcher.name) ? held === "undefined" : matcher.name === "toBeTruthy" && FALSY.has(held);
   }
-  if (EQUALITY.has(matcher.name)) {
+  if (EQUALITY_MATCHERS.has(matcher.name)) {
     return matcher.args.length === 1 && argument !== void 0 && tight(context.sourceCode.getText(argument)) === tight(held);
   }
   if (matcher.name === "toHaveLength") {
@@ -1724,7 +1793,6 @@ var noUnassertedConsoleSpy = defineRule({
 });
 
 // src/lib/eslint/constant-expect.ts
-var COMPARES = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var CLASSIFIES = /* @__PURE__ */ new Set(["toBeDefined", "toBeFalsy", "toBeNaN", "toBeNull", "toBeTruthy", "toBeUndefined"]);
 var OBJECT_LITERALS = /* @__PURE__ */ new Set([
   "ArrayExpression",
@@ -1758,17 +1826,8 @@ function isConstant(node) {
       return LITERALS.has(value.type);
   }
 }
-function matcherOf2(expectCall) {
-  let member = expectCall.parent;
-  while (memberName(member) === "not") {
-    member = member.parent;
-  }
-  const name = memberName(member);
-  const call = member.parent;
-  return name && isCallExpression(call) && call.callee === member ? { name, args: call.arguments } : void 0;
-}
 function isDecided(actual, matcher) {
-  if (COMPARES.has(matcher.name)) {
+  if (EQUALITY_MATCHERS.has(matcher.name)) {
     return isConstant(actual) && matcher.args.every(isConstant);
   }
   return CLASSIFIES.has(matcher.name) && (OBJECT_LITERALS.has(unwrapped(actual).type) || isConstant(actual));
@@ -1782,7 +1841,7 @@ var noConstantExpect = defineRule({
   create: (context) => ({
     'CallExpression[callee.name="expect"]': (node) => {
       const [actual] = node.arguments;
-      const matcher = matcherOf2(node);
+      const matcher = matcherOf(node);
       if (actual && matcher && isDecided(actual, matcher)) {
         context.report({ node, messageId: "noConstantExpect", data: { actual: excerpt(context, actual, 40), matcher: matcher.name } });
       }
@@ -3443,6 +3502,55 @@ var noInstanceLifecycleSpy = defineRule({
   })
 });
 
+// src/lib/eslint/matcher-as-instance.ts
+var AS_INSTANCE = "asInstance";
+function importedAsInstance(context, callee) {
+  const binding = findBinding(context.sourceCode.getScope(callee), callee.name);
+  return binding?.defs.some((definition) => definition.type === "ImportBinding") ? binding : void 0;
+}
+function unwrap2(context, fixer, wrapper, value, binding) {
+  const edits = [fixer.replaceText(wrapper, context.sourceCode.getText(value))];
+  const orphaned = binding.references.length === 1 ? dropNamedImport(context.sourceCode, fixer, binding) : void 0;
+  if (orphaned) {
+    edits.push(orphaned);
+  }
+  return edits;
+}
+var noRedundantAsInstance = defineRule({
+  name: "no-redundant-as-instance",
+  description: "Pass the value itself to a comparing matcher; asInstance() bridges slots typed as the real class",
+  fixable: true,
+  messages: {
+    noRedundantAsInstance: "`asInstance({{value}})` buys nothing under `.{{matcher}}()`: the matcher takes its argument as a free type parameter, so the value compiles as it is. Pass `{{value}}` directly."
+  },
+  create: (context) => ({
+    'CallExpression[callee.name="expect"]': (node) => {
+      const matcher = matcherOf(node);
+      if (!matcher || !EQUALITY_MATCHERS.has(matcher.name)) {
+        return;
+      }
+      for (const argument of matcher.args) {
+        if (!isCallExpression(argument) || !isIdentifier(argument.callee) || argument.callee.name !== AS_INSTANCE) {
+          continue;
+        }
+        const [value, ...extra] = argument.arguments;
+        if (value === void 0 || extra.length > 0) {
+          continue;
+        }
+        const binding = importedAsInstance(context, argument.callee);
+        if (binding) {
+          context.report({
+            node: argument,
+            messageId: "noRedundantAsInstance",
+            data: { matcher: matcher.name, value: excerpt(context, value, 40) },
+            fix: (fixer) => unwrap2(context, fixer, argument, value, binding)
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/lib/eslint/use-value-types.ts
 var PRIMITIVE_CHECKER_METHODS = [
   "getTypeAtLocation",
@@ -5101,7 +5209,6 @@ var preferRenderShallow = defineRule({
 });
 
 // src/lib/eslint/prefer-to-have-signal-value.ts
-var MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var VALUE_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"],
   ["toBeUndefined", "undefined"]
@@ -5110,7 +5217,7 @@ var SIGNAL_BRAND = "\u0275SIGNAL";
 var SIGNAL_BRAND_PROPERTY = /^__@(?:SIGNAL|ɵSIGNAL|ɵWRITABLE_SIGNAL)@\d+$/;
 function signalAssertionOf(node) {
   const callee = node.callee;
-  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !(MATCHERS.has(callee.property.name) || VALUE_MATCHERS.has(callee.property.name))) {
+  if (!isMemberExpression(callee) || callee.computed || !isIdentifier(callee.property) || !(EQUALITY_MATCHERS.has(callee.property.name) || VALUE_MATCHERS.has(callee.property.name))) {
     return void 0;
   }
   let expected = callee.object;
@@ -6537,7 +6644,7 @@ function isObjectPattern(node) {
 function isUnwrapped(node) {
   return isCast(node) || node.type === "TSNonNullExpression";
 }
-function unwrap2(node) {
+function unwrap3(node) {
   return isUnwrapped(node) ? node.expression : node;
 }
 function methodString(node) {
@@ -6545,7 +6652,7 @@ function methodString(node) {
   return typeof value === "string" && METHOD_NAME.test(value) ? value : void 0;
 }
 function listedMethod(value) {
-  const list = unwrap2(value);
+  const list = unwrap3(value);
   const elements = isArrayExpression(list) ? list.elements : [];
   const names = elements.filter((element) => element !== null).map(methodString);
   return elements.length === 1 ? names[0] : void 0;
@@ -6586,7 +6693,7 @@ function readsMethod(member, method) {
   return named === method && !(isAssignmentExpression(parent) && parent.left === member);
 }
 function isRealObject(scope, node, follow) {
-  const value = unwrap2(node);
+  const value = unwrap3(node);
   if (isIdentifier(value)) {
     const bound = follow ? boundValueOf(scope, value) : void 0;
     return bound ? isRealObject(scope, bound, false) : DOM_GLOBALS.has(value.name) && bindingState(scope, value.name) === "free";
@@ -7049,6 +7156,7 @@ var rules = {
   "no-mistyped-use-value": noMistypedUseValue,
   "no-unknown-use-value-key": noUnknownUseValueKey,
   "no-instance-lifecycle-spy": noInstanceLifecycleSpy,
+  "no-redundant-as-instance": noRedundantAsInstance,
   "no-ts-expect-error-on-double": noTsExpectErrorOnDouble,
   "no-constant-expect": noConstantExpect,
   "no-compile-components": noCompileComponents,
@@ -7127,7 +7235,8 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-relative-mock-under-builder`]: "error",
   [`${PLUGIN_NAME}/no-real-wait-in-test`]: "warn",
   [`${PLUGIN_NAME}/no-disabled-testbed-teardown`]: "error",
-  [`${PLUGIN_NAME}/no-inline-test-data`]: "warn"
+  [`${PLUGIN_NAME}/no-inline-test-data`]: "warn",
+  [`${PLUGIN_NAME}/no-redundant-as-instance`]: "warn"
 };
 var typeErrorRules = {
   [`${PLUGIN_NAME}/prefer-as-spy`]: "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.59.1",
+  "version": "5.62.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

@@ -1,6 +1,6 @@
 ---
 name: vitest-auto-spy
-description: Typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports vitest-auto-spy or a subpath (/angular, /angular/*, /signal-forms, /bun-angular, /bun, /node, /rstest, /rxjs, /diagnostics, /nestjs, /jasmine, /setup, /zone, /eslint-plugin), naming createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, stubResponse, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, provideLocationDouble, collectRouterEvents, createLog, createComponentStub, createForm, toHaveFieldErrors, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, adoptMock, spyOnOwnMethod, spyOnVoidMethod, explainSpy, compareTestRuns, expectEmission, setupAutoSpy, setSpyEngine, assertMocked, calledWith, mustBeCalledWith, captureArg, ArgumentCaptor, onlyMethodsToSpyOn, onUnstubbedCall, passthrough, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator, or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not a method of", "strict double has nothing configured", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
+description: Typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports vitest-auto-spy (/angular, /angular/*, /signal-forms, /bun-angular, /bun, /node, /rstest, /rxjs, /diagnostics, /nestjs, /jasmine, /setup, /zone, /eslint-plugin), naming createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, createWindowSpies, provideHttpTesting, expectRequest, stubResponse, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, provideLocationDouble, collectRouterEvents, createLog, createComponentStub, createForm, toHaveFieldErrors, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, adoptMock, spyOnOwnMethod, spyOnVoidMethod, explainSpy, compareTestRuns, expectEmission, setupAutoSpy, setSpyEngine, assertMocked, calledWith, mustBeCalledWith, captureArg, ArgumentCaptor, onlyMethodsToSpyOn, onUnstubbedCall, passthrough, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator, or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not a method of", "strict double has nothing configured", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
 ---
 
 # vitest-auto-spy
@@ -329,11 +329,17 @@ it('loads', async () => {
 | a component that reads `location.back()`, or asserts where a redirect landed                               | `provideLocationDouble()` + `injectLocationDouble()` — Angular's own `SpyLocation`; without the provider, `Location` is `providedIn: 'root'` and the real one answers                                                                                                                                                                                     |
 | "did A run before B?" across three collaborators                                                           | `createLog<'drop-cache' \| 'flush'>()` — hand `log.fn('drop-cache')` to each, assert `log.result()` once                                                                                                                                                                                                                                                  |
 | a `window` or `document` behind a DI token                                                                 | `provideWindowDouble(WINDOW, { screen })` / `provideDocumentDouble({ … })` — `/angular/doubles`                                                                                                                                                                                                                                                           |
+| selected void window methods, such as `location.reload` or `parent.postMessage`                            | `createWindowSpies({ location: ['reload'], parent: ['postMessage'] })` from `/angular/doubles` — pass the result to `provideWindowDouble(WINDOW, spies)`; each spy returns `undefined` without calling the browser. For root methods, use `createWindowSpies(['close', 'focus'])`.                                                                        |
 | `MAT_DIALOG_DATA` and `MatDialogRef` provided by hand                                                      | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(MatDialogRef)` + `injectMatDialogRef(Ref)` — `/angular/doubles`                                                                                                                                                                                                                                |
 | asserting a `computed()` did **not** recompute                                                             | `trackRecomputations(sig)` / `trackEffectRuns(ref)` — `{ count, stop() }`                                                                                                                                                                                                                                                                                 |
 | `form()` in a spec, or `errors()` read by hand                                                             | `createForm(model, schema)` + `registerFormMatchers()` — then `toHaveFieldErrors([…])` (`/signal-forms`)                                                                                                                                                                                                                                                  |
 | any of those doubles without a `TestBed`                                                                   | `createRouterDouble` (`/angular-router`) / `createWindowDouble` / `createDocumentDouble` / `createMatDialogRef` (`/angular/doubles`)                                                                                                                                                                                                                      |
 
+When composing window spies with data overrides, keep the nested spies too:
+`provideWindowDouble(WINDOW, { ...spies, location: { ...spies.location, hostname: 'example.test' } })`.
+Assert calls on `spies.location.reload` or `spies.parent.postMessage`. For methods returning a value,
+use `createFunctionSpy` from the core and configure that value explicitly.
+
 ## Rules that prevent most of the mistakes
 
 - Declare the variable as **`Spy<T>`, never as `T`** — `Spy<T>` is a mapped type and drops private