vitest-auto-spy 5.9.0 → 5.10.1

package/AGENTS.md

@@ -2345,27 +2345,41 @@ converged on, and every part of it is a guess the component falls through: `of()
 `url` is a string nobody updates, `routerState` is absent, `serializeUrl` throws on the first
 redirect a guard builds. `provideRouterDouble(init)` keeps one URL and derives the rest.
 
-| Call                            | Does                                                                                                         |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------ |
-| `provideRouterDouble(init?)`    | a `FactoryProvider` for the `Router` token — a fresh router per injector; `init` is `{ url }`, default `'/'` |
-| `injectRouterDouble(injector?)` | the handle: `.router`, `.navigate`, `.navigateByUrl`, `setUrl(url)`, `emitNavigation(event?)`                |
-| `createRouterDouble(init?)`     | the same handle without a `TestBed` — for `new AuthGuard(router)`                                            |
+| Call                            | Does                                                                                                                               |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `provideRouterDouble(init?)`    | a `FactoryProvider` for the `Router` token — a fresh router per injector; `init` is `{ url }`, default `'/'`                       |
+| `injectRouterDouble(injector?)` | the handle: `.router`, `.navigate`, `.navigateByUrl`, `setUrl(url)`, `emitNavigation(event?)`, `setCurrentNavigation(navigation?)` |
+| `createRouterDouble(init?)`     | the same handle without a `TestBed` — for `new AuthGuard(router)`                                                                  |
 
 Unlike the route, this is **not** an instance of Angular's class: a real `Router` drags the whole
 routing stack in. It is a structural double that answers `url` (serialized as the real router does),
 `events` (a `BehaviorSubject` starting at the `NavigationEnd` that put it there), `navigate` and
 `navigateByUrl` (spies resolving `true`), `serializeUrl` / `parseUrl` / `createUrlTree` (the
-router's own URL work, via `DefaultUrlSerializer` and `createUrlTreeFromSnapshot`) and `routerState`
-(Angular's own, its `snapshot.url` the URL). **Every other member `Router` declares throws by name**
-rather than reading `undefined`.
+router's own URL work, via `DefaultUrlSerializer` and `createUrlTreeFromSnapshot`), `routerState`
+(Angular's own, its `snapshot.url` the URL) and `currentNavigation` / `getCurrentNavigation()` (the
+navigation in flight, `null` while the router stands still). **Every other member `Router` declares
+throws by name** rather than reading `undefined` — and that holds for the instance fields too, which
+is why a hand-rolled double needs `instanceMethodsToSpyOn: ['currentNavigation']` and this one does
+not.
 
-Four things to know:
+Five things to know:
 
 - **It does not navigate.** `navigate()` records the call and resolves `true`; it does not move
   `url`. `setUrl()` and `emitNavigation()` move it; `RouterTestingHarness` over a real
   `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, 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.
@@ -2465,7 +2479,9 @@ Five things to know:
   `InjectionToken<Window>`. The helper is generic over the token's type, so an
   `InjectionToken<AppWindow>` has that interface's members checked in the overrides too.
 - **A plain `{ … }` merges, anything else replaces.** `{ screen: { width: 1920 } }` keeps
