vitest-auto-spy 5.23.0 → 5.24.0

package/AGENTS.md

@@ -2668,21 +2668,21 @@ replace a stack inside `@angular/core` with a line naming what is missing.
 // afterEach hooks in reverse registration order and this one must run before the teardown.
 import { enableAngularDiagnostics } from 'vitest-auto-spy/angular/diagnostics';
 
-enableAngularDiagnostics(); // { ngModuleScopes, deadSchemas, unspiedProviders, pendingRequests }
+enableAngularDiagnostics(); // { ngModuleScopes, deadSchemas, unspiedProviders, pendingRequests, shadowedProviders }
 ```
 
-| Member              | Fails when                                                                       |
-| ------------------- | -------------------------------------------------------------------------------- |
-| `ngModuleScopes`    | a testing module imports an NgModule that contributes nothing at runtime         |
-| `deadSchemas`       | `schemas` sit next to a standalone component (`declarations` empty) — a no-op    |
-| `unspiedProviders`  | `injectSpy` got a real instance; a `console.warn` alone, a throw under the group |
-| `pendingRequests`   | the test ended with unflushed `HttpTestingController` requests, named one by one |
-| `shadowedProviders` | a double on the testing module loses to the component's own `providers`          |
+| Member              | Fails when                                                                                                                                                    |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ngModuleScopes`    | a testing module imports an NgModule that contributes nothing at runtime                                                                                      |
+| `deadSchemas`       | `schemas` sit next to a standalone component (`declarations` empty) — a no-op                                                                                 |
+| `unspiedProviders`  | `injectSpy` got a real instance; a `console.warn` alone, a throw under the group                                                                              |
+| `pendingRequests`   | the test ended with unflushed `HttpTestingController` requests, named one by one; `{ ignoreCancelled: true }` forgives the ones the code under test cancelled |
+| `shadowedProviders` | a double on the testing module loses to the component's own `providers`                                                                                       |
 
 Every member defaults to `true`, takes `false` to opt out, and a second call **replaces** the
 selection (safe from anywhere, including inside a test). `disableAngularDiagnostics()` turns the
 group off and leaves the TestBed timing instrumentation alone. `assertNoShadowedProviders(Component, fixture)`
-and `assertNoPendingRequests()` are the same checks on their own, for a spec that renders through a
+and `assertNoPendingRequests({ ignoreCancelled }?)` are the same checks on their own, for a spec that renders through a
 helper of its own or wants the HTTP one mid-test — reading takes the requests, so the group will not
 re-report what you inspected.
 
@@ -2896,7 +2896,9 @@ router: one provider call, an `injectLocationDouble()` whose errors name the ins
 (`Location` is `providedIn: 'root'`, so the quiet failure is the real `Location` nobody configured).
 `createLocationDouble()` is the same without a `TestBed`. One asymmetry worth knowing: `back()` and
 `forward()` wake the popstate subscribers but do not write `urlChanges` — the journal holds what the
-app asked for, the subscribers carry what the browser did.
+app asked for, the subscribers carry what the browser did. And one deliberate difference from
+Angular's `SpyLocation`: `path()` keeps the query of `go(path, query)` / `replaceState(path, query)`
+(`/reports?tab=7`), as the real `Location.path()` does — `SpyLocation`'s own drops it.
 
 ### Signal forms — `vitest-auto-spy/signal-forms`
 
