vitest-auto-spy 5.10.0 → 5.11.0

package/AGENTS.md

@@ -1724,6 +1724,25 @@ Three rules worth stating outright, because each of them cost a day somewhere:
   teardown — a green run with `NG0205: Injector has already been destroyed` in "Unhandled Errors"
   and a non-zero exit code.
 
+**`stable()` and `flushEffects()` are not zoneless-only, and their tick runs inside the `NgZone` so
+that they are not.** `TestBed.createComponent` builds the component inside `ngZone.run(…)`, so an
+`effect()` its constructor registers records the zone's inner zone as its own. A bare `TestBed.tick()`
+from a test body runs in the runner's zone, so Angular hops back into the recorded one to run a
+**dirty** effect, and leaving that hop takes the zone from unstable to stable.
+`provideZoneChangeDetection()` — which `@angular/build:unit-test` installs for every suite that loads
+zone.js — answers `NgZone.onMicrotaskEmpty` with `ApplicationRef._tick()`, guarded against its own
+scheduler but not against `ApplicationRef._runningTick`, so the tick already on the stack is
+re-entered: `NG0101: ApplicationRef.tick is called recursively`. Angular hands that to `ErrorHandler`
+instead of throwing it at the call site, so a suite that does not fail on console output stays green
+with the change detection it asked for unfinished. Measured on an Angular 22 suite of 1771 spec files:
+451 `componentRef.setInput` calls rewritten to `setInputs` turned **57 green files red** on `NG0101`,
+and none of them after the tick moved inside the zone. Under zoneless `NgZone` is a `NoopNgZone` whose
+`run` is a straight call, so it costs nothing there. One thing is genuinely new for a zone-based
+consumer: leaving the zone reports it stable, so the same subscriber ticks once more — counted on
+`ApplicationRef.afterTick`, one `flushEffects()` is 1 → 2 application ticks, which is what
+`fixture.detectChanges()` has always done in the same position. Do not "simplify" either helper back
+to a bare `TestBed.tick()`; `src/zone-tests/stable.zone-test.ts` is the guard.
+
 `flushEventLoopUntil(isDone, { turns, label })` is the same thing with a condition and a budget —
 for a chunk becoming reachable, an SDK reporting itself ready, a queue draining. Use it instead of a
 hand-tuned turn count: the count depends on the dependency, not on the spec, and a condition that
@@ -2369,11 +2388,17 @@ Five things to know:
   `provideRouter()` is what tests a navigation.
 - **`emitNavigation()` takes what you have** — nothing, a URL string, or an event you built. A
   `NavigationEnd` moves the URL with it; any other event does not.
-- **The navigation in flight follows the events.** `setCurrentNavigation({ extras: { state } })`
-  puts one up and `setCurrentNavigation(null)` ends it; a `NavigationStart` pushed through
-  `emitNavigation()` starts one with that event's id, URL and trigger, and a `NavigationEnd`,
-  `NavigationCancel`, `NavigationError` or `NavigationSkipped` drops it back to `null` — which is
-  what the real router answers to a component reading it while handling a `NavigationEnd`.
+- **The navigation in flight follows the events, and a terminal event ends it _after_ delivering
+  it.** `setCurrentNavigation({ extras: { state } })` puts one up and `setCurrentNavigation(null)`
+  ends it; a `NavigationStart` pushed through `emitNavigation()` starts one with that event's id,
+  URL and trigger, and a `NavigationEnd`, `NavigationCancel`, `NavigationError` or
+  `NavigationSkipped` drops it back to `null` once its subscribers have run. Angular's doc comment
+  — "the current navigation becomes to null after the NavigationEnd event is emitted" — means
+  _after_ literally: the router emits the terminal event from a `tap` with the navigation still in
+  flight and clears it in the `finalize` below, and `events` is a Subject, so a synchronous
+  subscriber runs between the two. **A component that reads `currentNavigation()` while handling a
+  `NavigationEnd` gets the navigation that just finished**, here and in production; it reads `null`
+  only once `navigate()` has resolved. Probed against a real `provideRouter()` on Angular 22.
 - **Ordering does not matter here.** `Router` is `providedIn: 'root'` and `provideRouter()` does not
   re-provide the token, so the double wins in either order — and a `TestBed` without it hands out a
   real router, which is what `injectRouterDouble()` says by name.
