vitest-auto-spy 5.29.0 → 5.31.0

package/AGENTS.md

@@ -216,7 +216,10 @@ the test must not touch the real one.
 verbose for the most common thing it says — _observe one method of the object under test and let it
 run_ — so the helper says exactly that and hands back the single spy. It is also the drop-in for a
 bare `vi.spyOn(component, 'method')` where a preset's `no-restricted-properties` bans `vi.spyOn`:
-same default semantics, record and call through, and `restoreSpiedInstance` puts it back.
+same default semantics, record and call through, and `restoreSpiedInstance` puts it back. It is a
+core export — `import { spyOnOwnMethod } from 'vitest-auto-spy'`, or the runner entry on
+`bun test` / `node --test` — while `vitest-auto-spy/angular` and `vitest-auto-spy/nestjs` have no
+core re-export, so those suites import it from the root; `spyOnVoidMethod` below is the same.
 
 **Do not `createSpyFromInstance` a DOM node that must keep living a DOM life.** Discovery walks the
 node's prototype chain, and past the component's own class that chain is the engine's: happy-dom's
@@ -1508,15 +1511,24 @@ setupAutoSpy({ strayTimers: true }); // wrap the schedulers, sweep the survivors
 
 The pieces are exported too — `trackStrayTimers()` (idempotent, returns the undo),
 `cancelStrayTimers()` (returns how many it cancelled), `countStrayTimers()` and
-`describeStrayTimers()` (each pending timer's kind, the spec file that scheduled it and up to five
-frames), all from `vitest-auto-spy/setup`. Use `expect(countStrayTimers()).toBe(0)` in an `afterEach`
-to make a leak fail rather than be tidied away, or take the per-file report from the sweep itself —
-`timers` carries the same origins, so the failure diff names the file and the scheduling call:
+`describeStrayTimers()` (each pending timer's `kind`, the `delay` of a timeout or interval, the spec
+`file` that scheduled it and up to five `frames`), all from `vitest-auto-spy/setup`. Use
+`expect(countStrayTimers()).toBe(0)` in an `afterEach` to make a leak fail rather than be tidied
+away, or take the per-file report from the sweep itself — `timers` carries the same origins, so the
+failure diff names the file and the scheduling call:
 
 ```ts
 setupAutoSpy({ strayTimers: true, onStrayTimers: ({ timers }) => expect(timers).toEqual([]) });
 ```
 
+`frames` starts below the tracking wrapper and is up to forty frames deep, so a zone or an rxjs
+scheduler in between does not hide the caller: project frames come first; when the call came from
+dependencies only, their frames stand in. The package's own frames are never quoted, from source or
+from `dist`. `onStrayTimers: 'throw'` fails the file with a message that lists every stray as
+`timeout (300 ms) from <file> <frames[0]>`; a handler that prints its own message should print the
+same `kind`, `delay`, `file` and `frames[0]` — they are what makes a report that only reproduces
+under a slow coverage run actionable the first time.
+
 A stray whose `file` is not the file that failed was scheduled after the previous file's sweep —
 the previous file is the one to fix.
 
@@ -1651,7 +1663,13 @@ initialisation — and the `afterAll` takes off everything added since. The piec
 `removeStrayListeners()` (returns how many), `countStrayListeners()` (throws before
 `trackStrayListeners()` has run, like the timer counter) and `describeStrayListeners()` — each
 stray's target, type, spec file and up to five frames, the list `onStrayListeners({ removed, listeners })`
-receives when a file should fail instead: `onStrayListeners: ({ removed }) => expect(removed).toBe(0)`.
+receives when a file should fail instead: `onStrayListeners: ({ removed }) => expect(removed).toBe(0)`,
+or `onStrayListeners: 'throw'`, whose message lists each as `keydown on document from <file> <frames[0]>`.
+A listener has `type` and `target` where a timer has `kind` and `delay` — a handler that prints its own
+message prints those four fields instead.
+With `strayTimers` on too, both reports run after both sweeps and both run even if the first throws —
+a handler or `'throw'` alike; two failures surface as one `AggregateError`, so a throwing report never
+leaves a timer uncancelled.
 Under jsdom a listener registered with `{ once: true }` that already fired stays counted until
 something removes it: the wrapper cannot observe the firing without breaking identity-based
 `removeEventListener` from the code under test, and removing an already-fired listener is a no-op