@@ -3692,7 +3694,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `no-overridden-provider`          | `error` | suggest           | two providers for one token in one array, or one a `TestBed.overrideProvider` in the same hook replaces → 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 `as unknown as`, and a decoy type), `vi.spyOn(Object.getPrototypeOf(x), 'm')` → drive the member through the public API. **Type-aware**: silent without `parserOptions.project`, and silent on an index signature                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `no-reflect-member-access`        | `error` | suggest           | `Reflect.get(component, 'privateField')` / `Reflect.set(service, 'x', v)` on a subject the test holds — the second door out of `no-private-member-access`, and the one no compiler stands in: the key is an ordinary string argument, so a rename leaves the spec reading a property that is no longer there and `Reflect.set` writing a dead one nothing reads. `window` / `globalThis` and a computed key are never reported; a write onto a double this library built is reported apart and suggests `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `no-reflect-member-access`        | `error` | on a double       | `Reflect.get(component, 'privateField')` / `Reflect.set(service, 'x', v)` on a subject the test holds — the second door out of `no-private-member-access`, and the one no compiler stands in: the key is an ordinary string argument, so a rename leaves the spec reading a property that is no longer there and `Reflect.set` writing a dead one nothing reads. `window` / `globalThis` (or a name declared as `Window` / `typeof globalThis`) and a computed key are never reported; a write onto a double this library built is reported apart and suggests `mockValueProp`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `no-dead-schemas`                 | `error` | —                 | `schemas` on a testing module with no `declarations` — the schema applies to nothing; the file decides, so a `declarations` in another `configureTestingModule` call silences it                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `no-import-time-spread`           | `error` | suggest           | `export const x = [...Imported]` at module scope → a `TypeError`, or a silently empty object, 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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -3716,7 +3718,7 @@ blanket downgrade so those keep their severity; do not copy the two names into a
 | `prefer-settle-dynamic-import`    | `error` | suggest           | `await import('./thing')` and `import('./thing').then(…)` inside an `it` / `test` body or a `beforeEach` / `beforeAll` / `afterEach` / `afterAll` hook (the `.only`, `.skip` and `.each` spellings included) → `await settleDynamicImport(() => import('./thing'))`, which is the same load plus `flushEventLoop(1)` and returns the namespace, so the destructured form keeps reading the same way. The bare `await` waits for the **module** and not for the continuation of the code that was loading it, so the assertion runs a turn early and the test is green only while that continuation is short. Syntax only. Silent wherever a function of its own sits between the runner's callback and the import — a `vi.mock` factory, a lazy route's `loadComponent` / `loadChildren`, a callback handed to production code, `settleDynamicImport`'s own `() => import(…)` — and, by the same reading, silent on a spec-local `const load = async () => { await import('…') }`, which is written identically whether the spec calls it or the code under test does                                    |
 | `prefer-create-mock`              | `warn`  | suggest           | an object literal under `as SomeType` — `{ id: '1', isOffline: false } as Device`, `<Device>{ … }` too → `createMock<Device>({ … })`. A cast asks whether the two types overlap rather than whether the value is one of them, so it passes a key the type does not declare (the excess-property check is skipped) **and** a required field the fixture never sets; both type gates stay silent, and the same object is then spread into the expected payload of a call assertion. Where the literal already sits in a typed slot the first repair is to delete the cast. Silent on `as const`, `as unknown` / `as any` and the double cast built from them, on a cast of anything but a literal, and on a literal inside one of this library's own factories. `warn`, because accepting the suggestion makes a drifted fixture red on the next type-check — the finding, and a migration taken file by file                                                                                                                                                                                              |
 | `no-mock-cast`                    | `error` | suggest           | a cast to Vitest's `Mock` / `MockInstance` over a **member access** — `TestBed.inject(S).m as Mock` → `injectSpy(S).m`, which the suggestion writes whenever the token is in view (directly, or through a `const` the file settled with a `TestBed.inject`). `Mock` with no parameters is `Mock<any>`: `mockReturnValue` takes anything and `toHaveBeenCalledWith` stops comparing arguments. `(spy.m.mockReturnValue as Mock)(…)` gets its own message — the cast is on the member that installs the answer, so neither the value nor the method's return type is checked. The name must resolve to an import from `vitest` / `@rstest/core` / `bun:test` / `jest`, or to nothing at all, so a domain `Mock` is left alone                                                                                                                                                                                                                                                                                                                                                                              |
-| `no-redundant-mock-reset`         | `error` | `--fix` / suggest | a mock reset in a `beforeEach` / `afterEach` / `beforeAll` / `afterAll` — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — the runner already performs between tests → delete it, and the hook with it where that is all it held. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only as the first statement of the file's only `beforeEach`; a suggestion otherwise; never inside a test body                                                                                                                                                                                                                                                                                                                                                                                        |
+| `no-redundant-mock-reset`         | `error` | `--fix` / suggest | a mock reset the runner already performs between tests — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — standing where nothing the file wrote ran since the runner's own: the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear as the last statement of an `afterEach` → delete it, and the hook with it where that is all it held. A restore or reset in `afterEach` / `afterAll` is never reported: after the last test it is what takes a spy off before the `afterAll` hooks. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` (or `{ configFile }` naming the runner config) first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only in a file whose only before-hook it is; a suggestion otherwise; never inside a test body                                                                           |
 | `no-unasserted-argument`          | `warn`  | —                 | a bare `expect(spy).toHaveBeenCalled()` on evidence from the file: the same subject asserted with `toHaveBeenCalledWith(…)` in another test, or a title containing `with` over a body whose every assertion is a bare call → `toHaveBeenCalledWith(…)` / `mustBeCalledWith(…)`. `not.toHaveBeenCalled()` and the counting matchers are never reported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |

package/README.md

