vitest-auto-spy 3.16.0 → 3.18.0

package/AGENTS.md

@@ -49,16 +49,17 @@ adapter installed and spies fail at runtime.
 | Vue / Pinia          | `vitest-auto-spy/vue`         |
 | Svelte               | `vitest-auto-spy/svelte`      |
 
-Five add-ons, orthogonal to the runner:
-
-| Add-on            | Import                          | Needed for                                                                                                |
-| ----------------- | ------------------------------- | --------------------------------------------------------------------------------------------------------- |
-| Observable spies  | `import 'vitest-auto-spy/rxjs'` | `nextWith` & friends. **Side-effect import, once.**                                                       |
-| observer-spy shim | `vitest-auto-spy/observer-spy`  | `subscribeSpyTo` — the `@hirez_io/observer-spy` surface (§20). Its own entry so `/rxjs` does not carry it |
-| Console spies     | `vitest-auto-spy/console`       | silent typed spies over the global `console`                                                              |
-| Setup helpers     | `vitest-auto-spy/setup`         | `setupAutoSpy()`, `setupFakeTimers()`                                                                     |
-| Zone patch        | `import 'vitest-auto-spy/zone'` | `fakeAsync` / `waitForAsync` on Vitest (§14)                                                              |
-| jasmine compat    | `vitest-auto-spy/jasmine`       | `.and` / `.calls` / `.withArgs`, the `jasmine` namespace (§20)                                            |
+Add-ons, orthogonal to the runner:
+
+| Add-on            | Import                          | Needed for                                                                                                                      |
+| ----------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
+| Observable spies  | `import 'vitest-auto-spy/rxjs'` | `nextWith` & friends. **Side-effect import, once.**                                                                             |
+| observer-spy shim | `vitest-auto-spy/observer-spy`  | `subscribeSpyTo` — the `@hirez_io/observer-spy` surface (§20). Its own entry so `/rxjs` does not carry it                       |
+| Console spies     | `vitest-auto-spy/console`       | silent typed spies over the global `console`                                                                                    |
+| Angular HTTP      | `vitest-auto-spy/angular-http`  | `provideHttpTesting`, `expectRequest` — `httpResource()` / `HttpClient` (§13). Optional `@angular/common` peer, this entry only |
+| Setup helpers     | `vitest-auto-spy/setup`         | `setupAutoSpy()`, `setupFakeTimers()`                                                                                           |
+| Zone patch        | `import 'vitest-auto-spy/zone'` | `fakeAsync` / `waitForAsync` on Vitest (§14)                                                                                    |
+| jasmine compat    | `vitest-auto-spy/jasmine`       | `.and` / `.calls` / `.withArgs`, the `jasmine` namespace (§20)                                                                  |
 
 `vitest-auto-spy/jasmine` is Vitest-only, because it registers the Vitest adapter. On `bun test` and
 `node --test` call `enableJasmineCompat()` from `vitest-auto-spy/jasmine-compat` instead.
@@ -1115,6 +1116,21 @@ server is slow". One thing this cannot see through — a spec whose own `afterEa
 `vi.useRealTimers()`, because hooks run in reverse registration order and the clock is real again by
 the time the hint reads it. Nothing is reported then, rather than something wrong.
 
+`angularBuildHint` is the third read-only hint, and the only one that speaks before a test rather
+than after one. `@angular/build` in `[22.1.5, 22.1.7)` builds the unit-test bundle with esbuild code
+splitting off — every spec a self-contained bundle, `--coverage` growing by hundreds of megabytes
+with no plateau (791 chunks / 596 MB on a 784-spec suite) — and the builder says nothing. The
+`doctor` check `angular-build-splitting-off` reports it, but has to be run; this line is printed
+from inside the affected run, to stderr, once per worker. The builder is recognised by the marker
+its own `vitest-mock-patch` setup file sets (`Symbol.for('@angular/cli/vitest-mock-patch')` on
+`globalThis`, before any user setup file), so a plain Vitest run reads nothing; under the builder
+the version comes from the nearest `node_modules/@angular/build/package.json` above the working
+directory. That read is the one place the library touches the disk — one file, read-only, through
+`process.getBuiltinModule` so `/setup` still loads with no `process` — and `scripts/check-dist.mjs`
+allows `node:fs` in `dist/setup.js` for exactly that. Silent outside the builder, outside the
+window, and on a Node before `getBuiltinModule`. `setupAutoSpy({ angularBuildHint: false })` turns
+it off.
+
 One more field of the same family differs quietly and changes only the report:
 `slowTestThreshold` is `5` in Jest (**seconds**) and `300` in Vitest (**milliseconds**), so a
 migrated suite starts marking most of its files slow. That is a unit change, not a regression.
@@ -1726,6 +1742,51 @@ is legitimately scope-empty, so a stripped scope that still has providers passes
 `assertNgModuleScopes(...)` where you know what the module was supposed to bring. `deadSchemas` does
 not fire when `declarations` is non-empty.
 
+### `httpResource()` and `HttpClient` in two lines — `vitest-auto-spy/angular-http`
+
+```ts
+import { expectRequest, provideHttpTesting } from 'vitest-auto-spy/angular-http';
+
+TestBed.configureTestingModule({ providers: [...provideHttpTesting()] });
+
+const products = TestBed.runInInjectionContext(() => httpResource<Product[]>(() => '/api/products'));
+
+await expectRequest('/api/products').flush([product]);
+
+expect(products.value()).toEqual([product]); // no tick, no microtask, no detectChanges
+```
+
+`expectRequest` does the six steps a zoneless HTTP spec otherwise writes by hand: tick (an
+`httpResource()` created in an injection context has issued **nothing** until something does), inject
+the `HttpTestingController`, find the one matching request, flush it, let one microtask run so the
+response reaches the resource, tick again so the view reading it is current. Miss the first and
+`expectOne` reports a request that was never sent; miss the fifth and the assertion reads the
+resource's **default** value and passes.
+
+| Call                               | Does                                                                                            |
+| ---------------------------------- | ----------------------------------------------------------------------------------------------- |
+| `provideHttpTesting(opts?)`        | `provideHttpClient()` + `provideHttpClientTesting()`; `{ verifyOnTeardown }` defaults to `true` |
+| `expectRequest(matcher, opts?)`    | tick, then the one match — `.request`, `.flush(body, opts?)`, `.error(status, opts?)`           |
+| `expectNoRequest(matcher?, opts?)` | tick, then assert nothing matched; no argument means "nothing at all was requested"             |
+| `verifyNoPendingRequests()`        | the teardown check by hand, for mid-test use or a suite with `verifyOnTeardown: false`          |
+
+`matcher` is a URL (matched against either `url` or `urlWithParams`), a `RegExp` over
+`urlWithParams`, or a predicate `(request) => boolean`. `{ method }` is case-insensitive.
+`flush()` and `error()` are `async` because settling requires letting a microtask run — `await` them,
+and the next line reads the settled value.
+
+Three things to know before reaching for it:
+
+- **It does not re-export the core.** The one subpath that does not: it is a companion to
+  `vitest-auto-spy/angular`, which stays the import for spies, `TestBed` helpers and `settleResource`.
+  Staying narrow is what keeps `@angular/common` — an **optional** peer — out of every other entry.
+- **`settleResource` is unchanged and still the answer** whenever the wait is not tied to one
+  request: a `resource()` with an async loader, an `rxResource`, a reload, anything not HTTP.
+- **`enableAngularDiagnostics({ pendingRequests })` is unchanged and cooperates.** Both take the open
+  requests with the one-shot `match(() => true)`, so an unanswered request is reported once. For a
+  suite using `provideHttpTesting()` everywhere the diagnostic is redundant; keep it on while any
+  file still configures HTTP testing by hand.
+
 ### Which collaborators the code asked for — `trackInjections`
 
 Do **not** reach for `vi.mock('@app/services')` to answer "was this collaborator used". Register the
