vitest-auto-spy 5.6.0 → 5.7.0

package/AGENTS.md

@@ -121,7 +121,8 @@ and is only ever asserted on — `createAutoMock`. Handed to the function under
 (`detectVpnClient(url, logger)`, `applyPreferredTracks(target, …)`, `setLocalConfigEnabled(storage, …)`),
 it has to satisfy `T` at the call site _and_ expose the spy helpers at the assertion, and
 `autoMocked<T>()` is that intersection — otherwise every call site needs an `asInstance()` and the
-noise scales with the number of them.
+noise scales with the number of them. Both take the same second argument (`returns`, `name`, `strict`,
+`observablePropsToSpyOn`).
 
 `createMock<T>()` is the one to reach for on data shapes — it returns a plain `T`, so it satisfies a
 `no-type-assertion` lint rule without an `eslint-disable` on every fixture.
@@ -723,16 +724,24 @@ Called as: Cart.checkout(1,'now')
 Also on `createAutoMock`, `provideAutoSpy`, and suite-wide as `setupAutoSpy({ strict: true })` — which
 reaches a double whichever bundle of the package built it: the default lives on `globalThis`. Before
 this release it lived in module scope, and a setup file's `strict: true` reached no double a spec built.
-Precedence, first one set wins: the double's `onUnstubbedCall` → the global `onUnstubbedCall` → the
-double's `strict` (**including `strict: false`**, the only way to exempt one double from a suite-wide
-default) → the global `strict`.
+Precedence, first one set wins: the double's `onUnstubbedCall` → the double's explicit **`strict: false`**
+(the only way to exempt one double from a suite-wide default, a global handler included) → the global
+`onUnstubbedCall` → the double's `strict: true` → the global `strict`.
 
 - **It is not argument-level.** A `calledWith(1, 'now')` chain says the method is stubbed, so
   `checkout(9, 'later')` still answers `undefined`. Use `mustBeCalledWith` for that.
-- **`mockReturnValue` / `mockImplementation` / the `returns:` option replace the dispatch**, so they
-  never reach the guard. Consequence: after the last `mockReturnValueOnce` the queue empties back
-  onto the library dispatch and the next call **is** reported as unstubbed — seed
-  `mockReturnValue(...)` too when a `Once` sequence is meant to run out.
+- **`returns:` is a default in the spy's own container**: a `calledWith` / `resolveWith` / `failWith`
+  configured later wins for its arguments or supersedes it, every other call still gets it, and
+  `undefined` counts as configured. `returns: { save: undefined }` is how a `void` call is expected.
+- **`mockReturnValue` / `mockImplementation` replace the dispatch**, so they never reach the guard —
+  and a `calledWith` configured after them is never consulted. After the last `mockReturnValueOnce`
+  the queue empties back onto the library dispatch and the next call **is** reported as unstubbed —
+  seed `mockReturnValue(...)` too when a `Once` sequence is meant to run out.
+- **A throw something swallowed still fails the test.** Under `setupAutoSpy({ strict: true })` every
+  strict throw is recorded, and one that a `try`/`catch` in the code under test or an RxJS error with
+  no handler (its rethrow waits on a fake clock) kept from the test fails it after the test
+  (`swallowedStrictCalls`, `'throw'` by default with `strict: true`). Provoking one on purpose:
+  `expect(() => cart.total()).toThrow(…)` then `expect(takeStrictViolations()).toHaveLength(1)`.
 - **It does not reach** accessor spies, observable-property spies, `mockDeep` nodes, `console-spy`,
   `mockResourceProp`'s `reload` or a standalone `createFunctionSpy`. A strict double still answers
   `undefined` for an unconfigured getter or `items$`. `fillMissing` members **are** covered.