@@ -2858,18 +2858,18 @@ enableAngularDiagnostics(); // all five
 enableAngularDiagnostics({ pendingRequests: false }); // or pick
 ```
 
-| Member              | Fails when                                                                                             |
-| ------------------- | ------------------------------------------------------------------------------------------------------ |
-| `ngModuleScopes`    | a testing module imports an NgModule that contributes nothing at all at runtime                        |
-| `deadSchemas`       | `schemas` sit next to a standalone component, where they can never apply                               |
-| `unspiedProviders`  | `injectSpy` gets a real instance — a `console.warn` on its own, a throw in the group                   |
-| `shadowedProviders` | a double on the testing module loses to the component's own `providers` — the test runs the real thing |
-| `pendingRequests`   | a test ends with unflushed `HttpTestingController` requests                                            |
+| Member              | Fails when                                                                                                                               |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `ngModuleScopes`    | a testing module imports an NgModule that contributes nothing at all at runtime                                                          |
+| `deadSchemas`       | `schemas` sit next to a standalone component, where they can never apply                                                                 |
+| `unspiedProviders`  | `injectSpy` gets a real instance — a `console.warn` on its own, a throw in the group                                                     |
+| `shadowedProviders` | a double on the testing module loses to the component's own `providers` — the test runs the real thing                                   |
+| `pendingRequests`   | a test ends with unflushed `HttpTestingController` requests; `{ ignoreCancelled: true }` forgives the ones the code under test cancelled |
 
 Each has the same shape: something the spec wrote does nothing, nothing says so, and the test passes
 for a reason its author did not intend. Every member defaults to `true`; a second call **replaces**
 the previous selection, and `disableAngularDiagnostics()` turns the group off.
-`assertNoPendingRequests()` is the HTTP check on its own, for use mid-test, and
+`assertNoPendingRequests(opts?)` is the HTTP check on its own, for use mid-test, and
 `assertNoShadowedProviders(component, fixture)` is the shadow check on its own — a no-op when the
 fixture never rendered that component, and when everything it resolved is a double.
 
@@ -3830,7 +3830,7 @@ export can never be.
 | `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-reflect-member-access`        |   `error`   | suggest           | `Reflect.get(component, 'privateField')` / `Reflect.set(service, 'x', v)` on a subject the test holds — the second door out of `no-private-member-access`, and the one no compiler stands in: the key is an ordinary string argument, so a rename leaves the spec reading a property that is no longer there and `Reflect.set` writing a dead one nothing reads. `window` / `globalThis` and a computed key are never reported; a write onto a double this library built is reported apart and suggests `mockValueProp`                                                                                                                                                                                                                                                                       |
+| `no-reflect-member-access`        |   `error`   | on a double       | `Reflect.get(component, 'privateField')` / `Reflect.set(service, 'x', v)` on a subject the test holds — the second door out of `no-private-member-access`, and the one no compiler stands in: the key is an ordinary string argument, so a rename leaves the spec reading a property that is no longer there and `Reflect.set` writing a dead one nothing reads. `window` / `globalThis` and a computed key are never reported; a write onto a double this library built is reported apart and suggests `mockValueProp`                                                                                                                                                                                                                                                                       |
 | `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`, or a silently empty object, 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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
@@ -3854,7 +3854,7 @@ export can never be.
 | `prefer-settle-dynamic-import`    |   `error`   | suggest           | `await import('./thing')` — or `import('./thing').then(…)` — written in a test body or a hook to settle a module the code under test lazy-loads → `await settleDynamicImport(() => import('./thing'))`. Awaiting the specifier waits for the **module**; the handler's own continuation, the lines after _its_ `await`, is still queued behind it, so the assertion reads the state one turn early. The suggestion wraps the `import()` and imports the helper. Reported only where the innermost enclosing function is the runner's own callback, which is what exempts a `vi.mock` factory, a lazy route's `loadComponent` and a callback the spec hands to production code                                                                                                                 |
 | `prefer-create-mock`              |   `warn`    | suggest           | an object literal under `as SomeType` — `{ id: '1', isOffline: false } as Device`, and the `<Device>{ … }` spelling → `createMock<Device>({ … })`, which takes a `DeepPartial<Device>` and answers a `Device`. A cast asks whether the two types overlap, so it passes a key the type does not declare **and** a required field the fixture never sets; both type gates stay silent and the fixture is then spread into an expected payload. Silent on `as const`, on `as unknown` / `as any` and the double cast built from them, on a cast of anything that is not a literal, and on a literal inside one of this library's own factories. `warn`, not `error`: the repair makes a drifted fixture red on the next type-check, which is the finding and also a migration taken file by file |
 | `no-mock-cast`                    |   `error`   | suggest           | `TestBed.inject(S).m as Mock` — a cast to Vitest's `Mock` / `MockInstance` over a **member access** → `injectSpy(S).m`, which the suggestion writes when the token is in view. `Mock` with no parameters is `Mock<any>`, so `mockReturnValue` takes anything and `toHaveBeenCalledWith` stops comparing arguments; the worse form, `(spy.m.mockReturnValue as Mock)(…)`, gets a message of its own because the cast sits on the member that installs the answer. The name has to resolve to a runner's import, so a domain `Mock` is never reported                                                                                                                                                                                                                                           |
-| `no-redundant-mock-reset`         |   `error`   | `--fix` / suggest | a mock reset **inside a hook** — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — that the runner already performs between tests → delete it. **Silent until** the flags are known: `['error', { clearMocks: true, restoreMocks: true, mockReset: true }]`, or a `vitest.config.*` / `vite.config.*` found above the file. The flag has to match the call: `restoreMocks` alone does not make a `clearAllMocks()` dead, since it never reaches a plain `vi.fn()`. `--fix` only where nothing can have run in between — the first statement of the file's only `beforeEach` — a suggestion everywhere else, and **never** in a test body                                                                                    |
+| `no-redundant-mock-reset`         |   `error`   | `--fix` / suggest | a mock reset **the runner already performs** — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — as the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear closing an `afterEach` → delete it. **Silent until** the flags are known: `['error', { clearMocks: true, restoreMocks: true, mockReset: true }]`, `{ configFile }` naming the runner config, or a `vitest.config.*` / `vite.config.*` found above the file. The flag has to match the call: `restoreMocks` alone does not make a `clearAllMocks()` dead, since it never reaches a plain `vi.fn()`. `--fix` only in a file whose only before-hook it is, a suggestion everywhere else, and **never** in a test body                     |
 | `no-unasserted-argument`          |   `warn`    | —                 | a bare `expect(spy).toHaveBeenCalled()` where the file itself says the arguments are the point: the same subject is pinned with `toHaveBeenCalledWith(…)` in another test of the file, or the test's title says `with` and its body asserts nothing else → name the arguments. Narrower than `vitest/prefer-called-with` on purpose — 175 findings against its 1941 on the same suite                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `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`                                                                                                                                                                                                                                                                                                                                                                                                   |

package/dist/angular-diagnostics.d.ts

@@ -9,14 +9,25 @@ interface AngularDiagnosticsOptions {
     deadSchemas?: boolean;
     /** Fail — rather than warn — when `injectSpy` finds a real instance where a spy was expected. */
     unspiedProviders?: boolean;
-    /** Fail a test that ends with unflushed `HttpTestingController` requests. */
-    pendingRequests?: boolean;
+    /**
+     * Fail a test that ends with unflushed `HttpTestingController` requests.
+     *
+     * An object keeps the check on and carries its option to it: `{ ignoreCancelled: true }` is the
+     * opt-in `HttpTestingController.verify({ ignoreCancelled })` names — a request the code under test
+     * cancelled, by unsubscribing, is taken but no longer fails the test.
+     */
+    pendingRequests?: PendingRequestsOptions | boolean;
     /**
      * Fail when a double registered on the testing module loses to the component's own `providers`,
      * so the component under test is running against the real service.
      */
     shadowedProviders?: boolean;
 }
+/** What `pendingRequests` and {@link assertNoPendingRequests} accept. */
+interface PendingRequestsOptions {
+    /** Skip requests the code under test cancelled. Default `false`, like Angular's own `verify()`. */
+    ignoreCancelled?: boolean;
+}
 /**
  * Fail when the `HttpTestingController` this test configured is still holding requests.
  *
@@ -25,6 +36,7 @@ interface AngularDiagnosticsOptions {
  * reading it takes the requests, so calling it yourself is not paid for twice.
  *
  * A no-op when the group is off, or when the test never configured HTTP testing at all.
+ * `ignoreCancelled` defaults to what `enableAngularDiagnostics({ pendingRequests })` was given.
  *
  * @example
  * ```ts