@@ -2160,8 +2178,8 @@ an unconfigured call returns — a semantic switch, not a grade; the name was ta
 `unconfiguredReads`, its read side (survey with `onUnstubbedRead` before turning it on),
 `blockNetwork` (changes the code under test), `restoreMocks` (drops `beforeAll` spies), failing on
 stray-timer counts (the sweep fails the file from `afterAll`, and a callback scheduled after the
-previous file's sweep is charged to the next — opt in with
-`onStrayTimers: ({ timers }) => expect(timers).toEqual([])`, whose diff names each one's file), and
+previous file's sweep is charged to the next — opt in with `onStrayTimers: 'throw'`, whose message
+names each one's file, or `onStrayTimers: ({ timers }) => expect(timers).toEqual([])`), and
 `enableAngularDiagnostics()`, which lives in `/angular/diagnostics` — call it in the same setup file as the Angular half of strict.
 
 `misconfiguration: 'throw'` on its own makes the library's misuse reports — an `onlyMethodsToSpyOn`
@@ -3883,6 +3901,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-unregistered-inject-spy`      | `error` | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `prefer-render-shallow`           | `warn`  | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `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` | —                 | 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`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
@@ -3910,14 +3929,14 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
-Forty-eight rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+Forty-nine rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `prefer-create-mock`, `no-instance-lifecycle-spy`,
-`prefer-set-inputs` and `no-unasserted-argument`**; five fix on their own, eighteen offer suggestions. Forty-five are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
+`prefer-set-inputs`, `no-unasserted-argument` and `prefer-spy-on-own-method`**; six fix on their own, nineteen offer suggestions. Forty-six are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
 `no-unknown-use-value-key` read types, and all three 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. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. The
-seven `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
+eight `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
 about the _kind_ of finding: every other rule names something wrong or dead, while this one names a
 file that could render more cheaply, and `renderShallow` is a migration a suite either takes or does
 not. At `error` the plugin would gate that migration — 491 findings across 398 of one consumer's
@@ -3940,7 +3959,8 @@ repair _needs_ rather than on its evidence: both of its readings are facts out o
 subject some other test in the same file pins with `toHaveBeenCalledWith`, a title saying `with` over
 a body whose every assertion is a bare call — but the repair is the argument list the test should
 have named, which is the one thing the rule cannot supply. Every `error` here names an edit or names
-a helper; this one names a question for the author. Set any of the seven `warn`s to `'error'` once the batch is done. Three of
+a helper; this one names a question for the author. `prefer-spy-on-own-method` names a shorter spelling of a correct call — the
+`createSpyFromInstance` it reports does exactly what the helper does — and its exact shapes carry a fix. Set any of the eight `warn`s to `'error'` once the batch is done. Three of
 them can report on a _correct_ project, and only one has an option:
 `jasmine-namespace-without-entry` takes `['error', { setupModules: ['./test-setup'] }]`, naming the
 file where `enableJasmineCompat()` is called; `prefer-native-spy-api` goes `'off'` for as long as a

package/CHANGELOG.md

@@ -10,6 +10,90 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.31.0] - 2026-09-25
+
+### Added
+
+- **`onStrayTimers: 'throw'` and `onStrayListeners: 'throw'` fail the file with every stray named.**
+  Failing a file on a stray took a handler, and a handler that printed its own message had to rebuild
+  the line the `--detect-async-leaks` warning already prints. `'throw'` fails the file from the same
+  `afterAll` a handler runs in, with one line per stray — `timeout (300 ms) from <file> <frames[0]>`
+  for a timer, `keydown on document from <file> <frames[0]>` for a listener — every one, not the
+  warning's first three. The sweep still cancels and removes first; the preset is unchanged. The option
+  type widens from a handler to a handler or `'throw'`. With both set to `'throw'`, a file that leaks
+  a timer and a listener fails with both errors in one `AggregateError`, the timer already cancelled.
+
+### Fixed
+
+- **A throwing `onStrayListeners` no longer leaves the file's stray timers running.** The timer
+  sweep was its own `afterAll`, and Vitest skips the remaining `afterAll` hooks once one throws: with
+  `strayTimers` and `strayListeners` both on, a failing listener report hid the timer report and left
+  the timer uncancelled, free to fire in the next file on the worker under `isolate: false`. The timer
+  sweep now runs in the file-boundary hook, after the other repairs and before any handler; every
+  handler runs, and two failures are thrown together as an `AggregateError`. A single failure is
+  thrown as it was, and non-throwing handlers behave as before.
+- **`calledWith(new URL(a))` no longer answers a call made with `new URL(b)`.** A URL keeps its state
+  in internal slots, so the argument key rendered every one as `URL{}` and any two URLs matched each
+  other — `mustBeCalledWith` included, which then let the wrong URL through instead of throwing.
+  `toHaveBeenCalledWith` compares them by `href`, and so do `calledWith` and `mustBeCalledWith` now,
+  on the key path and beside an asymmetric matcher alike. A mismatch message prints the URL instead
+  of `URL{}`.
+
+### Docs
+
+- **A custom `onStrayListeners` handler is told which fields to print.** The advice to print `kind`,
+  `delay` and `frames[0]` sat next to the timer handler only, and a listener has neither `kind` nor
+  `delay`: the listener section now names `type`, `target`, `file` and `frames[0]`.
+- **The Russian API table lists the `delay` `describeStrayTimers()` returns**, as the English one does.
+- **"Which of the forty-nine apply to you" counts forty-five core rules, not forty-four.** 5.30.0 added
+  `prefer-spy-on-own-method` and bumped every total to forty-nine but this one, so core and jasmine
+  rules added up to forty-eight.
+
+## [5.30.0] - 2026-09-25
+
+### Added
+
+- **`prefer-spy-on-own-method`, in `recommended` at `warn`.** It finds the long spelling of the two
+  5.29 helpers, which a text search misses once the call spans several lines:
+  `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` — is
+  `spyOnOwnMethod(x, 'm')`, and the same whitelist with `returns: { m: undefined }` is
+  `spyOnVoidMethod(x, 'm')`. Both are exact, so `--fix` rewrites the call and every `v.m` read, imports
+  the helper beside the factory and drops the factory's import once nothing else uses it. A
+  `Spy<X>` annotation becomes `Spy<X>['m']` in a suggestion. A bare `returns: { m: undefined }` seed,
+  whose discovery also spies every other method, is offered as a suggestion only on a real event or
+  element (`new MouseEvent(…)`, `document.createElement(…)`, `fixture.nativeElement`, one name away
+  included), never on a double. `warn`, because the call it reports is correct. `/eslint-plugin`
+  grows 51.61 → 53.56 kB min+gzip (+1.96 kB, +3.8 %), all of it this rule: the fixer that follows
+  every `v.m` read, rewrites imports and the `Spy<X>` annotation. The plugin runs in the linter, never
+  in a test, and no runtime entry imports it.
+
+### Fixed
+
+- **A stray timer's origin names the code that scheduled it, not the tracking wrapper.** Built from
+  `dist`, the report quoted `at captureOrigin (…/node_modules/vitest-auto-spy/dist/setup.js)`: the
+  filter for the wrapper's own frames matched the source file name, which the bundle does not have,
+  and twelve frames ran out inside a zone or an rxjs scheduler before the first line outside
+  dependencies, so the fallback quoted the wrapper. The stack is now cut at the installed
+  `setTimeout` / `setInterval` / `requestAnimationFrame` wrapper and taken forty frames deep below it;
+  the package's own frames are never quoted, and when the call came from dependencies only, their
+  frames stand in. The same `dist` filter now applies to stray listeners, console calls and
+  rejections. A flaky stray that shows up only under a slow coverage run is now actionable from the
+  first report.
+- **`StrayTimer` carries the `delay`, and the `--detect-async-leaks` warning prints it.** Each
+  timeout and interval in `describeStrayTimers()` and in `onStrayTimers`' `timers` now has the delay
+  it was scheduled with (a frame has none), and the warning reads `timeout (300 ms) from …` instead
+  of `timeout from …`. An additive field; a handler that prints its own message should print `kind`,
+  `delay` and `frames[0]`.
+
+### Docs
+
+- **`AGENTS.md` says which entry `spyOnOwnMethod` and `spyOnVoidMethod` come from.** The §2
+  introduction sat in Angular-flavoured company, and `vitest-auto-spy/angular` has no core
+  re-export — an Angular-suite reader importing the helper there hit a missing export. The
+  paragraph now names the core entry (root, or the runner entry off Vitest), as the docs-site
+  page already does.
+
 ## [5.29.0] - 2026-09-24
 
 ### Added
