vitest-auto-spy 5.32.1 → 5.33.0

package/AGENTS.md

@@ -230,12 +230,17 @@ core re-export, so those suites import it from the root; `spyOnVoidMethod` below
 node's prototype chain, and past the component's own class that chain is the engine's: happy-dom's
 `Node.removeChild` calls an internal Symbol-keyed method on the child, and once discovery has
 patched it the strict guard refuses that call — the node cannot be removed from `document.body` at
-all, and the leak then fails later tests in the file far from the cause. For a still-attached
-element, spy one property with `mockValueProp(el, 'addEventListener', vi.fn())` (§9) — the node
-stays otherwise real and removable. For a native void method the handler is meant to call
-(`preventDefault`, `stopPropagation`, `focus`), `spyOnVoidMethod(event, 'preventDefault')` packs
-the whitelist and the `returns: { preventDefault: undefined }` seed a strict suite otherwise needs,
-naming the method once instead of twice.
+all, and the leak then fails later tests in the file far from the cause. Without `onlyMethodsToSpyOn`
+on a live `Node` or another `EventTarget`, the call now reports this itself, before patching
+anything — `warn` by default, or a throw right there under `setMisconfigurationReaction('throw')`.
+The bare-array shorthand does not silence it: `createSpyFromInstance(el, ['addEventListener'])`
+merges as `methodsToSpyOn`, the _additive_ list, so discovery still walks the whole node — only
+`{ onlyMethodsToSpyOn: [...] }` skips it. For a still-attached element, spy one property with
+`mockValueProp(el, 'addEventListener', vi.fn())` (§9) — the node stays otherwise real and removable.
+For a native void method the handler is meant to call (`preventDefault`, `stopPropagation`, `focus`),
+`spyOnVoidMethod(event, 'preventDefault')` packs the whitelist and the
+`returns: { preventDefault: undefined }` seed a strict suite otherwise needs, naming the method once
+instead of twice.
 
 **`createFixture<T>(defaults, overrides?)` / `createFixtureFactory<T>(defaults)` are for the model
 that more than one spec builds.** The difference from `createMock` is the `defaults` argument: it is