@@ -33,7 +45,7 @@ interface AngularDiagnosticsOptions {
  * assertNoPendingRequests(); // nothing else went out
  * ```
  */
-declare function assertNoPendingRequests(): void;
+declare function assertNoPendingRequests(options?: PendingRequestsOptions): void;
 /**
  * Fail when a double this test registered on the testing module never reached `component`.
  *
@@ -165,4 +177,4 @@ declare function reportSpecTiming(timing: SpecTiming): void;
  */
 declare function enableTestBedDiagnostics(options?: TestBedDiagnosticsOptions): void;
 
-export { type AngularDiagnosticsOptions, type SpecTiming, type TestBedDiagnosticsOptions, assertNoPendingRequests, assertNoShadowedProviders, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming };
+export { type AngularDiagnosticsOptions, type PendingRequestsOptions, type SpecTiming, type TestBedDiagnosticsOptions, assertNoPendingRequests, assertNoShadowedProviders, disableAngularDiagnostics, disableTestBedDiagnostics, enableAngularDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming };

package/dist/angular-diagnostics.js

@@ -1,7 +1,7 @@
-import { instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-KOR5OK4H.js';
-export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-KOR5OK4H.js';
+import { assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-RGRZDCM6.js';
+export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-RGRZDCM6.js';
 import { failOnUnspiedProvider } from './chunk-45W5LBPY.js';
-import { assertAngularInternals } from './chunk-WYYKUPXW.js';
+import './chunk-6UETTNQH.js';
 import './chunk-MBSPAUUD.js';
 import './chunk-DQ3SPSCH.js';
 import './chunk-MG7LKE4R.js';
@@ -170,7 +170,10 @@ function readControllerToken(config) {
 }
 function describeRequest(open) {
   const request = readProperty(open, "request");
-  return `${String(readProperty(request, "method"))} ${String(readProperty(request, "urlWithParams"))}`;
+  return {
+    description: `${String(readProperty(request, "method"))} ${String(readProperty(request, "urlWithParams"))}`,
+    cancelled: readProperty(open, "cancelled") === true
+  };
 }
 function takeOpenRequests(controller) {
   const match = readProperty(controller, "match");
@@ -189,16 +192,18 @@ function injectFromModule(token) {
 function readOpenRequests() {
   return controllerToken === void 0 ? [] : takeOpenRequests(injectFromModule(controllerToken));
 }
-function assertNoPendingRequests() {
-  const open = [...openAtReset.splice(0), ...readOpenRequests()];
+function assertNoPendingRequests(options = {}) {
+  const taken = [...openAtReset.splice(0), ...readOpenRequests()];
+  const ignoreCancelled = options.ignoreCancelled ?? active?.ignoreCancelled ?? false;
+  const open = ignoreCancelled ? taken.filter((request) => !request.cancelled) : taken;
   if (open.length === 0) {
     return;
   }
   throw new Error(
     withDocs(
-      `[vitest-auto-spy] enableAngularDiagnostics({ pendingRequests }): the test ended with ${open.length} unflushed HttpTestingController request(s): ${open.join(", ")}.
+      `[vitest-auto-spy] enableAngularDiagnostics({ pendingRequests }): the test ended with ${open.length} unflushed HttpTestingController request(s): ${open.map((request) => request.description).join(", ")}.
 Nothing answered them and nothing asserted them, so the code under test is still waiting on a response it never received \u2014 everything the spec expected to happen after that call did not happen here.
-Flush each one (\`controller.expectOne('/url').flush(body)\`), or call \`controller.verify()\` in the spec where the absence of a request is the thing being asserted.`,
+Flush each one (\`controller.expectOne('/url').flush(body)\`), or call \`controller.verify()\` in the spec where the absence of a request is the thing being asserted. A request the code cancels on purpose is excused by \`enableAngularDiagnostics({ pendingRequests: { ignoreCancelled: true } })\`.`,
       DOCS_LINKS.angularDiagnostics
     )
   );