@@ -7845,7 +7929,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.29.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.31.0...HEAD
+[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
 [5.29.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.28.0...v5.29.0
 [5.28.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.27.0...v5.28.0
 [5.27.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.26.0...v5.27.0

package/README.md

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-23.2%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-23.3%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -81,7 +81,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored; `moduleNamespace(await importOriginal(), { passthrough: true })` is Vitest's `{ spy: true }` with `calledWith` on top, on any runner
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`, and `outOfType()` for the fixture that is outside its type on purpose
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — forty-eight rules in `vitest-auto-spy/eslint-plugin` (five `--fix`, eighteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
+- 📏 Lint rules and one-line test-run hygiene — forty-nine rules in `vitest-auto-spy/eslint-plugin` (six `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
 - 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-and-init) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
@@ -3206,7 +3206,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `guardGlobalPatches(reaction)`                                                                              | `/setup`                      | Name the test that redefined a property of `document` / `navigator` / `globalThis` as non-configurable                                                                                                                                                                                                                                                  |
 | `guardStrayConsole(reaction)`                                                                               | `/setup`                      | Fail a test that wrote to the console without absorbing it, and a file that wrote outside any test ([details](#test-run-hygiene))                                                                                                                                                                                                                       |
 | `withoutStrayTimerTracking(work)`                                                                           | `/setup`                      | Run setup work whose timers the stray-timer tracker neither counts nor cancels — jsdom schedules one per Web Storage write                                                                                                                                                                                                                              |
-| `describeStrayTimers()`                                                                                     | `/setup`                      | Every timer still pending, with its kind, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets. Blind to anything scheduled under fake timers — `vi.useFakeTimers()` assigns over the wrapper                                                                                                                      |
+| `describeStrayTimers()`                                                                                     | `/setup`                      | Every timer still pending, with its kind and delay, the spec file that scheduled it and the scheduling frames — the list `onStrayTimers` gets. Blind to anything scheduled under fake timers — `vi.useFakeTimers()` assigns over the wrapper                                                                                                            |
 | `guardPrototypePollution(reaction)`                                                                         | `/setup`                      | Name the test that left a key on `Object.prototype` — it stops later files collecting ([details](#test-run-hygiene))                                                                                                                                                                                                                                    |
 | `guardDocumentPollution(option)`                                                                            | `/setup`                      | Name the test that left an attribute on `<html>` / `<body>`, and put it back ([details](#test-run-hygiene))                                                                                                                                                                                                                                             |
 | `installPerTest(install)`                                                                                   | `/setup`                      | Re-install a stub before every test of the block — a `describe`-level stub is restored away after the first                                                                                                                                                                                                                                             |
@@ -3587,7 +3587,7 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
 | `propsOutsideHooks`   | `'warn'`  | Name a `mock*Prop` patch made in a `describe` body or `beforeAll` — it survives one test; `'throw'`, `'off'`. `reportPropsOutsideHooks(reaction)` sets the same dial without the setup helper       |
 | `restoreMocks`        | `false`   | `vi.restoreAllMocks()` in a global `afterEach` — turn on for `isolate: false`                                                                                                                       |
 | `strayTimers`         | `false`   | Cancel timeouts, intervals and frames that outlive their file — does not compose with `globalFakeTimers`, which hands out timers the tracking never sees                                            |
-| `onStrayTimers`       | —         | Takes the per-file count and each stray's origin (file, frames) — see `--detect-async-leaks`                                                                                                        |
+| `onStrayTimers`       | —         | Takes the per-file count and each stray's origin (file, frames) — see `--detect-async-leaks`; `'throw'` fails the file with every stray listed                                                      |
 | `strayRejections`     | `false`   | Fail the test a rejection zone.js swallowed surfaced in — needs zone.js                                                                                                                             |
 | `blockNetwork`        | `false`   | Close every network channel the environment has — `true`, or a narrowing object                                                                                                                     |
 | `guardGlobals`        | `'off'`   | Report a test that **adds** a non-configurable property to `globalThis`, `document`, `navigator`, `location`, `screen` or the DOM prototypes; an existing name redefined in place is its blind spot |
@@ -3790,7 +3790,7 @@ export default [
 ];
 ```
 
-One of the four exceptions is `prefer-render-shallow`, which ships as a **`warn`**, and its reason is the kind
+One of the exceptions is `prefer-render-shallow`, which ships as a **`warn`**, and its reason is the kind
 of thing it says rather than how much it matters. Every other rule here names something wrong or dead
 — a double that drifts from its class, an assertion that never runs, a provider the container already
 dropped, a schema guarding nothing. That one names a file that could render more cheaply, which is a
@@ -3800,6 +3800,10 @@ it was measured against the rule reports 491 times across 398 files — a first
 have to answer with a project-wide `warn` of its own. A project that has decided to make the move sets
 it to `'error'` in the same one line that turns the others down.
 
+`prefer-spy-on-own-method` is graded on the same reading. The `createSpyFromInstance` call it reports is
+correct and does exactly what `spyOnOwnMethod` / `spyOnVoidMethod` does: the rule names a shorter
+spelling, not a defect, and its exact shapes carry a fix, so `'error'` is one `eslint --fix` away.
+
 The other two, `no-stub-class-double` and `no-structural-double` (5.5.0), are graded on the
 _evidence_ rather than on the kind of finding. Both report the same drift
 `prefer-create-spy-from-class` reports at `error` — a double whose shape was written by hand and is
@@ -3862,6 +3866,7 @@ export can never be.
 | `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `prefer-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer 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 `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `no-hand-assigned-global`         |   `error`   | —                 | `global.fetch = vi.fn(…)` and any other double assigned to a global with no restore in a teardown hook → `mockValueProp(globalThis, …)` / `vi.stubGlobal` + `unstubGlobals`, `blockNetwork()` for a spec that only stays offline, `stubWebStorage()` for the storages                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `prefer-stub-response`            |   `error`   | —                 | an object literal cast to `Response` (`as Response`, `as unknown as Response`, `<Response>{ … }`) or a `createMock<Response>(…)` / `createAutoMock<Response>(…)` call → `stubResponse({ body })` from `/setup`, which builds the platform's own and answers every member; `Response` has to resolve to the global, so an Express handler's or a generated client's envelope of the same name is left alone                                                                                                                                                                                                                                                                                                                                                                                    |
@@ -3893,7 +3898,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Five of the forty-eight fix on their own, eighteen offer suggestions**, and the split is not about how hard
+**Six of the forty-nine fix on their own, nineteen offer suggestions**, and the split is not about how hard
 the rewrite is. `no-mocked-for-spy` touches a _declaration_: get it wrong and the file stops
 compiling, which is the loudest, cheapest failure there is — so `--fix` rewrites the type, adds
 `import type { Spy } from 'vitest-auto-spy'` and drops the `Mocked` import once nothing else uses
@@ -4064,7 +4069,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the forty-eight rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the forty-nine rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -4081,7 +4086,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of forty-eight rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of forty-nine rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 

package/dist/angular-diagnostics.js

@@ -1,12 +1,12 @@
 import { assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-ROSQKG22.js';
 export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-ROSQKG22.js';
-import { failOnUnspiedProvider } from './chunk-34S5ZMWU.js';
+import { failOnUnspiedProvider } from './chunk-2O3N4OPX.js';
 import './chunk-FZMWANZV.js';
-import './chunk-73FGLUVI.js';
-import './chunk-6FIKN2RJ.js';
+import './chunk-TBT4J2AX.js';
+import './chunk-VSWA6PQW.js';
 import './chunk-YZSBSAYZ.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-V4XBUP4D.js';
+import './chunk-64KOOW3H.js';
 import { isAutoSpyLike } from './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/angular-doubles.js

@@ -1,10 +1,10 @@
-import { useVitestAdapter } from './chunk-2ISMAFNN.js';
-import './chunk-R7DIFC2L.js';
+import { useVitestAdapter } from './chunk-NFFBGS7E.js';
+import './chunk-5FM2TZKG.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-L6VPMLRJ.js';
 import './chunk-YZSBSAYZ.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-V4XBUP4D.js';
+import { createFunctionSpy } from './chunk-64KOOW3H.js';
 import './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/angular-router.js

@@ -1,5 +1,5 @@
 import { angularInternalsError } from './chunk-FZMWANZV.js';
-import { createFunctionSpy } from './chunk-V4XBUP4D.js';
+import { createFunctionSpy } from './chunk-64KOOW3H.js';
 import './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/angular.js

@@ -852,6 +852,9 @@ function serializeShape(value, context) {
   if (value instanceof RegExp) {
     return String(value);
   }
+  if (value instanceof URL) {
+    return `new URL(${quoteString(value.href)})`;
+  }
   if (value instanceof Error) {
     return serializeError(value, context);
   }
@@ -1012,6 +1015,9 @@ function sameSpecialObject(expected, actual, path, matchers) {
   if (expected instanceof RegExp || actual instanceof RegExp) {
     return expected instanceof RegExp && actual instanceof RegExp && String(expected) === String(actual);
   }
+  if (expected instanceof URL || actual instanceof URL) {
+    return expected instanceof URL && actual instanceof URL && expected.href === actual.href;
+  }
   if (expected instanceof Error || actual instanceof Error) {
     return expected instanceof Error && actual instanceof Error && expected.name === actual.name && expected.message === actual.message && sameEntries(expected, actual, path, matchers);
   }

package/dist/bun-angular.js

@@ -1,19 +1,19 @@
-import { createSpyForToken } from './chunk-IOBBADJP.js';
-export { injectSpy, provideAutoSpy } from './chunk-34S5ZMWU.js';
+import { createSpyForToken } from './chunk-33JL4DF3.js';
+export { injectSpy, provideAutoSpy } from './chunk-2O3N4OPX.js';
 import { stable, flushEffects } from './chunk-V76LFJW4.js';
 export { flushEffects, stable } from './chunk-V76LFJW4.js';
 import { angularInternalsError } from './chunk-FZMWANZV.js';
 import './chunk-6RP37RWX.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-CYS3E4TA.js';
-import { mockValueProp } from './chunk-73FGLUVI.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-73FGLUVI.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-6FIKN2RJ.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-F4SLC724.js';
+import { mockValueProp } from './chunk-TBT4J2AX.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-TBT4J2AX.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-VSWA6PQW.js';
 import './chunk-SOROJD3W.js';
 import './chunk-L6VPMLRJ.js';
 import './chunk-YZSBSAYZ.js';
 import './chunk-PC3FAZT3.js';
-import { libraryWarn } from './chunk-V4XBUP4D.js';
-export { createFunctionSpy, errorHandler } from './chunk-V4XBUP4D.js';
+import { libraryWarn } from './chunk-64KOOW3H.js';
+export { createFunctionSpy, errorHandler } from './chunk-64KOOW3H.js';
 import './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/bun.js

@@ -1,12 +1,12 @@
 import './chunk-6RP37RWX.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-CYS3E4TA.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-73FGLUVI.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-6FIKN2RJ.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-F4SLC724.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-TBT4J2AX.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-VSWA6PQW.js';
 import './chunk-SOROJD3W.js';
 import './chunk-L6VPMLRJ.js';
 import './chunk-YZSBSAYZ.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-V4XBUP4D.js';
+export { createFunctionSpy, errorHandler } from './chunk-64KOOW3H.js';
 import './chunk-7TGT2436.js';
 import './chunk-2XXGISYD.js';
 import './chunk-TZ7DRSRD.js';

package/dist/{chunk-34S5ZMWU.js → chunk-2O3N4OPX.js}

@@ -1,6 +1,6 @@
-import { currentSpecFile } from './chunk-73FGLUVI.js';
-import { createSpyFromClass } from './chunk-6FIKN2RJ.js';
-import { misconfigurationThrows, reportMisconfiguration } from './chunk-V4XBUP4D.js';
+import { currentSpecFile } from './chunk-TBT4J2AX.js';
+import { createSpyFromClass } from './chunk-VSWA6PQW.js';
+import { misconfigurationThrows, reportMisconfiguration } from './chunk-64KOOW3H.js';
 import { isAutoSpyLike } from './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/{chunk-IOBBADJP.js → chunk-33JL4DF3.js}

@@ -1,4 +1,4 @@
-import { createSpyFromClass, createAutoMock } from './chunk-6FIKN2RJ.js';
+import { createSpyFromClass, createAutoMock } from './chunk-VSWA6PQW.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';
 

package/dist/{chunk-R7DIFC2L.js → chunk-5FM2TZKG.js}

@@ -1,5 +1,5 @@
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-V4XBUP4D.js';
+import { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-64KOOW3H.js';
 import { setSharedHelperSink, hooksOf } from './chunk-7TGT2436.js';
 
 // src/lib/fast-spy.ts

package/dist/{chunk-V4XBUP4D.js → chunk-64KOOW3H.js}

@@ -75,6 +75,9 @@ function serializeShape(value, context) {
   if (value instanceof RegExp) {
     return String(value);
   }
+  if (value instanceof URL) {
+    return `new URL(${quoteString(value.href)})`;
+  }
   if (value instanceof Error) {
     return serializeError(value, context);
   }
@@ -271,6 +274,9 @@ function sameSpecialObject(expected, actual, path, matchers) {
   if (expected instanceof RegExp || actual instanceof RegExp) {
     return expected instanceof RegExp && actual instanceof RegExp && String(expected) === String(actual);
   }
+  if (expected instanceof URL || actual instanceof URL) {
+    return expected instanceof URL && actual instanceof URL && expected.href === actual.href;
+  }
   if (expected instanceof Error || actual instanceof Error) {
     return expected instanceof Error && actual instanceof Error && expected.name === actual.name && expected.message === actual.message && sameEntries(expected, actual, path, matchers);
   }

package/dist/{chunk-CYS3E4TA.js → chunk-F4SLC724.js}

@@ -1,9 +1,9 @@
-import { mockValueProp, mockAccessorsProp } from './chunk-73FGLUVI.js';
-import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-6FIKN2RJ.js';
+import { mockValueProp, mockAccessorsProp } from './chunk-TBT4J2AX.js';
+import { resolveConfiguration, mergeAutoSpyDefaults, resolveReadGuard, mergeMethodNames, getCallableMemberNames, createTrackedPropSpy, applyConfiguredReturns, createSpyFromClass, warnOnUnknownMethods, warnOnAccessorNamingAMethod, resolveAccessors, createAccessorsSpies, createProxyPropStore, storeWriteTraps, describeStoredProp, hasStoredProp, isProtocolKey, isDeletedProp, readStoredAccessor, NOT_STORED, disposeAutoSpy, writeStoredValue } from './chunk-VSWA6PQW.js';
 import { unpatchedSetTimeout, unpatchedClearTimeout } from './chunk-SOROJD3W.js';
 import { redefineFailure } from './chunk-YZSBSAYZ.js';
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy, reportMisconfiguration } from './chunk-V4XBUP4D.js';
+import { defineHelper, adoptFunctionSpy, reinstallDispatch, serializeValue, resolveUnstubbedGuard, createFunctionSpy, reportMisconfiguration } from './chunk-64KOOW3H.js';
 import { isMarkedMock, DEEP_CHILDREN } from './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/{chunk-2ISMAFNN.js → chunk-NFFBGS7E.js}

@@ -1,4 +1,4 @@
-import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-R7DIFC2L.js';
+import { clearAllFastSpies, resetAllFastSpies, getSpyEngine, createFastSpy } from './chunk-5FM2TZKG.js';
 import { SWEEP_SENTINEL } from './chunk-YHDBRBGU.js';
 import { guardAccessorSpies, spyOnAccessorByRedefine } from './chunk-L6VPMLRJ.js';
 import { hasMockAdapter, registerMockAdapter } from './shared-state.js';

package/dist/{chunk-73FGLUVI.js → chunk-TBT4J2AX.js}

@@ -1,5 +1,5 @@
 import { isCannotRedefine, redefineFailure } from './chunk-YZSBSAYZ.js';
-import { libraryWarn } from './chunk-V4XBUP4D.js';
+import { libraryWarn } from './chunk-64KOOW3H.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';
 import { getMockAdapter } from './shared-state.js';

package/dist/{chunk-6FIKN2RJ.js → chunk-VSWA6PQW.js}

@@ -1,5 +1,5 @@
 import { DISPOSE } from './chunk-PC3FAZT3.js';
-import { defaultStrict, resolveUnstubbedGuard, reportMisconfiguration, seedReturnValue, createFunctionSpy } from './chunk-V4XBUP4D.js';
+import { defaultStrict, resolveUnstubbedGuard, reportMisconfiguration, seedReturnValue, createFunctionSpy } from './chunk-64KOOW3H.js';
 import { runClearHook, runConfigReset, AUTO_SPY_MARK, markAsMock, isMarkedMock, readDeepChildren } from './chunk-7TGT2436.js';
 import { DOCS_LINKS } from './chunk-2XXGISYD.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/cli.js

@@ -3088,7 +3088,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.28.0";
+var EXPORT_MAP_VERSION = "5.30.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",

package/dist/console.js

@@ -1,10 +1,10 @@
-import { useVitestAdapter } from './chunk-2ISMAFNN.js';
-import './chunk-R7DIFC2L.js';
+import { useVitestAdapter } from './chunk-NFFBGS7E.js';
+import './chunk-5FM2TZKG.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-L6VPMLRJ.js';
 import './chunk-YZSBSAYZ.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-V4XBUP4D.js';
+import { createFunctionSpy } from './chunk-64KOOW3H.js';
 import './chunk-7TGT2436.js';
 import './chunk-2XXGISYD.js';
 import './chunk-TZ7DRSRD.js';

package/dist/diagnostics.js

@@ -123,6 +123,9 @@ function serializeShape(value, context) {
   if (value instanceof RegExp) {
     return String(value);
   }
+  if (value instanceof URL) {
+    return `new URL(${quoteString(value.href)})`;
+  }
   if (value instanceof Error) {
     return serializeError(value, context);
   }