-  `screen.colorDepth`; a `vi.fn()`, an array, a `URL` or a stub instance becomes the member whole.
+  `screen.colorDepth`; a `vi.fn()`, an array, a `URL` or a stub instance becomes the member whole. The
+  slice goes three levels down, the way the merge does — `{ document: { location: { href: '' } } }` is
+  checked and merged member by member.
 - **Nothing to restore.** The globals are never patched — the double is a view over them, and every
   write and delete lands on the view, which is also how a spec moves a value mid-test:
   `Object.assign(TestBed.inject(WINDOW), { scrollY: 40 })` (`Object.assign` because lib.dom declares
@@ -3127,6 +3143,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `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                                                                                                                                                                                                                                                                                                                                                                                       |
 | `no-ts-expect-error-on-double`    | `error` | —                 | `@ts-expect-error` / `@ts-ignore` above `nextWith`, `resolveWith`, `mockReturnValue`, `returnValue`, `calledWith(…)` and the other helpers that check a stub against the method's signature → an overloaded method takes `Spy<X, { overload: { m: 'first' } }>`; otherwise the fixture is the wrong shape, checked against `ReturnType<X['m']>`. A reason after the directive does not silence it; a deliberate out-of-type value keeps it under `eslint-disable-next-line … -- <why>`                                                                                                                                                                                                                                                               |
 | `no-constant-expect`              | `error` | —                 | `expect(true).toBe(true)`, `expect({ … }).toBeDefined()` — a value the spec spelled out, under a matcher whose answer it already fixes (`toBe` / `toEqual` / `toStrictEqual` against a literal; `toBeTruthy`, `toBeDefined`, `toBeNull`… for any literal) → assert on what the code produced, or `expect.fail(…)` for an unreachable branch                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `no-redundant-smoke-test`         | `error` | suggest           | `it('should create', () => expect(pipe).toBeTruthy())` — every statement of the body an `expect(x)` under `toBeTruthy` / `toBeDefined` / `toBeInstanceOf` (or their negated twins), weighed against the tests that run the same setup: the rest of the block, and everything the blocks nested in it declare → delete it; the suggestion removes the test and the blank line above it. Silent where that test is the block's only running one, and a skipped sibling does not count as proof                                                                                                                                                                                                                                                         |
 | `no-compile-components`           | `error` | suggest           | `compileComponents()` under a builder that inlines `templateUrl` / `styleUrls` — a promise already settled → delete it, and the `async` of a hook that awaits nothing else. **Silent until** `['error', { builder: 'inline-resources' }]`: under a JIT setup that loads resources at run time the call is load-bearing. **Keep the call for a component whose template holds a `@defer` block** — that ships async class metadata, which `TestBed` resolves in this very call whatever the builder did, and dropping it fails the test with `has unresolved metadata`; the rule cannot see another file's template, so such a call keeps its own `// eslint-disable-next-line vitest-auto-spy/no-compile-components -- @defer: async class metadata` |
 | `no-sync-testbed-await`           | `error` | suggest           | `await` on a TestBed call that answers the TestBed or a fixture — `configureTestingModule`, `override*`, `resetTestingModule`, `createComponent`, `getLastFixture`, through `TestBed`, `getTestBed()`, a chain of those, or a name holding one → drop the `await`, and the `async` of a hook that then awaits nothing else; the suggestion does both. Reads **no types**, so it reports without `parserOptions.project`, where `@typescript-eslint/await-thenable` cannot. `inject` and `runInInjectionContext` are never reported: each answers whatever the token or the callback holds, which can be a promise                                                                                                                                    |
 | `jasmine-namespace-without-entry` | `error` | —                 | `.and` / `.calls` / `.withArgs` on a library spy in a file that installs the compat layer nowhere — option: `{ setupModules: […] }`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
@@ -3134,8 +3151,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-six 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, eleven offer suggestions. Thirty-three are syntactic; `no-private-member-access`, `no-mistyped-use-value` and
+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
 `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
@@ -3408,7 +3425,7 @@ packages, which a subpath export can never be.
 | `injectActivatedRoute(): nothing provides ActivatedRoute here`                                                                                      | no `ActivatedRoute` provider in the injector it read                                                                                                                                                                                                                        | `provideActivatedRoute({ … })` from `vitest-auto-spy/angular-router` in `providers`; `injectActivatedRoute(fixture.debugElement.injector)` for a component-level one (§13)                                                                                                                                                                                                                                                                                                                                        |
 | `the ActivatedRoute here is … not one provideActivatedRoute() built`                                                                                | a later provider of `ActivatedRoute` won — `provideRouter()`, `RouterModule`, a `useValue`, `provideAutoSpy(ActivatedRoute)`                                                                                                                                                | list `provideActivatedRoute()` last, or drop the other provider (§13)                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `provideActivatedRoute: the installed @angular/router does not wire ActivatedRoute …`                                                               | a router major builds `ActivatedRoute` with different internal constructors                                                                                                                                                                                                 | report it with the `@angular/router` version; provide the route by hand until then (§13)                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `provideRouterDouble: the Router double has no …`                                                                                                   | the code under test reached for a `Router` member the double does not cover — `getCurrentNavigation`, `isActive`, `resetConfig`                                                                                                                                             | the double covers `url`, `events`, `navigate`, `navigateByUrl`, `createUrlTree`, `serializeUrl`, `parseUrl` and `routerState`; past that, a real `provideRouter([])` with `RouterTestingHarness` (§13)                                                                                                                                                                                                                                                                                                            |
+| `provideRouterDouble: the Router double has no …`                                                                                                   | the code under test reached for a `Router` member the double does not cover — `isActive`, `resetConfig`, `lastSuccessfulNavigation`                                                                                                                                         | the double covers `url`, `events`, `navigate`, `navigateByUrl`, `createUrlTree`, `serializeUrl`, `parseUrl`, `routerState` and `currentNavigation` / `getCurrentNavigation()`; past that, a real `provideRouter([])` with `RouterTestingHarness` (§13)                                                                                                                                                                                                                                                            |
 | `injectRouterDouble(): the Router here is Angular's own …`                                                                                          | `Router` is `providedIn: 'root'`, so a `TestBed` without the double hands out a real one                                                                                                                                                                                    | add `provideRouterDouble({ … })` from `vitest-auto-spy/angular-router` to `providers` (§13)                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
 **Seven of these are library defects, not spec ones.** On anything below 3.8.0, upgrade and change

package/README.md

@@ -65,7 +65,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
   `mock.reset()`, so a `mock.fn()` your spec made by hand is untouched.
 - 🌐 `httpResource()` and `HttpClient` in two lines — `provideHttpTesting()` + `await expectRequest(url).flush(body)` does the tick, the controller, the `expectOne`, the flush **and the settling**, so `resource.value()` reads on the next line; `@angular/common` stays an optional peer, confined to the `/angular-http` entry
 - 🧭 An `ActivatedRoute` that cannot disagree with itself — `provideActivatedRoute({ params, queryParams, data })` provides Angular's own route, its streams, `paramMap`s and snapshot built from one record, and `injectActivatedRoute().setParams(…)` moves them together the way a navigation does; `@angular/router` stays an optional peer, confined to the `/angular-router` entry
-- 🧱 The providers every suite hand-rolls, provided once — `provideRouterDouble({ url })` for a `Router` that derives `url`, `routerState` and `events` from one URL rather than four guesses; `provideWindowDouble(WINDOW, { screen })` and `provideDocumentDouble({ … })`, which merge what the spec names **over** the real jsdom object, so the member nobody thought of still answers; `provideMatDialogData(MAT_DIALOG_DATA, data)` and `provideMatDialogRef(MatDialogRef)` for the Material dialog trio, with Material itself staying out of this package's dependencies
+- 🧱 The providers every suite hand-rolls, provided once — `provideRouterDouble({ url })` for a `Router` that derives `url`, `routerState`, `events` and `currentNavigation()` from one URL rather than four guesses; `provideWindowDouble(WINDOW, { screen })` and `provideDocumentDouble({ … })`, which merge what the spec names **over** the real jsdom object, so the member nobody thought of still answers; `provideMatDialogData(MAT_DIALOG_DATA, data)` and `provideMatDialogRef(MatDialogRef)` for the Material dialog trio, with Material itself staying out of this package's dependencies
 - 🧪 A signal graph you can assert on — `mockSignalProp` writes **through** a member that is already a `signal()`, `model()` or `linkedSignal()` instead of replacing it, so a computed, an effect or a template that read it first is still connected; `setInputs(fixture, { … })` changes an input mid-test; `trackRecomputations` / `trackEffectRuns` count what actually re-ran; `runEffect` runs the previous cleanup first, the way Angular's own scheduler does
 - 🪆 NestJS units from their own DI metadata — `createNestUnit(Target, { expose, providers })`, the solitary / sociable model of `@suites/unit` with the real prototype behind every spy and no `@nestjs` dependency
 - 🧱 The providers a testing module cannot reach — `overrideComponentProvider` (which verifies the override actually applied), `provideAutoSpyForToken`, `assertNgModuleScopes`, `assertComponentDefIntact`, `createDirectiveHost`, and `createComponentStub` for a child whose selector and inputs are read off the real one, so the stub cannot drift
@@ -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-six rules in `vitest-auto-spy/eslint-plugin` (three `--fix`, eleven 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-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
 - 🩺 [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
@@ -2856,7 +2856,7 @@ single-purpose utility you can pick up independently — they all ride on the sa
 | `runEffect(effectRef)`                                                                   | `/angular`                    | Run one `effect()` body on demand, for an effect whose trigger a spec replaced with a static signal                                                                                                                           |
 | `setInputs(fixture, inputs, opts?)`                                                      | `/angular`                    | Change a component input mid-test — one `setInput` per name, checked against the compiled definition, then one wait                                                                                                           |
 | `trackRecomputations(signal)` / `trackEffectRuns(ref)`                                   | `/angular`                    | Count what the reactive graph actually did: `{ count, stop() }`, so "the filter change did not re-run the sync effect" is an assertion                                                                                        |
-| `provideRouterDouble(init?)` / `injectRouterDouble()`                                    | `/angular-router`             | A `Router` derived from one URL — real `serializeUrl` / `createUrlTree`, `navigate` spies, `emitNavigation()` over a `BehaviorSubject`                                                                                        |
+| `provideRouterDouble(init?)` / `injectRouterDouble()`                                    | `/angular-router`             | A `Router` derived from one URL — real `serializeUrl` / `createUrlTree`, `navigate` spies, `emitNavigation()` over a `BehaviorSubject`, `currentNavigation()` and `setCurrentNavigation()`                                    |
 | `createForm(model, schema?)` / `registerFormMatchers()`                                  | `/signal-forms`               | A signal form built where `form()` can inject, and `expect(field).toHaveFieldErrors(['required'])` over what it produced                                                                                                      |
 | `provideWindowDouble(TOKEN, over?)` / `provideDocumentDouble(over?)`                     | `/angular`                    | A `window` / `document` merged **over** the real jsdom one, so members the spec never named still answer; the globals stay untouched                                                                                          |
 | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(Ref, init?)`                  | `/angular`                    | The Material dialog trio without `@angular/material` as a dependency — the token and the ref class are arguments, `afterClosed()` still answers after the close                                                               |
@@ -3424,6 +3424,7 @@ export can never be.
 | `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                                                                                                                                                                                                                                                                                           |
@@ -3435,7 +3436,7 @@ Every message ends with a link to the matching [recipe](#how-to-mock): a rule th
 "don't" moves the problem rather than solving it. Rules travel with the API they recommend, so they
 are versioned together and stop being re-written in every project that installs the package.
 
-**Three of the thirty-six fix on their own, eleven offer suggestions**, and the split is not about how hard
+**Three of the thirty-seven fix on their own, twelve 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
@@ -3518,7 +3519,17 @@ reason is for. The report sits on the directive's line, so that comment reaches
 `no-constant-expect` reports `expect(true).toBe(true)` and its relatives: a value the spec spelled out,
 under a matcher whose answer that value already fixes. `@vitest/eslint-plugin` has no such rule. On
 the same suite it reports four — two tests with nothing else to assert and two that import a barrel
-for coverage. `no-compile-components` says nothing until `['error', { builder: 'inline-resources' }]`
+for coverage.
+
+`no-redundant-smoke-test` reports the other test that cannot fail: one whose whole body is
+`expect(pipe).toBeTruthy()`, standing in a block that already has tests which run the same
+`beforeEach` — a nullish subject fails one of those first, on the call it was making, rather than on a
+line named after construction. It is weighed against the tests that share its setup, the ones nested
+`describe`s declare included, and it says nothing where that smoke test is the only running test of
+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.
+
+`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
 else — 449 calls in 411 files there, 435 of them with the edit. Not every one of them, though: a
@@ -3573,7 +3584,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-six rules appear inline, in the **Problems** tool window, and
+all run ESLint natively, so the thirty-seven rules appear inline, in the **Problems** tool window, and
 under **Code → Inspect Code** for the whole project.
 
 ```js
@@ -3590,7 +3601,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-six rules, in Kotlin, in step with the TypeScript ones.
+and then keep a second copy of thirty-seven rules, in Kotlin, in step with the TypeScript ones.
 
 ### VS Code, Cursor, Windsurf, VSCodium
 
@@ -3700,7 +3711,7 @@ another, and the next one is in that same file.
 | `expectNoRequest(matcher?, opts?)` / `verifyNoPendingRequests()` _(`/angular-http`)_                                                        | Assert that nothing was requested / that the test left nothing unanswered                                                                                                                                                                                                     |
 | `provideActivatedRoute(init?)` / `injectActivatedRoute(injector?)` _(`/angular-router`)_                                                    | An `ActivatedRoute` provider whose streams, `paramMap`s and snapshot share one record, and the handle whose setters move them together                                                                                                                                        |
 | `createActivatedRoute(init?)` _(`/angular-router`)_                                                                                         | The same double without a `TestBed` — `.route` plus the setters                                                                                                                                                                                                               |
-| `provideRouterDouble(init?)` / `injectRouterDouble(injector?)` / `createRouterDouble(init?)` _(`/angular-router`)_                          | A `Router` derived from one URL — `navigate` spies, `setUrl`, `emitNavigation`, and the router's own URL serialization                                                                                                                                                        |
+| `provideRouterDouble(init?)` / `injectRouterDouble(injector?)` / `createRouterDouble(init?)` _(`/angular-router`)_                          | A `Router` derived from one URL — `navigate` spies, `setUrl`, `emitNavigation`, `setCurrentNavigation`, and the router's own URL serialization                                                                                                                                |
 | `createForm(model, schema?, options?)` / `registerFormMatchers()` _(`/signal-forms`)_                                                       | Angular's own signal `form()`, built in the `TestBed`'s injection context, and the `toHaveFieldErrors` matcher over its `errors()`                                                                                                                                            |
 | `registerSignalMatchers()` _(Angular)_                                                                                                      | Adds `expect(sig).toHaveSignalValue(value)`                                                                                                                                                                                                                                   |
 | `trackRecomputations(signal)` / `trackEffectRuns(effectRef)` _(Angular)_                                                                    | Count what the reactive graph re-ran — `{ count, stop() }`, undone by `restoreMockedProps()`                                                                                                                                                                                  |

package/dist/angular-router.d.ts

@@ -1,5 +1,5 @@
 import { Type, Injector, FactoryProvider } from '@angular/core';
-import { Params, Data, UrlSegment, ActivatedRoute, Route, Router, Event } from '@angular/router';
+import { Params, Data, UrlSegment, ActivatedRoute, Route, Navigation, Router, Event } from '@angular/router';
 import { g as AddSpyMethodsByReturnTypes } from './types-D3RkJjc_.js';
 import 'vitest';
 
@@ -114,8 +114,9 @@ declare function injectActivatedRoute(injector?: Injector): ActivatedRouteDouble
  * So the double keeps one URL and derives the rest of it: `url` is that URL serialized the way the
  * real router serializes it, `routerState` is Angular's own `RouterState` over a root route holding
  * its query parameters and fragment, `events` is a `BehaviorSubject` that starts at the
- * `NavigationEnd` which put the router there, and `createUrlTree` / `serializeUrl` / `parseUrl` are
- * the router's real URL work rather than stubs.
+ * `NavigationEnd` which put the router there, `currentNavigation()` is `null` because a router
+ * standing at a URL is idle, and `createUrlTree` / `serializeUrl` / `parseUrl` are the router's real
+ * URL work rather than stubs.
  *
  * Navigation itself stays a spy, because a navigation in an application is asynchronous, runs
  * guards and can be cancelled: a double that moved its own URL on `navigate()` would be testing the
@@ -125,10 +126,18 @@ declare function injectActivatedRoute(injector?: Injector): ActivatedRouteDouble
  * reason: `@angular/router` is an optional peer, paid for by the suites that import this entry.
  */
 
-/** Where the router starts. One field, because everything else about a router is derived from it. */
+/** What a spec names about the navigation in flight; every other field is derived from where the router stands. */
+type NavigationInit = Partial<Navigation>;
+/** Where the router starts: the URL it stands at, and whether a navigation is running. */
 interface RouterDoubleInit {
     /** The URL the router reports until the spec moves it. Serialized as the router would. Default `'/'`. */
     url?: string;
+    /**
+     * The navigation `currentNavigation()` and `getCurrentNavigation()` answer with. Default `null` —
+     * a router standing at a URL is idle, which is what the real one answers between navigations.
+     * Named here rather than only on the handle because a component reads it in a field initializer.
+     */
+    currentNavigation?: NavigationInit | null;
 }
 /** The handle a spec drives the router through. */
 interface RouterDouble {
@@ -140,6 +149,12 @@ interface RouterDouble {
     readonly navigateByUrl: AddSpyMethodsByReturnTypes<Router['navigateByUrl']>;
     /** Put the router at a URL: `url`, `routerState` and the root route move together. */
     setUrl(url: string): void;
+    /**
+     * Put a navigation in flight, or end it with `null`. What the spec names is kept; `id`,
+     * `initialUrl` and `extractedUrl` come from where the router stands, `trigger` is `'imperative'`
+     * and `extras` is empty.
+     */
+    setCurrentNavigation(navigation?: NavigationInit | null): void;
     /** Push an event through `router.events`. A `NavigationEnd`, or a URL, moves the URL with it. */
     emitNavigation(event?: Event | string): void;
 }
@@ -182,4 +197,4 @@ declare function provideRouterDouble(init?: RouterDoubleInit): FactoryProvider;
  */
 declare function injectRouterDouble(injector?: Injector): RouterDouble;
 
-export { type ActivatedRouteChange, type ActivatedRouteDouble, type ActivatedRouteInit, type RouterDouble, type RouterDoubleInit, createActivatedRoute, createRouterDouble, injectActivatedRoute, injectRouterDouble, provideActivatedRoute, provideRouterDouble };
+export { type ActivatedRouteChange, type ActivatedRouteDouble, type ActivatedRouteInit, type NavigationInit, type RouterDouble, type RouterDoubleInit, createActivatedRoute, createRouterDouble, injectActivatedRoute, injectRouterDouble, provideActivatedRoute, provideRouterDouble };

package/dist/angular-router.js

@@ -2,8 +2,9 @@ import { createFunctionSpy } from './chunk-NQNHA3R4.js';
 import './chunk-OTOCFH6B.js';
 import { withDocs, DOCS_LINKS } from './chunk-Q477VHHF.js';
 import { TestBed } from '@angular/core/testing';
-import { Router, DefaultUrlSerializer, PRIMARY_OUTLET, ActivatedRoute, RouterState, NavigationEnd, ActivatedRouteSnapshot, RouterStateSnapshot, createUrlTreeFromSnapshot, UrlSegment } from '@angular/router';
+import { Router, DefaultUrlSerializer, PRIMARY_OUTLET, ActivatedRoute, RouterState, NavigationEnd, ActivatedRouteSnapshot, RouterStateSnapshot, NavigationStart, NavigationCancel, NavigationError, NavigationSkipped, UrlSegment, createUrlTreeFromSnapshot } from '@angular/router';
 import { BehaviorSubject } from 'rxjs';
+import { signal } from '@angular/core';
 
 var doubles = /* @__PURE__ */ new WeakMap();
 function toSegments(url) {
@@ -182,8 +183,16 @@ function injectActivatedRoute(injector) {
   }
   return double;
 }
-var COVERED = "url, events, navigate, navigateByUrl, createUrlTree, serializeUrl, parseUrl and routerState";
-var DECLARED = new Set(Object.getOwnPropertyNames(Router.prototype));
+var COVERED = "url, events, navigate, navigateByUrl, createUrlTree, serializeUrl, parseUrl, routerState, currentNavigation and getCurrentNavigation";
+var DECLARED_FIELDS = [
+  "navigated",
+  "routeReuseStrategy",
+  "onSameUrlNavigation",
+  "config",
+  "componentInputBindingEnabled",
+  "currentNavigation"
+];
+var DECLARED = /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(Router.prototype), ...DECLARED_FIELDS]);
 var doubles2 = /* @__PURE__ */ new WeakMap();
 var serializer = new DefaultUrlSerializer();
 function stateSnapshot(url, root) {
@@ -237,16 +246,39 @@ function createUrlState(initial) {
     }
   };
 }
-function createRouterDouble(init = {}) {
-  const state = createUrlState(init.url ?? "/");
-  const events = new BehaviorSubject(new NavigationEnd(1, state.url(), state.url()));
-  const stream = events.asObservable();
-  let navigationId = 1;
-  const navigate = createFunctionSpy("Router.navigate");
-  const navigateByUrl = createFunctionSpy("Router.navigateByUrl");
-  navigate.resolveWith(true);
-  navigateByUrl.resolveWith(true);
-  const router = guardMissingMembers({
+function startEvent(event, inFlight, navigationOf) {
+  if (!(event instanceof NavigationStart)) {
+    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 {
+    id,
+    initialUrl: state.tree(),
+    extractedUrl: state.tree(),
+    trigger: "imperative",
+    extras: {},
+    previousNavigation: null,
+    // A no-op rather than a spy: a spec that asserts the abort passes its own, and every other spec
+    // would be carrying a spy nothing reads.
+    abort: () => void 0,
+    ...named
+  };
+}
+function buildRouter(state, stream, parts) {
+  return guardMissingMembers({
     get url() {
       return state.url();
     },
@@ -256,8 +288,8 @@ function createRouterDouble(init = {}) {
     get routerState() {
       return state.routerState;
     },
-    navigate,
-    navigateByUrl,
+    navigate: parts.navigate,
+    navigateByUrl: parts.navigateByUrl,
     createUrlTree: (commands, extras = {}) => createUrlTreeFromSnapshot(
       (extras.relativeTo ?? state.routerState.root).snapshot,
       commands,
@@ -266,22 +298,47 @@ function createRouterDouble(init = {}) {
     ),
     serializeUrl: (target) => serializer.serialize(target),
     parseUrl: (target) => serializer.parse(target),
+    get currentNavigation() {
+      return parts.currentNavigation;
+    },
+    getCurrentNavigation: () => parts.currentNavigation(),
     // Inert, and present rather than guarded: Angular's injector reads `ngOnDestroy` off every
     // value it builds, so a double that threw on it would throw on `TestBed.resetTestingModule()`.
     ngOnDestroy: () => void 0,
     dispose: () => void 0
   });
+}
+function createRouterDouble(init = {}) {
+  const state = createUrlState(init.url ?? "/");
+  const events = new BehaviorSubject(new NavigationEnd(1, state.url(), state.url()));
+  const stream = events.asObservable();
+  let navigationId = 1;
+  const navigationOf = (named) => buildNavigation(state, navigationId, named);
+  const inFlight = signal(init.currentNavigation ? navigationOf(init.currentNavigation) : null);
+  const currentNavigation = inFlight.asReadonly();
+  const navigate = createFunctionSpy("Router.navigate");
+  const navigateByUrl = createFunctionSpy("Router.navigateByUrl");
+  navigate.resolveWith(true);
+  navigateByUrl.resolveWith(true);
+  const router = buildRouter(state, stream, { navigate, navigateByUrl, currentNavigation });
   const double = {
     router,
     navigate,
     navigateByUrl,
     setUrl: state.set,
+    setCurrentNavigation: (navigation) => {
+      inFlight.set(navigation === null ? null : navigationOf(navigation ?? {}));
+    },
     emitNavigation: (event) => {
       const next = typeof event === "object" ? event : new NavigationEnd(++navigationId, event ?? state.url(), event ?? state.url());
       if (next instanceof NavigationEnd) {
         state.set(next.urlAfterRedirects);
       }
+      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-67EcdZwp.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-BoA6j-74.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';
@@ -841,12 +841,31 @@ declare function registerSignalMatchers(): void;
  * `InjectionToken<AppWindow>` gets its own members checked in the overrides too.
  */
 
+/** How many levels of slicing the type follows. Beyond it a member takes its whole type. */
+type Levels = [never, 0, 1, 2, 3];
+/**
+ * One member's override: the member's own type, or a slice of it wherever it is a plain-ish object.
+ *
+ * A method is matched whole and **first**: `Partial<(…) => …>` is a mapped type over a function,
+ * which drops the call signature and leaves `{}` — a slice branch that accepts anything at all. An
+ * array is matched whole too: slicing one by index describes nothing a spec means.
+ */
+type PlatformOverride<V, Depth extends number> = V extends (...args: never[]) => unknown ? V : V extends readonly unknown[] ? V : V extends object ? Depth extends 0 ? V : V | {
+    [K in keyof V]?: PlatformOverride<V[K], Levels[Depth]>;
+} : V;
 /**
  * What a spec says about a platform object: a value per member, and a **slice** wherever the member
  * is itself an object — `{ screen: { width: 1920 } }` leaves `screen.colorDepth` real.
+ *
+ * The slice goes as deep as the merge does, three levels of it: the proxy re-merges every plain
+ * object it hands out, so `{ document: { location: { href: '' } } }` works at run time, and a type
+ * that stopped at the first level sent a spec that wrote it to `createMock<Location>()` or to a
+ * cast for no reason anybody could state. Depth is bounded because `Window` is recursive —
+ * `window.window` is a `Window` — and an unbounded mapped type over it is a bill every call site
+ * pays.
  */
 type PlatformOverrides<T> = {
-    [K in keyof T]?: T[K] extends (...args: never[]) => unknown ? T[K] : T[K] extends object ? Partial<T[K]> | T[K] : T[K];
+    [K in keyof T]?: PlatformOverride<T[K], 3>;
 };
 /**
  * The `window` double without a `TestBed` — for a class built with `new`, or a plain function.

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-67EcdZwp.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';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/cli.js

@@ -2453,7 +2453,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.9.0";
+var EXPORT_MAP_VERSION = "5.10.1";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular-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",
@@ -2671,6 +2671,7 @@ var EXPORTED_BY = {
   mutationRecord: "7",
   MutationRecordInit: "7",
   narrow: "0 1 2 3 4 17 18 19",
+  NavigationInit: "14",
   NestModuleRef: "16",
   NestUnit: "16",
   NestUnitClass: "16",
@@ -3484,7 +3485,9 @@ Options
                  take (2), and the absolute floor under which it is noise
                  (500 ms).
   --top <n>      perf only. Rows in the "slowest files" and "slowest bodies"
-                 tables. 0 turns them off.
+                 tables. 0 turns them off. Asked for explicitly, a run whose
+                 slowest file is under the one-second floor says so rather
+                 than printing nothing.
   --check        init only. Write nothing; exit 1 if the block is out of date.
   --dry-run      init only. Print what would change and write nothing.
   --uninstall    init only. Remove the managed blocks and the files it created.
@@ -4389,6 +4392,10 @@ function formatHotspots(run, cwd, options = {}) {
   }
   return [...fileSection(files, totalTestMs(run, cwd), width), ...caseSection(caseHotspots(run, cwd, limit), width)].join("\n\n");
 }
+function hotspotFloorNote(run, cwd, floorMs = HOTSPOT_DEFAULTS.floorMs) {
+  const [slowest] = fileHotspots(run, cwd, 1);
+  return slowest === void 0 ? "No hotspot tables: no file in this run finished a test body, so there is nothing to rank." : `No hotspot tables: the slowest file spent ${formatMs(slowest.ms)} in its test bodies, under the ${formatMs(floorMs)} floor. Below it a ranking is the reader\u2019s attention spent on the machine rather than on a decision somebody made.`;
+}
 var UNIT_TEST_BUILDER2 = "@angular/build:unit-test";
 var WORKSPACE_FILES = ["angular.json", "workspace.json"];
 function targetsOf(project) {
@@ -4548,7 +4555,7 @@ var CONFIG_FILE = /(?:^|\/)vite(?:st)?[\w.-]*\.config\.[cm]?[jt]s$/;
 var NO_ISOLATION = /\bisolate\s*:\s*false/;
 var JSDOM = /\benvironment\s*:\s*["'`]jsdom["'`]/;
 var HAPPY_DOM = /happy-dom/;
-var WORKER_CAP = /\bmaxWorkers\s*:/;
+var WORKER_CAP = /\bmaxWorkers\s*[,:=}]|\bmaxWorkers\s*$/m;
 var LARGE_RUN_MS = 6e4;
 var WORKER_RSS_MB = 155;
 function remainder(total) {
@@ -4820,6 +4827,18 @@ function recordBaseline(run, cwd, path, io) {
 perf baseline: recorded ${Object.keys(baseline.files).length} files at a median of ${formatMs(baseline.median)} into ${path}. Commit it \u2014 it is only worth what the next reader can diff.`
   );
 }
+function reportHotspots(run, cwd, top, io) {
+  const hotspots = formatHotspots(run, cwd, top === void 0 ? {} : { limit: top });
+  if (hotspots !== "") {
+    io.out(`
+${hotspots}`);
+    return;
+  }
+  if (top !== void 0 && top > 0) {
+    io.out(`
+${hotspotFloorNote(run, cwd)}`);
+  }
+}
 function renderPerf(source, profile, io, options = {}) {
   const gate = options.gate;
   if (!source.ok) {
@@ -4848,11 +4867,7 @@ function renderPerf(source, profile, io, options = {}) {
 `);
   }
   io.out(formatPhases(analysis.phases));
-  const hotspots = formatHotspots(source.run, profile.cwd, options.top === void 0 ? {} : { limit: options.top });
-  if (hotspots !== "") {
-    io.out(`
-${hotspots}`);
-  }
+  reportHotspots(source.run, profile.cwd, options.top, io);
   reportFindings(analysis, io);
   if (options.baseline?.update === true) {
     recordBaseline(source.run, profile.cwd, options.baseline.path, io);

package/dist/eslint-plugin.cjs

@@ -757,14 +757,22 @@ function factoryBody(context, value) {
 }
 var SPY_FACTORIES = /* @__PURE__ */ new Set([
   "autoMocked",
+  "createActivatedRoute",
   "createAutoMock",
+  "createDocumentDouble",
   "createMock",
+  "createRouterDouble",
   "createSpyClass",
   "createSpyFromClass",
+  "createWindowDouble",
   "mockConstructor",
   "mockDeep",
+  "provideActivatedRoute",
   "provideAutoSpy",
-  "provideAutoSpyForToken"
+  "provideAutoSpyForToken",
+  "provideDocumentDouble",
+  "provideRouterDouble",
+  "provideWindowDouble"
 ]);
 function isFactoryCall(node) {
   return isCallExpression(node) && isIdentifier(node.callee) && SPY_FACTORIES.has(node.callee.name);
@@ -2067,6 +2075,206 @@ var preferProvideActivatedRoute = defineRule({
   })
 });
 
+// src/lib/eslint/smoke-test.ts
+var TESTS = /* @__PURE__ */ new Set(["fit", "it", "test", "xit", "xtest"]);
+var SKIPPED_TESTS = /* @__PURE__ */ new Set(["xit", "xtest"]);
+var SKIPPED_MEMBERS = /* @__PURE__ */ new Set(["skip", "todo"]);
+var EXISTS = /* @__PURE__ */ new Set(["toBeDefined", "toBeInstanceOf", "toBeTruthy"]);
+var MISSING = /* @__PURE__ */ new Set(["toBeFalsy", "toBeNull", "toBeUndefined"]);
+function calleeChain(node) {
+  const members = [];
+  let current = node.callee;
+  for (; ; ) {
+    if (isIdentifier(current)) {
+      return { members, root: current.name };
+    }
+    if (isMemberExpression(current)) {
+      const name = memberName(current);
+      if (name === void 0) {
+        return void 0;
+      }
+      members.unshift(name);
+      current = current.object;
+      continue;
+    }
+    if (!isCallExpression(current)) {
+      return void 0;
+    }
+    current = current.callee;
+  }
+}
+var TITLES = /* @__PURE__ */ new Set(["Literal", "TemplateLiteral"]);
+function testCall(node) {
+  const chain = calleeChain(node);
+  const [title] = node.arguments;
+  if (!chain || !TESTS.has(chain.root) || !title || !TITLES.has(title.type)) {
+    return void 0;
+  }
+  return { skipped: SKIPPED_TESTS.has(chain.root) || chain.members.some((member) => SKIPPED_MEMBERS.has(member)) };
+}
+var SUBJECT_BUILDERS = /* @__PURE__ */ new Set(["get", "inject"]);
+function containsCall(node) {
+  let current = node;
+  while (isMemberExpression(current)) {
+    if (isCallExpression(current.object)) {
+      return true;
+    }
+    current = current.object;
+  }
+  return isCallExpression(current);
+}
+function namesSubject(subject, matcher) {
+  if (isIdentifier(subject)) {
+    return true;
+  }
+  if (isMemberExpression(subject)) {
+    return !containsCall(subject);
+  }
+  if (!isCallExpression(subject)) {
+    return false;
+  }
+  if (matcher === "toBeInstanceOf") {
+    return false;
+  }
+  if (isIdentifier(subject.callee)) {
+    return subject.arguments.length === 0;
+  }
+  const [token, ...rest] = subject.arguments;
+  return isMemberExpression(subject.callee) && SUBJECT_BUILDERS.has(memberName(subject.callee) ?? "") && !containsCall(subject.callee.object) && rest.length === 0 && token !== void 0 && (isIdentifier(token) || isMemberExpression(token) && !containsCall(token));
+}
+function subjectReference(subject, context) {
+  if (isIdentifier(subject) || isMemberExpression(subject)) {
+    return context.sourceCode.getText(subject);
+  }
+  let current = subject;
+  while (isCallExpression(current) || isMemberExpression(current)) {
+    current = isCallExpression(current) ? current.callee : current.object;
+  }
+  return isIdentifier(current) ? current.name : void 0;
+}
+function existenceSubject(expression) {
+  if (!isCallExpression(expression) || !isMemberExpression(expression.callee)) {
+    return void 0;
+  }
+  const matcher = memberName(expression.callee);
+  let target = expression.callee.object;
+  let negated = false;
+  while (isMemberExpression(target) && memberName(target) === "not") {
+    negated = !negated;
+    target = target.object;
+  }
+  if (!matcher || !isCallExpression(target) || !isIdentifier(target.callee) || target.callee.name !== "expect") {
+    return void 0;
+  }
+  const [subject] = target.arguments;
+  if (!subject || !(negated ? MISSING.has(matcher) : EXISTS.has(matcher))) {
+    return void 0;
+  }
+  return namesSubject(subject, matcher) ? subject : void 0;
+}
+function existenceOnly(callback) {
+  const body = callback.body;
+  if (!isBlockStatement(body)) {
+    return existenceSubject(body);
+  }
+  const subjects = body.body.map((statement) => isExpressionStatement(statement) ? existenceSubject(statement.expression) : void 0);
+  return subjects.length > 0 && subjects.every(Boolean) ? subjects[0] : void 0;
+}
+function removal2(context, statement) {
+  return (fixer) => {
+    const text = context.sourceCode.getText();
+    let start = statement.range[0];
+    while (start > 0 && /\s/.test(text.charAt(start - 1))) {
+      start -= 1;
+    }
+    return fixer.replaceTextRange([start, statement.range[1]], "");
+  };
+}
+function recordName(names, node, context) {
+  const text = context.sourceCode.getText(node);
+  for (let scope = enclosingFunction(node); scope; scope = enclosingFunction(scope.parent)) {
+    const seen = names.get(scope) ?? /* @__PURE__ */ new Set();
+    seen.add(text);
+    names.set(scope, seen);
+  }
+}
+function countNested(blocks) {
+  blocks.forEach((block, scope) => {
+    let current = scope;
+    for (; ; ) {
+      const above = blocks.get(current);
+      if (above) {
+        above.below += block.proving;
+        above.running.push(...block.running);
+      }
+      if (current === void 0) {
+        return;
+      }
+      current = enclosingFunction(current.parent);
+    }
+  });
+}
+function reportBlock(context, block, names) {
+  if (block.below === 0) {
+    return;
+  }
+  const referenced = new Set(block.running.flatMap((callback) => [...names.get(callback) ?? []]));
+  block.smoke.forEach(({ node, subject }) => {
+    const reference = subjectReference(subject, context);
+    if (reference !== void 0 && !referenced.has(reference)) {
+      return;
+    }
+    const data = {
+      siblings: block.below === 1 ? "another test under the same setup already runs against it" : `${block.below} other tests under the same setup already run against it`,
+      subject: context.sourceCode.getText(subject)
+    };
+    const statement = node.parent;
+    const report = { data, messageId: "noRedundantSmokeTest", node };
+    context.report(
+      isExpressionStatement(statement) ? { ...report, suggest: [{ desc: "Remove this test", fix: removal2(context, statement) }] } : report
+    );
+  });
+}
+var noRedundantSmokeTest = defineRule({
+  anchor: "-a-promise-a-test-forgets-to-await",
+  description: "Delete a test whose whole body asserts that the subject exists, where the block already has tests that use it",
+  hasSuggestions: true,
+  messages: {
+    noRedundantSmokeTest: "The whole of this test is `{{subject}}` existing, and {{siblings}}: they run the same `beforeEach`, so a subject that came back nullish fails them first, and names what it was doing when it did. This one cannot fail on its own and covers nothing \u2014 it is a green line in the report standing in for a test. Delete it. If the construction is what the spec is about \u2014 a factory that rejects a bad config, a constructor that reads an optional token \u2014 assert on that instead: `expect(() => new Subject(null)).toThrow(\u2026)`, or on the value the subject produced."
+  },
+  create: (context) => {
+    const blocks = /* @__PURE__ */ new Map();
+    const names = /* @__PURE__ */ new Map();
+    return {
+      Identifier: (node) => recordName(names, node, context),
+      MemberExpression: (node) => recordName(names, node, context),
+      CallExpression: (node) => {
+        const test = testCall(node);
+        if (!test) {
+          return;
+        }
+        const scope = enclosingFunction(node);
+        const block = blocks.get(scope) ?? { below: 0, proving: 0, running: [], smoke: [] };
+        const callback = node.arguments.find(isFunctionNode);
+        const subject = callback && existenceOnly(callback);
+        if (subject) {
+          block.smoke.push({ node, subject });
+        } else if (!test.skipped) {
+          block.proving += 1;
+          if (callback) {
+            block.running.push(callback);
+          }
+        }
+        blocks.set(scope, block);
+      },
+      "Program:exit": () => {
+        countNested(blocks);
+        blocks.forEach((block) => reportBlock(context, block, names));
+      }
+    };
+  }
+});
+
 // src/lib/eslint/stub-class.ts
 function countStubFields(node) {
   return node.body.body.filter((member) => isStubField(member)).length;
@@ -2274,10 +2482,13 @@ function answersTheTestBed(context, node, seen) {
   const link = memberName(node.callee);
   return link !== void 0 && ANSWERS_THE_TEST_BED.has(link) && answersTheTestBed(context, node.callee.object, seen);
 }
-function removal2(context, awaited) {
+function answerOf(member) {
+  return ANSWERS_A_FIXTURE.has(member) ? "the `ComponentFixture`" : "the TestBed";
+}
+function removal3(context, awaited, answers) {
   const callback = asyncOnlyFor(awaited);
   return {
-    desc: "Remove the await \u2014 the TestBed call answers the TestBed, not a promise",
+    desc: `Remove the await \u2014 the TestBed call answers ${answers}, not a promise`,
     fix: (fixer) => {
       const fixes = [fixer.replaceText(awaited, context.sourceCode.getText(awaited.argument))];
       if (callback) {
@@ -2292,7 +2503,7 @@ var noSyncTestbedAwait = defineRule({
   description: "Drop the await on a TestBed call that answers the TestBed or a fixture rather than a promise",
   hasSuggestions: true,
   messages: {
-    noSyncTestbedAwait: "`{{member}}(\u2026)` answers the TestBed, not a promise, so this `await` waits for nothing. Every `configureTestingModule` and `override*` returns `TestBed` itself \u2014 that is what lets them chain \u2014 and `createComponent` / `getLastFixture` return the `ComponentFixture`; awaiting one of those only resumes the hook a microtask later, while making a synchronous setup read as an asynchronous one. Drop the `await`, and the `async` of a `beforeEach` / `beforeAll` / `afterEach` / `afterAll` / `it` / `test` callback that then awaits nothing else \u2014 the hook is not asynchronous any more, and leaving the `async` behind is the half `@typescript-eslint/require-await` would still have to report. The TestBed calls that really do return a promise keep their `await`: `compileComponents()`, and on a fixture `whenStable()`, `whenRenderingDone()` and `getDeferBlocks()`. `TestBed.inject(TOKEN)` and `TestBed.runInInjectionContext(fn)` are never reported \u2014 each answers whatever the token or the callback holds, which is a promise often enough to be awaited on purpose."
+    noSyncTestbedAwait: "`{{member}}(\u2026)` answers {{answers}}, not a promise, so this `await` waits for nothing. Every `configureTestingModule` and `override*` returns `TestBed` itself \u2014 that is what lets them chain \u2014 and `createComponent` / `getLastFixture` return the `ComponentFixture`; awaiting one of those only resumes the hook a microtask later, while making a synchronous setup read as an asynchronous one. Drop the `await`, and the `async` of a `beforeEach` / `beforeAll` / `afterEach` / `afterAll` / `it` / `test` callback that then awaits nothing else \u2014 the hook is not asynchronous any more, and leaving the `async` behind is the half `@typescript-eslint/require-await` would still have to report. The TestBed calls that really do return a promise keep their `await`: `compileComponents()`, and on a fixture `whenStable()`, `whenRenderingDone()` and `getDeferBlocks()`. `TestBed.inject(TOKEN)` and `TestBed.runInInjectionContext(fn)` are never reported \u2014 each answers whatever the token or the callback holds, which is a promise often enough to be awaited on purpose."
   },
   create: (context) => ({
     AwaitExpression: (node) => {
@@ -2307,7 +2518,8 @@ var noSyncTestbedAwait = defineRule({
       if (!answersTheTestBed(context, argument.callee.object, /* @__PURE__ */ new Set())) {
         return;
       }
-      context.report({ node, messageId: "noSyncTestbedAwait", data: { member }, suggest: [removal2(context, node)] });
+      const answers = answerOf(member);
+      context.report({ node, messageId: "noSyncTestbedAwait", data: { member, answers }, suggest: [removal3(context, node, answers)] });
     }
   })
 });
@@ -2924,6 +3136,7 @@ var rules = {
   "no-constant-expect": noConstantExpect,
   "no-compile-components": noCompileComponents,
   "no-sync-testbed-await": noSyncTestbedAwait,
+  "no-redundant-smoke-test": noRedundantSmokeTest,
   ...jasmineRules
 };
 
@@ -2962,6 +3175,7 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-constant-expect`]: "error",
   [`${PLUGIN_NAME}/no-compile-components`]: "error",
   [`${PLUGIN_NAME}/no-sync-testbed-await`]: "error",
+  [`${PLUGIN_NAME}/no-redundant-smoke-test`]: "error",
   [`${PLUGIN_NAME}/jasmine-namespace-without-entry`]: "error",
   [`${PLUGIN_NAME}/no-jasmine-globals`]: "error",
   [`${PLUGIN_NAME}/no-save-arguments-by-value`]: "error",

package/dist/{track-signal-runs-67EcdZwp.d.ts → track-signal-runs-BoA6j-74.d.ts}

@@ -207,8 +207,18 @@ declare function createWithAutoSpies<T>(target: Type<T>, options?: CreateWithAut
  * signals and DI — everything such a spec actually reads.
  */
 
-/** The value `componentRef.setInput` expects for a member — signal inputs are set with the value, not the signal. */
-type InputValue<Member> = Member extends InputSignalWithTransform<unknown, infer Write> ? Write : Member extends InputSignal<infer Value> ? Value : Member extends ModelSignal<infer Value> ? Value : Member;
+/**
+ * The value `componentRef.setInput` expects for a member — signal inputs are set with the value, not
+ * the signal.
+ *
+ * The read type in the pattern is what makes a transform input work.
+ * `input(false, { transform: booleanAttribute })` is an `InputSignalWithTransform<boolean, unknown>`,
+ * and against a pattern whose read type is fixed to `unknown` that match **fails**: the node behind
+ * the signal carries the read type in both directions, so a wider one is not a supertype, and
+ * `never` matches nothing at all. The member fell through to itself, and the spec was told to pass
+ * an `InputSignalWithTransform` where the component takes a boolean.
+ */
+type InputValue<Member> = Member extends InputSignalWithTransform<any, infer Write> ? Write : Member extends InputSignal<infer Value> ? Value : Member extends ModelSignal<infer Value> ? Value : Member;
 /** The inputs of a component, keyed as declared but typed as the values `setInput` takes. */
 type ComponentInputs<T> = {
     [Key in keyof T]?: InputValue<T[Key]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.9.0",
+  "version": "5.10.1",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",

package/skills/vitest-auto-spy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: vitest-auto-spy
-description: Write or fix tests that use vitest-auto-spy — typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports `vitest-auto-spy` or a subpath (`/angular`, `/bun-angular`, `/bun`, `/node`, `/rstest`, `/rxjs`, `/nestjs`, `/jasmine`, `/setup`, `/zone`, `/eslint-plugin`), the user names createSpyFromClass, createAutoMock, createMock, mockDeep, createSpyObj, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, createDirectiveHost, overrideComponentProvider, enableAngularDiagnostics, trackInjections, runEffect, settleResource, httpResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, createComponentStub, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, explainSpy, expectEmission, setupAutoSpy, takeStrictViolations, guardStrayConsole, setSpyEngine, assertMocked, Spy<T>, calledWith, mustBeCalledWith, onlyMethodsToSpyOn, onUnstubbedCall, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator (createSpyObject, mockProvider, SpectatorService), or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not on the class prototype", "strict mode is on", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
+description: Write or fix tests that use vitest-auto-spy — typed spies on Vitest, bun:test, node:test and Rstest. Use when a spec imports `vitest-auto-spy` or a subpath (`/angular`, `/bun-angular`, `/bun`, `/node`, `/rstest`, `/rxjs`, `/nestjs`, `/jasmine`, `/setup`, `/zone`, `/eslint-plugin`), the user names createSpyFromClass, createAutoMock, createMock, mockDeep, subscribeSpyTo, provideAutoSpy, provideHttpTesting, expectRequest, injectSpy, createNestUnit, extendWithAutoSpies, renderShallow, createWithAutoSpies, createDirectiveHost, overrideComponentProvider, enableAngularDiagnostics, trackInjections, runEffect, settleResource, mockResourceProp, mockSignalProp, mockReadonlyProp, registerAutoSpyDefaults, provideActivatedRoute, setCurrentNavigation, createComponentStub, stubWebStorage, assertNoShadowedProviders, createSpyFromInstance, explainSpy, expectEmission, setupAutoSpy, takeStrictViolations, guardStrayConsole, setSpyEngine, assertMocked, Spy<T>, calledWith, mustBeCalledWith, onlyMethodsToSpyOn, onUnstubbedCall, resolveWith or nextWith, migrating off jest-auto-spies, jasmine-auto-spies or @ngneat/spectator (createSpyObject, mockProvider, SpectatorService), or a test fails with "No mock adapter registered", "Observable spies require rxjs", "not on the class prototype", "strict mode is on", "the override did not apply", "is not a constructor", "Expected to be running in 'ProxyZone'", "jasmine is not defined", "no HttpTestingController", "localStorage.setItem is not a function" or "Spy<T> is not assignable".
 ---
 
 # vitest-auto-spy
@@ -221,6 +221,7 @@ it('loads', async () => {
 | "did the migration lose a test?" with matching counters                                   | `compareTestRuns(before, after)`                                                                                              |
 | an input that has to change after the first render                                        | `await setInputs(fixture, { … })` — one `setInput` per name, one wait                                                         |
 | a component that navigates, or reads `router.url`                                         | `provideRouterDouble({ url })` + `injectRouterDouble()` — `/angular-router`                                                   |
+| a component that reads `router.currentNavigation()` for `extras.state` or `trigger`       | `setCurrentNavigation({ extras: { state } })` on the same handle — no `instanceMethodsToSpyOn`                                |
 | a `window` or `document` behind a DI token                                                | `provideWindowDouble(WINDOW, { screen })` / `provideDocumentDouble({ … })`                                                    |
 | `MAT_DIALOG_DATA` and `MatDialogRef` provided by hand                                     | `provideMatDialogData(TOKEN, data)` / `provideMatDialogRef(MatDialogRef)` + `injectMatDialogRef(Ref)`                         |
 | asserting a `computed()` did **not** recompute                                            | `trackRecomputations(sig)` / `trackEffectRuns(ref)` — `{ count, stop() }`                                                     |
@@ -360,7 +361,7 @@ npx vitest-auto-spy codemod --verify  # after a migration: anything the transfor
 Most of this library's guarantees are type-level, so a green run that does not type-check is not
 done. Report failures with their output rather than describing them as passing.
 
-**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The thirty-six rules in
+**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The thirty-seven rules in
 `vitest-auto-spy/eslint-plugin` are lint, not typecheck: `no-mocked-for-spy` rewrites a declaration
 to `Spy<T>` and cannot see what the name is assigned two lines below, so a clean lint pass is not
 evidence that the types still hold. Where it cannot prove the rename it downgrades to a suggestion —
@@ -393,7 +394,11 @@ else is a fixture of the wrong shape — check it against `ReturnType<X['m']>` a
 with `createMock<…>()`. A value outside the declared type on purpose keeps the directive under
 `// eslint-disable-next-line vitest-auto-spy/no-ts-expect-error-on-double -- <why>`.
 `no-constant-expect` reports `expect(true).toBe(true)` and its relatives — assert on what the code
-produced, or `expect.fail(…)` for a branch the test must not reach. `no-compile-components` is silent
+produced, or `expect.fail(…)` for a branch the test must not reach.
+`no-redundant-smoke-test` reports the generated `it('should create', () => expect(x).toBeTruthy())`
+where the block — its nested `describe`s counted — already has tests that run the same `beforeEach`:
+they fail first on a subject that came back nullish, and say what they were doing. Delete it; keep it
+only where it is the block's one running test, or make it assert the construction itself. `no-compile-components` is silent
 until `['error', { builder: 'inline-resources' }]`; with it, drop `compileComponents()` and the
 `async` it forced — except for a component whose template holds a `@defer` block, which ships async
 class metadata that the call resolves whatever the builder did. Keep that one behind