@@ -271,7 +276,7 @@ function registerPerTestHooks() {
     }
     preparedTest = void 0;
     if (active?.pendingRequests) {
-      verifyOnTeardown(assertNoPendingRequests);
+      verifyOnTeardown(() => assertNoPendingRequests());
     }
   });
 }
@@ -281,7 +286,8 @@ function enableAngularDiagnostics(options = {}) {
     ngModuleScopes: options.ngModuleScopes ?? true,
     deadSchemas: options.deadSchemas ?? true,
     unspiedProviders: options.unspiedProviders ?? true,
-    pendingRequests: options.pendingRequests ?? true,
+    pendingRequests: options.pendingRequests !== false,
+    ignoreCancelled: typeof options.pendingRequests === "object" && options.pendingRequests.ignoreCancelled === true,
     shadowedProviders: options.shadowedProviders ?? true
   };
   assertAngularInternals();

package/dist/angular-doubles.d.ts

@@ -1,5 +1,5 @@
 import { AbstractType, Injector, InjectionToken, ValueProvider, FactoryProvider, ProviderToken } from '@angular/core';
-import { h as AddSpyMethodsByReturnTypes } from './types-BM3BcWj1.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-BuQtoidb.js';
 import 'vitest';
 
 /**

package/dist/angular-http.js

@@ -1,7 +1,7 @@
 import { writeWarning } from './chunk-3VXZRDH3.js';
-import { verifyOnTeardown, beforeTestBedReset } from './chunk-KOR5OK4H.js';
+import { assertAngularInternals, verifyOnTeardown, beforeTestBedReset } from './chunk-RGRZDCM6.js';
 import { flushEffects } from './chunk-JBV35SU3.js';
-import { assertAngularInternals } from './chunk-WYYKUPXW.js';
+import './chunk-6UETTNQH.js';
 import './chunk-SOROJD3W.js';
 import { DOCS_LINKS } from './chunk-QO4BPR3V.js';
 import { withDocs } from './chunk-TZ7DRSRD.js';

package/dist/angular-router.d.ts

@@ -1,6 +1,6 @@
 import { Type, Injector, FactoryProvider, Provider } from '@angular/core';
 import { Params, Data, UrlSegment, ActivatedRoute, Route, ResolveData, Navigation, Router, Event } from '@angular/router';
-import { h as AddSpyMethodsByReturnTypes } from './types-BM3BcWj1.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-BuQtoidb.js';
 import { SpyLocation } from '@angular/common/testing';
 import 'vitest';
 
@@ -251,12 +251,12 @@ type LocationDouble = SpyLocation;
  *
  * const location = injectLocationDouble();
  *
- * location.go('/reports/7'); // urlChanges records it; path() reads it back
+ * location.go('/reports', 'tab=7'); // urlChanges records it; path() reads '/reports?tab=7' back
  * location.simulateUrlPop('/'); // the popstate no method call can cause
  * ```
  *
- * Returns the provider pair Angular ships (`SpyLocation` for `Location`, `MockLocationStrategy` for
- * `LocationStrategy`) — a new array every call, so a list hoisted to a module constant still hands
+ * Returns the pair `provideLocationMocks()` ships (a `SpyLocation` for `Location`, whose `path()` keeps
+ * the query, and `MockLocationStrategy` for `LocationStrategy`) — a new array every call, so a list hoisted to a module constant still hands
  * each injector a double of its own.
  */
 declare function provideLocationDouble(): Provider[];

package/dist/angular-router.js

@@ -1,3 +1,4 @@
+import { angularInternalsError } from './chunk-6UETTNQH.js';
 import { createFunctionSpy } from './chunk-LZVIH54N.js';
 import './chunk-BBPYNKGB.js';
 import { DOCS_LINKS } from './chunk-QO4BPR3V.js';