@@ -2682,6 +2707,7 @@ const { fixture, component } = renderShallow(TaskListComponent, {
 // change an input after the first render — one setInput per key, then the wait, in one await
 await setInputs(fixture, { projectId: 7 }); // a name the component does not declare is refused here
 await setInputs(fixture, { projectId: 7 }, { label: 'the task list' }); // options go to stable()
+// a fixture whose componentType carries no ɵcmp is refused by name too, not as a bare TypeError
 
 // build a class through DI, every unprovided token auto-spied
 const { instance, spies } = createWithAutoSpies(CartService, {
@@ -3109,7 +3135,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | --------------------------------- | ------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `no-expect-in-subscribe`          | `error` | suggest           | `expect()` inside `subscribe()` → `expectEmission` / `firstValueFrom`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `no-object-define-property`       | `error` | suggest           | `Object.defineProperty` in a spec → `mockReadonlyProp` / `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `prefer-provide-auto-spy`         | `error` | —                 | a hand-rolled `useValue`, `useFactory`, `useClass` or `useExisting` (also `useValue: new StubMock()`), in a provider **or** a `TestBed.overrideProvider(X, { … })` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`. A name in the slot is followed one step, through an initialiser or a single `beforeEach` assignment                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `prefer-provide-auto-spy`         | `error` | fix               | a hand-rolled `useValue`, `useFactory`, `useClass` or `useExisting` (also `useValue: new StubMock()`), in a provider **or** a `TestBed.overrideProvider(X, { … })` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`. A name in the slot is followed one step, through an initialiser or a single `beforeEach` assignment. `{ provide: X, useValue: createSpyFromClass(X, config) }` — the factory's own body, written out — is reported and **rewritten** to `provideAutoSpy(X, config)`; a double read from a _different_ class (`{ provide: LocalStorage, useValue: createSpyFromClass(BaseLocalStorage) }`) is not, since the abstract token has no prototype for `provideAutoSpy` to read                                             |
 | `prefer-create-spy-from-class`    | `error` | —                 | an object literal of 2+ `vi.fn()`s → `createSpyFromClass` (a factory's own seed is exempt)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `no-stub-class-double`            | `warn`  | —                 | a class whose fields are `vi.fn()`s → `createSpyFromClass` / `provideAutoSpy` and delete the stub; a decorated, `implements`-ing, `extends`-ing or unnamed class is exempt — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `no-structural-double`            | `warn`  | —                 | an object of `vi.fn()`s bound to a name declared `{ load: Mock }` → `createAutoMock<T>()`; a bare `let fn: Mock` is a callback and never reported — option: `{ minRunnerFns }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
@@ -3127,6 +3153,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `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-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-observer-stub`            | `error` | —                 | a hand-rolled observer global → `stubIntersectionObserver()` / `stubResizeObserver()` / `stubMutationObserver()`; the manual save-and-restore goes too, `restoreMockedProps()` runs the undo                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `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)`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
@@ -3145,8 +3172,8 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-save-arguments-by-value`      | `error` | —                 | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `prefer-native-spy-api`           | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
-Thirty-seven 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, twelve offer suggestions. Thirty-four are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
+Thirty-eight rules, **every one an `error` since 4.0.0 except `prefer-render-shallow`,
+`no-stub-class-double`, `no-structural-double`, `no-instance-lifecycle-spy` and `prefer-set-inputs`**; four fix on their own, thirteen offer suggestions. Thirty-five are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
 `no-unknown-use-value-key` read types, and all three report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
 builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it. The config used to be a graded mix of `error` / `warn` / `off`, which decided for the
@@ -3390,6 +3417,7 @@ packages, which a subpath export can never be.
 | `nextWith` demanding `HttpEvent<T>` on a generated API client                                                                                       | `Parameters`/`ReturnType` read the **last** overload                                                                                                                                                                                                                        | `asSpy<Client, { overload: 'first' }>(…)`, or `Overload<M, 0>` — never `@ts-expect-error`, which `no-ts-expect-error-on-double` reports (§16)                                                                                                                                                                                                                                                                                                                                                                     |
 | `NG0303` / `NG0304` / nothing at all, from a directive spec                                                                                         | the host is `standalone: false`, or the module is in the TestBed                                                                                                                                                                                                            | `createDirectiveHost({ template, scope: [Module] })` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `setInputs: … declares no input named …`                                                                                                            | the key is not an input of that component — a typo, an input renamed since, or one of its own fields                                                                                                                                                                        | set the names the message lists; a signal the component owns is moved through the signal (§13)                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `setInputs: X carries no ɵcmp, so there are no inputs to set`                                                                                       | the fixture's `componentType` is not a compiled `@Component` — a `@Directive` or `@Pipe` class, or one Angular never compiled (a barrel import that resolved to `undefined`)                                                                                                | pass a component fixture; a directive takes its inputs through the host element that applies it (`createDirectiveHost`), and for `undefined` import the class from its own file (§13)                                                                                                                                                                                                                                                                                                                             |
 | `TS2540: Cannot assign to 'X' because it is a read-only property`                                                                                   | a `readonly` field of an object under test                                                                                                                                                                                                                                  | `mockValueProp(obj, 'X', value)` — on a class **getter**, `mockReadonlyProp`                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `TypeError: Cannot read properties of undefined (reading 'mockReturnValue')`                                                                        | the member is an **instance field**, not on the prototype — `Router.currentNavigation` since Angular 20                                                                                                                                                                     | `provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] })` (§5)                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `throwWith` reaching the success branch first, with the previous test's value                                                                       | the spy's `ReplaySubject(1)` outlived the test that filled it                                                                                                                                                                                                               | upgrade; and `resetAutoSpy(spy)` in `beforeEach` when the TestBed is built in `beforeAll`                                                                                                                                                                                                                                                                                                                                                                                                                         |

package/README.md

@@ -79,7 +79,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 — thirty-seven rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, twelve 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-eight rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, thirteen 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
@@ -2417,8 +2417,20 @@ flushEffects(); // the no-fixture half: services, stores, runInInjectionContext
 `fixture.detectChanges()` runs a single change-detection pass and does **not** flush pending
 effects, so an assertion right after it reads state that has not finished computing. In a zoneless
 app the state that matters is signal-derived and effects are what move it forward. `stable` does
-both, in the right order; `flushEffects` prefers `TestBed.tick()` (Angular ≥ 20) and falls back to
-`ApplicationRef.tick()`.
+both, in the right order; `flushEffects` is `TestBed.tick()`, run inside the `NgZone`.
+
+**Both work under zone.js, and the zone is why the tick is wrapped.** The name says zoneless and the
+helpers are written for it, but nothing in them is — `stable` and `setInputs` are the same two lines
+in a zone-based suite. `TestBed.createComponent` builds the component inside `ngZone.run(…)`, so an
+`effect()` its constructor registers records the zone's inner zone; a tick started from a test body
+runs in the runner's zone, hops back to run a **dirty** effect, and leaving that hop reports the zone
+stable mid-tick. `provideZoneChangeDetection()` — which the Angular CLI's unit-test builder installs
+for every suite that loads zone.js — answers that with `ApplicationRef._tick()`, guarded against its
+own scheduler but not against the tick already on the stack, which is
+`NG0101: ApplicationRef.tick is called recursively`. Running the tick inside the zone removes the hop.
+Measured on an Angular 22 suite of 1771 spec files: 451 `componentRef.setInput` calls rewritten to
+`setInputs` turned **57 green files red** on `NG0101`, and none of them after the fix. Under zoneless
+`NgZone` is a `NoopNgZone` whose `run` is a straight call, so it costs nothing there.
 
 The wait is bounded: `stable` gives the fixture **2000 ms** and then throws the cause, instead of
 letting the runner report a 5 s file-level timeout that names neither the helper nor the fixture.
@@ -3336,7 +3348,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 four.** The config used to grade them `error` / `warn` /
+**Every rule is an `error` since 4.0.0, bar five.** 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
@@ -3392,51 +3404,52 @@ 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                                                                                                                                                                                                      |
-| `prefer-provide-activated-route`  |   `error`   | —                 | a hand-built `ActivatedRoute` — any `useValue` / `useClass` / `useFactory`, 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 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-unknown-use-value-key`        |   `error`   | —                 | a key of an object `useValue` literal the provided type does not have — `T` of an `InjectionToken<T>`, or a class's instance; keys only, never the values; silent on `any` / `unknown`, an index signature, a spread and `multi: true`; **type-aware**                                                                                                                                             |
-| `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                                                                                                                                                                                  |
-| `no-ts-expect-error-on-double`    |   `error`   | —                 | `@ts-expect-error` / `@ts-ignore` above `nextWith`, `resolveWith`, `mockReturnValue`, `calledWith(…)` and the other helpers that check a stub against the method's signature — an overloaded method takes `Spy<X, { overload: { m: 'first' } }>`, anything else is a fixture of the wrong shape                                                                                                    |
-| `no-constant-expect`              |   `error`   | —                 | `expect(true).toBe(true)`, `expect({ … }).toBeDefined()` — a value the spec spelled out, under a matcher whose answer that value already fixes → assert on what the code produced, or `expect.fail(…)` for a branch the test must not reach                                                                                                                                                        |
-| `no-redundant-smoke-test`         |   `error`   | suggest           | `it('should create', () => expect(pipe).toBeTruthy())` — a test whose whole body asks whether the subject is there, in a block whose other tests run the same `beforeEach` and would fail first, naming what they were doing → delete it; the suggestion does. A block whose only running test is that one is left alone                                                                           |
-| `no-compile-components`           |   `error`   | suggest           | `compileComponents()` under a builder that inlines `templateUrl` / `styleUrls` — a promise already settled; **silent** until `{ builder: 'inline-resources' }` says so, because a JIT setup that loads resources at run time needs the call. One exception the rule cannot see: a component whose template holds a `@defer` block ships async class metadata, so the call stays load-bearing there |
-| `no-sync-testbed-await`           |   `error`   | suggest           | `await` on a TestBed call that answers the TestBed or a fixture — `configureTestingModule`, every `override*`, `resetTestingModule`, `createComponent`, `getLastFixture`; none of them is a promise, so the `await` waits for nothing and the `async` it forced on the hook awaits nothing either. The suggestion drops both. Reads no types, so it reports without `parserOptions.project`        |
-| `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`   | fix               | a hand-rolled `useValue`, `useFactory` **or** `useClass` → `provideAutoSpy(Class)` / `provideAutoSpyForToken(TOKEN)`; and `{ provide: X, useValue: createSpyFromClass(X) }` — the factory written out — which it rewrites                                                                                                                                                                                                                                                                                        |
+| `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-set-inputs`               |   `warn`    | suggest           | a run of `fixture.componentRef.setInput('title', v)` on one fixture → `await setInputs(fixture, { title: v })`, which resolves every name against the compiled definition before it writes one — an undeclared name is an `NG0303` on the console and no change at all — and types the value. The suggestion collapses the run, drops a `detectChanges()` under it and makes the callback `async`; it is offered rather than applied, because `stable()` ticks and a zone.js suite can answer that with `NG0101` |
+| `prefer-observer-stub`            |   `error`   | —                 | a hand-rolled `IntersectionObserver` / `ResizeObserver` / `MutationObserver` written into a global → `stubIntersectionObserver()` and friends, whose undo `restoreMockedProps()` already runs                                                                                                                                                                                                                                                                                                                    |
+| `prefer-provide-activated-route`  |   `error`   | —                 | a hand-built `ActivatedRoute` — any `useValue` / `useClass` / `useFactory`, 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 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-unknown-use-value-key`        |   `error`   | —                 | a key of an object `useValue` literal the provided type does not have — `T` of an `InjectionToken<T>`, or a class's instance; keys only, never the values; silent on `any` / `unknown`, an index signature, a spread and `multi: true`; **type-aware**                                                                                                                                                                                                                                                           |
+| `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                                                                                                                                                                                                                                                                                                |
+| `no-ts-expect-error-on-double`    |   `error`   | —                 | `@ts-expect-error` / `@ts-ignore` above `nextWith`, `resolveWith`, `mockReturnValue`, `calledWith(…)` and the other helpers that check a stub against the method's signature — an overloaded method takes `Spy<X, { overload: { m: 'first' } }>`, anything else is a fixture of the wrong shape                                                                                                                                                                                                                  |
+| `no-constant-expect`              |   `error`   | —                 | `expect(true).toBe(true)`, `expect({ … }).toBeDefined()` — a value the spec spelled out, under a matcher whose answer that value already fixes → assert on what the code produced, or `expect.fail(…)` for a branch the test must not reach                                                                                                                                                                                                                                                                      |
+| `no-redundant-smoke-test`         |   `error`   | suggest           | `it('should create', () => expect(pipe).toBeTruthy())` — a test whose whole body asks whether the subject is there, in a block whose other tests run the same `beforeEach` and would fail first, naming what they were doing → delete it; the suggestion does. A block whose only running test is that one is left alone                                                                                                                                                                                         |
+| `no-compile-components`           |   `error`   | suggest           | `compileComponents()` under a builder that inlines `templateUrl` / `styleUrls` — a promise already settled; **silent** until `{ builder: 'inline-resources' }` says so, because a JIT setup that loads resources at run time needs the call. One exception the rule cannot see: a component whose template holds a `@defer` block ships async class metadata, so the call stays load-bearing there                                                                                                               |
+| `no-sync-testbed-await`           |   `error`   | suggest           | `await` on a TestBed call that answers the TestBed or a fixture — `configureTestingModule`, every `override*`, `resetTestingModule`, `createComponent`, `getLastFixture`; none of them is a promise, so the `await` waits for nothing and the `async` it forced on the hook awaits nothing either. The suggestion drops both. Reads no types, so it reports without `parserOptions.project`                                                                                                                      |
+| `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 thirty-seven fix on their own, twelve offer suggestions**, and the split is not about how hard
+**Four of the thirty-eight fix on their own, thirteen 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
@@ -3529,6 +3542,17 @@ line named after construction. It is weighed against the tests that share its se
 its block. Measured over an Angular suite of 1771 spec files: 569 findings in 540 of them, 515 still carrying the
 `should create` / `should be created` title `ng generate` wrote; on a second suite of 845 files, 97 in 87. The suggestion deletes the test together with the blank line above it.
 
+`prefer-set-inputs` reports a run of `fixture.componentRef.setInput('name', value)` on one fixture.
+Angular checks that name against nothing: an input the component does not declare answers with an
+`NG0303` on the console and **no change at all**, so the spec fails several lines later, on state
+nothing moved. `setInputs(fixture, { … })` resolves every key against the compiled definition before
+it writes the first one and types the value — on the 1771-file suite, rewriting the 650 calls it can
+rewrite turned 72 drifted fixtures into compile errors across 21 files. It reports 504 times in 140
+files there, and the edit is a **suggestion**: `setInputs` awaits `stable()`, whose `TestBed.tick()`
+re-enters the tick zone.js schedules for itself, and accepting all 451 of them turned 57 of 105 green
+files red on `NG0101: ApplicationRef.tick is called recursively`. That is also why it ships as a
+`warn`: the finding is a fact, the repair is a migration a project takes file by file.
+
 `no-compile-components` says nothing until `['error', { builder: 'inline-resources' }]`
 states that the builder inlines `templateUrl` / `styleUrls`; then `compileComponents()` is a promise
 already settled, and a suggestion deletes it together with the `async` of a hook that awaits nothing
@@ -3584,7 +3608,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 thirty-seven rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the thirty-eight rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3601,7 +3625,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 thirty-seven rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of thirty-eight rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 

package/dist/angular-http.js

@@ -1,4 +1,4 @@
-import { flushEffects } from './chunk-GNJLDNJS.js';
+import { flushEffects } from './chunk-M5BULP7X.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 import { provideHttpClient } from '@angular/common/http';
 import { provideHttpClientTesting, HttpTestingController } from '@angular/common/http/testing';

package/dist/angular-router.js

@@ -246,22 +246,22 @@ function createUrlState(initial) {
     }
   };
 }