@@ -2486,9 +2491,13 @@ it('scrolls after the next frame', () => {
 `stubAnimationFrame` stubs `cancelAnimationFrame` too, and hands both spies back as
 `frames.requestAnimationFrame` / `frames.cancelAnimationFrame`. A frame requested from inside a
 running frame is queued in either mode, so a loop that requests its own next frame advances one step
-per `flush()`. `stubElementRect` returns a real `DOMRect` per call, edges derived, and returns the undo.
-Both go through `mockValueProp`, so `restoreMockedProps()` (and `setupAutoSpy()` between tests) takes
-them off; `frames.restore()` does it sooner.
+per `flush()`. A callback that throws stops `flush()` (or propagates out of `requestAnimationFrame`
+in `'immediate'` mode); pass `onError: (error) => { … }` to intercept it instead — rethrow from
+inside to keep the default for an error you did not mean to swallow. `stubElementRect` returns a real
+`DOMRect` per call, edges derived, plus the installed spy as `.getBoundingClientRect` for
+`expect(el.getBoundingClientRect).toHaveBeenCalled()`, and the return value is still callable as the
+undo. Both go through `mockValueProp`, so `restoreMockedProps()` (and `setupAutoSpy()` between tests)
+takes them off; `frames.restore()` does it sooner.
 
 ### A module mock that did nothing
 
@@ -4000,7 +4009,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)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
@@ -4260,6 +4269,7 @@ packages, which a subpath export can never be.
 | `Cannot read properties of undefined (reading 'name')` on `value.constructor.name`, with `createAutoMock<T>()`                                     | `constructor` answered `undefined` on an auto-mock                                                                                                                                                                                                                          | upgrade — it answers `Object`, as every other double does; or seed it: `createAutoMock<T>({ constructor: … })`                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `Cannot redefine property: …` from a library accessor spy                                                                                          | the target is an ES module namespace a bundler inlined                                                                                                                                                                                                                      | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `Cannot spy on this instance in place: it is not extensible`                                                                                       | `createSpyFromInstance` was handed a frozen or sealed object                                                                                                                                                                                                                | spy it before it is frozen, or build a separate double with `createSpyFromClass` (§2)                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `createSpyFromInstance(X): no onlyMethodsToSpyOn was given for a live DOM/BOM object`                                                              | discovery is about to walk the whole prototype chain of a live `Node` / `EventTarget`, engine internals included — the bare-array shorthand does not avoid this, since it merges as `methodsToSpyOn`, not `onlyMethodsToSpyOn`                                              | list the methods the test needs: `{ onlyMethodsToSpyOn: [...] }`; for one method on a node that must keep living a DOM life, `mockValueProp` / `spyOnVoidMethod` instead (§2, live DOM node)                                                                                                                                                                                                                                                                                                                      |
 | `Cannot mock the property 'X': it is not configurable`                                                                                             | the member was defined with `configurable: false`, so it cannot be redefined                                                                                                                                                                                                | members replaced before it are still restorable — `restoreSpiedInstance(instance)` or `restoreMockedProps()`                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `overrideComponentProvider(…): the override did not apply — C resolved T to …`                                                                     | the component injects a different token, or something configured the token again after the call; the message says whether the real service or a different double won                                                                                                        | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures                                                                                                                                                                                                                                                                                                                                                                                  |
 | `.value() was read while the resource is in the error state: …`                                                                                    | `mockResourceProp`'s double after `fail(reason)`, as a real `ResourceRef` behaves; the reason is on `cause`                                                                                                                                                                 | branch on `hasValue()` / `status()` first, or assert with `toHaveResourceError()` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                           |

package/CHANGELOG.md

@@ -10,6 +10,62 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.33.0] - 2026-09-26
+
+### Added
+
+- **`stubElementRect` hands back the installed `getBoundingClientRect` spy alongside the restore.**
+  The return value stays callable — `stubElementRect(el)()` still restores the element's own method —
+  and now also carries `.getBoundingClientRect`, for a spec that must assert the measurement happened
+  rather than only shape the box it reports.
+
+- **`createSpyFromInstance` warns before it patches a live DOM/BOM object without `onlyMethodsToSpyOn`.**
+  Full discovery on a live `Node` (or another `EventTarget`) reaches the engine's own prototype chain,
+  not just the class's, and can spy a Symbol-keyed internal the engine calls on its own — happy-dom's
+  `Node.prototype[Symbol(clearCache)]`, called from `removeChild`, is one. Under a strict double the
+  node could then no longer be removed from `document.body`, from inside `removeChild` rather than the
+  spec, and the leak cascaded into later tests. The report goes through the same
+  `reportMisconfiguration` channel as every other misconfiguration (`warn` by default, `throw` under
+  `setMisconfigurationReaction('throw')`), and names `onlyMethodsToSpyOn`, `mockValueProp` and
+  `spyOnVoidMethod` as the way to keep the rest of the node real.
+
+- **`stubAnimationFrame` takes an `onError` callback.** Called with whatever a frame's callback threw,
+  instead of letting it propagate out of `requestAnimationFrame` (in `'immediate'` mode) or stop the
+  rest of a `flush()`. Rethrow from inside it to keep the default behaviour for an error the callback
+  did not expect — for a component whose zoneless effect re-enters the scheduler on a synchronous
+  frame, tolerating that one message without giving up on every other throw.
+
+### Fixed
+
+- **`prefer-render-shallow` no longer misses a file that reads the template through `hostElement`/
+  `queryElement`.** Its own `TEMPLATE_READS` list matched `nativeElement`, `querySelector` and the
+  rest of the raw DOM idioms it replaces, but not the helper names themselves — so a spec migrated
+  from `fixture.nativeElement` to `hostElement(fixture)` lost the very read that had kept the rule
+  quiet, and `TestBed.createComponent` was reported as unnecessary on a file that still measures a
+  real element.
+
+- **`mockValueProp` no longer throws on a writable, non-configurable property.** It always forced
+  `configurable: true`, so `Array.prototype.length` — `{ writable: true, configurable: false }` —
+  threw `Cannot redefine property` on every array-length write, even though the runtime allows
+  changing the value of a writable-but-non-configurable data property outright. It now keeps
+  `configurable: false` when the property already demands it, and only forces `true` when the
+  property is new or already configurable. The undo restores the number, not elements a shrink
+  already deleted — the array setter's own behaviour, unrelated to this package.
+
+## [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
@@ -8232,7 +8288,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.1...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.33.0...HEAD
+[5.33.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.32.2...v5.33.0
+[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

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-26.1%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-26.4%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)
@@ -3191,8 +3191,8 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `stubAbortController()`                                                                                     | `/dom-stubs`                  | A realm-consistent `AbortController`, so `addEventListener(…, { signal })` works under jsdom + zone.js                                                                                                                                                                                                                                                  |
 | `stubWebStorage(key?, opts?)`                                                                               | `/dom-stubs`                  | An in-memory `localStorage` / `sessionStorage` for this test, with `snapshot()` to assert on ([details](#how-to-mock-localstorage-and-sessionstorage))                                                                                                                                                                                                  |
 | `stubWorker(opts?)`                                                                                         | `/dom-stubs`                  | A `Worker` whose script is the spec — listeners stack, replies arrive on a microtask, `emit()` / `fail()` from the worker's side ([details](#how-to-mock-a-web-worker))                                                                                                                                                                                 |
-| `stubAnimationFrame(opts?)`                                                                                 | `/dom-stubs`                  | `requestAnimationFrame` / `cancelAnimationFrame` run on the spot or on `flush(timestamp?)`; a frame requested inside a frame waits for the next flush                                                                                                                                                                                                   |
-| `stubElementRect(el, rect?)`                                                                                | `/dom-stubs`                  | `getBoundingClientRect()` answering a real `DOMRect` built from a partial `DOMRectInit`; returns the undo                                                                                                                                                                                                                                               |
+| `stubAnimationFrame(opts?)`                                                                                 | `/dom-stubs`                  | `requestAnimationFrame` / `cancelAnimationFrame` run on the spot or on `flush(timestamp?)`; a frame requested inside a frame waits for the next flush; `onError` intercepts a throwing callback                                                                                                                                                         |
+| `stubElementRect(el, rect?)`                                                                                | `/dom-stubs`                  | `getBoundingClientRect()` answering a real `DOMRect` built from a partial `DOMRectInit`; returns the undo, plus the installed spy as `.getBoundingClientRect`                                                                                                                                                                                           |
 | `flushEventLoop(turns?)` / `settleDynamicImport(load, turns?)`                                              | core                          | Real event-loop turns while the timers are faked — for a dynamic `import()` or native `async` in a dependency                                                                                                                                                                                                                                           |
 | `flushEventLoopUntil(isDone, opts?)`                                                                        | core                          | Real turns until a condition holds — a `resource()` leaving `loading` — with a budget instead of a hang                                                                                                                                                                                                                                                 |
 | `stubMediaElement(opts?)`                                                                                   | `/dom-stubs`                  | A `<video>` / `<audio>` that plays, reports a duration and fires the media events jsdom never does                                                                                                                                                                                                                                                      |
@@ -4216,7 +4216,7 @@ another, and the next one is in that same file.
 | `stubWebStorage(key?, opts?)` _(`/dom-stubs`)_                                                                                              | An in-memory `localStorage` / `sessionStorage` a spec installs for itself, seeded or empty; `snapshot()` reads it back as a plain record                                                                                                                                                                                 |
 | `stubWorker(opts?)` _(`/dom-stubs`)_                                                                                                        | A `Worker` a spec drives from the worker's side: `respond` per message, `messages` / `terminated` to assert, `emit()` / `fail()`; returns `WorkerStub<TIn, TOut>`                                                                                                                                                        |
 | `stubAnimationFrame(opts?)` _(`/dom-stubs`)_                                                                                                | Frames on the spec's schedule: `'immediate'` or `'queued'` + `flush()`, `pending`, both globals as spies; returns `AnimationFrameStub`                                                                                                                                                                                   |
-| `stubElementRect(el, rect?)` _(`/dom-stubs`)_                                                                                               | A box for `getBoundingClientRect()` — missing fields `0`, edges derived; returns `RestoreProp`                                                                                                                                                                                                                           |
+| `stubElementRect(el, rect?)` _(`/dom-stubs`)_                                                                                               | A box for `getBoundingClientRect()` — missing fields `0`, edges derived; returns `ElementRectRestore` (callable undo plus `.getBoundingClientRect`)                                                                                                                                                                      |
 | `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?, config?)`                                                                                                        | `createAutoMock` typed as `T & Spy<T>`; `AutoMocked<T>` names it for a `let`                                                                                                                                                                                                                                             |

package/dist/angular-diagnostics.js

@@ -1,15 +1,15 @@
-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 { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-4XDGO2IR.js';
+export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-4XDGO2IR.js';
+import { failOnUnspiedProvider } from './chunk-GHP66ADY.js';
+import './chunk-C5H7JCPE.js';
+import './chunk-IH7NDMVG.js';
+import './chunk-UMBYWKKX.js';
+import './chunk-HCBVNAMT.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-72H6HNDI.js';
-import { isAutoSpyLike } from './chunk-XNXIHKVM.js';
+import './chunk-LGGUCVT5.js';
+import { isAutoSpyLike } from './chunk-TQXPN6GV.js';
 import { count, taskName } from './chunk-M3NTXLZG.js';
-import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-JOPCMFYN.js';
+import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-DN4MV4FB.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-24JTFFQL.js';
-import { useVitestAdapter } from './chunk-6JLBZHQ3.js';
-import './chunk-JR55747M.js';
+import { describeInstance } from './chunk-ON4SQZQL.js';
+import { useVitestAdapter } from './chunk-DMW7ROVM.js';
+import './chunk-4YZ7PIXM.js';
 import './chunk-YHDBRBGU.js';
-import './chunk-2QEM4WP7.js';
-import './chunk-CLQUJX6E.js';
+import './chunk-YVH6M22H.js';
+import './chunk-HCBVNAMT.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-72H6HNDI.js';
-import './chunk-XNXIHKVM.js';
+import { createFunctionSpy } from './chunk-LGGUCVT5.js';
+import './chunk-TQXPN6GV.js';
 import './chunk-M3NTXLZG.js';
-import { angularDialog } from './chunk-JOPCMFYN.js';
+import { angularDialog } from './chunk-DN4MV4FB.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-F2KBJC7P.js';
-import { flushEffects } from './chunk-DNXCZOYY.js';
-import './chunk-YUGSITWJ.js';
+import { assertAngularInternals, pendingRequestsReport, verifyOnTeardown, beforeTestBedReset } from './chunk-4XDGO2IR.js';
+import { flushEffects } from './chunk-NVCLX43M.js';
+import './chunk-C5H7JCPE.js';
 import './chunk-W5EXSI22.js';
 import { count, taskName } from './chunk-M3NTXLZG.js';
-import { angularHttpNoRequest, angularHttpPending, angularHttpController, angularHttpExpectRequest } from './chunk-JOPCMFYN.js';
+import { angularHttpNoRequest, angularHttpPending, angularHttpController, angularHttpExpectRequest } from './chunk-DN4MV4FB.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-JOPCMFYN.js';
+import { angularDirectiveApplied } from './chunk-DN4MV4FB.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-24JTFFQL.js';
-import { angularInternalsError } from './chunk-YUGSITWJ.js';
-import { createFunctionSpy } from './chunk-72H6HNDI.js';
-import './chunk-XNXIHKVM.js';
+import { describeInstance } from './chunk-ON4SQZQL.js';
+import { angularInternalsError } from './chunk-C5H7JCPE.js';
+import { createFunctionSpy } from './chunk-LGGUCVT5.js';
+import './chunk-TQXPN6GV.js';
 import { count } from './chunk-M3NTXLZG.js';
-import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-JOPCMFYN.js';
+import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-DN4MV4FB.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,11 +1,11 @@
-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';
+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-CT3BLyTB.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';
 import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, s as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-BVKEkhWj.js';
 import { TestAPI } from 'vitest';
 export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-DyqkWQmT.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-DUcl1uMH.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-DiEcCltd.js';
 import '@angular/core/testing';
 
 /**

package/dist/angular.js

@@ -3007,7 +3007,11 @@ function mockReadonlyPropGetter(object, property, getter) {
   return applyPatch(object, property, { get: getter, set: void 0, configurable: true }, "mockReadonlyPropGetter");
 }
 function mockValueProp(object, property, value) {
-  return applyPatch(object, property, { value, writable: true, configurable: true }, "mockValueProp");
+  return applyPatch(object, property, valueDescriptorFor(object, property, value), "mockValueProp");
+}
+function valueDescriptorFor(object, property, value) {
+  const previous = Object.getOwnPropertyDescriptor(object, property);
+  return previous?.configurable === false && previous.writable === true ? { value, writable: true, configurable: false } : { value, writable: true, configurable: true };
 }
 function mockAccessorsProp(object, property, accessors) {
   const adapter = getMockAdapter();

package/dist/bun-angular.d.ts

@@ -2,8 +2,8 @@ export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c a
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, outOfType, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, spyOnOwnMethod, spyOnVoidMethod, stubConstructor, withOverrides } from './bun.js';
 export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-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-BVbIBVS7.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-DiEcCltd.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-CT3BLyTB.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,22 +1,22 @@
-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 { createSpyForToken } from './chunk-ABJTCB5O.js';
+export { injectSpy, provideAutoSpy } from './chunk-GHP66ADY.js';
+import { stable, flushEffects } from './chunk-NVCLX43M.js';
+export { flushEffects, stable } from './chunk-NVCLX43M.js';
+import { angularInternalsError } from './chunk-C5H7JCPE.js';
+import './chunk-4AQIDYTD.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-VGC5JZ5R.js';
+import { mockValueProp } from './chunk-IH7NDMVG.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-IH7NDMVG.js';
+import { closestName } from './chunk-UMBYWKKX.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-UMBYWKKX.js';
 import { fakeClockBacklog } from './chunk-W5EXSI22.js';
-import './chunk-2QEM4WP7.js';
-import './chunk-CLQUJX6E.js';
+import './chunk-YVH6M22H.js';
+import './chunk-HCBVNAMT.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-72H6HNDI.js';
-import { libraryWarn } from './chunk-XNXIHKVM.js';
+export { createFunctionSpy, errorHandler } from './chunk-LGGUCVT5.js';
+import { libraryWarn } from './chunk-TQXPN6GV.js';
 import { displayPath, count } from './chunk-M3NTXLZG.js';
-import { angularEffects, angularTrackRuns, bunAngular, angularUnreadResource, angularCreateWithAutoSpies, angularResources, angularTypedElements, angularInputs, angularKeepTemplate } from './chunk-JOPCMFYN.js';
+import { angularEffects, angularTrackRuns, bunAngular, angularUnreadResource, angularCreateWithAutoSpies, angularResources, angularTypedElements, angularInputs, angularKeepTemplate } from './chunk-DN4MV4FB.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';

package/dist/bun.d.ts

@@ -2,7 +2,7 @@ import { z as SpyOptions, C as ClassType, m as ClassSpyConfiguration, s as OnlyM
 export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, E as ErrorValueConfig, p as FunctionSpy, M as MethodReturns, q as Mutable, N as NextValueConfig, r as NotAPublicKey, O as ObservableLike, t as OnlyObservablePropsOf, u as OnlyPropsOf, v as Overload, w as OverloadChoice, x as Overloads, P as PropStubValue, y as SpyDisposable, B as StrictSpyConfiguration, G as SubjectLike, H as SubjectOf, U as UnstubbedCall, J as UnstubbedCallHandler, K as UnstubbedRead, L as UnstubbedReadHandler, V as ValueConfig, Q as ValueConfigPerCall, W as WithMockReturnValue } from './types-BVKEkhWj.js';
 export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, e as autoMocked, f as clearAutoSpyDefaults, g as createAutoMock, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-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 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-DiEcCltd.js';
 import { Mock, MockInstance } from 'vitest';
 
 /**

package/dist/bun.js

@@ -1,13 +1,13 @@
-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-4AQIDYTD.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-VGC5JZ5R.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-IH7NDMVG.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-UMBYWKKX.js';
 import './chunk-W5EXSI22.js';
-import './chunk-2QEM4WP7.js';
-import './chunk-CLQUJX6E.js';
+import './chunk-YVH6M22H.js';
+import './chunk-HCBVNAMT.js';
 import './chunk-PC3FAZT3.js';
-export { createFunctionSpy, errorHandler } from './chunk-72H6HNDI.js';
-import './chunk-XNXIHKVM.js';
+export { createFunctionSpy, errorHandler } from './chunk-LGGUCVT5.js';
+import './chunk-TQXPN6GV.js';
 import './chunk-M3NTXLZG.js';
-import './chunk-JOPCMFYN.js';
+import './chunk-DN4MV4FB.js';
 import './chunk-ENCEEH23.js';

package/dist/{chunk-XUPBHHJD.js → chunk-4AQIDYTD.js}

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

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

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

package/dist/{chunk-JR55747M.js → chunk-4YZ7PIXM.js}

@@ -1,7 +1,7 @@
 import { DISPOSE } from './chunk-PC3FAZT3.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 { isFastSpy, FAST_SPY_BRAND, isThenable } from './chunk-LGGUCVT5.js';
+import { setSharedHelperSink, hooksOf } from './chunk-TQXPN6GV.js';
+import { mockConstructor } from './chunk-DN4MV4FB.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 
 // src/lib/fast-spy.ts

package/dist/{chunk-LAPHUX5G.js → chunk-7C6PVODW.js}

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

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

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

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

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

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

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

package/dist/{chunk-JOPCMFYN.js → chunk-DN4MV4FB.js}

@@ -36,6 +36,7 @@ var createSpyFromClassAccessorSpies = "https://asdalexey.github.io/vitest-auto-s
 var createSpyFromClassAccessors = "https://asdalexey.github.io/vitest-auto-spy/core/create-spy-from-class#getterstospyon-accepts-a-signal-valued-getter";
 var createSpyFromClassInstanceMethods = "https://asdalexey.github.io/vitest-auto-spy/core/create-spy-from-class#instancemethodstospyon-\u2014-callables-that-are-not-on-the-prototype";
 var createSpyFromClassLazySpies = "https://asdalexey.github.io/vitest-auto-spy/core/create-spy-from-class#lazy-spies-\u2014-lazyspies";
+var createSpyFromClassLiveDomNode = "https://asdalexey.github.io/vitest-auto-spy/core/create-spy-from-class#live-dom-node";
 var createSpyFromClassReturns = "https://asdalexey.github.io/vitest-auto-spy/core/create-spy-from-class#returns-\u2014-the-value-where-the-spy-is-built";
 var mockConstructor = "https://asdalexey.github.io/vitest-auto-spy/utilities/constructor-doubles#mockconstructor-factory-name";
 var controlHelpers = "https://asdalexey.github.io/vitest-auto-spy/core/control-helpers";
@@ -63,4 +64,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, 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 };
+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, createSpyFromClassLiveDomNode, 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-GSMWYZ5A.js → chunk-GHP66ADY.js}

@@ -1,7 +1,7 @@
-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 { currentSpecFile } from './chunk-IH7NDMVG.js';
+import { createSpyFromClass } from './chunk-UMBYWKKX.js';
+import { isAutoSpyLike, misconfigurationThrows, reportMisconfiguration } from './chunk-TQXPN6GV.js';
+import { angularInjectSpyReal } from './chunk-DN4MV4FB.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { TestBed } from '@angular/core/testing';
 

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

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

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

@@ -1,7 +1,7 @@
-import { isCannotRedefine, redefineFailure } from './chunk-CLQUJX6E.js';
-import { libraryWarn } from './chunk-XNXIHKVM.js';
+import { isCannotRedefine, redefineFailure } from './chunk-HCBVNAMT.js';
+import { libraryWarn } from './chunk-TQXPN6GV.js';
 import { count, displayPath } from './chunk-M3NTXLZG.js';
-import { setupGlobals, setupWrongHook, setup } from './chunk-JOPCMFYN.js';
+import { setupGlobals, setupWrongHook, setup } from './chunk-DN4MV4FB.js';
 import { withDocs } from './chunk-ENCEEH23.js';
 import { getMockAdapter } from './shared-state.js';
 
@@ -205,7 +205,11 @@ function mockReadonlyPropGetter(object, property, getter) {
   return applyPatch(object, property, { get: getter, set: void 0, configurable: true }, "mockReadonlyPropGetter");
 }
 function mockValueProp(object, property, value) {
-  return applyPatch(object, property, { value, writable: true, configurable: true }, "mockValueProp");
+  return applyPatch(object, property, valueDescriptorFor(object, property, value), "mockValueProp");
+}
+function valueDescriptorFor(object, property, value) {
+  const previous = Object.getOwnPropertyDescriptor(object, property);
+  return previous?.configurable === false && previous.writable === true ? { value, writable: true, configurable: false } : { value, writable: true, configurable: true };
 }
 function mockAccessorsProp(object, property, accessors) {
   const adapter = getMockAdapter();

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

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

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

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

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

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