@@ -7,8 +8,8 @@ import { Router, DefaultUrlSerializer, PRIMARY_OUTLET, ActivatedRoute, RouterSta
 import { BehaviorSubject, skip } from 'rxjs';
 import { signal } from '@angular/core';
 import { onTestFinished, expect } from 'vitest';
-import { Location } from '@angular/common';
-import { provideLocationMocks, SpyLocation } from '@angular/common/testing';
+import { Location, LocationStrategy } from '@angular/common';
+import { MockLocationStrategy, SpyLocation } from '@angular/common/testing';
 
 var doubles = /* @__PURE__ */ new WeakMap();
 function toSegments(url) {
@@ -436,13 +437,35 @@ function collectRouterEvents(source) {
     }
   };
 }
+function currentQuery(location) {
+  const history = Reflect.get(location, "_history");
+  const index = Reflect.get(location, "_historyIndex");
+  const entry = Array.isArray(history) && typeof index === "number" ? history[index] : void 0;
+  const query = Reflect.get(Object(entry), "query");
+  if (typeof query !== "string") {
+    throw angularInternalsError(
+      "SpyLocation#_history[\u2026].query",
+      "`provideLocationDouble()` can no longer answer the query in `path()`, as the real `Location` does."
+    );
+  }
+  return query;
+}
+var QueryAwareSpyLocation = class extends SpyLocation {
+  path() {
+    const query = currentQuery(this);
+    return super.path() + Location.normalizeQueryParams(query);
+  }
+};
 function describeInstance(instance) {
   const prototype = Reflect.getPrototypeOf(instance);
   const owner = prototype === null || prototype === Object.prototype ? void 0 : Reflect.get(prototype, "constructor");
   return typeof owner === "function" ? `an instance of ${owner.name}` : "a plain object";
 }
 function provideLocationDouble() {
-  return [...provideLocationMocks()];
+  return [
+    { provide: Location, useFactory: createLocationDouble },
+    { provide: LocationStrategy, useClass: MockLocationStrategy }
+  ];
 }
 function injectLocationDouble(injector) {
   const caller = "[vitest-auto-spy] injectLocationDouble()";
@@ -463,7 +486,7 @@ function injectLocationDouble(injector) {
   return location;
 }
 function createLocationDouble() {
-  return new SpyLocation();
+  return new QueryAwareSpyLocation();
 }
 
 export { collectRouterEvents, createActivatedRoute, createLocationDouble, createRouterDouble, injectActivatedRoute, injectLocationDouble, injectRouterDouble, provideActivatedRoute, provideLocationDouble, provideRouterDouble };

package/dist/angular.d.ts

@@ -1,11 +1,11 @@
-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-BSVObkds.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-DsBgqliM.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
-import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-S5asJaJP.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-S5asJaJP.js';
-import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, q as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes } from './types-BM3BcWj1.js';
+import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-CD6thEE8.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-CD6thEE8.js';
+import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, q as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes } from './types-BuQtoidb.js';
 import { TestAPI } from 'vitest';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-Dig5t28T.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-C--a8rpU.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-L6IgAUL7.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-yHR11U7R.js';
 import '@angular/core/testing';
 
 /**

package/dist/angular.js

@@ -3196,33 +3196,6 @@ Nothing here is fixable from a spec: report the Angular version above, and pin t
     )
   );
 }
-var PROBES = [
-  {
-    what: "TestBed#_testModuleRef",
-    consequence: "The live testing module can no longer be told from a reset one, so `provideHttpTesting({ verifyOnTeardown })` and `enableAngularDiagnostics({ pendingRequests, shadowedProviders })` would report nothing at all.",
-    ok: () => "_testModuleRef" in getTestBed()
-  },
-  {
-    what: "ReactiveNode#consumers / #kind",
-    consequence: "`mockSignalProp()` can no longer see whether a signal has been read, nor write through a read-only one, so a patch applied after the first read would be accepted and quietly change nothing.",
-    ok: () => {
-      const node = Object(Reflect.get(signal(0), _SIGNAL));
-      return "consumers" in node && Reflect.get(node, "kind") === "signal";
-    }
-  }
-];
-var failure;
-var checked = false;
-function assertAngularInternals() {
-  if (!checked) {
-    checked = true;
-    const broken = PROBES.find((probe) => !probe.ok());
-    failure = broken === void 0 ? void 0 : angularInternalsError(broken.what, broken.consequence);
-  }
-  if (failure) {
-    throw failure;
-  }
-}
 
 // src/lib/component-stub.ts
 var NOT = 1;
@@ -3885,6 +3858,35 @@ function installResourceDouble(object, property, initialValue, options) {
     resource
   };
 }
+var PROBES = [
+  {
+    what: "TestBed#_testModuleRef",
+    consequence: "The live testing module can no longer be told from a reset one, so `provideHttpTesting({ verifyOnTeardown })` and `enableAngularDiagnostics({ pendingRequests, shadowedProviders })` would report nothing at all.",
+    ok: () => "_testModuleRef" in getTestBed()
+  },
+  {
+    what: "ReactiveNode#consumers / #kind",
+    consequence: "`mockSignalProp()` can no longer see whether a signal has been read, nor write through a read-only one, so a patch applied after the first read would be accepted and quietly change nothing.",
+    ok: () => {
+      const node = Object(Reflect.get(signal(0), _SIGNAL));
+      return "consumers" in node && Reflect.get(node, "kind") === "signal";
+    }
+  }
+];
+var failure;
+var checked = false;
+function assertAngularInternals() {
+  if (!checked) {
+    checked = true;
+    const broken = PROBES.find((probe) => !probe.ok());
+    failure = broken === void 0 ? void 0 : angularInternalsError(broken.what, broken.consequence);
+  }
+  if (failure) {
+    throw failure;
+  }
+}
+
+// src/lib/signal-prop.ts
 function isWritableMember(candidate) {
   const maybe = Object(candidate);
   return isSignal(candidate) && typeof maybe.set === "function";

package/dist/bun-angular.d.ts

@@ -1,9 +1,9 @@
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, m as ClassSpyConfiguration, C as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, I as InstanceSpyConfiguration, M as MethodReturns, p as Mutable, N as NextValueConfig, O as ObservableLike, q as OnlyMethodKeysOf, r as OnlyObservablePropsOf, s as OnlyPropsOf, t as Overload, u as OverloadChoice, v as Overloads, P as PropStubValue, S as Spy, w as SpyDisposable, x as SpyOptions, y as StrictSpyConfiguration, z as SubjectLike, B as SubjectOf, U as UnstubbedCall, G as UnstubbedCallHandler, H as UnstubbedRead, J as UnstubbedReadHandler, V as ValueConfig, K as ValueConfigPerCall, W as WithMockReturnValue } from './types-BM3BcWj1.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, h as AddSpyMethodsByReturnTypes, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, m as ClassSpyConfiguration, C as ClassType, n as CompleteValueConfig, D as DeepMockProxy, o as DeepPartial, E as ErrorValueConfig, F as Func, I as InstanceSpyConfiguration, M as MethodReturns, p as Mutable, N as NextValueConfig, O as ObservableLike, q as OnlyMethodKeysOf, r as OnlyObservablePropsOf, s as OnlyPropsOf, t as Overload, u as OverloadChoice, v as Overloads, P as PropStubValue, S as Spy, w as SpyDisposable, x as SpyOptions, y as StrictSpyConfiguration, z as SubjectLike, B as SubjectOf, U as UnstubbedCall, G as UnstubbedCallHandler, H as UnstubbedRead, J as UnstubbedReadHandler, V as ValueConfig, K as ValueConfigPerCall, W as WithMockReturnValue } from './types-BuQtoidb.js';
 export { AdoptMockOptions, AdoptedMock, ArgCaptor, AsInstances, AssertMockedOptions, CallLog, CaptureArgOptions, ConstructorMock, ConstructorSpy, FixtureFactory, FlushUntilOptions, MockDeepOptions, ModuleNamespace, ModuleNamespaceOptions, SpyClassOptions, adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, clearAutoSpy, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromClass, createSpyFromInstance, errorHandler, flushEventLoop, flushEventLoopUntil, mockConstructor, mockDeep, moduleNamespace, narrow, resetAutoSpy, restoreSpiedInstance, settleDynamicImport, stubConstructor, withOverrides } from './bun.js';
-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-S5asJaJP.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-Cn7yncmJ.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-C--a8rpU.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-BSVObkds.js';
+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-CD6thEE8.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-CqrrGVDm.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-yHR11U7R.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-DsBgqliM.js';
 import 'vitest';
 import '@angular/core';
 import '@angular/core/testing';

package/dist/bun-angular.js

@@ -2,7 +2,7 @@ import { createSpyForToken } from './chunk-ZCWAFGHX.js';
 export { injectSpy, provideAutoSpy } from './chunk-45W5LBPY.js';
 import { stable, flushEffects } from './chunk-JBV35SU3.js';
 export { flushEffects, stable } from './chunk-JBV35SU3.js';
-import { angularInternalsError } from './chunk-WYYKUPXW.js';
+import { angularInternalsError } from './chunk-6UETTNQH.js';
 import './chunk-YEQQIKQR.js';
 export { adoptMock, asInstance, asInstances, asSpy, assertMocked, captureArg, createFixture, createFixtureFactory, createLog, createMock, createSpyClass, createSpyFromInstance, describeDuplicateCopies, expectCompletion, expectEmission, expectEmissions, expectError, expectNoEmission, flushEventLoop, flushEventLoopUntil, getPackageCopies, mockConstructor, mockDeep, moduleNamespace, narrow, restoreSpiedInstance, setEmissionTimeout, settleDynamicImport, stubConstructor, withOverrides } from './chunk-E5M7DBWB.js';
 import { mockValueProp } from './chunk-MBSPAUUD.js';

package/dist/bun.d.ts

@@ -1,8 +1,8 @@
-import { x as SpyOptions, C as ClassType, m as ClassSpyConfiguration, q as OnlyMethodKeysOf, S as Spy, I as InstanceSpyConfiguration, o as DeepPartial, D as DeepMockProxy, F as Func, h as AddSpyMethodsByReturnTypes } from './types-BM3BcWj1.js';
-export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, p as Mutable, N as NextValueConfig, O as ObservableLike, r as OnlyObservablePropsOf, s as OnlyPropsOf, t as Overload, u as OverloadChoice, v as Overloads, P as PropStubValue, w as SpyDisposable, y as StrictSpyConfiguration, z as SubjectLike, B as SubjectOf, U as UnstubbedCall, G as UnstubbedCallHandler, H as UnstubbedRead, J as UnstubbedReadHandler, V as ValueConfig, K as ValueConfigPerCall, W as WithMockReturnValue } from './types-BM3BcWj1.js';
-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-S5asJaJP.js';
-export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-Cn7yncmJ.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-C--a8rpU.js';
+import { x as SpyOptions, C as ClassType, m as ClassSpyConfiguration, q as OnlyMethodKeysOf, S as Spy, I as InstanceSpyConfiguration, o as DeepPartial, D as DeepMockProxy, F as Func, h as AddSpyMethodsByReturnTypes } from './types-BuQtoidb.js';
+export { A as AccessorKeysOf, a as AddAccessorsSpies, b as AddCalledWithAny, c as AddCalledWithObservable, d as AddCalledWithPromise, e as AddCalledWithSpyMethods, f as AddObservableSpyMethods, g as AddPromiseSpyMethods, i as AddThrowHelper, j as AddVoidReturnHelpers, k as AnyReturnHelpers, l as AutoSpyRxjsTypes, n as CompleteValueConfig, E as ErrorValueConfig, M as MethodReturns, p as Mutable, N as NextValueConfig, O as ObservableLike, r as OnlyObservablePropsOf, s as OnlyPropsOf, t as Overload, u as OverloadChoice, v as Overloads, P as PropStubValue, w as SpyDisposable, y as StrictSpyConfiguration, z as SubjectLike, B as SubjectOf, U as UnstubbedCall, G as UnstubbedCallHandler, H as UnstubbedRead, J as UnstubbedReadHandler, V as ValueConfig, K as ValueConfigPerCall, W as WithMockReturnValue } from './types-BuQtoidb.js';
+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-CD6thEE8.js';
+export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-CqrrGVDm.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-yHR11U7R.js';
 import { Mock, MockInstance } from 'vitest';
 
 /**

package/dist/chunk-6UETTNQH.js

@@ -0,0 +1,16 @@
+import { DOCS_LINKS } from './chunk-QO4BPR3V.js';
+import { withDocs } from './chunk-TZ7DRSRD.js';
+import { VERSION } from '@angular/core';
+
+function angularInternalsError(what, consequence) {
+  return new Error(
+    withDocs(
+      `[vitest-auto-spy] @angular/core ${VERSION.full} no longer carries ${what}, which this package reads.
+${consequence}
+Nothing here is fixable from a spec: report the Angular version above, and pin the previous one until a release of this package reads the new shape.`,
+      DOCS_LINKS.angular
+    )
+  );
+}
+
+export { angularInternalsError };

package/dist/{chunk-KOR5OK4H.js → chunk-RGRZDCM6.js}

@@ -1,7 +1,8 @@
+import { angularInternalsError } from './chunk-6UETTNQH.js';
 import { TestBed, getTestBed } from '@angular/core/testing';
 import { expect, beforeAll, afterAll } from 'vitest';
+import { signal, ɵSIGNAL as _SIGNAL } from '@angular/core';
 
-// src/lib/testbed-diagnostics.ts
 var INSTRUMENTED = [
   { method: "configureTestingModule", counter: "configurations" },
   { method: "createComponent", counter: "components" },
@@ -115,6 +116,33 @@ function enableTestBedDiagnostics(options = {}) {
     }
   });
 }
+var PROBES = [
+  {
+    what: "TestBed#_testModuleRef",
+    consequence: "The live testing module can no longer be told from a reset one, so `provideHttpTesting({ verifyOnTeardown })` and `enableAngularDiagnostics({ pendingRequests, shadowedProviders })` would report nothing at all.",
+    ok: () => "_testModuleRef" in getTestBed()
+  },
+  {
+    what: "ReactiveNode#consumers / #kind",
+    consequence: "`mockSignalProp()` can no longer see whether a signal has been read, nor write through a read-only one, so a patch applied after the first read would be accepted and quietly change nothing.",
+    ok: () => {
+      const node = Object(Reflect.get(signal(0), _SIGNAL));
+      return "consumers" in node && Reflect.get(node, "kind") === "signal";
+    }
+  }
+];
+var failure;
+var checked = false;
+function assertAngularInternals() {
+  if (!checked) {
+    checked = true;
+    const broken = PROBES.find((probe) => !probe.ok());
+    failure = broken === void 0 ? void 0 : angularInternalsError(broken.what, broken.consequence);
+  }
+  if (failure) {
+    throw failure;
+  }
+}
 function beforeTestBedReset(wrapped, beforeReset) {
   const testBed = getTestBed();
   const original = Reflect.get(testBed, "resetTestingModule");
@@ -131,4 +159,4 @@ function beforeTestBedReset(wrapped, beforeReset) {
   });
 }
 
-export { beforeTestBedReset, disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, onComponentCreated, onTestingModuleConfigured, reportSpecTiming, verifyOnTeardown };
+export { assertAngularInternals, beforeTestBedReset, disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, onComponentCreated, onTestingModuleConfigured, reportSpecTiming, verifyOnTeardown };