-function followEvent(event, inFlight, navigationOf) {
-  if (event instanceof NavigationStart) {
-    inFlight.set(
-      navigationOf({
-        id: event.id,
-        initialUrl: serializer.parse(event.url),
-        extractedUrl: serializer.parse(event.url),
-        trigger: event.navigationTrigger ?? "imperative"
-      })
-    );
-    return event.id;
-  }
-  if (event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError || event instanceof NavigationSkipped) {
-    inFlight.set(null);
+function startEvent(event, inFlight, navigationOf) {
+  if (!(event instanceof NavigationStart)) {
+    return void 0;
   }
-  return void 0;
+  inFlight.set(
+    navigationOf({
+      id: event.id,
+      initialUrl: serializer.parse(event.url),
+      extractedUrl: serializer.parse(event.url),
+      trigger: event.navigationTrigger ?? "imperative"
+    })
+  );
+  return event.id;
+}
+function endsNavigation(event) {
+  return event instanceof NavigationEnd || event instanceof NavigationCancel || event instanceof NavigationError || event instanceof NavigationSkipped;
 }
 function buildNavigation(state, id, named) {
   return {
@@ -334,8 +334,11 @@ function createRouterDouble(init = {}) {
       if (next instanceof NavigationEnd) {
         state.set(next.urlAfterRedirects);
       }
-      navigationId = followEvent(next, inFlight, navigationOf) ?? navigationId;
+      navigationId = startEvent(next, inFlight, navigationOf) ?? navigationId;
       events.next(next);
+      if (endsNavigation(next)) {
+        inFlight.set(null);
+      }
     }
   };
   doubles2.set(router, double);

package/dist/angular.d.ts

@@ -1,4 +1,4 @@
-export { o as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, 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 injectSpy, p as provideAutoSpy, q as provideAutoSpyForToken, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-BoA6j-74.js';
+export { o as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, 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 injectSpy, p as provideAutoSpy, q as provideAutoSpyForToken, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-C-DgtCj9.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal, ProviderToken, FactoryProvider, AbstractType, Injector, ValueProvider } from '@angular/core';
 import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-CmN9ADyN.js';
 export { C as CallbackSubscribable, E as EmissionObserver, b as EmissionOptions, c as EmissionSource, S as SubscribableLike, g as expectCompletion, h as expectEmission, i as expectEmissions, j as expectError, k as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CmN9ADyN.js';

package/dist/angular.js

@@ -2,7 +2,7 @@ import { registerMockAdapter, getMockAdapter, emissionTimeout, getObservableSupp
 export { setEmissionTimeout } from './shared-state.js';
 import { vi, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
 import { TestBed, getTestBed } from '@angular/core/testing';
-import { DOCUMENT, isStandalone, Component, Pipe, Directive, Input, Output, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, untracked, isSignal, signal, ɵSIGNAL as _SIGNAL, computed, InjectionToken, model, EventEmitter, input } from '@angular/core';
+import { DOCUMENT, isStandalone, Component, Pipe, Directive, Input, Output, Injector, runInInjectionContext, NO_ERRORS_SCHEMA, untracked, NgZone, isSignal, signal, ɵSIGNAL as _SIGNAL, computed, InjectionToken, model, EventEmitter, input } from '@angular/core';
 import { By } from '@angular/platform-browser';
 import { ReplaySubject } from 'rxjs';
 
@@ -3326,7 +3326,9 @@ function runEffect(effectRef) {
 var setTimer = globalThis.setTimeout.bind(globalThis);
 var clearTimer = globalThis.clearTimeout.bind(globalThis);
 function flushEffects() {
-  TestBed.tick();
+  TestBed.inject(NgZone).run(() => {
+    TestBed.tick();
+  });
 }
 async function stable(fixture, options = {}) {
   flushEffects();
@@ -3359,7 +3361,10 @@ function unstableError(timeout, label) {
 
 // src/lib/set-inputs.ts
 function inputNames(component) {
-  const definition2 = Reflect.get(component, "\u0275cmp");
+  const definition2 = typeof component === "function" ? Reflect.get(component, "\u0275cmp") : void 0;
+  if (!definition2) {
+    throw missingDefinitionError(component);
+  }
   const declared = Object.entries(definition2.inputs);
   const names = new Map(declared.map(([publicName, [property]]) => [property, publicName]));
   declared.forEach(([publicName]) => names.set(publicName, publicName));
@@ -3368,6 +3373,15 @@ function inputNames(component) {
 function quote(names) {
   return names.map((name) => `'${name}'`).join(", ");
 }
+function missingDefinitionError(component) {
+  const name = typeof component === "function" ? component.name : String(component);
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] setInputs: ${name} carries no \u0275cmp, so there are no inputs to set. The fixture must be a @Component's: a @Directive (\u0275dir) takes its inputs through the host element that applies it, a @Pipe (\u0275pipe) has none, and a class Angular never compiled carries no definition at all. For \`undefined\`, import the component from its own file rather than from a barrel.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
 function unknownInputsError(component, unknown, declared) {
   const known = declared.length > 0 ? `Its inputs are ${quote(declared)}.` : "It declares no inputs at all.";
   return new Error(

package/dist/bun-angular.d.ts

@@ -3,7 +3,7 @@ export { ArgCaptor, AsInstances, AssertMockedOptions, ConstructorMock, Construct
 export { A as AutoMockConfiguration, a as AutoSpyDefaultEntry, C as CallbackSubscribable, E as EmissionObserver, b as EmissionOptions, c as EmissionSource, S as SubscribableLike, d as autoMocked, e as clearAutoSpyDefaults, f as createAutoMock, g as expectCompletion, h as expectEmission, i as expectEmissions, j as expectError, k as expectNoEmission, r as registerAutoSpyDefaults, s as setEmissionTimeout } from './expect-emission-CmN9ADyN.js';
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-lm-gqZAR.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-DnYNBNJL.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, 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 injectSpy, p as provideAutoSpy, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-BoA6j-74.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, 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 injectSpy, p as provideAutoSpy, r as renderShallow, k as runEffect, s as setInputs, l as settleResource, m as stable, t as trackEffectRuns, n as trackRecomputations } from './track-signal-runs-C-DgtCj9.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -1,5 +1,5 @@
-import { stable, flushEffects } from './chunk-GNJLDNJS.js';
-export { flushEffects, stable } from './chunk-GNJLDNJS.js';
+import { stable, flushEffects } from './chunk-M5BULP7X.js';
+export { flushEffects, stable } from './chunk-M5BULP7X.js';
 import './chunk-M6VMOOZ2.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-JOI3BLCL.js';
 import { currentSpecFile, mockValueProp } from './chunk-N3T7KWWA.js';
@@ -414,7 +414,10 @@ function runEffect(effectRef) {
 
 // src/lib/set-inputs.ts
 function inputNames(component) {
-  const definition = Reflect.get(component, "\u0275cmp");
+  const definition = typeof component === "function" ? Reflect.get(component, "\u0275cmp") : void 0;
+  if (!definition) {
+    throw missingDefinitionError(component);
+  }
   const declared = Object.entries(definition.inputs);
   const names = new Map(declared.map(([publicName, [property]]) => [property, publicName]));
   declared.forEach(([publicName]) => names.set(publicName, publicName));
@@ -423,6 +426,15 @@ function inputNames(component) {
 function quote2(names) {
   return names.map((name) => `'${name}'`).join(", ");
 }
+function missingDefinitionError(component) {
+  const name = typeof component === "function" ? component.name : String(component);
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] setInputs: ${name} carries no \u0275cmp, so there are no inputs to set. The fixture must be a @Component's: a @Directive (\u0275dir) takes its inputs through the host element that applies it, a @Pipe (\u0275pipe) has none, and a class Angular never compiled carries no definition at all. For \`undefined\`, import the component from its own file rather than from a barrel.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
 function unknownInputsError(component, unknown, declared) {
   const known = declared.length > 0 ? `Its inputs are ${quote2(declared)}.` : "It declares no inputs at all.";
   return new Error(

package/dist/{chunk-GNJLDNJS.js → chunk-M5BULP7X.js}

@@ -1,10 +1,13 @@
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
+import { NgZone } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 
 var setTimer = globalThis.setTimeout.bind(globalThis);
 var clearTimer = globalThis.clearTimeout.bind(globalThis);
 function flushEffects() {
-  TestBed.tick();
+  TestBed.inject(NgZone).run(() => {
+    TestBed.tick();
+  });
 }
 async function stable(fixture, options = {}) {
   flushEffects();

package/dist/cli.js

@@ -2453,7 +2453,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.10.0";
+var EXPORT_MAP_VERSION = "5.11.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 17 18 19",