@@ -2635,17 +2644,19 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-passthrough-console-spy`      | `error` | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and prints → `installConsoleSpies()` + `consoleXSpy`, or `.mockImplementation(() => undefined)` |
 | `no-console-in-spec`              | `error` | —                 | a spec calling `console.x(…)` itself, or `console.x = …`, which nothing restores → absorb the code's output through `vitest-auto-spy/console` |
 | `no-import-time-console-spies`    | `error` | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and silences every later file → `installConsoleSpies()` in `beforeEach`, `restoreConsole()` in `afterEach` |
+| `no-mistyped-use-value`           | `error` | —                 | `{ provide: TOKEN, useValue }` whose value is not assignable to the primitive `T` of `InjectionToken<T>` (string, number, boolean, bigint, enum, their literals, `null`, `undefined`) — `useValue` is `any`, so `{}` for a `boolean` token compiles and is truthy. **Type-aware**: silent without `parserOptions.project`; object-typed tokens are out of scope |
+| `no-instance-lifecycle-spy`       | `warn`  | —                 | `vi.spyOn(instance, 'ngOnInit')` (and `ngOnDestroy`, `ngDoCheck`, `ngAfterContent*`, `ngAfterView*`) — a view calls the hook read off the prototype, so the instance spy is never called and its stub never runs → `vi.spyOn(Cls.prototype, …)` before `createComponent`, or assert the effect. `ngOnChanges` is exempt: Angular calls it through the instance |
 | `jasmine-namespace-without-entry` | `error` | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compat layer nowhere — option: `{ setupModules: […] }`                                                                                                                                                                                                 |
 | `no-jasmine-globals`              | `error` | —                 | `jasmine.*`, bare `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(`                                                                                                                                                                                                                        |
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                                                                                                                                                                                                              |
 | `prefer-native-spy-api`           | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim                                                                                                                                                                                                                   |
 
-Twenty-eight rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
-`no-stub-class-double` and `no-structural-double`**; three fix on their own, nine offer suggestions. Twenty-seven are syntactic; `no-private-member-access` is the one
-that reads types, and it reports nothing at all without `parserOptions.project` / `projectService`
+Thirty rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+`no-stub-class-double`, `no-structural-double` and `no-instance-lifecycle-spy`**; three fix on their own, nine offer suggestions. Twenty-eight are syntactic; `no-private-member-access` and `no-mistyped-use-value`
+read types, and both report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
 consumer how much each finding mattered — a `warn` nothing reads is `off` with extra output. The
-three `warn`s left are not judgements about how much a finding matters. `prefer-render-shallow` is
+four `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
@@ -2658,7 +2669,9 @@ and moved a long way inside the release: measured on the same 1759 files, the tw
 reports in 8 files and 115 in 74, and are 10 in 7 and 5 in 4 once `prefer-provide-auto-spy` learnt to
 follow a name into a `useValue` — 112 of those doubles are handed to Angular DI one name away, where
 a `provide:` settles it. That rule reports **154 times across 87 files** on the same suite, all at
-`error`. Set any of the three `warn`s to `'error'` once the batch is done. Three of
+`error`. `no-instance-lifecycle-spy` is on the evidence too: Angular never calls an instance spy on a
+hook it read off the prototype, but a spec that calls `component.ngOnInit()` itself does, and so does
+the injector for a service's `ngOnDestroy`. Set any of the four `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
@@ -2878,6 +2891,8 @@ packages, which a subpath export can never be.
 | `createNestUnit(X): A -> B -> A is a cycle among the classes built for real`                                  | two exposed / `useClass` classes depend on each other; the helper does not resolve `forwardRef` cycles                                                                                                                                                                     | expose one side less, or provide it                                                                                                                                                                                                                                                                       |
 | `createNestUnit(X).spies.get(Y): the unit never asked for that token`                                         | same guard as `createWithAutoSpies` — the spy would not be the one the unit uses                                                                                                                                                                                           | stub the token the unit actually injects (the message lists the auto-spied ones)                                                                                                                                                                                                                          |
 | `createNestUnit(X).spies.get(Y): Y is in \`expose\`, so the unit got a real instance`                         | an exposed class is real, not a spy                                                                                                                                                                                                                                        | read the spies of its own collaborators, or drop it from `expose`                                                                                                                                                                                                                                         |
+| `expect(component.ngOnInit).toHaveBeenCalled()` fails after `fixture.detectChanges()`, or a hook's `.mockImplementation` never runs | the spy was put on the **instance**; a view calls the hook it read off the class prototype when the component was created | `vi.spyOn(Cls.prototype, 'ngOnInit')` before `TestBed.createComponent`, or assert what the hook does — `no-instance-lifecycle-spy` (§16) |
+| a spec runs down the "browser" (or any flag-on) branch whatever its `useValue` says                           | `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>` — `useValue` is `any`, and an object is truthy | a value of the token's type (`useValue: false`) — `no-mistyped-use-value` (§16), with type information |
 | `no request matched …` (with the requests that were made listed)                                              | the URL, verb or predicate does not describe anything the code under test sent, or nothing subscribed                                                                                                                                                                      | read the list in the message — it is the requests that were actually made; then fix the URL, add `{ method }`, or subscribe (§13)                                                                                                                                                                         |
 | `this TestBed has no HttpTestingController`                                                                   | `expectRequest` / `expectNoRequest` on a module that never got the testing backend                                                                                                                                                                                         | `TestBed.configureTestingModule({ providers: [...provideHttpTesting()] })` from `vitest-auto-spy/angular-http` (§13)                                                                                                                                                                                      |
 | `the test ended with N unanswered request(s)`                                                                 | `provideHttpTesting({ verifyOnTeardown })` found a request the spec never flushed                                                                                                                                                                                          | answer it (`await expectRequest(url).flush(body)`), assert its absence (`expectNoRequest(url)`), or `{ verifyOnTeardown: false }` (§13)                                                                                                                                                                   |
@@ -2913,6 +2928,8 @@ diagnostic and is free to change: print it, never assert on it.
 | `createSpyFromClass(X) as unknown as X`                                     | `asInstance(createSpyFromClass(X))`                                     |
 | `{ provide: X, useValue: { a: vi.fn(), b: vi.fn() } }`                      | `provideAutoSpy(X)`                                                     |
 | `vi.spyOn(TestBed.inject(X), 'method')`                                     | `injectSpy(X).method`                                                   |
+| `vi.spyOn(component, 'ngOnInit')` after `createComponent`                   | `vi.spyOn(Cls.prototype, 'ngOnInit')` before it, or assert the effect   |
+| `{ provide: IS_BROWSER, useValue: {} }` for an `InjectionToken<boolean>`   | `useValue: false` — a value of the type the token declares             |
 | `Object.defineProperty(service, 'ready', { value: true })`                  | `mockReadonlyProp(service, 'ready', true)`                              |
 | `source$.subscribe(v => expect(v).toBe(1))`                                 | `await expect(expectEmission(source$)).resolves.toBe(1)`                |
 | `await lastValueFrom(done$, { defaultValue: undefined })`                   | `await expectCompletion(done$)`                                         |

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-16.6%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-16.8%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -76,7 +76,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🧩 Module mocks that prove they applied — `assertMocked`, `moduleNamespace`, for a `vi.mock()` a bundler quietly ignored
 - 🧾 Fixtures without casts — deep-partial `createMock`, `createFixture` / `createFixtureFactory`, `narrow()`, `withOverrides()`, `asInstances()`, `captureArg()`
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
-- 📏 Lint rules and one-line test-run hygiene — twenty-eight rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, nine suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade
+- 📏 Lint rules and one-line test-run hygiene — thirty rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, nine suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade
 - 🩺 [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
@@ -799,6 +799,11 @@ cart.total.mockReturnValue(42);
 `CartService` and the spy has it. A hand-written `{ provide: CartService, useValue: { total:
 vi.fn() } }` silently keeps mocking yesterday's class.
 
+A token with a primitive value is the one place a `useValue` stays right: `{ provide: IS_BROWSER,
+useValue: false }`. Angular types `useValue` as `any`, though, so nothing compares it with the
+`InjectionToken<boolean>` it is for — `useValue: {}` compiles and is truthy. `no-mistyped-use-value`
+reports that, given type information.
+
 On **Vitest 4.1+**, the same thing as fixtures — one statement, types inferred, and a test that
 never names a dependency never builds it:
 
@@ -984,6 +989,22 @@ One call for `configureTestingModule` + `NO_ERRORS_SCHEMA` + `overrideComponent`
 `@angular/core/testing` still applies. See [shallow rendering](#shallow-component-rendering) for
 `keepTemplate`, `keepChildren` and what it actually saves.
 
+### How to mock: a lifecycle hook
+
+```ts
+const init = vi.spyOn(CardComponent.prototype, 'ngOnInit').mockImplementation(() => undefined);
+const fixture = TestBed.createComponent(CardComponent);
+
+fixture.detectChanges();
+expect(init).toHaveBeenCalledTimes(1);
+```
+
+On the prototype, and before the component is created. A view calls the hook it read off the class
+when the component was created, so `vi.spyOn(component, 'ngOnInit')` on the instance is never
+called by Angular and its `.mockImplementation` never runs — the real hook does, under a spec that
+reads as though it stubbed it. Better still, assert what the hook does rather than that it ran.
+`no-instance-lifecycle-spy` reports the instance form.
+
 ### How to mock: a class the code under test builds with `new`
 
 ```ts
@@ -1808,6 +1829,19 @@ createSpyFromClass(Cart).total(); // throws
 createSpyFromClass(Cart, { strict: false }).total(); // undefined — the way to exempt one double
 ```
 
+A throw the production code caught used to end the test green — a `try`/`catch` took its error
+branch, or an RxJS operator with no error handler parked the rethrow on a `setTimeout` a fake clock
+never runs. Under `setupAutoSpy({ strict: true })` the test fails anyway, after it
+(`swallowedStrictCalls`: `'throw'` by default, `'warn'` to print, `'off'` to skip), naming each
+swallowed call with its first production frames. A test that provokes one on purpose takes it:
+
+```ts
+import { takeStrictViolations } from 'vitest-auto-spy/setup';
+
+expect(() => cart.total()).toThrow('Nothing configured Cart.total');
+expect(takeStrictViolations()).toHaveLength(1);
+```
+
 Two limits worth knowing before turning it on. It answers _"nobody configured this method"_, never
 _"nobody configured this call"_ — a `calledWith` chain for other arguments does not trip it, because
 argument-level strictness is what `mustBeCalledWith` already does, with a better message. And it
@@ -2664,9 +2698,9 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `blockNetwork(options?)`                                                                 | `/setup`                      | Close `fetch`, `XMLHttpRequest` and `sendBeacon`, naming what was requested ([details](#test-run-hygiene))                                                                                            |
 | `trackStrayRejections()` / `flushStrayRejections()` / `countStrayRejections()`           | `/setup`                      | Read back the promise rejections zone.js swallowed into `console.error`, so one can fail a test ([details](#test-run-hygiene))                                                                        |
 | `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 |
+| `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                                                                   |
 | `guardPrototypePollution(reaction)`                                                      | `/setup`                      | Name the test that left a key on `Object.prototype` — it stops later files collecting ([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                                                                                           |
 | `setupAngularTestEnv(opts)`                                                              | `/angular`                    | Zone and zoneless spec files in one worker, switching platforms per file                                                                                                                              |
@@ -2968,8 +3002,8 @@ not a function` on Node 25, `undefined` on Node 26, under jsdom and happy-dom al
 | `blockNetwork`        | `false`   | Close every network channel the environment has — `true`, or a narrowing object                                                                                                               |
 | `guardGlobals`        | `'off'`   | Report a test that redefines a global property as non-configurable                                                                                                                            |
 | `prototypePollution`  | `'throw'` | Sweep and report an enumerable key a test left on a built-in prototype                                                                                                                        |
-| `strayConsole`        | `'off'`   | Fail a test (or a file) whose console output nothing absorbed — `'warn'`, `'throw'`, or `{ reaction, allow }`                                                                                  |
-| `misconfiguration`    | `'warn'`  | `'throw'` fails the library's own misuse reports at the call site, every occurrence                                                                                                            |
+| `strayConsole`        | `'off'`   | Fail a test (or a file) whose console output nothing absorbed — `'warn'`, `'throw'`, or `{ reaction, allow }`                                                                                 |
+| `misconfiguration`    | `'warn'`  | `'throw'` fails the library's own misuse reports at the call site, every occurrence                                                                                                           |
 | `preset`              | —         | `'strict'` starts every guard above at its strictest grade; explicit options still win                                                                                                        |
 | `globalFakeTimers`    | `false`   | Fake timers for every test **and between them** — Jest's `enableGlobally`                                                                                                                     |
 | `restoreTimerGlobals` | `true`    | Put back timer globals that uninstalling the fakes deleted                                                                                                                                    |
@@ -3135,7 +3169,7 @@ import autoSpy from 'vitest-auto-spy/eslint-plugin';
 export default [{ files: ['**/*.spec.ts'], ...autoSpy.configs.recommended }];
 ```
 
-**Every rule is an `error` since 4.0.0, bar one.** The config used to grade them `error` / `warn` /
+**Every rule is an `error` since 4.0.0, bar four.** The config used to grade them `error` / `warn` /
 `off`, which chose for you how much each finding mattered; a `warn` in a repository that does not read
 lint output is `off` with extra noise, and which findings block a merge is one line of config either
 way. To turn one down, spread the rule map as well — a bare `rules` key beside the spread config
@@ -3151,7 +3185,7 @@ export default [
 ];
 ```
 
-One of the three exceptions is `prefer-render-shallow`, which ships as a **`warn`**, and its reason is the kind
+One of the four 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
@@ -3173,6 +3207,10 @@ a heuristic — and it is also why they are rules of their own rather than arms
 a project that disagrees with either reading switches it off without losing the rule that reads a
 count.
 
+The fourth, `no-instance-lifecycle-spy`, is graded on the evidence too. A spy on an instance hook is
+never called by Angular, but it is by a spec that calls `component.ngOnInit()` itself, and by the
+injector for a service's `ngOnDestroy` — and one file's syntax cannot tell those apart.
+
 A second config, `autoSpy.configs.typeErrors`, holds the subset whose findings are compile errors
 (`prefer-as-spy` is `TS2352`, `no-mocked-for-spy` is `TS2322`). Spread it **after** a blanket
 downgrade so those keep their severity — the recipe is a spread rather than rule names copied into
@@ -3187,42 +3225,44 @@ object of `vi.fn()`s is perfectly reasonable in application code. Flat config on
 `.eslintrc` `plugins: ['…']` form resolves names to `eslint-plugin-*` packages, which a subpath
 export can never be.
 
-| Rule                              | Recommended | Fix               | Flags                                                                                                                                                                                                                  |
-| --------------------------------- | :---------: | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `prefer-provide-auto-spy`         |   `error`   | —                 | a hand-rolled `useValue`, `useFactory` **or** `useClass` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`                                                                                                   |
-| `prefer-create-spy-from-class`    |   `error`   | —                 | an object literal of two or more `vi.fn()`s → `createSpyFromClass` / `createAutoMock`, unless it is a factory's own seed                                                                                               |
-| `no-stub-class-double`            |   `warn`    | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy`, the stub class deleted                                                                                                                  |
-| `no-structural-double`            |   `warn`    | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`                                                                                                                              |
-| `prefer-inject-spy`               |   `error`   | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, in one step or two → `injectSpy(X).m`                                                                                                                                              |
-| `no-object-define-property`       |   `error`   | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                               |
-| `no-expect-in-subscribe`          |   `error`   | suggest           | `expect()` inside a `subscribe()` callback → `expectEmission` / `firstValueFrom`                                                                                                                                       |
-| `no-shared-module-level-mock`     |   `error`   | —                 | an **exported** value holding `vi.fn()`s → export a factory that returns it                                                                                                                                            |
-| `no-mocked-for-spy`               |   `error`   | `--fix` / suggest | `Mocked<T>` in any type position → `Spy<T>`, import and all — a suggestion where the value assigned is not one of this library's factories                                                                             |
-| `prefer-as-spy`                   |   `error`   | `--fix`           | `TestBed.inject(X) as Spy<X>` → `asSpy<X>(TestBed.inject(X))`, import and all                                                                                                                                          |
-| `no-done-callback`                |   `error`   | —                 | `it('x', (done) => …)` → `async` + an awaited assertion, and `done.fail(…)` at the call site                                                                                                                           |
-| `no-floating-assertion`           |   `error`   | —                 | `expect()` in a `.then()` nobody awaits → `expect(await promise)`                                                                                                                                                      |
-| `no-bare-called-with`             |   `error`   | —                 | `spy.m.calledWith(1);` as a statement of its own — a stub nobody continued, asserting nothing                                                                                                                          |
-| `no-overridden-provider`          |   `error`   | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                                                                                              |
-| `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                                                              |
-| `no-private-member-access`        |   `error`   | —                 | `instance['privateMember']`, `(instance as any).privateMember` and `vi.spyOn(Object.getPrototypeOf(x), 'm')` — the three spellings that get past `private`; **type-aware**, and silent without `parserOptions.project` |
-| `no-dead-schemas`                 |   `error`   | —                 | `schemas` on a testing module that declares nothing — a charm protecting nobody, and one that starts working the day `declarations` arrive                                                                             |
-| `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                                                                                                |
-| `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                               |
-| `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                       |
-| `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                          |
-| `no-passthrough-console-spy`      |   `error`   | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and still prints → `installConsoleSpies()` from `vitest-auto-spy/console`, or `.mockImplementation(() => undefined)` |
-| `no-console-in-spec`              |   `error`   | —                 | a spec that calls `console.x(…)` itself, or replaces a method with `console.x = …`, which nothing puts back — under `isolate: false` every later file inherits it |
-| `no-import-time-console-spies`    |   `error`   | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and, under `isolate: false`, silences every later file |
-| `jasmine-namespace-without-entry` |   `error`   | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compatibility layer nowhere                                                                                                               |
-| `no-jasmine-globals`              |   `error`   | —                 | `jasmine.*`, `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(` — none of them exist under Vitest                                                                              |
-| `no-save-arguments-by-value`      |   `error`   | —                 | `spy.calls.saveArgumentsByValue()`, which is a no-op here → take the copy at call time                                                                                                                                 |
-| `prefer-native-spy-api`           |   `error`   | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — the last mile off the jasmine shim                                                                                                                     |
+| Rule                              | Recommended | Fix               | Flags                                                                                                                                                                                                                                             |
+| --------------------------------- | :---------: | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefer-provide-auto-spy`         |   `error`   | —                 | a hand-rolled `useValue`, `useFactory` **or** `useClass` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`                                                                                                                              |
+| `prefer-create-spy-from-class`    |   `error`   | —                 | an object literal of two or more `vi.fn()`s → `createSpyFromClass` / `createAutoMock`, unless it is a factory's own seed                                                                                                                          |
+| `no-stub-class-double`            |   `warn`    | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy`, the stub class deleted                                                                                                                                             |
+| `no-structural-double`            |   `warn`    | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`                                                                                                                                                         |
+| `prefer-inject-spy`               |   `error`   | suggest           | `vi.spyOn(TestBed.inject(X), 'm')`, in one step or two → `injectSpy(X).m`                                                                                                                                                                         |
+| `no-object-define-property`       |   `error`   | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                                                          |
+| `no-expect-in-subscribe`          |   `error`   | suggest           | `expect()` inside a `subscribe()` callback → `expectEmission` / `firstValueFrom`                                                                                                                                                                  |
+| `no-shared-module-level-mock`     |   `error`   | —                 | an **exported** value holding `vi.fn()`s → export a factory that returns it                                                                                                                                                                       |
+| `no-mocked-for-spy`               |   `error`   | `--fix` / suggest | `Mocked<T>` in any type position → `Spy<T>`, import and all — a suggestion where the value assigned is not one of this library's factories                                                                                                        |
+| `prefer-as-spy`                   |   `error`   | `--fix`           | `TestBed.inject(X) as Spy<X>` → `asSpy<X>(TestBed.inject(X))`, import and all                                                                                                                                                                     |
+| `no-done-callback`                |   `error`   | —                 | `it('x', (done) => …)` → `async` + an awaited assertion, and `done.fail(…)` at the call site                                                                                                                                                      |
+| `no-floating-assertion`           |   `error`   | —                 | `expect()` in a `.then()` nobody awaits → `expect(await promise)`                                                                                                                                                                                 |
+| `no-bare-called-with`             |   `error`   | —                 | `spy.m.calledWith(1);` as a statement of its own — a stub nobody continued, asserting nothing                                                                                                                                                     |
+| `no-overridden-provider`          |   `error`   | suggest           | two providers for one token in one array → the earlier one never runs; the exact duplicate can be deleted                                                                                                                                         |
+| `no-inject-before-override`       |   `error`   | —                 | `TestBed.inject()` / `injectSpy()` / `renderShallow()` in a hook, in a suite that still calls `override*`                                                                                                                                         |
+| `no-private-member-access`        |   `error`   | —                 | `instance['privateMember']`, `(instance as any).privateMember` and `vi.spyOn(Object.getPrototypeOf(x), 'm')` — the three spellings that get past `private`; **type-aware**, and silent without `parserOptions.project`                            |
+| `no-dead-schemas`                 |   `error`   | —                 | `schemas` on a testing module that declares nothing — a charm protecting nobody, and one that starts working the day `declarations` arrive                                                                                                        |
+| `no-import-time-spread`           |   `error`   | suggest           | `export const x = [...Imported]` at module scope → a `TypeError` while the bundle loads                                                                                                                                                           |
+| `no-unregistered-inject-spy`      |   `error`   | —                 | `injectSpy(X)` for a token this file never registered → the real instance, whose spy helpers exist only for the compiler                                                                                                                          |
+| `prefer-render-shallow`           |   `warn`    | suggest           | `TestBed.createComponent` in a file that never reads the template → `renderShallow(X)`; 0.24× the per-test cycle at 100 children                                                                                                                  |
+| `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                     |
+| `no-passthrough-console-spy`      |   `error`   | suggest           | `vi.spyOn(console, m)` nothing gives an implementation — it calls through and still prints → `installConsoleSpies()` from `vitest-auto-spy/console`, or `.mockImplementation(() => undefined)`                                                    |
+| `no-console-in-spec`              |   `error`   | —                 | a spec that calls `console.x(…)` itself, or replaces a method with `console.x = …`, which nothing puts back — under `isolate: false` every later file inherits it                                                                                 |
+| `no-import-time-console-spies`    |   `error`   | —                 | an import of `vitest-auto-spy/console` in a file that never calls `installConsoleSpies()` — the import installs once per worker and, under `isolate: false`, silences every later file                                                            |
+| `no-mistyped-use-value`           |   `error`   | —                 | `{ provide: TOKEN, useValue }` whose value is not assignable to the primitive `TOKEN` declares — `useValue` is `any`, so `{}` for an `InjectionToken<boolean>` compiles and is truthy; **type-aware**, and silent without `parserOptions.project` |
+| `no-instance-lifecycle-spy`       |   `warn`    | —                 | `vi.spyOn(component, 'ngOnInit')` and the other hooks a view reads off the prototype — Angular never calls the instance spy → spy on `Cls.prototype` before the component is created, or assert the hook's effect                                 |
+| `jasmine-namespace-without-entry` |   `error`   | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compatibility layer nowhere                                                                                                                                          |
+| `no-jasmine-globals`              |   `error`   | —                 | `jasmine.*`, `spyOn(` / `spyOnProperty(` / `spyOnAllFunctions(` / `fail(` / `pending(`, `.withContext(` — none of them exist under Vitest                                                                                                         |
+| `no-save-arguments-by-value`      |   `error`   | —                 | `spy.calls.saveArgumentsByValue()`, which is a no-op here → take the copy at call time                                                                                                                                                            |
+| `prefer-native-spy-api`           |   `error`   | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — the last mile off the jasmine shim                                                                                                                                                |
 
 Every message ends with a link to the matching [recipe](#how-to-mock): a rule that only says
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Three of the twenty-eight fix on their own, nine offer suggestions**, and the split is not about how hard
+**Three of the thirty fix on their own, nine 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
@@ -3326,7 +3366,7 @@ package's own — it needs its ESLint integration switched on.
 ### WebStorm and the other JetBrains IDEs
 
 No plugin to install: WebStorm, IntelliJ IDEA Ultimate, PhpStorm, PyCharm Professional and RubyMine
-all run ESLint natively, so the twenty-eight rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the thirty rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3343,7 +3383,7 @@ has supported flat config since 2023.3); scope the block to spec files yourself;
 the fixes and suggestions live.
 
 A native JetBrains plugin is **not** planned — it would duplicate an integration the IDE already has
-and then keep a second copy of twenty-eight rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of thirty rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -3455,8 +3495,8 @@ another, and the next one is in that same file.
 | `flushEventLoopUntil(isDone, opts?)`                                                                                                        | Real event-loop turns until a condition holds, with a budget instead of a hang                                                                                                                                                                                                |
 | `diffByField(actual, expected)`                                                                                                             | Which field of an array of records moved, and in how many elements                                                                                                                                                                                                            |
 | `guardGlobalPatches(reaction)` / `installPerTest(install)` _(`/setup`)_                                                                     | Name the test that sealed a global property; re-install a stub before every test                                                                                                                                                                                              |
-| `guardStrayConsole(reaction)` / `withoutStrayTimerTracking(work)` _(`/setup`)_                                                              | Fail a test on console output nothing absorbed; keep setup work's timers out of the stray-timer count |
-| `describeStrayTimers()` _(`/setup`)_                                                                                                        | Each pending timer with the spec file and frames that scheduled it — for a suite that sweeps by hand |
+| `guardStrayConsole(reaction)` / `withoutStrayTimerTracking(work)` _(`/setup`)_                                                              | Fail a test on console output nothing absorbed; keep setup work's timers out of the stray-timer count                                                                                                                                                                         |
+| `describeStrayTimers()` _(`/setup`)_                                                                                                        | Each pending timer with the spec file and frames that scheduled it — for a suite that sweeps by hand                                                                                                                                                                          |
 | `guardPrototypePollution(reaction)` _(`/setup`)_                                                                                            | Name the test that left a key on `Object.prototype`, before the next file fails to collect                                                                                                                                                                                    |
 | `consoleDebugSpy` … `consoleWarnSpy` _(`/console`)_                                                                                         | Silent typed spies replacing the global `console` methods on import                                                                                                                                                                                                           |
 | `installConsoleSpies()` / `resetConsoleSpies()` / `restoreConsole()`                                                                        | Install / clear / undo the console spies                                                                                                                                                                                                                                      |

package/dist/angular.d.ts

@@ -1,10 +1,10 @@
-export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-DnjTTKlC.js';
+export { l as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, m as provideAutoSpyForToken, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-CvgjkxKw.js';
 import { InjectionToken, Provider, Type, Signal, WritableSignal } from '@angular/core';
 import { TestAPI } from 'vitest';
-import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-DTi4dIeN.js';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-D4TuS8yk.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-DmM-rPcG.js';
-export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C0xY_mYK.js';
+import { C as ClassType, S as Spy, k as ClassSpyConfiguration, o as OnlyMethodKeysOf, g as AddSpyMethodsByReturnTypes } from './types-DYGoBQGg.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-Bh7AZ2-0.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-DSWMTtRE.js';
+export { C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-H8lAQz2f.js';
 import '@angular/core/testing';
 
 /**

package/dist/angular.js

@@ -1154,7 +1154,23 @@ function throwUnstubbedCall(call) {
   const message = `[vitest-auto-spy] Nothing configured ${target}, and strict mode is on.
 Called as: ${target}(${call.args.map(renderArgument).join(",")})
 Configure it \u2014 .mockReturnValue(\u2026), .mockImplementation(\u2026), .resolveWith(\u2026), .nextWith(\u2026) or .calledWith(\u2026), or seed it through the 'returns' option \u2014 or drop 'strict' from this double.`;
-  throw new Error(withDocs(message, DOCS_LINKS.strictMode));
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 30;
+  const error = new Error(withDocs(message, DOCS_LINKS.strictMode));
+  Error.stackTraceLimit = limit;
+  recordStrictViolation(error);
+  throw error;
+}
+var MAX_RECORDED_VIOLATIONS = 50;
+var sharedViolations;
+function strictViolations() {
+  return sharedViolations ??= globalThis.__vitestAutoSpyStrictViolations__ ??= { errors: [] };
+}
+function recordStrictViolation(error) {
+  const { errors } = strictViolations();
+  if (errors.length < MAX_RECORDED_VIOLATIONS) {
+    errors.push(error);
+  }
 }
 var sharedStrictDefault;
 function strictDefault() {
@@ -1162,7 +1178,7 @@ function strictDefault() {
 }
 function resolveUnstubbedGuard(className2, config) {
   const defaults = strictDefault().config;
-  const handler = config.onUnstubbedCall ?? defaults?.onUnstubbedCall;
+  const handler = config.onUnstubbedCall ?? (config.strict === false ? void 0 : defaults?.onUnstubbedCall);
   if (handler) {
     return { className: className2, handle: handler };
   }
@@ -1173,7 +1189,7 @@ function resolveUnstubbedGuard(className2, config) {
 }
 function isUnconfigured(state) {
   const container = state.valueContainer;
-  return state.calledWith === void 0 && state.mustBeCalledWith === void 0 && container.value === void 0 && !container._isRejectedPromise && !container._isThrown && !container.valuesPerCalls?.length;
+  return state.calledWith === void 0 && state.mustBeCalledWith === void 0 && container.value === void 0 && !container._isRejectedPromise && !container._isThrown && !container._isSeeded && !container.valuesPerCalls?.length;
 }
 function lookupConfigured(calledWithObject, actualArgs) {
   const configured = calledWithObject.argsToValuesMap.get(actualArgs);
@@ -1266,6 +1282,7 @@ var FunctionSpyInternals = class {
     valueContainer.value = void 0;
     delete valueContainer._isRejectedPromise;
     delete valueContainer._isThrown;
+    delete valueContainer._isSeeded;
     delete valueContainer.valuesPerCalls;
     this.#observable?.reset();
     getMockAdapter().restoreImplementation(this.host, this.dispatch);
@@ -1275,6 +1292,19 @@ var FunctionSpyInternals = class {
     this.recorder.clear();
   }
 };
+function seedReturnValue(spy, value) {
+  const mark = Reflect.get(spy, AUTO_SPY_MARK);
+  if (!(mark instanceof FunctionSpyInternals)) {
+    return false;
+  }
+  const { valueContainer } = mark;
+  valueContainer.value = value;
+  valueContainer._isSeeded = true;
+  delete valueContainer._isRejectedPromise;
+  delete valueContainer._isThrown;
+  delete valueContainer.valuesPerCalls;
+  return true;
+}
 function internalsOf(self2, helper) {
   const mark = typeof self2 === "function" || typeof self2 === "object" && self2 !== null ? Reflect.get(self2, AUTO_SPY_MARK) : void 0;
   if (mark instanceof FunctionSpyInternals) {
@@ -1506,7 +1536,9 @@ function applyMockReturns(mock, returns) {
       );
       continue;
     }
-    adapter.restoreImplementation(spy, () => value);
+    if (!seedReturnValue(spy, value)) {
+      adapter.restoreImplementation(spy, () => value);
+    }
   }
 }
 var INTERNALS = /* @__PURE__ */ Symbol("vitest-auto-spy.autoMock.internals");
@@ -1874,7 +1906,9 @@ function applyReturns(autoSpy, factory, returns) {
       );
       return;
     }
-    adapter.restoreImplementation(spy, () => value);
+    if (!seedReturnValue(spy, value)) {
+      adapter.restoreImplementation(spy, () => value);
+    }
   });
 }
 function materializeMethodSpy(autoSpy, methodName, value) {

package/dist/bun-angular.d.ts

@@ -1,9 +1,9 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as OverloadChoice, t as Overloads, P as PropStubValue, S as Spy, u as SpyDisposable, v as SpyOptions, w as StrictSpyConfiguration, x as SubjectLike, y as SubjectOf, U as UnstubbedCall, z as UnstubbedCallHandler, V as ValueConfig, B as ValueConfigPerCall, W as WithMockReturnValue } from './types-DTi4dIeN.js';
-export { ArgCaptor, AsInstances, AssertMockedOptions, AutoSpyDefaultEntry, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, createFixture, createFixtureFactory, createFunctionSpy, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, registerAutoSpyDefaults, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
-export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-C0xY_mYK.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-DmM-rPcG.js';
-export { d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B1pqa-Sh.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-DnjTTKlC.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithObservable, c as AddCalledWithPromise, d as AddCalledWithSpyMethods, e as AddObservableSpyMethods, f as AddPromiseSpyMethods, g as AddSpyMethodsByReturnTypes, h as AddThrowHelper, i as AddVoidReturnHelpers, j as AutoSpyRxjsTypes, k as ClassSpyConfiguration, C as ClassType, l as CompleteValueConfig, D as DeepMockProxy, m as DeepPartial, E as ErrorValueConfig, F as Func, M as MethodReturns, n as Mutable, N as NextValueConfig, O as ObservableLike, o as OnlyMethodKeysOf, p as OnlyObservablePropsOf, q as OnlyPropsOf, r as Overload, s as OverloadChoice, t as Overloads, P as PropStubValue, S as Spy, u as SpyDisposable, v as SpyOptions, w as StrictSpyConfiguration, x as SubjectLike, y as SubjectOf, U as UnstubbedCall, z as UnstubbedCallHandler, V as ValueConfig, B as ValueConfigPerCall, W as WithMockReturnValue } from './types-DYGoBQGg.js';
+export { ArgCaptor, AsInstances, AssertMockedOptions, AutoSpyDefaultEntry, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, clearAutoSpyDefaults, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, registerAutoSpyDefaults, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
+export { A as AutoMockConfiguration, C as CallbackSubscribable, E as EmissionObserver, a as EmissionOptions, b as EmissionSource, S as SubscribableLike, c as autoMocked, d as createAutoMock, e as expectCompletion, f as expectEmission, g as expectEmissions, h as expectError, i as expectNoEmission, s as setEmissionTimeout } from './expect-emission-H8lAQz2f.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-B3aSBJRI.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-DSWMTtRE.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, R as RenderShallowOptions, c as ResourceStatusLike, S as SettleResourceOptions, d as ShallowRender, e as SpyRegistry, f as StableOptions, g as createWithAutoSpies, h as flushEffects, i as injectSpy, p as provideAutoSpy, r as renderShallow, j as runEffect, s as settleResource, k as stable } from './zoneless-CvgjkxKw.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,14 +1,14 @@
 import { flushEffects } from './chunk-ALFMIDWW.js';
 export { flushEffects, stable } from './chunk-ALFMIDWW.js';
-import './chunk-X57WQSOC.js';
-import { createSpyForToken } from './chunk-SWXAPWFW.js';
-export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-C5EPUC3A.js';
-import { currentSpecFile } from './chunk-APSBHO3I.js';
-export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-APSBHO3I.js';
-import { createSpyFromClass } from './chunk-GSWNTF5E.js';
-export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-GSWNTF5E.js';
+import './chunk-IW6ZHFTL.js';
+import { createSpyForToken } from './chunk-374SMZYV.js';
+export { asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-G73VE5ED.js';
+import { currentSpecFile } from './chunk-2PBOTZ4S.js';
+export { countMockedProps, mockAccessorsProp, mockReadonlyProp, mockReadonlyPropGetter, mockValueProp, reportPropsOutsideHooks, restoreMockedProps } from './chunk-2PBOTZ4S.js';
+import { createSpyFromClass } from './chunk-O5IKAXWI.js';
+export { autoMocked, clearAutoSpy, clearAutoSpyDefaults, createAutoMock, createSpyFromClass, registerAutoSpyDefaults, resetAutoSpy } from './chunk-O5IKAXWI.js';
 import { misconfigurationThrows, reportMisconfiguration } from './chunk-RZRKEUE6.js';
-export { createFunctionSpy, errorHandler } from './chunk-AVVUXEEI.js';
+export { createFunctionSpy, errorHandler } from './chunk-6ER757ZM.js';
 import './chunk-PC3FAZT3.js';
 import { isAutoSpyLike } from './chunk-B4Z3CFDJ.js';
 import { withDocs, DOCS_LINKS } from './chunk-B45HLBA4.js';