@@ -1959,6 +2020,56 @@ and type the value against the member's **own** type. For a signal-valued member
 `mockSignalProp(service, 'state', initial)` over `gettersToSpyOn`: a spied getter returns `undefined`
 until configured, a real signal keeps everything downstream reactive.
 
+**A spec importing `@ngneat/spectator`** is on a package whose repository is a 404 and which does not
+resolve on Angular 22 (it imports `@angular/platform-browser-dynamic/testing` without declaring it).
+`createSpyObject` → `createSpyFromClass`, `mockProvider` → `provideAutoSpy`, `spectator.inject` →
+`injectSpy`, `SpyObject<T>` → `Spy<T>`, `createComponentFactory` → `renderShallow`. There is no
+replacement here for `spectator.query`, the event helpers or the DOM matchers — leave those on
+`@testing-library/angular` rather than inventing an equivalent. Full mapping:
+[Migrating from @ngneat/spectator](https://asdalexey.github.io/vitest-auto-spy/migrating-spectator).
+
+A suite coming off [`@suites/unit`](https://github.com/suites-dev/suites) maps one to one:
+`TestBed.solitary(S).compile()` → `createNestUnit(S)`, `TestBed.sociable(S).expose(D).compile()` →
+`createNestUnit(S, { expose: [D] })`, `unitRef.get` → `spies.get`, `.final(v)` →
+`{ provide, useValue }`, and the `await` goes away because the graph is built synchronously. The one
+thing to check by hand after the swap: Suites' double answers every property name, so a spec that
+stubbed a since-renamed method was passing over nothing and will now fail. Full mapping:
+<https://asdalexey.github.io/vitest-auto-spy/migrating-suites>.
+
+- **`renderShallow` has no single speed number, and quoting one is a bug.** Per render it ranges
+  from 1.2× (no children) to 16.2× (400 child instances) — `docs-site/core/performance.md`,
+  measured 2026-08-26. Per spec file, where imports and the `TestBed` module are also on the clock,
+  the published conversion is 1.7× over three specs with one of them a 0.8× regression. The two are
+  not interchangeable: the per-render ratio is the upper bound on what a file can gain. Any surface
+  that mentions the helper's speed quotes the range and links to
+  `/core/performance#_2-rendering-the-child-subtree`. A figure of **4.1×** appears in
+  `PRIORITIES.md` and is backed by nothing in this repository — do not publish it until someone
+  produces the measurement.
+- **Competitor defects are quoted from the published tarball, with a file, a line and a date.** The
+  `@testing-library/angular` `createMock` claims in `docs-site/comparison.md` are pinned to
+  `fesm2022/testing-library-angular-vitest-utils.mjs` lines 14 and 18 at 19.4.2. Re-`npm pack` and
+  re-read before restating them against a new version; the "Where the numbers come from" box records
+  each re-verification date rather than replacing the previous one.
+
+`node:test` keeps every `mock.fn()` in one process-wide `MockTracker` for the life of the process.
+On a long suite that is real memory — 20 000 spies of a 10-method class retained 124.5 MB on
+Node v24.19.0. `trackNodeMocks()` puts this library's spies on a tracker it owns and replaces it per
+test: 5.9 MB for the same run, against a 5.4 MB baseline.
+
+\```ts
+import { before } from 'node:test';
+import { trackNodeMocks } from 'vitest-auto-spy/node';
+
+before(() => trackNodeMocks()); // opt-in, idempotent, returns the undo
+
+// by hand, for a concurrent suite: pruneNodeMocks() → how many were dropped; countNodeMocks() → how many are held
+\```
+
+It never calls `mock.reset()` — that would restore and forget the `mock.fn()` the spec made itself —
+and it never throws: the class is reached through the undocumented `mock.constructor`, so the
+constructed tracker is probed first and any failure leaves spies on `node:test`'s own tracker.
+Spies created **before** the call stay there too. `mock.reset()` in `afterEach` is the fallback.
+
 ---
 
 ## 14. `fakeAsync` needs `vitest-auto-spy/zone`
@@ -1991,9 +2102,14 @@ convenient re-export from the root: it would quietly hand zone.js to every zonel
 
 ```ts
 // NestJS
-import { injectSpy, provideAutoSpy } from 'vitest-auto-spy/nestjs';
+import { createNestUnit, injectSpy, provideAutoSpy } from 'vitest-auto-spy/nestjs';
 const moduleRef = await Test.createTestingModule({ providers: [provideAutoSpy(MyService)] }).compile();
 const spy = injectSpy(moduleRef, MyService);
+// or no module at all: the unit built from its DI metadata, every unprovided token spied
+const { unit, spies } = createNestUnit(CartService, { expose: [PricingService], providers: [{ provide: 'CONFIG', useValue: cfg }] });
+spies.get(TaxService).rate.mockReturnValue(0.2); // spies.get refuses a token the unit never asked for, and an exposed class
+spies.autoSpiedTokens(); // what nothing provided — the list the refusal message prints; spies.exposedTokens() is what `expose` actually built
+// needs what Nest needs: emitDecoratorMetadata (tsc / SWC, not esbuild) and reflect-metadata loaded first
 
 // Vue / Pinia — provideAutoSpy(token, Class, methodsOrConfig?) returns a `global.provide` map
 import { provideAutoSpy } from 'vitest-auto-spy/vue';
@@ -2168,83 +2284,91 @@ packages, which a subpath export can never be.
 
 ## 17. Error → fix
 
-| Message contains                                                                             | Cause                                                                                                                                                | Fix                                                                                                                               |
-| -------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| `No mock adapter registered`                                                                 | no runtime entry was imported, or the wrong one                                                                                                      | import `vitest-auto-spy` (Vitest) / `…/bun` / `…/node` once before creating spies                                                 |
-| `Observable spies require rxjs`                                                              | the rxjs layer was never loaded                                                                                                                      | `import 'vitest-auto-spy/rxjs';` once, in the setup file                                                                          |
-| `Cannot read properties of undefined (reading 'returnValue')` on `spy.m.and.…`               | the jasmine namespaces are not installed — the spy was built before them, or nothing installed them at all                                           | import from `vitest-auto-spy/jasmine`; on Bun / `node:test`, `enableJasmineCompat()` in the setup file (§20)                      |
-| `spy.withArgs is not a function`                                                             | the same, seen from the argument-matching side                                                                                                       | the same — or write `spy.m.calledWith(a).mockReturnValue(v)`, which needs no layer (§20)                                          |
-| `jasmine is not defined`                                                                     | jasmine's global is the runner's, and Vitest declares none                                                                                           | `import { jasmine } from 'vitest-auto-spy/jasmine'`, then `codemod --from jasmine` to rewrite the members (§20)                   |
-| `done.fail is not a function`                                                                | Vitest passes a `TestContext`, not jasmine's `done`; the line usually sits in an `error` callback nobody awaits, so the run stays **green**          | assert on the failure — `await expect(firstValueFrom(src$)).rejects.toMatchObject({ … })`, or `expect.fail(message)`              |
-| a `.withContext('…')` message that never appears in the failure output                       | Vitest's chai layer has an `@internal` `withContext(flags)`; handed a string it walks the character indices, sets nonsense flags and returns `this`  | `expect(actual, 'message').toBe(expected)` — the second argument of `expect` is the label. Nothing throws, so nothing warns (§20) |
-| `requested method(s) not found on the class prototype`                                       | typo, or an instance-field callable                                                                                                                  | fix the name, or move it to `instanceMethodsToSpyOn`                                                                              |
-| `was configured with 'mustBeCalledWith'`                                                     | the code called the spy with other arguments                                                                                                         | that is the assertion firing — fix the code, or relax to `calledWith`                                                             |
-| `extendWithAutoSpies needs Vitest 4.1 or newer`                                              | the `test` handed in has only the object-form `extend` (Vitest ≤ 4.0); the builder form the helper is written against arrived in 4.1                 | upgrade Vitest, or keep `provideAutoSpy` + `injectSpy` in a `beforeEach` until then                                               |
-| `advanceTimers() requires fake timers`                                                       | no fake timers installed                                                                                                                             | `setupFakeTimers()` or `vi.useFakeTimers()` first                                                                                 |
-| `Nothing configured X.method, and strict mode is on`                                         | a strict double was asked for a method no line configured                                                                                            | configure it (`mockReturnValue` / `resolveWith` / `nextWith` / `calledWith`), or `{ strict: false }` on that double (§5)          |
-| `Cannot redefine property: …` from a library accessor spy                                    | the target is an ES module namespace a bundler inlined                                                                                               | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that                                   |
-| `overrideComponentProvider(…): the override did not apply`                                   | the component injects a different token, or a later `overrideProvider` won                                                                           | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures  |
-| `the test ended with N unflushed HttpTestingController request(s)`                           | `enableAngularDiagnostics({ pendingRequests })` — nothing answered them                                                                              | flush each (`controller.expectOne(url).flush(body)`), or `controller.verify()` where absence is the assertion (§13)               |
-| `NgModule(s) with an empty runtime scope: …`                                                 | `ngModuleScopes` (or `assertNgModuleScopes`) — an AOT test bundle stripped `ɵɵsetNgModuleScope`, so the import contributes nothing                   | declare what the spec needs in the TestBed module directly; pass only modules expected to bring declarations (§13)                |
-| `Cannot read properties of undefined (reading 'provide')`, stack inside `render3/di_setup`   | a barrel chunk had not run when the component's definition was built, so a provider slot is `undefined`                                              | `assertComponentDefIntact(Cmp)` before `createComponent` — it names the list and the index (§13)                                  |
-| `assertComponentDefIntact(): argument N is undefined, which carries no ɵcmp or ɵdir`         | the class reference itself never arrived — the `Cannot read properties of undefined (reading 'ɵcmp')` case                                           | the same split barrel; import the component from its own module, not the barrel (§13)                                             |
-| `TS1117: An object literal cannot have multiple properties with the same name`, in a fixture | a hundred-line model literal copied into eight specs and edited independently                                                                        | one `createFixtureFactory<T>(defaults)`; note the runtime keeps the **second** key, so do not auto-fix by dropping one (§12)      |
-| `configureTestingModule was given N schema(s) that can never apply`                          | `enableAngularDiagnostics({ deadSchemas })` — `schemas` next to a standalone component, with `declarations` empty                                    | drop the `schemas` entry and put the missing directive/pipe in the component's own `imports`, or use `createDirectiveHost` (§13)  |
-| `injectSpy(X): the injector returned a plain instance, not an auto-spy`                      | the token is provided for real; a `console.warn` on its own, a **throw** under `enableAngularDiagnostics({ unspiedProviders })`                      | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants            |
-| `trackInjections(...).get(X): that token is not tracked by this log`                         | `get` only answers for tokens whose providers the log created                                                                                        | add the token to the `trackInjections([...])` list, or read it from the injector directly (§13)                                   |
-| `Spread syntax requires ...iterable[Symbol.iterator] to be a function`, at load time         | a module-scope spread of an imported binding, inside a bundle                                                                                        | build the array in a function or a getter — `no-import-time-spread` (§16)                                                         |
-| `the timers APIs are not mocked` in a nested `describe`'s `beforeAll`                        | fakes armed in `beforeEach` only; Jest armed them for the whole file                                                                                 | `setupFakeTimers(cfg, { betweenTests: true })` / `setupAutoSpy({ globalFakeTimers: true })`                                       |
-| setup-file hooks reaching only the first spec file of a worker                               | the setup module stayed cached (Angular unit-test builder + coverage)                                                                                | run coverage with `--isolate`, or call `setupAutoSpy()` from a per-file module                                                    |
-| `no DOM could be installed`                                                                  | `bun-angular` preload with no DOM package                                                                                                            | `bun add -d @happy-dom/global-registrator` (or `jsdom`)                                                                           |
-| `cannot read "…" referenced by …`                                                            | a `templateUrl` / `styleUrls` path does not resolve                                                                                                  | fix the path, relative to the component file                                                                                      |
-| duplicate-copy report from `setupAutoSpy()`                                                  | two installs, or one loaded as both ESM and CJS                                                                                                      | dedupe the dependency; `setupAutoSpy({ duplicateCopies: 'warn' })` to downgrade                                                   |
-| `Type 'Spy<T>' is not assignable to type 'T'`                                                | `Spy<T>` drops private members — by design                                                                                                           | declare as `Spy<T>`, or use `asInstance()` / `asSpy()` (§6)                                                                       |
-| a spy is never called, no warning                                                            | the method is an instance field, not on the prototype                                                                                                | `instanceMethodsToSpyOn`, or `createAutoMock<T>()`                                                                                |
-| `Cannot access '__vi_import_N__' before initialization`                                      | `vi.mock()` on `@angular/core` or a relative path                                                                                                    | you cannot mock it — the specs are bundled. Assert the result instead                                                             |
-| `AggregateError at Object.dispatchError`, for a request nothing asserts on                   | jsdom really served an `XMLHttpRequest` — `blockNetwork` used to cover only `fetch`                                                                  | `setupAutoSpy({ blockNetwork: true })`, or `{ xhr: 'empty' }` for tracker pings (§10)                                             |
-| `Schedulers cannot synchronously execute watches while scheduling`                           | a timer from a **previous** file, under `isolate: false`                                                                                             | track and cancel pending timers/frames in the setup file (§10)                                                                    |
-| `signal read during notification phase`                                                      | same — a stray `requestAnimationFrame` callback                                                                                                      | same                                                                                                                              |
-| an assertion error printed to stderr, every test green and the run exiting 0                 | zone.js swallowed a rejection nobody handled                                                                                                         | `setupAutoSpy({ strayRejections: true })` fails the test it surfaced in (§10)                                                     |
-| an `expect()` inside a `.then()` that never seems to run                                     | nothing awaits the chain, so the test ended first                                                                                                    | `await` the promise and assert the settled value — `no-floating-assertion` (§16)                                                  |
-| `trackStrayRejections() found no zone.js on the host`                                        | `strayRejections` turned on where zone.js is not loaded                                                                                              | `import 'zone.js';` in the setup file, or drop the option                                                                         |
-| `… .destroy is not a function`                                                               | an ngrx `rxMethod` replaced with a bare mock                                                                                                         | `Object.assign(vi.fn(), { destroy: vi.fn() })`                                                                                    |
-| `NullInjectorError` for a service you did provide                                            | it is a component-level provider, not a module one                                                                                                   | `asSpy(fixture.debugElement.injector.get(X))`, not `injectSpy(X)`                                                                 |
-| `runEffect(): … not an EffectRef returned by effect()`                                       | passed the callback, a signal, or an unassigned field                                                                                                | pass what `effect()` returned; a field may need its lifecycle hook to run first                                                   |
-| `X is not a constructor`, stack in production code                                           | a `vi.fn(() => …)` where the code does `new X()`                                                                                                     | `mockConstructor` / `stubConstructor` / `createSpyClass` (§12)                                                                    |
-| `Date is not a constructor`                                                                  | `vi.spyOn(globalThis, 'Date')` — the fakes own it                                                                                                    | `mockSystemTime(date)` / `vi.setSystemTime`                                                                                       |
-| `TS2352: … 'accessorSpies' is missing in type 'X'`                                           | `TestBed.inject(X) as Spy<X>`                                                                                                                        | `asSpy(TestBed.inject(X))` — never a double assertion (§6)                                                                        |
-| `TS2739` / `TS2740` / `TS2345` with `Spy<X>` on the left                                     | a spy handed to an API typed against the class                                                                                                       | `asInstance(spy)` (§6)                                                                                                            |
-| `is missing the following properties: _private, …`                                           | declared as Vitest's `Mocked<T>`                                                                                                                     | declare `Spy<T>` (§6)                                                                                                             |
-| `AddPromiseSpyMethods<unknown>` vs `WithMockReturnValue<…>`                                  | a generic class inferred as `Service<any>`                                                                                                           | `asSpy<Service>(…)` / `injectSpy<Service>(…)` (§6)                                                                                |
-| `'addEventListener' called on an object that is not a valid instance of EventTarget`         | Node's `AbortSignal` under jsdom + zone.js                                                                                                           | `stubAbortController()` (§12)                                                                                                     |
-| `vi.requireMock is not a function`                                                           | a mechanical `jest.` → `vi.` rename                                                                                                                  | there is no equivalent — provide the double through the TestBed instead                                                           |
-| a `vi.mock()` factory that never applies, only sometimes                                     | under `isolate: false` the module was already in the worker's graph                                                                                  | do not mock it; inject the dependency, or `vi.hoisted()` + a real seam                                                            |
-| a `vi.mock()` of a workspace alias that never applies at all                                 | a bundler inlined the module before the mock could be installed                                                                                      | `assertMocked(ns, { specifier })` to prove it, then inject instead of mocking                                                     |
-| `No "default" export is defined on the mock`, thrown inside a dependency                     | a factory returning bare named exports; the dep probes `default`                                                                                     | `vi.mock('x', () => moduleNamespace({ … }))`                                                                                      |
-| `Not implemented: HTMLMediaElement.play`, or `duration` is `NaN` and cannot be set           | jsdom implements the media elements as a shell                                                                                                       | `stubMediaElement({ duration })`, then `media.set(el, …)` to fire the events                                                      |
-| `Cannot set base providers because it has already been called`                               | zone and zoneless spec files sharing one worker                                                                                                      | `setupAngularTestEnv({ zoneless, initZone, initZoneless })` (§13)                                                                 |
-| a stub that works in the first test of the file and in no other                              | installed at `describe` level or in `beforeAll`, then restored away                                                                                  | install it in `beforeEach`, or `installPerTest(() => stub…())`                                                                    |
-| a third-party library failing every other run, no test named                                 | a test sealed a global with `Object.defineProperty` (non-configurable)                                                                               | `setupAutoSpy({ guardGlobals: 'throw' })` names the file; then `mockValueProp`                                                    |
-| `expected [ { at: 1, …(5) }, …(8) ] to deeply equal [ { …(6) }, … ]`                         | one field moved in every element — usually a frozen clock or an id                                                                                   | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                           |
-| a hand-tuned number of turns waiting for a `resource()` to load                              | a resource needs a change-detection **tick**, not event-loop turns; `flushEventLoopUntil` never ticks and the resource never even issues its request | `flushEffects()`, flush the request, then `await settleResource(r, { label })`                                                    |
-| a `resource()` assertion that passes but reads the **default** value                         | the spec asserted before the resource left `loading`                                                                                                 | `await settleResource(r, { label })` — it fails loudly instead                                                                    |
-| a spec dying on the runner's 5 s file timeout right after `await stable(fixture)`            | the fixture never stabilised — an unflushed request, a real `setInterval`                                                                            | `stable` now fails at 2000 ms naming the cause; raise `{ timeout }` only once neither is true                                     |
-| `flushEventLoopUntil` timing out on the **first** such test only, the rest green             | a cold dynamic `import()` outran the turn budget; later tests hit the module cache                                                                   | `await settleDynamicImport(() => import('…'))` — await the module, do not count turns                                             |
-| `Expected to be running in 'ProxyZone', but it was not found`                                | `zone.js/testing` patches jasmine/mocha/jest, not Vitest                                                                                             | `import 'vitest-auto-spy/zone'` after zone.js, with `globals: true` (§14)                                                         |
-| `nextWith` demanding `HttpEvent<T>` on a generated API client                                | `Parameters`/`ReturnType` read the **last** overload                                                                                                 | `asSpy<Client, { overload: 'first' }>(…)`, or `Overload<M, 0>`                                                                    |
-| `NG0303` / `NG0304` / nothing at all, from a directive spec                                  | the host is `standalone: false`, or the module is in the TestBed                                                                                     | `createDirectiveHost({ template, scope: [Module] })` (§13)                                                                        |
-| `TS2540: Cannot assign to 'X' because it is a read-only property`                            | a `readonly` field of an object under test                                                                                                           | `mockValueProp(obj, 'X', value)` — on a class **getter**, `mockReadonlyProp`                                                      |
-| `TypeError: Cannot read properties of undefined (reading 'mockReturnValue')`                 | the member is an **instance field**, not on the prototype — `Router.currentNavigation` since Angular 20                                              | `provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] })` (§5)                                                  |
-| `throwWith` reaching the success branch first, with the previous test's value                | the spy's `ReplaySubject(1)` outlived the test that filled it                                                                                        | upgrade; and `resetAutoSpy(spy)` in `beforeEach` when the TestBed is built in `beforeAll`                                         |
-| `TS2540` on a `Spy<T>` / `createAutoMock` member, which the runtime writes fine              | `Spy<T>` is homomorphic, so it keeps the `readonly` of an abstract getter                                                                            | `Mutable<Spy<T>>` for direct assignment, or `mockValueProp` for a patch that is undone                                            |
-| `delete mock.optionalMethod` leaving the member present and truthy                           | the Proxy had no `deleteProperty` trap before 3.5.0                                                                                                  | upgrade; before that, `mock.optionalMethod = undefined`                                                                           |
-| half a double's methods reaching the real implementation after `Object.assign`               | `ownKeys` on a type-driven Proxy lists only the keys already read                                                                                    | `createSpyFromClass(X)` — a real object, with enumerable method keys                                                              |
-| `let s: MockInstance<() => unknown>` not matching anything                                   | `MockInstance<F>` is invariant in `F`; Jest's `SpyInstance` was not                                                                                  | `MockInstance<T['method']>`, or better `injectSpy(X).method`                                                                      |
-| two runs with the same totals, one of them missing a suite                                   | a lost `describe` and a fixed flake cancel out in the counters                                                                                       | `compareTestRuns(before, after)` — compare the set of names, not the numbers                                                      |
-| a 30 s timeout, in a different file each run                                                 | module-level `vi.fn()` in a fixture shared by files                                                                                                  | make the fixture a factory (§10)                                                                                                  |
-| a component's `afterNextRender` state is empty                                               | `detectChanges()` does not run the after-render phase                                                                                                | `await stable(fixture)` (§11)                                                                                                     |
-| a green test whose only line about a call is `spy.m.calledWith(1);`                          | that is a **stub**, not an assertion — chai's `expect(fn).to.have.been.calledWith(x)` is the one that checks                                         | continue the chain, or `expect(spy.m).toHaveBeenCalledWith(1)` — `no-bare-called-with` (§16)                                      |
-| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers               | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                         | re-run that file with `strayTimers` off; the warning on stderr says how many were taken (§10)                                     |
+| Message contains                                                                                         | Cause                                                                                                                                                | Fix                                                                                                                                     |
+| -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `No mock adapter registered`                                                                             | no runtime entry was imported, or the wrong one                                                                                                      | import `vitest-auto-spy` (Vitest) / `…/bun` / `…/node` once before creating spies                                                       |
+| `Observable spies require rxjs`                                                                          | the rxjs layer was never loaded                                                                                                                      | `import 'vitest-auto-spy/rxjs';` once, in the setup file                                                                                |
+| `Cannot read properties of undefined (reading 'returnValue')` on `spy.m.and.…`                           | the jasmine namespaces are not installed — the spy was built before them, or nothing installed them at all                                           | import from `vitest-auto-spy/jasmine`; on Bun / `node:test`, `enableJasmineCompat()` in the setup file (§20)                            |
+| `spy.withArgs is not a function`                                                                         | the same, seen from the argument-matching side                                                                                                       | the same — or write `spy.m.calledWith(a).mockReturnValue(v)`, which needs no layer (§20)                                                |
+| `jasmine is not defined`                                                                                 | jasmine's global is the runner's, and Vitest declares none                                                                                           | `import { jasmine } from 'vitest-auto-spy/jasmine'`, then `codemod --from jasmine` to rewrite the members (§20)                         |
+| `done.fail is not a function`                                                                            | Vitest passes a `TestContext`, not jasmine's `done`; the line usually sits in an `error` callback nobody awaits, so the run stays **green**          | assert on the failure — `await expect(firstValueFrom(src$)).rejects.toMatchObject({ … })`, or `expect.fail(message)`                    |
+| a `.withContext('…')` message that never appears in the failure output                                   | Vitest's chai layer has an `@internal` `withContext(flags)`; handed a string it walks the character indices, sets nonsense flags and returns `this`  | `expect(actual, 'message').toBe(expected)` — the second argument of `expect` is the label. Nothing throws, so nothing warns (§20)       |
+| `requested method(s) not found on the class prototype`                                                   | typo, or an instance-field callable                                                                                                                  | fix the name, or move it to `instanceMethodsToSpyOn`                                                                                    |
+| `was configured with 'mustBeCalledWith'`                                                                 | the code called the spy with other arguments                                                                                                         | that is the assertion firing — fix the code, or relax to `calledWith`                                                                   |
+| `extendWithAutoSpies needs Vitest 4.1 or newer`                                                          | the `test` handed in has only the object-form `extend` (Vitest ≤ 4.0); the builder form the helper is written against arrived in 4.1                 | upgrade Vitest, or keep `provideAutoSpy` + `injectSpy` in a `beforeEach` until then                                                     |
+| `advanceTimers() requires fake timers`                                                                   | no fake timers installed                                                                                                                             | `setupFakeTimers()` or `vi.useFakeTimers()` first                                                                                       |
+| `Nothing configured X.method, and strict mode is on`                                                     | a strict double was asked for a method no line configured                                                                                            | configure it (`mockReturnValue` / `resolveWith` / `nextWith` / `calledWith`), or `{ strict: false }` on that double (§5)                |
+| `Cannot redefine property: …` from a library accessor spy                                                | the target is an ES module namespace a bundler inlined                                                                                               | no spy library can win this — give the code a real seam (inject it, pass it in) and spy on that                                         |
+| `overrideComponentProvider(…): the override did not apply`                                               | the component injects a different token, or a later `overrideProvider` won                                                                           | pass the token the component actually injects (a base class, an `InjectionToken`), and override after nothing else re-configures        |
+| `the test ended with N unflushed HttpTestingController request(s)`                                       | `enableAngularDiagnostics({ pendingRequests })` — nothing answered them                                                                              | flush each (`controller.expectOne(url).flush(body)`), or `controller.verify()` where absence is the assertion (§13)                     |
+| `NgModule(s) with an empty runtime scope: …`                                                             | `ngModuleScopes` (or `assertNgModuleScopes`) — an AOT test bundle stripped `ɵɵsetNgModuleScope`, so the import contributes nothing                   | declare what the spec needs in the TestBed module directly; pass only modules expected to bring declarations (§13)                      |
+| `Cannot read properties of undefined (reading 'provide')`, stack inside `render3/di_setup`               | a barrel chunk had not run when the component's definition was built, so a provider slot is `undefined`                                              | `assertComponentDefIntact(Cmp)` before `createComponent` — it names the list and the index (§13)                                        |
+| `assertComponentDefIntact(): argument N is undefined, which carries no ɵcmp or ɵdir`                     | the class reference itself never arrived — the `Cannot read properties of undefined (reading 'ɵcmp')` case                                           | the same split barrel; import the component from its own module, not the barrel (§13)                                                   |
+| `TS1117: An object literal cannot have multiple properties with the same name`, in a fixture             | a hundred-line model literal copied into eight specs and edited independently                                                                        | one `createFixtureFactory<T>(defaults)`; note the runtime keeps the **second** key, so do not auto-fix by dropping one (§12)            |
+| `configureTestingModule was given N schema(s) that can never apply`                                      | `enableAngularDiagnostics({ deadSchemas })` — `schemas` next to a standalone component, with `declarations` empty                                    | drop the `schemas` entry and put the missing directive/pipe in the component's own `imports`, or use `createDirectiveHost` (§13)        |
+| `injectSpy(X): the injector returned a plain instance, not an auto-spy`                                  | the token is provided for real; a `console.warn` on its own, a **throw** under `enableAngularDiagnostics({ unspiedProviders })`                      | `provideAutoSpy(X)` / `provideAutoSpyForToken(TOKEN)`, or `TestBed.inject(X)` if the real thing is what the spec wants                  |
+| `trackInjections(...).get(X): that token is not tracked by this log`                                     | `get` only answers for tokens whose providers the log created                                                                                        | add the token to the `trackInjections([...])` list, or read it from the injector directly (§13)                                         |
+| `Spread syntax requires ...iterable[Symbol.iterator] to be a function`, at load time                     | a module-scope spread of an imported binding, inside a bundle                                                                                        | build the array in a function or a getter — `no-import-time-spread` (§16)                                                               |
+| `the timers APIs are not mocked` in a nested `describe`'s `beforeAll`                                    | fakes armed in `beforeEach` only; Jest armed them for the whole file                                                                                 | `setupFakeTimers(cfg, { betweenTests: true })` / `setupAutoSpy({ globalFakeTimers: true })`                                             |
+| setup-file hooks reaching only the first spec file of a worker                                           | the setup module stayed cached (Angular unit-test builder + coverage)                                                                                | run coverage with `--isolate`, or call `setupAutoSpy()` from a per-file module                                                          |
+| `no DOM could be installed`                                                                              | `bun-angular` preload with no DOM package                                                                                                            | `bun add -d @happy-dom/global-registrator` (or `jsdom`)                                                                                 |
+| `cannot read "…" referenced by …`                                                                        | a `templateUrl` / `styleUrls` path does not resolve                                                                                                  | fix the path, relative to the component file                                                                                            |
+| duplicate-copy report from `setupAutoSpy()`                                                              | two installs, or one loaded as both ESM and CJS                                                                                                      | dedupe the dependency; `setupAutoSpy({ duplicateCopies: 'warn' })` to downgrade                                                         |
+| `Type 'Spy<T>' is not assignable to type 'T'`                                                            | `Spy<T>` drops private members — by design                                                                                                           | declare as `Spy<T>`, or use `asInstance()` / `asSpy()` (§6)                                                                             |
+| a spy is never called, no warning                                                                        | the method is an instance field, not on the prototype                                                                                                | `instanceMethodsToSpyOn`, or `createAutoMock<T>()`                                                                                      |
+| `Cannot access '__vi_import_N__' before initialization`                                                  | `vi.mock()` on `@angular/core` or a relative path                                                                                                    | you cannot mock it — the specs are bundled. Assert the result instead                                                                   |
+| `AggregateError at Object.dispatchError`, for a request nothing asserts on                               | jsdom really served an `XMLHttpRequest` — `blockNetwork` used to cover only `fetch`                                                                  | `setupAutoSpy({ blockNetwork: true })`, or `{ xhr: 'empty' }` for tracker pings (§10)                                                   |
+| `Schedulers cannot synchronously execute watches while scheduling`                                       | a timer from a **previous** file, under `isolate: false`                                                                                             | track and cancel pending timers/frames in the setup file (§10)                                                                          |
+| `signal read during notification phase`                                                                  | same — a stray `requestAnimationFrame` callback                                                                                                      | same                                                                                                                                    |
+| an assertion error printed to stderr, every test green and the run exiting 0                             | zone.js swallowed a rejection nobody handled                                                                                                         | `setupAutoSpy({ strayRejections: true })` fails the test it surfaced in (§10)                                                           |
+| an `expect()` inside a `.then()` that never seems to run                                                 | nothing awaits the chain, so the test ended first                                                                                                    | `await` the promise and assert the settled value — `no-floating-assertion` (§16)                                                        |
+| `trackStrayRejections() found no zone.js on the host`                                                    | `strayRejections` turned on where zone.js is not loaded                                                                                              | `import 'zone.js';` in the setup file, or drop the option                                                                               |
+| `… .destroy is not a function`                                                                           | an ngrx `rxMethod` replaced with a bare mock                                                                                                         | `Object.assign(vi.fn(), { destroy: vi.fn() })`                                                                                          |
+| `NullInjectorError` for a service you did provide                                                        | it is a component-level provider, not a module one                                                                                                   | `asSpy(fixture.debugElement.injector.get(X))`, not `injectSpy(X)`                                                                       |
+| `runEffect(): … not an EffectRef returned by effect()`                                                   | passed the callback, a signal, or an unassigned field                                                                                                | pass what `effect()` returned; a field may need its lifecycle hook to run first                                                         |
+| `X is not a constructor`, stack in production code                                                       | a `vi.fn(() => …)` where the code does `new X()`                                                                                                     | `mockConstructor` / `stubConstructor` / `createSpyClass` (§12)                                                                          |
+| `Date is not a constructor`                                                                              | `vi.spyOn(globalThis, 'Date')` — the fakes own it                                                                                                    | `mockSystemTime(date)` / `vi.setSystemTime`                                                                                             |
+| `TS2352: … 'accessorSpies' is missing in type 'X'`                                                       | `TestBed.inject(X) as Spy<X>`                                                                                                                        | `asSpy(TestBed.inject(X))` — never a double assertion (§6)                                                                              |
+| `TS2739` / `TS2740` / `TS2345` with `Spy<X>` on the left                                                 | a spy handed to an API typed against the class                                                                                                       | `asInstance(spy)` (§6)                                                                                                                  |
+| `is missing the following properties: _private, …`                                                       | declared as Vitest's `Mocked<T>`                                                                                                                     | declare `Spy<T>` (§6)                                                                                                                   |
+| `AddPromiseSpyMethods<unknown>` vs `WithMockReturnValue<…>`                                              | a generic class inferred as `Service<any>`                                                                                                           | `asSpy<Service>(…)` / `injectSpy<Service>(…)` (§6)                                                                                      |
+| `'addEventListener' called on an object that is not a valid instance of EventTarget`                     | Node's `AbortSignal` under jsdom + zone.js                                                                                                           | `stubAbortController()` (§12)                                                                                                           |
+| `vi.requireMock is not a function`                                                                       | a mechanical `jest.` → `vi.` rename                                                                                                                  | there is no equivalent — provide the double through the TestBed instead                                                                 |
+| a `vi.mock()` factory that never applies, only sometimes                                                 | under `isolate: false` the module was already in the worker's graph                                                                                  | do not mock it; inject the dependency, or `vi.hoisted()` + a real seam                                                                  |
+| a `vi.mock()` of a workspace alias that never applies at all                                             | a bundler inlined the module before the mock could be installed                                                                                      | `assertMocked(ns, { specifier })` to prove it, then inject instead of mocking                                                           |
+| `No "default" export is defined on the mock`, thrown inside a dependency                                 | a factory returning bare named exports; the dep probes `default`                                                                                     | `vi.mock('x', () => moduleNamespace({ … }))`                                                                                            |
+| `Not implemented: HTMLMediaElement.play`, or `duration` is `NaN` and cannot be set                       | jsdom implements the media elements as a shell                                                                                                       | `stubMediaElement({ duration })`, then `media.set(el, …)` to fire the events                                                            |
+| `Cannot set base providers because it has already been called`                                           | zone and zoneless spec files sharing one worker                                                                                                      | `setupAngularTestEnv({ zoneless, initZone, initZoneless })` (§13)                                                                       |
+| a stub that works in the first test of the file and in no other                                          | installed at `describe` level or in `beforeAll`, then restored away                                                                                  | install it in `beforeEach`, or `installPerTest(() => stub…())`                                                                          |
+| a third-party library failing every other run, no test named                                             | a test sealed a global with `Object.defineProperty` (non-configurable)                                                                               | `setupAutoSpy({ guardGlobals: 'throw' })` names the file; then `mockValueProp`                                                          |
+| `expected [ { at: 1, …(5) }, …(8) ] to deeply equal [ { …(6) }, … ]`                                     | one field moved in every element — usually a frozen clock or an id                                                                                   | `expect(diffByField(actual, expected)).toBeUndefined()`                                                                                 |
+| a hand-tuned number of turns waiting for a `resource()` to load                                          | a resource needs a change-detection **tick**, not event-loop turns; `flushEventLoopUntil` never ticks and the resource never even issues its request | `flushEffects()`, flush the request, then `await settleResource(r, { label })`                                                          |
+| a `resource()` assertion that passes but reads the **default** value                                     | the spec asserted before the resource left `loading`                                                                                                 | `await settleResource(r, { label })` — it fails loudly instead                                                                          |
+| a spec dying on the runner's 5 s file timeout right after `await stable(fixture)`                        | the fixture never stabilised — an unflushed request, a real `setInterval`                                                                            | `stable` now fails at 2000 ms naming the cause; raise `{ timeout }` only once neither is true                                           |
+| `flushEventLoopUntil` timing out on the **first** such test only, the rest green                         | a cold dynamic `import()` outran the turn budget; later tests hit the module cache                                                                   | `await settleDynamicImport(() => import('…'))` — await the module, do not count turns                                                   |
+| `Expected to be running in 'ProxyZone', but it was not found`                                            | `zone.js/testing` patches jasmine/mocha/jest, not Vitest                                                                                             | `import 'vitest-auto-spy/zone'` after zone.js, with `globals: true` (§14)                                                               |
+| `nextWith` demanding `HttpEvent<T>` on a generated API client                                            | `Parameters`/`ReturnType` read the **last** overload                                                                                                 | `asSpy<Client, { overload: 'first' }>(…)`, or `Overload<M, 0>`                                                                          |
+| `NG0303` / `NG0304` / nothing at all, from a directive spec                                              | the host is `standalone: false`, or the module is in the TestBed                                                                                     | `createDirectiveHost({ template, scope: [Module] })` (§13)                                                                              |
+| `TS2540: Cannot assign to 'X' because it is a read-only property`                                        | a `readonly` field of an object under test                                                                                                           | `mockValueProp(obj, 'X', value)` — on a class **getter**, `mockReadonlyProp`                                                            |
+| `TypeError: Cannot read properties of undefined (reading 'mockReturnValue')`                             | the member is an **instance field**, not on the prototype — `Router.currentNavigation` since Angular 20                                              | `provideAutoSpy(Router, { instanceMethodsToSpyOn: ['currentNavigation'] })` (§5)                                                        |
+| `throwWith` reaching the success branch first, with the previous test's value                            | the spy's `ReplaySubject(1)` outlived the test that filled it                                                                                        | upgrade; and `resetAutoSpy(spy)` in `beforeEach` when the TestBed is built in `beforeAll`                                               |
+| `TS2540` on a `Spy<T>` / `createAutoMock` member, which the runtime writes fine                          | `Spy<T>` is homomorphic, so it keeps the `readonly` of an abstract getter                                                                            | `Mutable<Spy<T>>` for direct assignment, or `mockValueProp` for a patch that is undone                                                  |
+| `delete mock.optionalMethod` leaving the member present and truthy                                       | the Proxy had no `deleteProperty` trap before 3.5.0                                                                                                  | upgrade; before that, `mock.optionalMethod = undefined`                                                                                 |
+| half a double's methods reaching the real implementation after `Object.assign`                           | `ownKeys` on a type-driven Proxy lists only the keys already read                                                                                    | `createSpyFromClass(X)` — a real object, with enumerable method keys                                                                    |
+| `let s: MockInstance<() => unknown>` not matching anything                                               | `MockInstance<F>` is invariant in `F`; Jest's `SpyInstance` was not                                                                                  | `MockInstance<T['method']>`, or better `injectSpy(X).method`                                                                            |
+| two runs with the same totals, one of them missing a suite                                               | a lost `describe` and a fixed flake cancel out in the counters                                                                                       | `compareTestRuns(before, after)` — compare the set of names, not the numbers                                                            |
+| a 30 s timeout, in a different file each run                                                             | module-level `vi.fn()` in a fixture shared by files                                                                                                  | make the fixture a factory (§10)                                                                                                        |
+| a component's `afterNextRender` state is empty                                                           | `detectChanges()` does not run the after-render phase                                                                                                | `await stable(fixture)` (§11)                                                                                                           |
+| a green test whose only line about a call is `spy.m.calledWith(1);`                                      | that is a **stub**, not an assertion — chai's `expect(fn).to.have.been.calledWith(x)` is the one that checks                                         | continue the chain, or `expect(spy.m).toHaveBeenCalledWith(1)` — `no-bare-called-with` (§16)                                            |
+| `--detect-async-leaks` reporting no leaks in a suite that visibly leaks timers                           | `setupAutoSpy({ strayTimers: true })` cancelled them before Vitest collected                                                                         | re-run that file with `strayTimers` off; the warning on stderr says how many were taken (§10)                                           |
+| `createNestUnit(X): parameter #n of Y is typed as \`Object\``(or`undefined — usually a circular import`) | the compiler emitted no runtime class for that parameter — interface, union, primitive, or a circular import                                         | `@Inject(TOKEN)` plus a `providers` entry, or `@Optional()` to receive `undefined`; `@Inject(forwardRef(() => X))` for the import cycle |
+| `createNestUnit(X): Y declares n constructor parameter(s) but carries no design:paramtypes metadata`     | no `emitDecoratorMetadata` (esbuild / Vite), or `reflect-metadata` loaded after the class                                                            | tsc or SWC with `decoratorMetadata`, `@Injectable()`, `reflect-metadata` first; or `@Inject(X)` on every parameter                      |
+| `createNestUnit(X): A -> B -> A is a cycle among the classes built for real`                             | two exposed / `useClass` classes depend on each other; the helper does not resolve `forwardRef` cycles                                               | expose one side less, or provide it                                                                                                     |
+| `createNestUnit(X).spies.get(Y): the unit never asked for that token`                                    | same guard as `createWithAutoSpies` — the spy would not be the one the unit uses                                                                     | stub the token the unit actually injects (the message lists the auto-spied ones)                                                        |
+| `createNestUnit(X).spies.get(Y): Y is in \`expose\`, so the unit got a real instance`                    | an exposed class is real, not a spy                                                                                                                  | read the spies of its own collaborators, or drop it from `expose`                                                                       |
+| `no request matched …` (with the requests that were made listed)                                         | the URL, verb or predicate does not describe anything the code under test sent, or nothing subscribed                                                | read the list in the message — it is the requests that were actually made; then fix the URL, add `{ method }`, or subscribe (§13)       |
+| `this TestBed has no HttpTestingController`                                                              | `expectRequest` / `expectNoRequest` on a module that never got the testing backend                                                                   | `TestBed.configureTestingModule({ providers: [...provideHttpTesting()] })` from `vitest-auto-spy/angular-http` (§13)                    |
+| `the test ended with N unanswered request(s)`                                                            | `provideHttpTesting({ verifyOnTeardown })` found a request the spec never flushed                                                                    | answer it (`await expectRequest(url).flush(body)`), assert its absence (`expectNoRequest(url)`), or `{ verifyOnTeardown: false }` (§13) |
 
 **Seven of these are library defects, not spec ones.** On anything below 3.8.0, upgrade and change
 nothing in the spec: `of(double)` never emitting; `accessorSpies.setters.X` still `undefined` after
@@ -2518,3 +2642,9 @@ failure with a watchdog. Land the suite green on `subscribeSpyTo`, then move the
 
 Full mapping, including what upstream cannot do at all:
 <https://asdalexey.github.io/vitest-auto-spy/migrating-jasmine>.
+
+An Angular suite that came through `ng generate @schematics/angular:refactor-jasmine-vitest` rather
+than through `jasmine-auto-spies` is a different input — a `MockedObject<T>` literal per double and
+`// TODO: vitest-migration:` comments on the `createSpyObj` calls it could not expand. That diff is
+covered at <https://asdalexey.github.io/vitest-auto-spy/migrating-angular-schematic>; the answer to
+all three TODO categories is `createSpyFromClass(Api)`, which reads the prototype, not the call site.