vitest-auto-spy 5.32.0 → 5.32.2

package/AGENTS.md

@@ -16,7 +16,9 @@ Setting this up for a team? `npx vitest-auto-spy init` writes a pointer to this
 instruction files this repository's agents actually read — `AGENTS.md` (Codex, Cursor, Copilot and
 most of the field), `CLAUDE.md` (Claude Code) and `GEMINI.md` (Gemini CLI), plus the glob-scoped
 rule file of any tool whose own directory already exists. `--check` is the CI form; `--only
-CLAUDE.md,.claude` limits it to the files a repository keeps untracked. Full table:
+CLAUDE.md,.claude` limits it to the files a repository keeps untracked. A hand-made copy of the
+package's skill in `.claude/skills/vitest-auto-spy/` is reported `stale` (and fails `--check`): delete
+it and re-run `init`. Full table:
 <https://asdalexey.github.io/vitest-auto-spy/agents>.
 
 | Resource                | Where                                                                                                                                                           |
@@ -3499,6 +3501,10 @@ const host = hostElement(fixture); // HTMLElement, checked with instanceof
 queryElement(fixture, '.close').click(); // HTMLElement; throws naming the selector when nothing matches
 queryElement(fixture.debugElement, 'input[name=q]', HTMLInputElement).value; // typed; wrong type throws
 // also on /bun-angular; queryElement takes an element found earlier as its root too
+// a null source (debugElement.query() that matched nothing) throws saying so, not 'Cannot read properties of null'
+expect(queryElement(fixture, '.title').textContent.trim()).toBe('Orders'); // present: read through queryElement
+expect(host.querySelector('.empty-state')).toBeNull(); // absent: querySelector on the typed host, no cast
+// NOT host.querySelector('.title')?.textContent.trim() — a miss is undefined, which toBeFalsy() accepts
 
 // build a class through DI, every unprovided token auto-spied
 const { instance, spies } = createWithAutoSpies(CartService, {
@@ -3994,7 +4000,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-set-inputs`               | `warn`  | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })` — the name is resolved against the compiled definition before the first write (an undeclared one is an `NG0303` and no change) and the value is typed. The run collapses into one call and a `detectChanges()` under it goes; offered, not applied, because `stable()` ticks and a zone.js suite answers that with `NG0101`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `prefer-spy-on-own-method`        | `warn`  | `--fix` / suggest | `createSpyFromInstance(x, { onlyMethodsToSpyOn: ['m'], passthrough: true })` read for `m` alone — `.m` on the call, `const { m } = …`, a bare statement, or a name read only as `v.m` → `spyOnOwnMethod(x, 'm')`; the same whitelist with `returns: { m: undefined }` → `spyOnVoidMethod(x, 'm')`. Both fix, import and all; a `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed is a suggestion, offered only on a real event or element — `new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement` — never on a double                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `prefer-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `no-hand-assigned-global`         | `error` | `--fix`           | a double assigned to a global (`global.fetch = vi.fn()`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }`) with no restore in `afterEach` / `afterAll` / `onTestFinished` → `mockValueProp(globalThis, name, value)` or `vi.stubGlobal` + `unstubGlobals`; `blockNetwork()` for network globals, `stubWebStorage()` for the storages; the three observers stay with `prefer-observer-stub`; any value written into an imported object (`environment.production = true`) → `mockValueProp(environment, 'production', true)`, fixed in a test or `beforeEach`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `no-hand-assigned-global`         | `error` | `--fix`           | a double assigned to a global (`global.fetch = vi.fn()`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }`) with no restore in `afterEach` / `afterAll` / `onTestFinished` → `mockValueProp(globalThis, name, value)` or `vi.stubGlobal` + `unstubGlobals`; `blockNetwork()` for network globals, `stubWebStorage()` for the storages, `stubWorker({ respond })` for `Worker`; the three observers stay with `prefer-observer-stub`; any value written into an imported object (`environment.production = true`) → `mockValueProp(environment, 'production', true)`, fixed in a test or `beforeEach`                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `prefer-stub-response`            | `error` | —                 | an object literal cast to `Response` (`as Response`, `as unknown as Response`, `<Response>{ … }`) or `createMock<Response>(…)` / `createAutoMock<Response>(…)` → `stubResponse({ body })` from `/setup`; the literal answers `undefined` for every member it does not list (`status`, `headers`, `text()`) and the cast is what makes that compile. `Response` must resolve to the **global**, so an Express handler's or a generated client's `Response` is never reported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `prefer-provide-activated-route`  | `error` | —                 | a hand-built `ActivatedRoute` — any `useValue` / `useClass` / `useFactory` / `useExisting`, and `provideAutoSpy(ActivatedRoute)` too → `provideActivatedRoute({ … })`; the double knows either the streams or the snapshot, never both, and `injectActivatedRoute().setParams(…)` moves them together mid-test                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `no-passthrough-console-spy`      | `error` | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and prints → `installConsoleSpies()` + `consoleXSpy`, or `.mockImplementation(() => undefined)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

package/CHANGELOG.md

@@ -10,6 +10,66 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.32.2] - 2026-09-25
+
+### Fixed
+
+- **`no-hand-assigned-global` points a hand-assigned `Worker` at `stubWorker`.** `globalThis.Worker = …`
+  got the generic `handAssignedGlobal` message and the `stubConstructor` suggestion; it now gets its own
+  message naming `stubWorker({ respond })` from `/dom-stubs`, the way the storages name `stubWebStorage()`.
+
+### Docs
+
+- **The introduction no longer says the spy is powered by the runner's mock primitive.** Since 4.1 the
+  default engine is the library's own mock function; the introduction page and its Russian counterpart
+  now say so and name `setSpyEngine('runner')` as the way back to `vi.fn()`.
+
+## [5.32.1] - 2026-09-25
+
+### Fixed
+
+- **`hostElement` and `queryElement` name the cause when handed the `null` of a query that matched
+  nothing.** Angular types `debugElement.query()` as `DebugElement`, but it returns `null` on a miss,
+  so `hostElement(fixture.debugElement.query(By.directive(Missing)))` type-checked and then died on
+  `Cannot read properties of null (reading 'nativeElement')`. Both helpers now throw their own
+  error, which asks whether a `debugElement.query()` matched nothing. Every message the two throw
+  now starts with `[vitest-auto-spy]` and ends with a `Docs:` link, like the rest of the package.
+  On `/angular` and `/bun-angular`.
+- **`init` no longer passes over an old copy of the shipped skill.** A
+  `.claude/skills/vitest-auto-spy/SKILL.md` without the managed markers was left alone as
+  hand-written, and `init --check` said "Up to date" — even when it was a verbatim copy of the
+  package's skill from dozens of versions back. A file there whose frontmatter says
+  `name: vitest-auto-spy` is now listed as `stale`: `init` still does not overwrite it, but warns to
+  delete it and re-run `init`, which writes the managed pointer in its place, and `init --check`
+  exits 1 on it.
+- **ESLint fixes import helpers from the adapter entry the spec already uses.** A fix or suggestion
+  that adds `mockValueProp`, `mockReadonlyPropGetter`, `asSpy`, `createMock` or `settleDynamicImport`
+  (`no-hand-assigned-global`, `no-object-define-property`, `no-reflect-member-access` and the other
+  rules that write them) always imported from the root, which in a `/bun`, `/bun-angular`, `/node`
+  or `/rstest` spec registered Vitest's adapter next to the runner's own. The import now joins the
+  adapter entry the file already imports, and falls back to the root only when it imports none.
+
+### Docs
+
+- **Reading text and asserting absence next to `queryElement`.** README, AGENTS.md, the skill and
+  the Angular page now show `queryElement(fixture, '.title').textContent.trim()` for an element that
+  must be there and `expect(host.querySelector('.x')).toBeNull()` for one that must not, and say why
+  `host.querySelector('.title')?.textContent.trim()` is the wrong reading: a miss is `undefined`, which
+  `toBeFalsy()` or `not.toContain()` accepts.
+- **The API page lists what 5.32.0 exported.** A row for `stubAnimationFrame` / `stubElementRect`,
+  and the public types `AutoMocked<T>`, `ElementConstructor<E>`, `NativeElementHolder`,
+  `DialogDataOf<T, Token>`, `AnimationFrameStub`, `AnimationFrameStubOptions` and
+  `AnimationFrameMode`.
+- **The docs site covers `autoMocked<T>()` and `AutoMocked<T>`.** The auto-mock page shows a double
+  passed as an argument and declared `let logger: AutoMocked<Logger>`; the README rows give the
+  `config` argument and name the type.
+- **The Angular page carries the two dialog typing traps AGENTS.md already had.** Naming the type
+  argument of `provideMatDialogData` is what passes `no-unsafe-argument`, and the ref type goes in
+  the type argument of `injectMatDialogRef`, not in an instantiation expression.
+- **`no-hand-assigned-global` says where its fix imports `mockValueProp` from.** The adapter entry
+  the file already imports, or `vitest-auto-spy` when it imports none, when the file has no
+  `mockValueProp` in scope; one imported from another entry is used as it is.
+
 ## [5.32.0] - 2026-09-25
 
 ### Added
@@ -8186,7 +8246,9 @@ by hand there, in more than one place, by more than one person.
   `mockAccessorsProp`.
 - Dual ESM + CJS build with type declarations; 100% test coverage.
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.32.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.32.2...HEAD
+[5.32.2]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.32.1...v5.32.2
+[5.32.1]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.32.0...v5.32.1
 [5.32.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.31.0...v5.32.0
 [5.31.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.30.0...v5.31.0
 [5.30.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.29.0...v5.30.0

package/README.md

@@ -2710,6 +2710,12 @@ or `Element` for markup that is not HTML. A selector that matches nothing throws
 the selector in the message, and so does a match of another type:
 `'.close' matched <a.close> (HTMLAnchorElement), not HTMLButtonElement`.
 
+Read text through `queryElement` too — `queryElement(fixture, '.title').textContent.trim()` — rather
+than `host.querySelector('.title')?.textContent.trim()`, whose miss is an `undefined` that
+`toBeFalsy()` or `not.toContain()` accepts. For an element that must be absent, keep
+`expect(host.querySelector('.empty-state')).toBeNull()`: `querySelector` on the typed host needs no
+cast.
+
 #### Building a class with auto-spied dependencies
 
 ```ts
@@ -3207,7 +3213,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `registerResourceMatchers()`                                                                                | `/angular/matchers`           | Adds `toBeLoading` / `toHaveResourceValue` / `toHaveResourceError`; the value matcher fails an unresolved resource                                                                                                                                                                                                                                      |
 | `registerDirectiveMatchers()`                                                                               | `/angular/matchers`           | Adds `expect(fixture).toHaveDirectiveApplied(Directive, selector?)`                                                                                                                                                                                                                                                                                     |
 | `installProxyZonePatch(opts?)`                                                                              | `/zone`                       | `fakeAsync` / `waitForAsync` on Vitest — the patch `zone.js/testing` does not ship; `scope: 'callback'` per callback                                                                                                                                                                                                                                    |
-| `autoMocked<T>(overrides?)`                                                                                 | core                          | `createAutoMock` typed as `T & Spy<T>`, for a collaborator passed as an argument rather than injected                                                                                                                                                                                                                                                   |
+| `autoMocked<T>(overrides?, config?)`                                                                        | core                          | `createAutoMock` typed as `T & Spy<T>`; `AutoMocked<T>` names it for a `let` (`AutoMocked<T>`), for a collaborator passed as an argument rather than injected                                                                                                                                                                                           |
 | `mockSystemTime(time)` / `withSystemTime(time, fn)`                                                         | `/setup`                      | Freeze the clock whether or not fake timers are already running                                                                                                                                                                                                                                                                                         |
 | `mockNow(source)` / `useCountingClock(opts?)`                                                               | `/setup`                      | A `Date.now` that survives fake timers being re-installed around every test; counts ticks instead of telling the time                                                                                                                                                                                                                                   |
 | `registerFocusMatchers()`                                                                                   | `/setup`                      | Adds `expect(el).toHaveFocus()`, which names _why_ focus is elsewhere                                                                                                                                                                                                                                                                                   |
@@ -4213,7 +4219,7 @@ another, and the next one is in that same file.
 | `stubElementRect(el, rect?)` _(`/dom-stubs`)_                                                                                               | A box for `getBoundingClientRect()` — missing fields `0`, edges derived; returns `RestoreProp`                                                                                                                                                                                                                           |
 | `createComponentStub(Class, overrides?, opts?)` _(`/angular`)_                                                                              | A standalone stand-in for a child component, directive or pipe, built from its compiled definition so the selector cannot drift                                                                                                                                                                                          |
 | `flushEventLoop(turns?)` / `settleDynamicImport(load, turns?)`                                                                              | Real event-loop turns under fake timers; wait for a dynamic `import()`                                                                                                                                                                                                                                                   |
-| `autoMocked<T>(overrides?)`                                                                                                                 | `createAutoMock` typed as `T & Spy<T>`                                                                                                                                                                                                                                                                                   |
+| `autoMocked<T>(overrides?, config?)`                                                                                                        | `createAutoMock` typed as `T & Spy<T>`; `AutoMocked<T>` names it for a `let`                                                                                                                                                                                                                                             |
 | `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                                                                                                                                                                         |

package/dist/angular-diagnostics.js

@@ -1,15 +1,15 @@
-import { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-4H6KZWGX.js';
-export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-4H6KZWGX.js';
-import { failOnUnspiedProvider } from './chunk-SQFEEO4W.js';
-import './chunk-X74IM4MQ.js';
-import './chunk-KCMPDMLY.js';
-import './chunk-25OHJOAA.js';
-import './chunk-EDEGKIIR.js';
+import { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-F2KBJC7P.js';
+export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-F2KBJC7P.js';
+import { failOnUnspiedProvider } from './chunk-GSMWYZ5A.js';
+import './chunk-YUGSITWJ.js';
+import './chunk-6JQ7AFWM.js';
+import './chunk-YDPOBKST.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-K3EUF6RK.js';
-import { isAutoSpyLike } from './chunk-D2R6EQJJ.js';
+import './chunk-72H6HNDI.js';
+import { isAutoSpyLike } from './chunk-XNXIHKVM.js';
 import { count, taskName } from './chunk-M3NTXLZG.js';
-import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-3Q76UTT6.js';
+import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { getTestBed } from '@angular/core/testing';
 import { beforeEach, afterEach } from 'vitest';

package/dist/angular-doubles.js

@@ -1,14 +1,14 @@
-import { describeInstance } from './chunk-SDTXE5SW.js';
-import { useVitestAdapter } from './chunk-ANQVIGAG.js';
-import './chunk-TH64BXPP.js';
+import { describeInstance } from './chunk-24JTFFQL.js';
+import { useVitestAdapter } from './chunk-6JLBZHQ3.js';
+import './chunk-JR55747M.js';
 import './chunk-YHDBRBGU.js';
-import './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-K3EUF6RK.js';
-import './chunk-D2R6EQJJ.js';
+import { createFunctionSpy } from './chunk-72H6HNDI.js';
+import './chunk-XNXIHKVM.js';
 import './chunk-M3NTXLZG.js';
-import { angularDialog } from './chunk-3Q76UTT6.js';
+import { angularDialog } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { TestBed } from '@angular/core/testing';
 import { ReplaySubject } from 'rxjs';

package/dist/angular-http.js

@@ -1,9 +1,9 @@
-import { assertAngularInternals, pendingRequestsReport, verifyOnTeardown, beforeTestBedReset } from './chunk-4H6KZWGX.js';
-import { flushEffects } from './chunk-G5KZLT7Q.js';
-import './chunk-X74IM4MQ.js';
+import { assertAngularInternals, pendingRequestsReport, verifyOnTeardown, beforeTestBedReset } from './chunk-F2KBJC7P.js';
+import { flushEffects } from './chunk-DNXCZOYY.js';
+import './chunk-YUGSITWJ.js';
 import './chunk-W5EXSI22.js';
 import { count, taskName } from './chunk-M3NTXLZG.js';
-import { angularHttpNoRequest, angularHttpPending, angularHttpController, angularHttpExpectRequest } from './chunk-3Q76UTT6.js';
+import { angularHttpNoRequest, angularHttpPending, angularHttpController, angularHttpExpectRequest } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { provideHttpClient } from '@angular/common/http';
 import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';

package/dist/angular-matchers.js

@@ -1,5 +1,5 @@
 import { count } from './chunk-M3NTXLZG.js';
-import { angularDirectiveApplied } from './chunk-3Q76UTT6.js';
+import { angularDirectiveApplied } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import '@angular/compiler';
 import { ɵSIGNAL as _SIGNAL, isStandalone } from '@angular/core';

package/dist/angular-router.js

@@ -1,9 +1,9 @@
-import { describeInstance } from './chunk-SDTXE5SW.js';
-import { angularInternalsError } from './chunk-X74IM4MQ.js';
-import { createFunctionSpy } from './chunk-K3EUF6RK.js';
-import './chunk-D2R6EQJJ.js';
+import { describeInstance } from './chunk-24JTFFQL.js';
+import { angularInternalsError } from './chunk-YUGSITWJ.js';
+import { createFunctionSpy } from './chunk-72H6HNDI.js';
+import './chunk-XNXIHKVM.js';
 import { count } from './chunk-M3NTXLZG.js';
-import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-3Q76UTT6.js';
+import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { TestBed } from '@angular/core/testing';
 import { Router, DefaultUrlSerializer, PRIMARY_OUTLET, RouterState, ActivatedRoute, NavigationEnd, RouterStateSnapshot, ActivatedRouteSnapshot, NavigationStart, NavigationCancel, NavigationError, NavigationSkipped, UrlSegment, VERSION, createUrlTreeFromSnapshot } from '@angular/router';

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-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-pFMHNAPy.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-BVbIBVS7.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
 import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-wUaoy0NW.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-wUaoy0NW.js';

package/dist/angular.js

@@ -40,6 +40,7 @@ var angularMockResource = "https://asdalexey.github.io/vitest-auto-spy/adapters/
 var angularResources = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#resources-httpresource-and-resource";
 var angularSignalProp = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#signal-readonly-property-mocking";
 var angularStable = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#zoneless-waiting";
+var angularTypedElements = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#typed-elements-under-a-strict-lint";
 var angularTrackRuns = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#counting-recomputations-and-effect-runs";
 var autoMockByType = "https://asdalexey.github.io/vitest-auto-spy/core/auto-mock-by-type";
 var autoMockHeldBack = "https://asdalexey.github.io/vitest-auto-spy/core/auto-mock-by-type#it-answers-everything-so-it-must-not-answer-these";
@@ -3694,18 +3695,31 @@ function describeElement(element) {
   const classes = [...element.classList].map((name) => `.${name}`).join("");
   return `<${element.tagName.toLowerCase()}${classes}> (${element.constructor.name})`;
 }
+function fail(message) {
+  return withDocs(`[vitest-auto-spy] ${message}`, angularTypedElements);
+}
 function rootElement(helper, source) {
+  if (source === null) {
+    throw new TypeError(
+      fail(
+        `${helper}: received null instead of a ComponentFixture, a DebugElement or an Element \u2014 a debugElement.query() that matched nothing?
+Check the predicate against the rendered template, or use queryElement(fixture, selector), which names the selector on a miss.`
+      )
+    );
+  }
   const element = source instanceof Element ? source : source.nativeElement;
   if (!(element instanceof Element)) {
     throw new TypeError(
-      `${helper}: expected a ComponentFixture, a DebugElement or an Element, received a nativeElement of ${element === null ? "null" : typeof element}.`
+      fail(
+        `${helper}: expected a ComponentFixture, a DebugElement or an Element, received a nativeElement of ${element === null ? "null" : typeof element}.`
+      )
     );
   }
   return element;
 }
 function checkType(element, type, what, helper) {
   if (!(element instanceof type)) {
-    throw new TypeError(`${helper}: ${what} ${describeElement(element)}, not ${type.name}.`);
+    throw new TypeError(fail(`${helper}: ${what} ${describeElement(element)}, not ${type.name}.`));
   }
   return element;
 }
@@ -3717,8 +3731,10 @@ function queryElement(source, selector, type = HTMLElement) {
   const match = root.querySelector(selector);
   if (match === null) {
     throw new Error(
-      `queryElement: no element matches '${selector}' inside ${describeElement(root)}.
+      fail(
+        `queryElement: no element matches '${selector}' inside ${describeElement(root)}.
 Render first (\`fixture.detectChanges()\` or \`await stable(fixture)\`), then check the selector against the template.`
+      )
     );
   }
   return checkType(match, type, `'${selector}' matched`, "queryElement");
@@ -4511,7 +4527,7 @@ function collectingObserver(collected, context, settle, handlers) {
   const options = context.options;
   const skip = options?.skip ?? 0;
   const until = options?.until;
-  const fail = (error) => {
+  const fail2 = (error) => {
     collected.stop();
     settle.reject(
       emissionFailure(
@@ -4533,7 +4549,7 @@ function collectingObserver(collected, context, settle, handlers) {
           settle.resolve(collected.accepted, collected.subscribing);
         }
       } catch (error) {
-        fail(error);
+        fail2(error);
       }
     },
     error: (error) => {
@@ -4643,16 +4659,16 @@ function collectEmissions(source$, count2, options, anchor2, helper) {
     );
   }
   return new Promise((resolve, reject) => {
-    const fail = anchoredRejecter(reject, anchor2);
+    const fail2 = anchoredRejecter(reject, anchor2);
     subscribeAndCollect(
       source$,
       options,
       // Resolved with everything that arrived, then narrowed to the accepted ones: the collector's
       // job is to record, and `skip` / `until` decide what the caller is handed.
-      { resolve: (values) => resolve(values.slice(0, count2)), reject: fail },
+      { resolve: (values) => resolve(values.slice(0, count2)), reject: fail2 },
       {
         isDone: (acceptedCount) => acceptedCount >= count2,
-        onComplete: (_values, received) => fail(completedError(received, { helper, options, expected: count2 })),
+        onComplete: (_values, received) => fail2(completedError(received, { helper, options, expected: count2 })),
         onTimeout: timeoutError,
         onError: rejectAsSourceError,
         emissionsSettle: true,
@@ -4668,13 +4684,13 @@ function expectNoEmission(source$, options) {
   let quietWindow = void 0;
   const context = { helper: "expectNoEmission", options, expected: 1 };
   return new Promise((resolve, reject) => {
-    const fail = anchoredRejecter(reject, anchor2);
+    const fail2 = anchoredRejecter(reject, anchor2);
     const collector = subscribeAndCollect(
       source$,
       { ...options, timeout: 0 },
       {
-        resolve: (emitted, onSubscribe) => fail(unexpectedEmissionError(emitted, context, onSubscribe)),
-        reject: fail
+        resolve: (emitted, onSubscribe) => fail2(unexpectedEmissionError(emitted, context, onSubscribe)),
+        reject: fail2
       },
       {
         isDone: (acceptedCount) => acceptedCount > 0,
@@ -4746,15 +4762,15 @@ function expectError(source$, options) {
   const anchor2 = captureAnchor(expectError);
   const context = { helper: "expectError", options, expected: 0 };
   return new Promise((resolve, reject) => {
-    const fail = anchoredRejecter(reject, anchor2);
+    const fail2 = anchoredRejecter(reject, anchor2);
     subscribeAndCollect(
       source$,
       options,
-      { resolve, reject: fail },
+      { resolve, reject: fail2 },
       {
         // Only `error` settles this one: an emission is not the answer, and neither is completion.
         isDone: staysOpen,
-        onComplete: (_values, received) => fail(completedWithoutErrorError(received, context)),
+        onComplete: (_values, received) => fail2(completedWithoutErrorError(received, context)),
         onTimeout: notErroredError,
         onError: resolveWithError,
         emissionsSettle: false,

package/dist/bun-angular.d.ts

@@ -3,7 +3,7 @@ export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOpti
 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-wUaoy0NW.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-5pFBRWW9.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-DUcl1uMH.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-pFMHNAPy.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-BVbIBVS7.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,22 +1,22 @@
-import { createSpyForToken } from './chunk-4IRFL76M.js';
-export { injectSpy, provideAutoSpy } from './chunk-SQFEEO4W.js';
-import { stable, flushEffects } from './chunk-G5KZLT7Q.js';
-export { flushEffects, stable } from './chunk-G5KZLT7Q.js';
-import { angularInternalsError } from './chunk-X74IM4MQ.js';
-import './chunk-FRD6NXVY.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-NTCEH2FY.js';
-import { mockValueProp } from './chunk-KCMPDMLY.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-KCMPDMLY.js';
-import { closestName } from './chunk-25OHJOAA.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-25OHJOAA.js';
+import { createSpyForToken } from './chunk-7WM3A4IB.js';
+export { injectSpy, provideAutoSpy } from './chunk-GSMWYZ5A.js';
+import { stable, flushEffects } from './chunk-DNXCZOYY.js';
+export { flushEffects, stable } from './chunk-DNXCZOYY.js';
+import { angularInternalsError } from './chunk-YUGSITWJ.js';
+import './chunk-XUPBHHJD.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-TMFV4DXT.js';
+import { mockValueProp } from './chunk-6JQ7AFWM.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-6JQ7AFWM.js';
+import { closestName } from './chunk-YDPOBKST.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-YDPOBKST.js';
 import { fakeClockBacklog } from './chunk-W5EXSI22.js';
-import './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-K3EUF6RK.js';
-import { libraryWarn } from './chunk-D2R6EQJJ.js';
+export { createFunctionSpy, errorHandler } from './chunk-72H6HNDI.js';
+import { libraryWarn } from './chunk-XNXIHKVM.js';
 import { displayPath, count } from './chunk-M3NTXLZG.js';
-import { angularEffects, angularTrackRuns, bunAngular, angularUnreadResource, angularCreateWithAutoSpies, angularResources, angularInputs, angularKeepTemplate } from './chunk-3Q76UTT6.js';
+import { angularEffects, angularTrackRuns, bunAngular, angularUnreadResource, angularCreateWithAutoSpies, angularResources, angularTypedElements, angularInputs, angularKeepTemplate } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import '@angular/compiler';
 import { NgModule, provideZonelessChangeDetection, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, untracked, ɵSIGNAL as _SIGNAL } from '@angular/core';
@@ -289,18 +289,31 @@ function describeElement(element) {
   const classes = [...element.classList].map((name) => `.${name}`).join("");
   return `<${element.tagName.toLowerCase()}${classes}> (${element.constructor.name})`;
 }
+function fail(message) {
+  return withDocs(`[vitest-auto-spy] ${message}`, angularTypedElements);
+}
 function rootElement(helper, source) {
+  if (source === null) {
+    throw new TypeError(
+      fail(
+        `${helper}: received null instead of a ComponentFixture, a DebugElement or an Element \u2014 a debugElement.query() that matched nothing?
+Check the predicate against the rendered template, or use queryElement(fixture, selector), which names the selector on a miss.`
+      )
+    );
+  }
   const element = source instanceof Element ? source : source.nativeElement;
   if (!(element instanceof Element)) {
     throw new TypeError(
-      `${helper}: expected a ComponentFixture, a DebugElement or an Element, received a nativeElement of ${element === null ? "null" : typeof element}.`
+      fail(
+        `${helper}: expected a ComponentFixture, a DebugElement or an Element, received a nativeElement of ${element === null ? "null" : typeof element}.`
+      )
     );
   }
   return element;
 }
 function checkType(element, type, what, helper) {
   if (!(element instanceof type)) {
-    throw new TypeError(`${helper}: ${what} ${describeElement(element)}, not ${type.name}.`);
+    throw new TypeError(fail(`${helper}: ${what} ${describeElement(element)}, not ${type.name}.`));
   }
   return element;
 }
@@ -312,8 +325,10 @@ function queryElement(source, selector, type = HTMLElement) {
   const match = root.querySelector(selector);
   if (match === null) {
     throw new Error(
-      `queryElement: no element matches '${selector}' inside ${describeElement(root)}.
+      fail(
+        `queryElement: no element matches '${selector}' inside ${describeElement(root)}.
 Render first (\`fixture.detectChanges()\` or \`await stable(fixture)\`), then check the selector against the template.`
+      )
     );
   }
   return checkType(match, type, `'${selector}' matched`, "queryElement");

package/dist/bun.js

@@ -1,13 +1,13 @@
-import './chunk-FRD6NXVY.js';
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-NTCEH2FY.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-KCMPDMLY.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-25OHJOAA.js';
+import './chunk-XUPBHHJD.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-TMFV4DXT.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-6JQ7AFWM.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-YDPOBKST.js';
 import './chunk-W5EXSI22.js';
-import './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-K3EUF6RK.js';
-import './chunk-D2R6EQJJ.js';
+export { createFunctionSpy, errorHandler } from './chunk-72H6HNDI.js';
+import './chunk-XNXIHKVM.js';
 import './chunk-M3NTXLZG.js';
-import './chunk-3Q76UTT6.js';
+import './chunk-JOPCMFYN.js';
 import './chunk-ENCEEH23.js';

package/dist/{chunk-SDTXE5SW.js → chunk-24JTFFQL.js}

@@ -1,4 +1,4 @@
-import { isAutoSpyLike } from './chunk-D2R6EQJJ.js';
+import { isAutoSpyLike } from './chunk-XNXIHKVM.js';
 
 // src/lib/angular-instance-name.ts
 function describeInstance(instance) {

package/dist/{chunk-LWSUV6IX.js → chunk-2QEM4WP7.js}

@@ -1,4 +1,4 @@
-import { isCannotRedefine, redefineFailure } from './chunk-EDEGKIIR.js';
+import { isCannotRedefine, redefineFailure } from './chunk-CLQUJX6E.js';
 
 // src/lib/redefine-accessor-spy.ts
 function createRedefineMockAdapter({

package/dist/{chunk-ANQVIGAG.js → chunk-6JLBZHQ3.js}

@@ -1,6 +1,6 @@
-import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-TH64BXPP.js';
+import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-JR55747M.js';
 import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
-import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-LWSUV6IX.js';
+import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-2QEM4WP7.js';
 import { hasMockAdapter, registerMockAdapter } from './shared-state.js';
 import { vi } from 'vitest';
 

package/dist/{chunk-KCMPDMLY.js → chunk-6JQ7AFWM.js}

@@ -1,7 +1,7 @@
-import { isCannotRedefine, redefineFailure } from './chunk-EDEGKIIR.js';
-import { libraryWarn } from './chunk-D2R6EQJJ.js';
+import { isCannotRedefine, redefineFailure } from './chunk-CLQUJX6E.js';
+import { libraryWarn } from './chunk-XNXIHKVM.js';
 import { count, displayPath } from './chunk-M3NTXLZG.js';
-import { setupGlobals, setupWrongHook, setup } from './chunk-3Q76UTT6.js';
+import { setupGlobals, setupWrongHook, setup } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { getMockAdapter } from './shared-state.js';
 

package/dist/{chunk-K3EUF6RK.js → chunk-72H6HNDI.js}

@@ -1,6 +1,6 @@
-import { AUTO_SPY_MARK, attachHelpers, markAsMock, reportMisconfiguration, detachedHelperError, decorate } from './chunk-D2R6EQJJ.js';
+import { AUTO_SPY_MARK, attachHelpers, markAsMock, reportMisconfiguration, detachedHelperError, decorate } from './chunk-XNXIHKVM.js';
 import { displayPath } from './chunk-M3NTXLZG.js';
-import { mustBeCalledWith, strictCall, createSpyFromClass } from './chunk-3Q76UTT6.js';
+import { mustBeCalledWith, strictCall, createSpyFromClass } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { getMockAdapter, getObservableSupport, getJasmineSupport, requireObservableSupport } from './shared-state.js';
 

package/dist/{chunk-4IRFL76M.js → chunk-7WM3A4IB.js}

@@ -1,5 +1,5 @@
-import { createSpyFromClass, createAutoMock } from './chunk-25OHJOAA.js';
-import { trackInjectionsUntracked } from './chunk-3Q76UTT6.js';
+import { createSpyFromClass, createAutoMock } from './chunk-YDPOBKST.js';
+import { trackInjectionsUntracked } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/track-injections.ts

package/dist/{chunk-EDEGKIIR.js → chunk-CLQUJX6E.js}

@@ -1,4 +1,4 @@
-import { realSeam, createSpyFromClass, autoMockByType, createSpyFromClassAccessorSpies } from './chunk-3Q76UTT6.js';
+import { realSeam, createSpyFromClass, autoMockByType, createSpyFromClassAccessorSpies } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/redefine-failure.ts

package/dist/{chunk-G5KZLT7Q.js → chunk-DNXCZOYY.js}

@@ -1,6 +1,6 @@
 import { unpatchedSetTimeout, unpatchedClearTimeout, fakeClockBacklog } from './chunk-W5EXSI22.js';
 import { count } from './chunk-M3NTXLZG.js';
-import { angularStable } from './chunk-3Q76UTT6.js';
+import { angularStable } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { NgZone } from '@angular/core';
 import { TestBed } from '@angular/core/testing';

package/dist/{chunk-4H6KZWGX.js → chunk-F2KBJC7P.js}

@@ -1,4 +1,4 @@
-import { angularInternalsError } from './chunk-X74IM4MQ.js';
+import { angularInternalsError } from './chunk-YUGSITWJ.js';
 import { count } from './chunk-M3NTXLZG.js';
 import { TestBed, getTestBed } from '@angular/core/testing';
 import { expect, beforeAll, afterAll } from 'vitest';

package/dist/{chunk-SQFEEO4W.js → chunk-GSMWYZ5A.js}

@@ -1,7 +1,7 @@
-import { currentSpecFile } from './chunk-KCMPDMLY.js';
-import { createSpyFromClass } from './chunk-25OHJOAA.js';
-import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-D2R6EQJJ.js';
-import { angularInjectSpyReal } from './chunk-3Q76UTT6.js';
+import { currentSpecFile } from './chunk-6JQ7AFWM.js';
+import { createSpyFromClass } from './chunk-YDPOBKST.js';
+import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-XNXIHKVM.js';
+import { angularInjectSpyReal } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { TestBed } from '@angular/core/testing';
 

package/dist/{chunk-3Q76UTT6.js → chunk-JOPCMFYN.js}

@@ -24,6 +24,7 @@ var angularShadowedProviders = "https://asdalexey.github.io/vitest-auto-spy/adap
 var angularEffects = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#running-one-effect-on-demand";
 var angularResources = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#resources-httpresource-and-resource";
 var angularStable = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#zoneless-waiting";
+var angularTypedElements = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#typed-elements-under-a-strict-lint";
 var angularTrackRuns = "https://asdalexey.github.io/vitest-auto-spy/adapters/angular#counting-recomputations-and-effect-runs";
 var angularUnreadResource = "https://asdalexey.github.io/vitest-auto-spy/runtimes/bun-angular#a-template-or-stylesheet-that-cannot-be-read";
 var autoMockByType = "https://asdalexey.github.io/vitest-auto-spy/core/auto-mock-by-type";
@@ -62,4 +63,4 @@ var strictModePassthrough = "https://asdalexey.github.io/vitest-auto-spy/core/st
 var trackInjectionsUntracked = "https://asdalexey.github.io/vitest-auto-spy/utilities/track-injections#get-on-a-token-that-is-not-tracked";
 var zoneRequirements = "https://asdalexey.github.io/vitest-auto-spy/utilities/zone#requirements";
 
-export { adoptMock, angularCreateWithAutoSpies, angularDeadSchemas, angularDialog, angularDirectiveApplied, angularEffects, angularHttpController, angularHttpExpectRequest, angularHttpNoRequest, angularHttpPending, angularInjectSpyReal, angularInputs, angularInternals, angularKeepTemplate, angularLocationDouble, angularNgModuleScopesAuto, angularPendingRequests, angularResources, angularRouteDouble, angularRouteWiring, angularRouterDouble, angularRouterEvents, angularRouterInject, angularShadowedProviders, angularStable, angularTrackRuns, angularUnreadResource, autoMockByType, autoMockHeldBack, bunAngular, captureArg, controlHelpers, createSpyFromClass, createSpyFromClassAccessorSpies, createSpyFromClassAccessors, createSpyFromClassInstanceMethods, createSpyFromClassLazySpies, createSpyFromClassReturns, eventLoopUntil, jasmineAutoSpies, jasmineClock, jasmineGlobals, jasmineTimeout, jasmineWithArgs, mockConstructor, moduleMocksAssert, moduleMocksNoOp, mustBeCalledWith, narrow, nestUnitRefusals, nextWithValuesLate, observableFailures, realSeam, setup, setupGlobals, setupWrongHook, signalFormsCreate, signalFormsErrors, strictCall, strictModePassthrough, trackInjectionsUntracked, zoneRequirements };
+export { adoptMock, angularCreateWithAutoSpies, angularDeadSchemas, angularDialog, angularDirectiveApplied, angularEffects, angularHttpController, angularHttpExpectRequest, angularHttpNoRequest, angularHttpPending, angularInjectSpyReal, angularInputs, angularInternals, angularKeepTemplate, angularLocationDouble, angularNgModuleScopesAuto, angularPendingRequests, angularResources, angularRouteDouble, angularRouteWiring, angularRouterDouble, angularRouterEvents, angularRouterInject, angularShadowedProviders, angularStable, angularTrackRuns, angularTypedElements, angularUnreadResource, autoMockByType, autoMockHeldBack, bunAngular, captureArg, controlHelpers, createSpyFromClass, createSpyFromClassAccessorSpies, createSpyFromClassAccessors, createSpyFromClassInstanceMethods, createSpyFromClassLazySpies, createSpyFromClassReturns, eventLoopUntil, jasmineAutoSpies, jasmineClock, jasmineGlobals, jasmineTimeout, jasmineWithArgs, mockConstructor, moduleMocksAssert, moduleMocksNoOp, mustBeCalledWith, narrow, nestUnitRefusals, nextWithValuesLate, observableFailures, realSeam, setup, setupGlobals, setupWrongHook, signalFormsCreate, signalFormsErrors, strictCall, strictModePassthrough, trackInjectionsUntracked, zoneRequirements };

package/dist/{chunk-TH64BXPP.js → chunk-JR55747M.js}

@@ -1,7 +1,7 @@
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-K3EUF6RK.js';
-import { setSharedHelperSink, hooksOf } from './chunk-D2R6EQJJ.js';
-import { mockConstructor } from './chunk-3Q76UTT6.js';
+import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-72H6HNDI.js';
+import { setSharedHelperSink, hooksOf } from './chunk-XNXIHKVM.js';
+import { mockConstructor } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/fast-spy.ts

package/dist/{chunk-E46PPK33.js → chunk-LAPHUX5G.js}

@@ -1,4 +1,4 @@
-import { jasmineWithArgs } from './chunk-3Q76UTT6.js';
+import { jasmineWithArgs } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { registerJasmineSupport, getMockAdapter } from './shared-state.js';
 

package/dist/{chunk-NTCEH2FY.js → chunk-TMFV4DXT.js}

@@ -1,12 +1,12 @@
-import { mockValueProp, mockAccessorsProp } from './chunk-KCMPDMLY.js';
-import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-25OHJOAA.js';
+import { mockValueProp, mockAccessorsProp } from './chunk-6JQ7AFWM.js';
+import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, ownerOf, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-YDPOBKST.js';
 import { unpatchedSetTimeout, unpatchedClearTimeout, fakeClockAdvice, fakeClockBacklog } from './chunk-W5EXSI22.js';
-import { redefineFailure } from './chunk-EDEGKIIR.js';
+import { redefineFailure } from './chunk-CLQUJX6E.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-K3EUF6RK.js';
-import { isMarkedMock, reportMisconfiguration, DEEP_CHILDREN } from './chunk-D2R6EQJJ.js';
+import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy } from './chunk-72H6HNDI.js';
+import { isMarkedMock, reportMisconfiguration, DEEP_CHILDREN } from './chunk-XNXIHKVM.js';
 import { count, displayPath } from './chunk-M3NTXLZG.js';
-import { moduleMocksAssert, moduleMocksNoOp, narrow, adoptMock, observableFailures, strictModePassthrough, createSpyFromClassReturns, captureArg, eventLoopUntil, mockConstructor } from './chunk-3Q76UTT6.js';
+import { moduleMocksAssert, moduleMocksNoOp, narrow, adoptMock, observableFailures, strictModePassthrough, createSpyFromClassReturns, captureArg, eventLoopUntil, mockConstructor } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { getMockAdapter, emissionTimeout, registerEmissionWait, forgetEmissionWait } from './shared-state.js';
 export { describeDuplicateCopies, getPackageCopies, setEmissionTimeout } from './shared-state.js';

package/dist/{chunk-D2R6EQJJ.js → chunk-XNXIHKVM.js}

@@ -1,4 +1,4 @@
-import { controlHelpers } from './chunk-3Q76UTT6.js';
+import { controlHelpers } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/guard-reaction.ts

package/dist/{chunk-FRD6NXVY.js → chunk-XUPBHHJD.js}

@@ -1,4 +1,4 @@
-import { guardAccessorSpies, createRedefineMockAdapter } from './chunk-LWSUV6IX.js';
+import { guardAccessorSpies, createRedefineMockAdapter } from './chunk-2QEM4WP7.js';
 import { mock } from 'bun:test';
 import { registerMockAdapter } from './shared-state.js';
 

package/dist/{chunk-25OHJOAA.js → chunk-YDPOBKST.js}

@@ -1,7 +1,7 @@
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defaultStrict, resolveUnstubbedGuard, seedReturnValue, createFunctionSpy } from './chunk-K3EUF6RK.js';
-import { runClearHook, runConfigReset, reportMisconfiguration, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-D2R6EQJJ.js';
-import { autoMockHeldBack, createSpyFromClassInstanceMethods, createSpyFromClassAccessors, createSpyFromClassReturns, createSpyFromClassLazySpies } from './chunk-3Q76UTT6.js';
+import { defaultStrict, resolveUnstubbedGuard, seedReturnValue, createFunctionSpy } from './chunk-72H6HNDI.js';
+import { runClearHook, runConfigReset, reportMisconfiguration, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-XNXIHKVM.js';
+import { autoMockHeldBack, createSpyFromClassInstanceMethods, createSpyFromClassAccessors, createSpyFromClassReturns, createSpyFromClassLazySpies } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { getMockAdapter, requireObservableSupport, getJasmineSupport } from './shared-state.js';
 

package/dist/{chunk-X74IM4MQ.js → chunk-YUGSITWJ.js}

@@ -1,4 +1,4 @@
-import { angularInternals } from './chunk-3Q76UTT6.js';
+import { angularInternals } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { VERSION } from '@angular/core';
 

package/dist/cli.js

@@ -3204,7 +3204,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.31.0";
+var EXPORT_MAP_VERSION = "5.32.1";
 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",
@@ -4730,6 +4730,9 @@ function isStampOnly(plan) {
 }
 var STAMP_ONLY_NOTE = "only the version stamp differs, which `--check` does not count; a plain `init` refreshes it";
 function statusOf(plan, check) {
+  if (plan.staleCopy === true) {
+    return "stale";
+  }
   if (plan.desired === void 0) {
     return "skipped";
   }
@@ -4755,9 +4758,14 @@ function collectTargets(profile, only) {
 function readTarget(cwd, target) {
   return pathExists(join(cwd, target.path)) ? readTextFile(join(cwd, target.path)) : void 0;
 }
+function isShippedSkillCopy(content) {
+  const frontmatter = /^---\r?\n([\S\s]*?)\r?\n---/.exec(content)?.[1] ?? "";
+  return /^name:\s*(["']?)vitest-auto-spy\1\s*$/m.test(frontmatter);
+}
+var STALE_COPY_NOTE = "a copy of the shipped skill that init did not write \u2014 frozen at the version it was copied from";
 function skillPlan(plan, version, frontmatter) {
   if (plan.desired === void 0 && plan.existing !== void 0) {
-    return plan;
+    return isShippedSkillCopy(plan.existing) ? { ...plan, staleCopy: true, note: STALE_COPY_NOTE } : plan;
   }
   if (frontmatter === void 0) {
     return { ...plan, desired: void 0, note: "the shipped skill could not be read \u2014 skipped" };
@@ -4824,7 +4832,7 @@ function budgetWarnings(plans) {
 }
 function untouchedWarnings(plans) {
   return plans.filter((plan) => plan.desired === void 0 && plan.existing !== void 0 && plan.target.kind === "owned").map(
-    (plan) => `${plan.target.path} exists and was not written by init \u2014 left untouched; fold it into the managed block by hand if you want init to own it.`
+    (plan) => plan.staleCopy === true ? `${plan.target.path} is a copy of the shipped vitest-auto-spy skill, not written by init, so no upgrade refreshes it \u2014 left untouched. Delete it and re-run \`npx vitest-auto-spy init\` to replace it with the managed pointer.` : `${plan.target.path} exists and was not written by init \u2014 left untouched; fold it into the managed block by hand if you want init to own it.`
   );
 }
 function unmatchedWarnings(only) {
@@ -4837,7 +4845,7 @@ function unmatchedWarnings(only) {
 function runInit(profile, version, options) {
   const plans = buildPlans(profile, version, options.only).map((plan) => options.uninstall ? uninstallPlan(plan) : plan);
   const actions = plans.map((plan) => applyPlan(profile.cwd, plan, options));
-  const pending = actions.some((action) => action.status === "created" || action.status === "updated");
+  const pending = actions.some((action) => action.status === "created" || action.status === "updated" || action.status === "stale");
   return {
     actions,
     warnings: [...unmatchedWarnings(options.only), ...options.uninstall ? [] : [...untouchedWarnings(plans), ...budgetWarnings(plans)]],
@@ -7267,10 +7275,16 @@ warning  ${warning}`);
   }
   if (!result.ok) {
     const stale = result.actions.filter((action) => action.status === "created" || action.status === "updated").map((action) => action.path);
-    io.err(
-      `
+    if (stale.length > 0) {
+      io.err(
+        `
 ${stale.join(", ")} ${stale.length === 1 ? "is" : "are"} out of date. Run \`npx vitest-auto-spy init\` to update ${stale.length === 1 ? "it" : "them"}.`
-    );
+      );
+    }
+    for (const action of result.actions.filter((candidate) => candidate.status === "stale")) {
+      io.err(`
+${action.path} is a stale copy of the shipped skill. Delete it, then run \`npx vitest-auto-spy init\`.`);
+    }
     return 1;
   }
   io.out(check ? "\nUp to date." : "\nDone. Re-run after upgrading the package; the block between the markers is regenerated.");

package/dist/console.js

@@ -1,13 +1,13 @@
-import { useVitestAdapter } from './chunk-ANQVIGAG.js';
-import './chunk-TH64BXPP.js';
+import { useVitestAdapter } from './chunk-6JLBZHQ3.js';
+import './chunk-JR55747M.js';
 import './chunk-YHDBRBGU.js';
-import './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-K3EUF6RK.js';
-import './chunk-D2R6EQJJ.js';
+import { createFunctionSpy } from './chunk-72H6HNDI.js';
+import './chunk-XNXIHKVM.js';
 import './chunk-M3NTXLZG.js';
-import './chunk-3Q76UTT6.js';
+import './chunk-JOPCMFYN.js';
 import './chunk-ENCEEH23.js';
 import { getMockAdapter } from './shared-state.js';
 

package/dist/eslint-plugin.cjs

@@ -181,6 +181,9 @@ function enclosingFunction(node) {
 
 // src/lib/eslint/bindings.ts
 var PACKAGE = "vitest-auto-spy";
+var CORE_ENTRIES = new Set(
+  ["", "/bun", "/bun-angular", "/node", "/rstest", "/react", "/vue", "/svelte"].map((entry) => `${PACKAGE}${entry}`)
+);
 var IMPORT_DEFINITION = "ImportBinding";
 function findBinding(scope, name) {
   for (let current = scope; current; current = current.upper) {
@@ -225,12 +228,16 @@ function insertImport(fixer, node, module, clause) {
   return fixer.insertTextBeforeRange([at, at], `import ${clause} from '${module}';
 `);
 }
+function coreEntryOf(node) {
+  return importsOf(node).map((declaration) => String(declaration.source.value)).find((module) => CORE_ENTRIES.has(module)) ?? PACKAGE;
+}
 function namedImportFrom(node, module) {
   const declarations = importsOf(node).filter((declaration) => declaration.source.value === module && declaration.importKind !== "type");
   const [only] = declarations;
   return declarations.length === 1 && only?.specifiers.every(isNamedImportSpecifier) === true ? only : void 0;
 }
-function importNamed(fixer, node, name, module) {
+function importNamed(fixer, node, name, requested) {
+  const module = requested === PACKAGE ? coreEntryOf(node) : requested;
   const specifiers = namedImportFrom(node, module)?.specifiers.filter(isNamedImportSpecifier) ?? [];
   const entries2 = specifiers.map((specifier) => ({
     specifier,
@@ -1746,7 +1753,7 @@ function asSpyFixes(context, fixer, node, value, spy) {
   const call = `asSpy${typeArguments ? sourceCode.getText(typeArguments) : ""}(${sourceCode.getText(value)})`;
   const edits = [fixer.replaceText(node, call)];
   if (bindingState(sourceCode.getScope(node), "asSpy") === "free") {
-    edits.push(insertImport(fixer, node, PACKAGE, "{ asSpy }"));
+    edits.push(importNamed(fixer, node, "asSpy", PACKAGE));
   }
   const orphaned = spy?.references.length === 1 ? dropNamedImport(sourceCode, fixer, spy) : void 0;
   if (orphaned) {
@@ -2084,6 +2091,7 @@ var preferObserverStub = defineRule({
 // src/lib/eslint/global-assignment.ts
 var NETWORK_GLOBALS = /* @__PURE__ */ new Set(["EventSource", "WebSocket", "XMLHttpRequest", "fetch"]);
 var WEB_STORAGES = /* @__PURE__ */ new Set(["localStorage", "sessionStorage"]);
+var WORKER_GLOBALS = /* @__PURE__ */ new Set(["Worker"]);
 var TEARDOWN_HOOKS = /* @__PURE__ */ new Set(["afterAll", "afterEach", "onTestFinished"]);
 var PER_TEST = /* @__PURE__ */ new Set(["beforeEach", "it", "test"]);
 function insideTeardown(node) {
@@ -2114,6 +2122,9 @@ function messageFor(name) {
   if (NETWORK_GLOBALS.has(name)) {
     return "networkGlobal";
   }
+  if (WORKER_GLOBALS.has(name)) {
+    return "workerGlobal";
+  }
   return WEB_STORAGES.has(name) ? "webStorage" : "handAssignedGlobal";
 }
 function globalFix(name) {
@@ -2192,6 +2203,7 @@ var noHandAssignedGlobal = defineRule({
   messages: {
     networkGlobal: "`{{name}}` is replaced by assignment and nothing puts the real one back, so under `isolate: false` the fake answers every later test in the worker. Install it with `{{fix}}`, which restores the original after the test.",
     webStorage: "`{{name}}` is replaced by assignment and nothing puts the real one back, so the fake storage, and whatever the test wrote into it, leaks into every later test. Use `stubWebStorage('{{name}}')` from `vitest-auto-spy/dom-stubs`, which is restored after every test.",
+    workerGlobal: "`{{name}}` is replaced by assignment and nothing puts the real one back, so under `isolate: false` every later test in the worker constructs the double. Use `stubWorker({ respond })` from `vitest-auto-spy/dom-stubs`, which is restored after every test.",
     handAssignedGlobal: "`{{name}}` is replaced by assignment and nothing puts the real one back, so under `isolate: false` the double stays installed for every later test in the worker. Install it with `{{fix}}`, which restores the original after the test.",
     importedMember: "`{{object}}.{{name}}` is written into an imported module, which stays cached for the worker, so the value answers later tests that never set it. Use `mockValueProp({{object}}, '{{name}}', value)`, which restores it after the test.",
     restoreInTest: "`{{name}}` is replaced and put back by hand outside a teardown hook, so the first failing assertion before the restore leaves the double installed for every later test. Use `mockValueProp(globalThis, '{{name}}', value)`, whose undo runs in a hook, or move the restore into `afterEach`."
@@ -3506,7 +3518,6 @@ var noPrivateMemberAccess = defineRule({
 });
 
 // src/lib/eslint/prop-helpers.ts
-var PACKAGE2 = "vitest-auto-spy";
 function helperFor(property) {
   const name = propertyName(property);
   if (name === "value") {
@@ -3542,7 +3553,7 @@ function propHelperSuggestion(context, node) {
     fix: (fixer) => {
       const edits = [fixer.replaceText(node, replacement)];
       if (state === "free") {
-        edits.push(insertImport(fixer, node, PACKAGE2, `{ ${rewrite2.helper} }`));
+        edits.push(importNamed(fixer, node, rewrite2.helper, PACKAGE));
       }
       return edits;
     }
@@ -4551,9 +4562,6 @@ var noRedundantSmokeTest = defineRule({
 var FACTORY = "createSpyFromInstance";
 var OWN = "spyOnOwnMethod";
 var VOID = "spyOnVoidMethod";
-var CORE_ENTRIES = new Set(
-  ["", "/bun", "/bun-angular", "/node", "/rstest", "/react", "/vue", "/svelte"].map((entry) => `${PACKAGE}${entry}`)
-);
 var METHOD_NAME = /^[$A-Z_a-z][\w$]*$/;
 var EVENT_CONSTRUCTOR = /^[A-Za-z]*Event$/;
 var DOM_GLOBALS = /* @__PURE__ */ new Set(["document", "window"]);

package/dist/jasmine-compat.js

@@ -1,3 +1,3 @@
-export { enableJasmineCompat } from './chunk-E46PPK33.js';
-import './chunk-3Q76UTT6.js';
+export { enableJasmineCompat } from './chunk-LAPHUX5G.js';
+import './chunk-JOPCMFYN.js';
 import './chunk-ENCEEH23.js';

package/dist/jasmine.js

@@ -1,16 +1,16 @@
-import { enableJasmineCompat } from './chunk-E46PPK33.js';
-export { enableJasmineCompat } from './chunk-E46PPK33.js';
-import { createSpyFromClass } from './chunk-25OHJOAA.js';
-import { useVitestAdapter } from './chunk-ANQVIGAG.js';
-import './chunk-TH64BXPP.js';
+import { enableJasmineCompat } from './chunk-LAPHUX5G.js';
+export { enableJasmineCompat } from './chunk-LAPHUX5G.js';
+import { createSpyFromClass } from './chunk-YDPOBKST.js';
+import { useVitestAdapter } from './chunk-6JLBZHQ3.js';
+import './chunk-JR55747M.js';
 import './chunk-YHDBRBGU.js';
-import './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-K3EUF6RK.js';
-import { reportMisconfiguration, misconfigurationThrows } from './chunk-D2R6EQJJ.js';
+import { createFunctionSpy } from './chunk-72H6HNDI.js';
+import { reportMisconfiguration, misconfigurationThrows } from './chunk-XNXIHKVM.js';
 import './chunk-M3NTXLZG.js';
-import { jasmineGlobals, jasmineClock, jasmineAutoSpies, jasmineTimeout } from './chunk-3Q76UTT6.js';
+import { jasmineGlobals, jasmineClock, jasmineAutoSpies, jasmineTimeout } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { expect, vi } from 'vitest';
 import { getMockAdapter } from './shared-state.js';

package/dist/nestjs.js

@@ -1,16 +1,16 @@
-import { createSpyForToken } from './chunk-4IRFL76M.js';
-export { trackInjections } from './chunk-4IRFL76M.js';
-import { createSpyFromClass } from './chunk-25OHJOAA.js';
-import { useVitestAdapter } from './chunk-ANQVIGAG.js';
-import './chunk-TH64BXPP.js';
+import { createSpyForToken } from './chunk-7WM3A4IB.js';
+export { trackInjections } from './chunk-7WM3A4IB.js';
+import { createSpyFromClass } from './chunk-YDPOBKST.js';
+import { useVitestAdapter } from './chunk-6JLBZHQ3.js';
+import './chunk-JR55747M.js';
 import './chunk-YHDBRBGU.js';
-import './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-K3EUF6RK.js';
-import './chunk-D2R6EQJJ.js';
+import './chunk-72H6HNDI.js';
+import './chunk-XNXIHKVM.js';
 import './chunk-M3NTXLZG.js';
-import { nestUnitRefusals } from './chunk-3Q76UTT6.js';
+import { nestUnitRefusals } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/nestjs.ts

package/dist/rstest.js

@@ -1,15 +1,15 @@
-export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-NTCEH2FY.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-KCMPDMLY.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-25OHJOAA.js';
+export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectAllEmissions, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './chunk-TMFV4DXT.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-6JQ7AFWM.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-YDPOBKST.js';
 import './chunk-W5EXSI22.js';
-import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-TH64BXPP.js';
-import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-LWSUV6IX.js';
-import './chunk-EDEGKIIR.js';
+import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-JR55747M.js';
+import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-2QEM4WP7.js';
+import './chunk-CLQUJX6E.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-K3EUF6RK.js';
-import './chunk-D2R6EQJJ.js';
+export { createFunctionSpy, errorHandler } from './chunk-72H6HNDI.js';
+import './chunk-XNXIHKVM.js';
 import './chunk-M3NTXLZG.js';
-import './chunk-3Q76UTT6.js';
+import './chunk-JOPCMFYN.js';
 import './chunk-ENCEEH23.js';
 import { rstest } from '@rstest/core';
 import { registerMockAdapter } from './shared-state.js';

package/dist/rxjs.js

@@ -1,6 +1,6 @@
 import { REPLAY_BUFFER_SIZE } from './chunk-YHDBRBGU.js';
-import { decorate, attachHelpers, misconfigurationThrows, reportMisconfiguration, hooksOf, detachedHelperError } from './chunk-D2R6EQJJ.js';
-import { nextWithValuesLate } from './chunk-3Q76UTT6.js';
+import { decorate, attachHelpers, misconfigurationThrows, reportMisconfiguration, hooksOf, detachedHelperError } from './chunk-XNXIHKVM.js';
+import { nextWithValuesLate } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { defer, ReplaySubject, from, concatMap, of, delay, takeWhile, timer, switchMap, throwError, EMPTY, merge, takeUntil, take } from 'rxjs';
 import { registerObservableSupport } from './shared-state.js';

package/dist/signal-forms.js

@@ -1,4 +1,4 @@
-import { signalFormsErrors, signalFormsCreate } from './chunk-3Q76UTT6.js';
+import { signalFormsErrors, signalFormsCreate } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { Injector, isSignal, signal, ɵSIGNAL as _SIGNAL } from '@angular/core';
 import { TestBed } from '@angular/core/testing';

package/dist/{track-signal-runs-pFMHNAPy.d.ts → track-signal-runs-BVbIBVS7.d.ts}

@@ -201,19 +201,6 @@ interface AutoSpiedInstance<T> {
  */
 declare function createWithAutoSpies<T>(target: Type<T>, options?: CreateWithAutoSpiesOptions): AutoSpiedInstance<T>;
 
-/**
- * `hostElement` / `queryElement` — a typed element out of a fixture, without a cast.
- *
- * Angular types `ComponentFixture.nativeElement` and `DebugElement.nativeElement` as `any`. Under
- * `@typescript-eslint/strict-type-checked` every read of it is a `no-unsafe-*` report, and the one
- * way to type it — `fixture.nativeElement as HTMLElement` — is exactly what
- * `consistent-type-assertions: 'never'` forbids. A suite that turns both on has no clean route to
- * its own DOM.
- *
- * These two check the element at run time with `instanceof` and return it typed, so the narrowing
- * is a fact rather than a claim: a selector that matches nothing, or matches an element of another
- * kind, fails at the call that asked, with the selector and what it found in the message.
- */
 /** A `ComponentFixture` or a `DebugElement` — the only member read is `nativeElement`. */
 interface NativeElementHolder {
     readonly nativeElement: unknown;
@@ -230,7 +217,7 @@ type ElementConstructor<E extends Element> = abstract new (...args: never[]) =>
  *
  * @param source A `ComponentFixture` or a `DebugElement`.
  * @param type The element type to check against and return; `HTMLElement` when omitted.
- * @throws TypeError when `nativeElement` is not an element, or not an instance of `type`.
+ * @throws TypeError when `source` is null, `nativeElement` is not an element, or it is not an instance of `type`.
  */
 declare function hostElement(source: NativeElementHolder): HTMLElement;
 declare function hostElement<E extends Element>(source: NativeElementHolder, type: ElementConstructor<E>): E;

package/dist/zone.js

@@ -1,4 +1,4 @@
-import { zoneRequirements } from './chunk-3Q76UTT6.js';
+import { zoneRequirements } from './chunk-JOPCMFYN.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/proxy-zone.ts

package/package.json

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

@@ -146,6 +146,9 @@ would have broken is reported as `codemod-broke-syntax` and left byte for byte a
 specs are visited too. An unknown flag for a known command, and a path matching no file, are errors
 with **exit 2** and nothing runs — `init --dryrun` used to write the files.
 
+`init` lists a hand-made copy of this skill in `.claude/skills/vitest-auto-spy/` as `stale` and
+`init --check` exits 1 on it: delete the copy and re-run `init`, which writes the managed pointer.
+
 ## Skeleton — anything else
 
 ```ts
@@ -280,6 +283,8 @@ it('loads', async () => {
 | "did the migration lose a test?" with matching counters                                             | `compareTestRuns(before, after)` — `counts` reports `name (×2 → ×1)`                                                                                                                              |
 | an input that has to change after the first render                                                  | `await setInputs(fixture, { … })` — aliases and `hostDirectives` inputs resolve, unknown names refused                                                                                            |
 | `fixture.nativeElement as HTMLElement`, or `no-unsafe-*` on `nativeElement` under a strict lint     | `hostElement(fixture)` / `queryElement(fixture, '.close', HTMLButtonElement)` — typed and `instanceof`-checked; a miss throws naming the selector                                                 |
+| `host.querySelector('.title')?.textContent.trim()` after `hostElement`                              | `queryElement(fixture, '.title').textContent.trim()` — a miss throws instead of passing as `undefined`; for absence keep `expect(host.querySelector('.x')).toBeNull()`                            |
+| `Cannot read properties of null (reading 'nativeElement')` on a `debugElement.query(…)`             | the query matched nothing — `hostElement` / `queryElement` now throw saying so; fix the predicate                                                                                                 |
 | `CalledExactlyOnceWith()` failing `[] vs [undefined]` on an `output<void>()` listener               | the listener gets `undefined` — `await expect(expectEmission(cmp.closed)).resolves.toBeUndefined()`, or `subscribeSpyTo(subject$)`                                                                |
 | `replaced the dispatch … after calledWith()` right after `mockReset()`                              | `mockReset()` keeps the chain — `resetAutoSpy(spy.method)`, then `mockReturnValue(…)`                                                                                                             |
 | `injectMatDialogRef(MatDialogRef<C, R>)` comes back `any` (`no-unsafe-assignment`)                  | `injectMatDialogRef<MatDialogRef<C, R>>(MatDialogRef)` — the instantiation expression is read off Material's `any` prototype                                                                      |
@@ -534,7 +539,7 @@ from `vitest-auto-spy/angular-router` rather than at `provideAutoSpy`.
 
 **`no-unasserted-argument` reports a bare `expect(spy).toHaveBeenCalled()` where the file itself says the arguments are the point** — either the same subject is pinned with `toHaveBeenCalledWith(…)` in another test of the file, or the test's title says `with` and its body asserts nothing but bare calls. Narrower than `vitest/prefer-called-with` on purpose: on one 2032-file suite that reports 1941 times in 360 files and this one 175 in 90. `not.toHaveBeenCalled()` and the counting matchers are never reported. `warn` rather than `error`, because the repair is the argument list the test should have named — `toHaveBeenCalledWith(…)`, `toHaveBeenCalledExactlyOnceWith(…)`, or `mustBeCalledWith(…)` where the double is configured — and that is the one thing the rule cannot write.
 
-**`no-hand-assigned-global` reports a double assigned straight to a global** — `global.fetch = vi.fn(…)`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }` — unless the file puts it back in `afterEach` / `afterAll` / `onTestFinished`. Replace the assignment with `mockValueProp(globalThis, 'fetch', vi.fn(…))` (undone by `restoreMockedProps()`, which `setupAutoSpy()` runs), use `blockNetwork()` when the spec only has to stay offline, and `stubWebStorage('localStorage')` for the storages. Do not "fix" it by adding a restore as the last line of the `it`: that form is reported too, because a red assertion skips it. The same rule reports any value written into an imported object — `environment.production = true` — and `--fix` rewrites it to `mockValueProp(environment, 'production', true)` inside a test or `beforeEach`.
+**`no-hand-assigned-global` reports a double assigned straight to a global** — `global.fetch = vi.fn(…)`, `window.matchMedia = vi.fn()`, `window.localStorage = { getItem: vi.fn() }` — unless the file puts it back in `afterEach` / `afterAll` / `onTestFinished`. Replace the assignment with `mockValueProp(globalThis, 'fetch', vi.fn(…))` (undone by `restoreMockedProps()`, which `setupAutoSpy()` runs), use `blockNetwork()` when the spec only has to stay offline, `stubWebStorage('localStorage')` for the storages, and `stubWorker({ respond })` for `globalThis.Worker`. Do not "fix" it by adding a restore as the last line of the `it`: that form is reported too, because a red assertion skips it. The same rule reports any value written into an imported object — `environment.production = true` — and `--fix` rewrites it to `mockValueProp(environment, 'production', true)` inside a test or `beforeEach`.
 
 **`registerAutoSpyDefaults(Class, config)` puts a spy's composition with the class, once.** Call it
 from the setup file for a class every suite doubles the same way (`Router` with