vitest-auto-spy 5.41.0 → 5.43.0

package/CHANGELOG.md

@@ -10,6 +10,151 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.43.0] - 2026-09-27
+
+### Added
+
+- **`trackInjections(...).names({ clean: true })`.** `names()` returns each token's `Function.name`
+  as is, so under esbuild a decorated `FeatureFlagService` came back as `_FeatureFlagService` while
+  `get()` and every message printed the clean name. The option takes the rename off (the leading `_`,
+  Rollup's `$1`); without it the result is unchanged.
+- **`toHaveSignalValue(expected, { strict: true })`.** The matcher compares the way `toEqual` does, so
+  `signal({ color: undefined })` passed against `{}` and a class instance against a plain object; a
+  spec on `expect(sig()).toStrictEqual(x)` lost precision by moving to it. `strict` counts
+  `undefined` properties, array holes and the object's class, as `toStrictEqual` does. The options
+  type is exported from `/angular/matchers` as `SignalValueOptions`. `/angular/matchers` is +137 B
+  min+gzip (2662 → 2799 B, +5.1 %) and +0.6 kB to import (22349 → 22906 B): the strict comparison,
+  its class tester, and the structural-directive message below.
+
+### Changed
+
+- **`angular-build-istanbul-module-cache` puts its −46 % in range.** A second suite, 862 spec files on
+  `@angular/build` 22.2 and Vitest 5.0.2, gained −19 % from the cache (48 → 39 s), while switching it
+  to v8 ran in 19–22 s, about twice as fast as istanbul with the cache, on 7.5–8 GB RSS against
+  10–11 GB. The finding now gives −46 % as "up to", adds that data point, says the cache pays off on
+  CI only when CI keeps `node_modules/.vitest-cache`, and its fix offers `coverage.provider: 'v8'` as
+  the alternative. Still an info.
+
+### Fixed
+
+- **`toHaveDirectiveApplied(Structural, selector)` no longer sends a structural directive to
+  `detectChanges()`.** When the directive rendered nothing the selector names, the failure said no
+  element matches and to run `fixture.detectChanges()`, which changes nothing. It now says the
+  directive is on a template anchor, that the element exists only in a view the directive chose to
+  render, and to assert without a selector.
+- **Docs that disagreed with 5.41–5.42.** The performance table and README called the
+  `lazySpies: true` path "the default" (a class of 8+ methods now gets `'proxy'`) and said lazy spies
+  change no behaviour; the width is now defined as the methods the double spies, after
+  `onlyMethodsToSpyOn` / `methodsToSpyOn`. The Russian Angular page carried the pre-4.1 speed table.
+  The strict-mode and control-helper pages now say a delegating `mockImplementation` and `vi.when` are
+  not reported, and a `vi.when` over a `mockReturnValue` is. The CLI page counts `ng-test` among the
+  commands, says it exits with `ng`'s code, lists its exit-2 cases, that `--related` takes a
+  comma-separated list and that the builder compiles only included specs from `@angular/build` 22.2
+  (also in `--help`); the Russian CLI page gains the exit-code table. `RouteResources` is `never` up
+  to router 22.1, not only on 20 and 21.
+
+## [5.42.0] - 2026-09-27
+
+### Added
+
+- **`npx vitest-auto-spy ng-test` — sharding and changed-only runs under the Angular unit-test
+  builder.** `ng test` has no pass-through for Vitest's flags: `startVitest()` receives an object the
+  builder built, and Vitest's own `--changed` / `--related` find nothing there because its module graph
+  holds the builder's bundles, not your sources. `ng-test --shard 2/4` lists the target's specs with
+  `ng test --list-tests` (`@angular/build` 21+), splits them the way Vitest does and hands the shard to
+  the builder as `--include` paths, so it compiles only that shard; `ng-test --changed [ref]` and
+  `--related <files>` run the specs whose imports reach a changed file (relative imports,
+  `compilerOptions.paths` aliases, a template or stylesheet through the component naming it; a config,
+  a lockfile or a change the setup files reach runs everything). Everything after `--` goes to
+  `ng run <project>:<target>`. On a 700-spec workspace with coverage and the builder cache off, as in
+  CI, the slower of two `ng-test` shards took 7.58 s against 11.21 s for the whole run, and 9.38 s for
+  a `test.shard` set in the runner config, which still compiles every spec.
+- **`provideActivatedRoute({ resources })` / `createActivatedRoute({ resources })`.** Angular 22.2
+  gave a route a `resources` record (developer preview), and a component reading
+  `route.resources['user']` got `undefined` from the double. The record now lands on
+  `route.resources` and on every snapshot's `resources` — the same object, carried into each new
+  snapshot as a navigation that keeps the route does. Arrange a value with
+  `mockResourceProp(resources, 'user', undefined)` on that record. On Angular 20 and 21 the key
+  exists in the type as `never`, so nothing can be passed where the router has no such field.
+- **`doctor` points at the module cache where the unit-test builder runs istanbul.**
+  `angular-build-istanbul-module-cache` (info) fires for an `@angular/build:unit-test` target on 21+
+  and Vitest 5 whose coverage provider resolves to istanbul and whose runner config lacks
+  `fsModuleCache`; on a 700-file Angular 22.2 suite the cache took the run from
+  24.55 s to 13.20 s (−46 %), −41 % with the builder cache off as on CI. The fix names the runner
+  config, or asks for `"runnerConfig"` on the target, and adds the CI cache step when no CI config
+  keeps `node_modules/.vitest-cache`. Quiet with v8, where the cache gained nothing, and for a
+  `browsers` target unless its runner config names istanbul itself: browser mode was not measured.
+- **`doctor` warns before `fsModuleCache` breaks an Analog suite.** `analog-module-cache-inline-styles`
+  (warning): with the Analog plugin in JIT mode and a component with inline `styles`, the warm run
+  fails with `Cannot find module '/@id/__x00__virtual:angular:jit:style:inline;<hash>'` (verified on
+  Analog 2.7.5, Angular 22.2, Vitest 5.0.0).
+- **`doctor` warns when Analog `fastCompile` drops constructor types.**
+  `analog-fast-compile-ctor-injection` (warning): with `fastCompile` in JIT mode, an `@Injectable`
+  class that takes a constructor parameter known only by its type gets no `ctorParameters`, so it
+  throws NG0202 in `TestBed.inject` and `createWithAutoSpies` alike. The finding lists each class and
+  the fixes: `inject()`, `@Inject(X)`, or `fastCompile` off.
+- **`doctor` notes happy-dom for builder users.** `angular-build-happy-dom` (info): on
+  `@angular/build` 21+ the builder picks happy-dom itself once installed; −4.6 % wall and −6 % RSS on
+  the 700-file suite.
+
+### Changed
+
+- **`createSpyFromClass` builds a double of a class with 8 or more methods as a `Proxy`.** When
+  `lazySpies` is not set, a class of 8+ methods gets `lazySpies: 'proxy'`; a narrower one keeps the
+  accessor placeholders it had. Why upgrade: a wide double a test touches holds 21–68 % less and is
+  built 2–6× faster — measured per double with one and two methods called: 2 110 → 1 417 B and
+  3 269 → 2 573 B at 8–16 methods, 4 412 → 1 417 B and 5 570 → 2 577 B at 45; create and call 2.2 →
+  1.1 µs at 8 methods, 6.5 → 1.0 µs at 45. The accessor placeholders put a touched double into a
+  property dictionary as wide as the class; the proxy defines nothing until a method is read. What a
+  wide class's double now does differently: every read of a member costs ~20 ns more;
+  `util.types.isProxy(double)` is `true`; `console.log` shows only the methods already read;
+  `vi.spyOn` on a method nobody has read returns the double's own spy, so `mockRestore()` resets it;
+  `Object.create(double).method` builds the spy on the double; an untouched double is ~100 B heavier.
+  Snapshots, `toEqual`, `Object.keys` and spread are unchanged. `lazySpies: true` brings the
+  placeholders back for one class, `registerAutoSpyDefaults(Class, { lazySpies: true })` for all its
+  doubles. `provideAutoSpy` and `injectSpy` follow the same rule.
+- **`lazySpies: 'proxy'` holds ~0.26 kB per untouched double at any width**, down from 1 860 B at 10
+  methods and 4 097 B at 100 (`bench:memory`, 258 and 259 B): one trap handler per double and one
+  method-name set per class.
+- **`createSpyFromClass` without `returns`, `selfReturning` or `overrides` no longer builds its message
+  label** — eight regex replacements per call, −0.2 µs per double in every mode.
+- **A double retains less.** A materialised method spy no longer allocates an empty `Once` queue, a
+  closure context for its callable, a separate state object, or a six-slot context for its dispatch
+  (−128 B per method); the empty `accessorSpies` bag of a class without spied accessors is built from
+  objects sized to hold nothing (−64 B per double, identical to `{}` to every reader); and
+  `createAutoMock` / `mockDeep` nodes create their accessor and tombstone collections on first write
+  (−336 B each). `bench:memory` on the `lazySpies: true` arm (the default before this release):
+  untouched 243 → 178 B at 100 methods, all called 128 956 → 116 082 B (−10 %); `createAutoMock`
+  untouched 705 → 369 B (−48 %). Construction and call timings are unchanged within noise.
+
+### Fixed
+
+- **`vi.when` on a method spy no longer reports the `calledWith()` as deciding nothing.** Vitest 5's
+  `vi.when(spy)` reads the spy's implementation and installs a wrapper that answers its own rows and
+  passes every other call through to it — to the library's dispatch, so the `calledWith` chain keeps
+  deciding. Both orders printed the "replaced the dispatch" warning, and under
+  `setupAutoSpy({ preset: 'strict' })` it threw. An implementation installed right after
+  `getMockImplementation()` handed out the current one is now treated as a wrapper; a `vi.when` over
+  a `mockReturnValue` is still reported.
+- **A `calledWith` after a `mockReturnValue` that was the spy's first touch since `vi.resetAllMocks()`
+  is reported again.** The pending reset was applied after the replacement was recorded and erased it.
+- **`perf` stops giving advice that fails under `@angular/build:unit-test` and Analog.** Under the
+  builder the settings findings (`perf-transform`, `perf-workers`, `perf-isolation`,
+  `perf-environment-engine`) name the runner config the run reads — `--runner-config` in `--command`,
+  then the target's `runnerConfig` — instead of the first `vite(st).config.*` in the tree, say to add
+  `"runnerConfig": "vitest-base.config.mts"` to the target when it names none, and say the setting is
+  not available on `@angular/build` 20.x, which reads no runner config. `perf-vitest-doctor` no longer
+  sends a builder workspace to `npx vitest doctor`, which fails there on every file with
+  `describe is not defined`; it gives an A/B recipe through
+  `ng run <project>:<target> --runner-config=<variant>` instead. `isolate` and `environment` the
+  builder passes to Vitest itself no longer count as the user's choice, and the DOM-engine advice
+  there becomes "install `happy-dom`": from 21 the builder picks it by itself. The barrel advice is
+  off under the builder, and the confirmed-finding card names a spec's `spec-*.js` bundle after the
+  spec and drops `chunk-*.js`, neither of which exists on disk. Under `@analogjs/vite-plugin-angular`
+  2.7.5 and older with an inline-styled component, `perf-transform` is a warning not to turn
+  `fsModuleCache` on: the warm run fails with
+  `Cannot find module '/@id/__x00__virtual:angular:jit:style:inline;<hash>'`.
+
 ## [5.41.0] - 2026-09-27
 
 ### Changed
@@ -5590,7 +5735,9 @@ moved under 1 %: `/angular` +192 B (+1.0 %) for the override queue and the HTTP
 This copy ships with the package and carries 5.x only. Releases before 5.0.0 are in the
 [full changelog](https://github.com/ASDAlexey/vitest-auto-spy/blob/master/CHANGELOG.md).
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.41.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.43.0...HEAD
+[5.43.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.42.0...v5.43.0
+[5.42.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.41.0...v5.42.0
 [5.41.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.40.1...v5.41.0
 [5.40.1]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.40.0...v5.40.1
 [5.40.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.39.0...v5.40.0

package/README.md

@@ -23,7 +23,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 [![downloads per month](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2Flast-month%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2Fmonth)](https://www.npmjs.com/package/vitest-auto-spy)
 [![downloads over 18 months](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.npmjs.org%2Fdownloads%2Fpoint%2F2026-06-21%3A2030-01-01%2Fvitest-auto-spy&query=%24.downloads&color=brightgreen&logo=npm&label=downloads%2F18mo)](https://www.npmjs.com/package/vitest-auto-spy)
 [![CI](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml/badge.svg)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
-[![minzipped size](https://img.shields.io/badge/minzip-27.3%20kB-brightgreen)](#install)
+[![minzipped size](https://img.shields.io/badge/minzip-27.6%20kB-brightgreen)](#install)
 [![types](https://img.shields.io/npm/types/vitest-auto-spy?logo=typescript&logoColor=white)](https://www.npmjs.com/package/vitest-auto-spy)
 [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/ASDAlexey/vitest-auto-spy/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/vitest-auto-spy?color=blue)](./LICENSE)
@@ -83,7 +83,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
 - 🚚 A migration you can verify — `vitest-auto-spy/diagnostics`: `compareTestRuns` on the two JSON reports, `summarizeTestRun` / `formatTestRunComparison` to read the answer, `diffByField` for the assertion the reporter collapses, `explainSpy` for a double that answered something you did not configure
 - 📏 Lint rules and one-line test-run hygiene — forty-nine rules in `vitest-auto-spy/eslint-plugin` (six `--fix`, nineteen suggestions, four of them for a suite mid-migration off jasmine), `setupAutoSpy()` — with `preset: 'strict'` for every guard at its strictest grade, and under `isolate: false` `strayListeners` / `restoreGlobals` for the listeners and raw global assignments a file leaves the next one, `restoreStorageSpies` (on by default) for the storage spy happy-dom will not let `mockRestore()` remove
 - 🩺 [Editor diagnostics](#editor-diagnostics--webstorm--vs-code) — the same anti-patterns underlined while you type: native ESLint inspections in **WebStorm** and the other JetBrains IDEs, the ESLint extension in **VS Code**, no extra plugin either way
-- 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-and-init) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
+- 🔎 [`npx vitest-auto-spy doctor`](#the-cli--doctor-perf-codemod-init-and-ng-test) — suite-level defects **that never fail a run**: a `tsconfig` `include` matching no file, a production module importing a spec, a `@jest-environment` pragma the runner never reads, config left behind for a runner that is gone. Read-only, no config, exits 1 in CI
 - ⏱️ [`npx vitest-auto-spy perf`](#perf--where-the-cpu-time-actually-goes) — where a suite's CPU time actually goes, phase by phase, and which spec files to act on: the ones that reach no DOM and could run under `node`, the ones that import a barrel. Runs Vitest once with a reporter this package ships, reads `TestModule.diagnostic()`, names files, states the rule behind each finding
 - 🚚 [`npx vitest-auto-spy codemod`](#codemod--migrating-a-suite-off-jest-auto-spies) — thirteen transforms that move a suite off `jest-auto-spies` and Jest, or off `jasmine-auto-spies` and jasmine (`--from jasmine`), dry-run by default, with a `--verify` pass that also checks a file somebody edited by hand
 - 🔇 Console spies — `import { consoleInfoSpy } from 'vitest-auto-spy/console'` silences `console` and asserts its calls; [`setupAutoSpy({ strayConsole: 'throw' })`](#how-to-mock-the-console) fails any test whose console output nothing absorbed
@@ -126,7 +126,7 @@ faster at suite scale ([benchmarks](#benchmarks)) — and for
   - [A jasmine suite mid-migration](#how-to-mock-a-jasmine-suite-mid-migration)
 - [New in 5](#new-in-5)
 - [New in 4](#new-in-4)
-- [The CLI — `doctor`, `perf`, `codemod` and `init`](#the-cli--doctor-perf-codemod-and-init)
+- [The CLI — `doctor`, `perf`, `codemod`, `init` and `ng-test`](#the-cli--doctor-perf-codemod-init-and-ng-test)
   - [`doctor` — defects that never fail](#doctor--defects-that-never-fail)
   - [`perf` — where the CPU time actually goes](#perf--where-the-cpu-time-actually-goes)
   - [`codemod` — migrating a suite off `jest-auto-spies`](#codemod--migrating-a-suite-off-jest-auto-spies)
@@ -989,7 +989,7 @@ a `.d.ts` your `tsconfig` includes — that one import is what keeps `returnSubj
 own `Subject<T>`. From `@angular/build:unit-test` 22.2.0 the test program is the specs, the setup
 files and the `.d.ts` files, so a plain `.ts` listed only in the spec `tsconfig`'s `include` is out.
 
-## The CLI — `doctor`, `perf`, `codemod` and `init`
+## The CLI — `doctor`, `perf`, `codemod`, `init` and `ng-test`
 
 The package ships one executable, with no dependencies and nothing to configure:
 
@@ -998,10 +998,16 @@ npx vitest-auto-spy doctor   # read-only. Exits 1 when it finds something
 npx vitest-auto-spy perf     # where the suite's CPU time goes. --gate fails a budget and says why
 npx vitest-auto-spy codemod  # prints the migration diff. Writes nothing without --write
 npx vitest-auto-spy init     # writes the agent instructions pointer
+npx vitest-auto-spy ng-test  # ng test with --shard / --changed the Angular builder does not pass through
 ```
 
+[`ng-test`](https://asdalexey.github.io/vitest-auto-spy/utilities/cli#ng-test-—-sharding-and-changed-only-runs-under-the-angular-builder)
+shards a suite under `@angular/build:unit-test`, or runs only the specs a change reaches: `ng test`
+passes neither Vitest's `--shard` nor its `--changed` through, so it picks the specs itself and hands
+them to the builder as `--include` paths.
+
 **Exit `0` means "ran, nothing to report"; `1` means "ran, and here is the finding"; `2` means
-"there was nothing to judge".** The third one is the reason to read this line: an unknown flag for a
+"there was nothing to judge".** (`ng-test` passes `ng`'s own exit code through once it runs.) The third one is the reason to read this line: an unknown flag for a
 known command is an error and **nothing runs** — `init --dryrun` used to write the files and
 `perf --gat` used to pass with no gate at all, which is a typo that reads as a clean CI step. A path
 that matches no file is the same kind of error, because _Nothing left to migrate_ off a tree nobody
@@ -1035,31 +1041,35 @@ error  tsconfig-glob-matches-nothing libs/users/tsconfig.spec.json
 3 errors, 4 warnings, 1 note
 ```
 
-| Check                                | What it finds                                                                                                                                                                        |
-| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `tsconfig-glob-matches-nothing`      | An `include` pattern that matches no file — so it type-checks nothing; `info` when nothing beside the config is there to miss yet                                                    |
-| `tsconfig-file-missing`              | A `files` entry naming a file that is gone                                                                                                                                           |
-| `spec-imported-by-non-spec`          | A production module importing a `*.spec.ts`                                                                                                                                          |
-| `spec-exports-fixture`               | A spec importing another spec, whose hooks then run in a foreign file                                                                                                                |
-| `foreign-runner-pragma`              | `@jest-environment` left in a spec, which Vitest never reads                                                                                                                         |
-| `dead-runner-config`                 | `jest.config.*` / `karma.conf.*` for a runner that is not installed                                                                                                                  |
-| `orphan-runner-file`                 | A setup file only that dead config referenced                                                                                                                                        |
-| `angular-build-splitting-off`        | `@angular/build` in `[22.1.5, 22.1.7)` — the OOM under `--coverage`                                                                                                                  |
-| `angular-build-splitting-deprecated` | `"splitting"` on a unit-test target under `@angular/build` 22.2+, which deprecates it — `true` is a no-op, `false` still costs the memory                                            |
-| `analog-behind-angular-build`        | `@analogjs/vite-plugin-angular` below 2.7.5 next to `@angular/build` 22.2+ — `TypeError: cache.has is not a function` at startup                                                     |
-| `coverage-all-removed`               | `coverage.all` in a config, on a Vitest that stopped reading the key                                                                                                                 |
-| `coverage-include-misses-bundle`     | A `coverage.include` of sources only, in a runner config over a bundle                                                                                                               |
-| `coverage-include-recompiles-globs`  | A coverage scope large enough that `picomatch` recompiling it per file costs more than the coverage. Info                                                                            |
-| `vitest-5-removed`                   | What Vitest 5 removed — `vitest/reporters`-style imports, `.sequential`, `--outputJson`/`--compare`; error on 5, note on 4. Also `poolOptions` (warning, ignored since 4)            |
-| `vitest-5-deprecated`                | `experimental_clearCache` / `experimental_parseSpecifications` on Vitest 5, which nothing warns about at run time. Info                                                              |
-| `vitest-5-clear-mocks`               | `clearMocks: true` restating the Vitest 5 default, or a Vitest 4 suite that never decided and will have mocks cleared after the upgrade. Info                                        |
-| `mock-reset-config-unread`           | `no-redundant-mock-reset` given a `configFile` whose default export is a factory or `mergeConfig` call and no flag beside it — the rule reads none of the flags that call sets. Info |
-| `vitest-5-available`                 | Vitest 4 with nothing holding back 5 — what it buys (−46 % v8 / −35.5 % istanbul on a 700-file Angular suite with coverage) — or what holds it back. Info                            |
-| `fs-module-cache-not-persisted`      | `fsModuleCache` on, and no CI config caches its directory — every CI run starts cold                                                                                                 |
-| `jasmine-era-project`                | `jasmine-core`, `@types/jasmine`, `karma.conf.*` or `@hirez_io/observer-spy` still installed. Info, not an error                                                                     |
-| `no-agent-instructions`              | No instruction file names the package. A note, not an error                                                                                                                          |
-| `helper-from-wrong-entry`            | A named import taken from an entry that does not export it — `provideAutoSpy` from the root                                                                                          |
-| `no-unawaited-helper`                | An `expectEmission` / `stable` / `flushEventLoop` call dropped as a bare statement, so nothing awaits it                                                                             |
+| Check                                 | What it finds                                                                                                                                                                        |
+| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `tsconfig-glob-matches-nothing`       | An `include` pattern that matches no file — so it type-checks nothing; `info` when nothing beside the config is there to miss yet                                                    |
+| `tsconfig-file-missing`               | A `files` entry naming a file that is gone                                                                                                                                           |
+| `spec-imported-by-non-spec`           | A production module importing a `*.spec.ts`                                                                                                                                          |
+| `spec-exports-fixture`                | A spec importing another spec, whose hooks then run in a foreign file                                                                                                                |
+| `foreign-runner-pragma`               | `@jest-environment` left in a spec, which Vitest never reads                                                                                                                         |
+| `dead-runner-config`                  | `jest.config.*` / `karma.conf.*` for a runner that is not installed                                                                                                                  |
+| `orphan-runner-file`                  | A setup file only that dead config referenced                                                                                                                                        |
+| `angular-build-splitting-off`         | `@angular/build` in `[22.1.5, 22.1.7)` — the OOM under `--coverage`                                                                                                                  |
+| `angular-build-splitting-deprecated`  | `"splitting"` on a unit-test target under `@angular/build` 22.2+, which deprecates it — `true` is a no-op, `false` still costs the memory                                            |
+| `analog-behind-angular-build`         | `@analogjs/vite-plugin-angular` below 2.7.5 next to `@angular/build` 22.2+ — `TypeError: cache.has is not a function` at startup                                                     |
+| `analog-fast-compile-ctor-injection`  | Analog `fastCompile` in JIT mode with an `@Injectable` whose constructor parameter is known only by its type — NG0202 at injection                                                   |
+| `analog-module-cache-inline-styles`   | `fsModuleCache` on under the Analog plugin with a component that has inline `styles` — the warm run fails on `virtual:angular:jit:style:inline`                                      |
+| `angular-build-istanbul-module-cache` | istanbul coverage under the unit-test builder (not in `browsers`) without `fsModuleCache` — up to −46 %; v8 beat istanbul with the cache ~2x. Info                                   |
+| `angular-build-happy-dom`             | jsdom only because `happy-dom` is not installed; the builder picks it by itself from 21 — −4.6 % wall, −6 % RSS. Info                                                                |
+| `coverage-all-removed`                | `coverage.all` in a config, on a Vitest that stopped reading the key                                                                                                                 |
+| `coverage-include-misses-bundle`      | A `coverage.include` of sources only, in a runner config over a bundle                                                                                                               |
+| `coverage-include-recompiles-globs`   | A coverage scope large enough that `picomatch` recompiling it per file costs more than the coverage. Info                                                                            |
+| `vitest-5-removed`                    | What Vitest 5 removed — `vitest/reporters`-style imports, `.sequential`, `--outputJson`/`--compare`; error on 5, note on 4. Also `poolOptions` (warning, ignored since 4)            |
+| `vitest-5-deprecated`                 | `experimental_clearCache` / `experimental_parseSpecifications` on Vitest 5, which nothing warns about at run time. Info                                                              |
+| `vitest-5-clear-mocks`                | `clearMocks: true` restating the Vitest 5 default, or a Vitest 4 suite that never decided and will have mocks cleared after the upgrade. Info                                        |
+| `mock-reset-config-unread`            | `no-redundant-mock-reset` given a `configFile` whose default export is a factory or `mergeConfig` call and no flag beside it — the rule reads none of the flags that call sets. Info |
+| `vitest-5-available`                  | Vitest 4 with nothing holding back 5 — what it buys (−46 % v8 / −35.5 % istanbul on a 700-file Angular suite with coverage) — or what holds it back. Info                            |
+| `fs-module-cache-not-persisted`       | `fsModuleCache` on, and no CI config caches its directory — every CI run starts cold                                                                                                 |
+| `jasmine-era-project`                 | `jasmine-core`, `@types/jasmine`, `karma.conf.*` or `@hirez_io/observer-spy` still installed. Info, not an error                                                                     |
+| `no-agent-instructions`               | No instruction file names the package. A note, not an error                                                                                                                          |
+| `helper-from-wrong-entry`             | A named import taken from an entry that does not export it — `provideAutoSpy` from the root                                                                                          |
+| `no-unawaited-helper`                 | An `expectEmission` / `stable` / `flushEventLoop` call dropped as a bare statement, so nothing awaits it                                                                             |
 
 The check that motivated the tool: a spec showing `Cannot find name 'vi'` in the editor while
 `tsc --noEmit` reported zero errors. A migration codemod editing `include` had eaten a `/**`,
@@ -1879,7 +1889,8 @@ multipliers do not transfer to suite scale: building a double is on the order of
 so a 10× win on the double shows up as a few per cent on the run, and nearly everything else in a
 suite swamps it.
 
-**Memory, `isolate: false`, 100-method class, 10 000 tests, peak RSS:**
+**Memory, `isolate: false`, 100-method class, 10 000 tests, peak RSS** — measured before 2026-09-27,
+on the accessor-placeholder default and the proxy mode of that time:
 
 | Arm                                   | Peak RSS |
 | ------------------------------------- | -------: |
@@ -1891,19 +1902,35 @@ Hand-written doubles use 3.0x the default's peak RSS here — the difference bet
 OOM'd worker on a large suite.
 
 That gap traces down to a single double: on the same 100-method class, untouched, a hand-written
-double retains **414 462 B**. The two arms above are what the library retained against it when they
-were captured; the per-double figure has since moved a long way, and in the direction that makes the
-table's third row unnecessary. Re-measured 2026-09-17 on Node 24, the **default** retains **215 B**
-per untouched 100-method double — the lazy placeholder's accessor pair is now shared by method name
-rather than minted per double — and `lazySpies: 'proxy'` retains **4 090 B**, nineteen times more.
-Full retained-memory tables:
+double retains **414 462 B**. Re-measured 2026-09-27 (`npm run bench:memory`, Node 24, Vitest 5), the
+default on that class retains **259 B** per untouched double and `lazySpies: true` **178 B** — the lazy
+placeholder's accessor pair is shared by method name rather than minted per double. Full
+retained-memory tables:
 [Performance](https://asdalexey.github.io/vitest-auto-spy/core/performance#retained-memory-per-double).
 
+The first read is where the accessor placeholders pay: it drops the double into a property
+dictionary as wide as the class. That dictionary is why a class of 8 methods or more gets `'proxy'`
+when `lazySpies` is not set. The proxy answers every method from one trap handler and one name set
+per class and defines nothing, so there is no shared map to leave and no dictionary to grow. Bytes
+per double with one and two methods called (1 000 doubles held at once, 2026-09-27):
+
+| Methods in the class | `true`, 1 / 2 touched | `'proxy'`, 1 / 2 touched |        Saving |
+| -------------------: | --------------------: | -----------------------: | ------------: |
+|                  4–6 |       1 743 / 2 887 B |          1 415 / 2 573 B | −19 % / −11 % |
+|                 8–16 |       2 110 / 3 269 B |          1 417 / 2 573 B | −33 % / −21 % |
+|                20–30 |       2 877 / 4 036 B |          1 416 / 2 573 B | −51 % / −36 % |
+|                   45 |       4 412 / 5 570 B |          1 417 / 2 577 B | −68 % / −54 % |
+
+The steps are V8's: the dictionary holds `pow2ceil(1.5·(width + 3))` slots. Building and touching the
+double is cheaper too — 2.2 → 1.1 µs at 8 methods, 6.5 → 1.0 µs at 45. The price is a trap on every
+read of a member for the life of the double, about 25 ns against 5 ns for a plain property, ~100 B more
+on a double nobody touches, and a double a spec can see is a `Proxy`. Eight methods is the smallest
+width where the proxy saves at least 15 % on both profiles; below it the default stays a plain object.
+`lazySpies: true` opts a wide class out.
+
 **Guidance keyed to suite size:** `isolate: false` is worth about 4x on its own — more than any
-library choice measured here — and it makes memory, not wall-clock, the binding constraint. The
-default is the memory answer at every width now; `lazySpies: 'proxy'` is left for the one thing it
-is still faster at, building a double of a very wide class, and it taxes every read for the life of
-that double (53 ns against 7 ns).
+library choice measured here — and it makes memory, not wall-clock, the binding constraint. Leave
+`lazySpies` alone: the width picks the lighter double.
 
 Full write-up, methodology and the complete suite-scale tables:
 [Performance](https://asdalexey.github.io/vitest-auto-spy/core/performance).
@@ -2395,7 +2422,9 @@ expect(() => myService.getName(2)).toThrow();
 install an implementation on the host mock, and the dispatch that reads a `calledWith` chain **is**
 the implementation they replace — so the one written later wins outright and the other decides
 nothing, in either order, without failing. Both orders are now reported as a misconfiguration (a
-warning, a throw under the `strict` preset). Where both are wanted, the fallback goes in the spy's
+warning, a throw under the `strict` preset) — except a wrapper that delegates, `vi.when(spy)` on
+Vitest 5 or a `mockImplementation` built from `spy.getMockImplementation()`, which the chain still
+answers through. Where both are wanted, the fallback goes in the spy's
 own container, which a chain still wins over: the `returns` option where the double is built, or
 `resolveWith` / `nextWith` / `failWith`. The report comes from this library's own spy engine — so
 Vitest and Rstest, not Bun or `node:test`, and not under `setSpyEngine('runner')` — and the `Once`
@@ -2629,11 +2658,12 @@ beforeEach(() => {
 > `@angular/build` 22.2 or newer, both `@analogjs` packages need 2.7.5 or newer — older ones crash at
 > startup with `TypeError: cache.has is not a function`.
 
-> **Lazy by default, everywhere.** Every factory builds each method spy on first access
-> (`lazySpies: true`), since Angular tests typically spy a wide service but call
+> **Lazy by default.** `createSpyFromClass` and `provideAutoSpy` build each method spy on first access
+> (accessor placeholders below 8 methods, a `Proxy` from 8), since Angular tests typically spy a wide service but call
 > only a few of its methods — and the margin widens as the class does: **1.4×** on a ten-method
-> class a test calls twice, **1.9×** on a forty-method one it calls three times. Behaviour is
-> unchanged; pass `{ lazySpies: false }` to build every spy eagerly.
+> class a test calls twice, **1.9×** on a forty-method one it calls three times. Calls, `Object.keys`,
+> spread and snapshots behave the same; a wide class's double is a `Proxy`, so pass
+> `{ lazySpies: true }` for a plain object, or `{ lazySpies: false }` to build every spy eagerly.
 
 #### Signal / readonly property mocking (bonus)
 
@@ -2903,8 +2933,9 @@ expect(component.items).toHaveSignalValue([{ id: 1 }]);
 ```
 
 `expect(component.total).toBeTruthy()` passes for every signal ever created — a signal is a
-function. The matcher reads it, deep-compares, and rejects anything that is not a zero-argument
-getter, so the missing-parentheses mistake fails instead of quietly passing.
+function. The matcher reads it, deep-compares (as `toEqual` does; `{ strict: true }` as
+`toStrictEqual` does), and rejects anything that is not a zero-argument getter, so the
+missing-parentheses mistake fails instead of quietly passing.
 
 #### Where a spec spends its time
 
@@ -3005,7 +3036,7 @@ collaborators.get(FeatureFlagService).isOn.mockReturnValue(true);
 
 TestBed.inject(CheckoutFacade).start();
 
-expect(collaborators.names()).toEqual(['FeatureFlagService']); // analytics was never asked for
+expect(collaborators.names({ clean: true })).toEqual(['FeatureFlagService']); // analytics was never asked for
 ```
 
 The assertion behind most `vi.mock('@app/services')` calls is not "this module was replaced" — it is
@@ -3034,7 +3065,8 @@ injectActivatedRoute().setParams({ id: '8' }); // params and paramMap emit; snap
 has neither, and a hand-written `useValue` usually has one half — the component that reads the other
 gets `undefined`, or a spec tests a route no navigation can produce. The double here is Angular's own
 `ActivatedRoute` over one record: `params`, `queryParams`, `data`, `fragment`, `url`, both
-`ParamMap`s and `snapshot` come from the same values, and each setter (`setParams`,
+`ParamMap`s and `snapshot` come from the same values (plus `title`, `children` and, on Angular 22.2+,
+the `resources` record), and each setter (`setParams`,
 `setQueryParams`, `setData`, `setFragment`, `setUrl`, or `set({ … })` for several at once) rebuilds
 the snapshot first and then emits what changed, in the router's order and with its equality. It is a
 real route to the real `Router` too: `relativeTo` resolves against its `url`. `createActivatedRoute()`
@@ -4336,7 +4368,7 @@ as `methodsToSpyOn`, named for callables that live on the instance — `signal()
 `gettersToSpyOn`, `settersToSpyOn`, `autoSpyAccessors` (discover every getter/setter),
 `fillMissing` (answer a name the prototype never carried with a spy — for a **partially** abstract
 class, where `abstract` members are erased and the empty-prototype fallback no longer fires),
-`lazySpies` (materialize method spies on first access — the `provideAutoSpy` default on Angular; the placeholder's accessor pair is shared by method name, so an untouched 100-method double retains 215 B. `'proxy'` answers every method from one trap object instead: it retains 4 090 B on the same class and pays a trap on every read (53 ns against 7 ns), so what is left of it is build time on a very wide class — see [Performance](https://asdalexey.github.io/vitest-auto-spy/core/performance#retained-memory-per-double))
+`lazySpies` (build each method spy on first read. Unset: accessor placeholders below 8 methods, `'proxy'` from 8 — a `Proxy` that defines nothing per method, 1.4 kB against 2.1 kB for a 8–16-method double with one method called and 1.4 against 4.4 kB at 45, at ~20 ns per read. `true` keeps a plain object at any width, `false` builds every spy up front — see [Performance](https://asdalexey.github.io/vitest-auto-spy/core/performance#retained-memory-per-double))
 
 `ValueConfig` (for `nextWithValues`): `{ value, delay? }` | `{ errorValue, delay? }` | `{ complete?, delay? }`.
 

package/agent-docs/angular.md

@@ -14,8 +14,8 @@ TestBed.configureTestingModule({
 const myService = injectSpy(MyService); // Spy<MyService>
 ```
 
-`provideAutoSpy` defaults to `lazySpies: true` (the plain `createSpyFromClass` does not). Pass
-`{ lazySpies: false }` to opt out. The spies never touch `NgZone`, so they work zoneless and with
+`provideAutoSpy` is lazy by default, as `createSpyFromClass` is: an unset `lazySpies` is `true` below 8
+methods and `'proxy'` from 8. Pass `{ lazySpies: false }` to opt out. The spies never touch `NgZone`, so they work zoneless and with
 zone.js alike. The entry needs **Angular >= 20** (§1); on 16 or 17 it does not link at all, because
 `ɵSIGNAL` is not there to import.
 
@@ -524,7 +524,7 @@ built over one record, so every stream, both `ParamMap`s and `snapshot` read the
 
 | Call | Does |
 | --- | --- |
-| `provideActivatedRoute(init?)` | a `FactoryProvider` — a fresh route per injector; `init`: `params`, `queryParams`, `data`, `title`, `fragment`, `url`, `outlet`, `component`, `routeConfig`, `resolve` |
+| `provideActivatedRoute(init?)` | a `FactoryProvider` — a fresh route per injector; `init`: `params`, `queryParams`, `data`, `title`, `fragment`, `url`, `outlet`, `component`, `routeConfig`, `resolve`, `children`, `resources` (22.2+: one record on the route and every snapshot — fill it with `mockResourceProp(resources, 'user', …)`) |
 | `injectActivatedRoute(injector?)` | the handle: `.route`, `setParams`, `setQueryParams`, `setData`, `setFragment`, `setUrl`, `set({ … })` |
 | `createActivatedRoute(init?)` | the same handle without a `TestBed` — for `new Page(route)`, or a guard given `route.snapshot` |
 
@@ -538,8 +538,9 @@ Four things to know:
 - **List it after `provideRouter()`** — the later provider of `ActivatedRoute` wins, and
   `injectActivatedRoute()` throws naming the one that did. With the real router present, the double
   still works as `relativeTo` for `router.createUrlTree`.
-- **One node, no tree.** `root` is the route itself, `parent` / `firstChild` are `null`. For
-  `route.parent.params` patch that member with `mockReadonlyProp`, or use `RouterTestingHarness`.
+- **No parent above it.** `root` is the route itself and `parent` is `null`; below it there are only
+  the routes passed as `children`. For `route.parent.params` patch that member with
+  `mockReadonlyProp`, or use `RouterTestingHarness`.
 - **`title` is given, not resolved; no navigation, no input binding.** `provideActivatedRoute({
 title: 'Product 7' })` answers `route.snapshot.title` — the double puts the string under the
   router's own `RouteTitleKey`, read off the installed router, and does not run a `title: () => …`
@@ -857,10 +858,11 @@ collaborators.get(FeatureFlagService).isOn.mockReturnValue(true);
 
 TestBed.inject(CheckoutFacade).start();
 
-expect(collaborators.names()).toEqual(['FeatureFlagService']); // analytics was never asked for
+expect(collaborators.names({ clean: true })).toEqual(['FeatureFlagService']); // analytics was never asked for
 ```
 
-`providers`, `injectedTokens()` (in factory-run order), `names()`, `wasInjected(token)`,
+`providers`, `injectedTokens()` (in factory-run order), `names()` (raw `Function.name`, so `_Service`
+under esbuild; `names({ clean: true })` strips the rename), `wasInjected(token)`,
 `get<D>(token)` → `Spy<D>`, `reset()` (the record only — the doubles survive). A class token gets a
 class spy, anything else a `createAutoMock()`; pass `{ double: () => … }` when a collaborator has to
 be a real object. Doubles are built eagerly, so stub before the entry point runs; a factory runs once
@@ -1025,7 +1027,7 @@ expect(products.reload).toHaveBeenCalled(); // reload is spied, answers true, an
 
 // signal assertions
 registerSignalMatchers(); // once, in the setup file — /angular/matchers
-expect(component.total).toHaveSignalValue(3);
+expect(component.total).toHaveSignalValue(3); // toEqual semantics; { strict: true } for toStrictEqual's
 
 // resource assertions — value AND status, which is the whole point
 registerResourceMatchers(); // once, in the setup file — /angular/matchers

package/agent-docs/checklist.md

@@ -50,9 +50,18 @@ a unit-test target, Analog below 2.7.5, `vite` below 6.4, or Node below 22.12 in
 `.node-version`, CI or a private package's `engines`. `fs-module-cache-not-persisted` warns when
 `fsModuleCache` is on and no CI config caches its directory. Renamed config keys Vitest 5 still
 honours (`experimental.fsModuleCache`, `browser.isolate`, `cache.dir`, …) are left to Vitest's own
-deprecation line. `mock-reset-config-unread` notes a `no-redundant-mock-reset` whose `configFile` names
-a config built by a factory or `mergeConfig`, with no flag beside it: the rule cannot see the flags
-that call sets.
+deprecation line. Four more cover the Angular unit-test builder and Analog:
+`angular-build-istanbul-module-cache` notes an istanbul run under `@angular/build:unit-test` 21+ on
+Vitest 5 without `fsModuleCache` in the target's runner config (up to −46 %, −19 % on another suite;
+v8 was about 2x faster than istanbul with the cache there, and the cache pays off on CI only when
+`node_modules/.vitest-cache` is kept), and
+`analog-module-cache-inline-styles` warns that `fsModuleCache` under the Analog plugin breaks the
+warm run of any spec reaching a component with inline `styles`. `angular-build-happy-dom` notes a
+builder target on jsdom only because `happy-dom` is not installed.
+`analog-fast-compile-ctor-injection` warns that Analog `fastCompile` in JIT mode leaves
+`@Injectable` constructor parameters without a token (NG0202). `mock-reset-config-unread` notes a
+`no-redundant-mock-reset` whose `configFile` names a config built by a factory or `mergeConfig`,
+with no flag beside it: the rule cannot see the flags that call sets.
 It is worth one run after any large edit to a test suite — especially after a codemod, which is where
 the eaten glob below came from.
 
@@ -133,6 +142,11 @@ per file on 5, where it is the wait for Vite's transforms and `import`/`setup` a
 totals are CPU time summed across every worker, not wall clock** — a report showing `20.29s of CPU
 time` under `986ms wall clock` is not a bug, it is the work spread over workers.
 
+Under `@angular/build:unit-test`, `ng test` takes no Vitest flag. Shard or run only what a change
+reaches with `npx vitest-auto-spy ng-test --shard 1/4` / `--changed [ref]` / `--related a.ts,b.ts`
+(`@angular/build` 21+; everything after `--` goes to `ng`); `test.repeats` in the runner config
+reaches Vitest as it is. `vitest doctor` does not work there — use `perf --command`.
+
 When `environment` dominates, the `perf-environment` finding names spec files that could run under
 the `node` environment instead — but only the ones it could _prove_ reach no DOM: the spec, its
 configured setup files, and every repository module any of them imports were all read, none
@@ -173,7 +187,9 @@ used rather than the machine's cores; under `isolate: false`, `perf-heap` lists
 to its lane's heap. Environment time is counted once per lane (`concurrencyId`) and value — not per
 `workerId`, which Vitest 5 renews for every file even in a reused worker. A finding about a switch
 also prints `perf-vitest-doctor`: confirm it with `npx vitest doctor`, Vitest's own A/B runner, not
-this package's `doctor`. A bare run on Vitest 5 passes `--experimental.diagnostics=false` so Vitest's
+this package's `doctor`. Under `@angular/build:unit-test` it gives an A/B through `ng run <project>:<target> --runner-config=<variant>`
+instead, because `npx vitest doctor` cannot build that suite; every settings finding there names the runner config
+the target reads. A bare run on Vitest 5 passes `--experimental.diagnostics=false` so Vitest's
 own hints do not repeat these. The reporter rewrites a `partial: true` report every ~2 s while the run
 goes, so a killed or timed-out run still leaves one: `perf` prints it under a warning and the gate
 refuses it like a red run.

package/agent-docs/configuration.md

@@ -15,7 +15,7 @@ createSpyFromClass(MyService, {
   gettersToSpyOn: ['userName'],
   settersToSpyOn: ['userName'],
   autoSpyAccessors: true, // discover every accessor on the prototype chain
-  lazySpies: true, // build each method spy on first access ('proxy' for very wide classes)
+  lazySpies: true, // unset: true below 8 methods, 'proxy' from 8; false = eager
   returns: { getProducts: of([]) }, // what a spied METHOD answers
   selfReturning: ['where'], // a method that answers the double itself, for a chained call
   overrides: { products$: subject }, // a member that is not a method result
@@ -28,7 +28,7 @@ createSpyFromClass(MyService, {
 | `onlyMethodsToSpyOn` | **Exhaustive whitelist.** Skips discovery; anything not listed is absent. |
 | `instanceMethodsToSpyOn` | **Additive.** The name to prefer in new code (see below). |
 | `autoSpyAccessors` | Merged with the explicit getter/setter lists. |
-| `lazySpies` | Behaviour-identical; only changes _when_ each spy is built. `'proxy'` also changes _what holds the name_. |
+| `lazySpies` | Unset: `true` (accessor placeholders) below 8 methods, `'proxy'` (a `Proxy`, lighter once touched) from 8, counting the methods the double spies (after `onlyMethodsToSpyOn` / `methodsToSpyOn`). Explicit `true` / `false` / `'proxy'` apply at any width. Calls, `Object.keys`, spread and snapshots behave the same in every mode. |
 | `strict` | Throw on a method nobody configured, instead of answering `undefined` (below). |
 | `onUnstubbedCall` | The general form of `strict`; its return value becomes the call's return value. |
 | `selfReturning` | The named methods answer the double itself — a default like `returns`; a name in both answers `returns`. |
@@ -251,6 +251,10 @@ Precedence, first one set wins: the double's `onUnstubbedCall` → the double's
   double is built, or `resolveWith` / `nextWith` / `failWith` — which a `calledWith` still wins over.
   The report is this library's own spy engine's, so Vitest and Rstest have it; Bun, `node:test` and
   `setSpyEngine('runner')` do not. The `Once` family is never reported.
+  `vi.when(spy)` (Vitest 5) is not reported either, nor any `mockImplementation` built from
+  `spy.getMockImplementation()`: it wraps the dispatch rather than replacing it,
+  so a `calledWith` on the same method still answers every call `vi.when` has no row for. A
+  `vi.when` over a `mockReturnValue` still is.
 - **A throw something swallowed still fails the test.** Under `setupAutoSpy({ strict: true })` every
   strict throw is recorded, and one that a `try`/`catch` in the code under test or an RxJS error with
   no handler (its rethrow waits on a fake clock) kept from the test fails it after the test

package/agent-docs/errors.md

@@ -126,6 +126,7 @@ Part of the agent reference [`AGENTS.md`](../AGENTS.md), which maps every sectio
 | `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>` — never `@ts-expect-error`, which `no-ts-expect-error-on-double` reports (§16) |
+| `NG0202 … dependency at index N of the parameter list is invalid` from `createWithAutoSpies` or plain `TestBed.inject`, under Analog `fastCompile: true` | the plugin drops the constructor types of `@Injectable` classes in JIT mode — not a library bug (`doctor` reports `analog-fast-compile-ctor-injection` and lists the classes) | an `inject()` field, or `@Inject(X)` on the parameter; or turn `fastCompile` off (§13) |
 | `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] })`; on Angular ≥ 22.2, for a directive with no static host attribute, `TemplateRef` or sibling markup, `TestBed.createDirective(Dir, { tagName, bindings })` (§13) |
 | `setInputs: … declares no input named …` (with a `Did you mean` for a near typo) | the key is not an input of that component — a typo, an input renamed since, or one of its own fields | take the suggestion, or set a name the message lists; a signal the component owns is moved through the signal (§13) |
 | `setInputs: X carries no ɵcmp, so there are no inputs to set` (or `the component class is undefined`, `X is a @Pipe`) | the fixture's `componentType` is not a compiled `@Component` — a `@Pipe`, a class Angular never compiled, or `undefined` from a barrel split across chunks | pass the `@Component` class the fixture was created from; call a pipe's `transform()` directly; for `undefined` import the class from its own file (§13) |

package/agent-docs/factories.md

@@ -349,12 +349,13 @@ retains: an untouched 100-method double holds **215 B** where it held 25 593, an
 construction on very wide classes — building a 300-method double costs about 28 % more — and
 materialising every method of one is about 26 % cheaper in exchange.
 
-That inverts the case for `lazySpies: 'proxy'`, which answers every method from a single trap
-object: it now retains **4 090 B** against the default's 215 B at 100 methods — 19× more — and still
-pays a trap on every read (53 ns against 7 ns) for the life of the double, because a `Proxy` cannot
-remove itself while the default leaves a plain data property behind once a method materialises. What
-is left of its advantage is build time on a wide class. The option is unchanged and still supported;
-there is no longer a memory reason to reach for it.
+The first materialisation is where the accessor path pays: it drops the double into a property
+dictionary as wide as the class. So since 2026-09-27 an unset `lazySpies` depends on width: a class of
+8 methods or more gets `'proxy'`, which defines nothing per method and never enters dictionary mode —
+21–68 % lighter once touched, 2–6× faster to build — for ~20 ns on every read and ~100 B more on an
+untouched double. A narrower class keeps the accessor placeholders. A spec on a wide class that needs a
+plain object (`util.types.isProxy`, `console.log` of an unread double, `vi.spyOn` wrapping an unread
+method) passes `lazySpies: true`.
 
 A frozen or sealed double is fine now. `Object.freeze(spy)` — a deep-freeze fixture helper, a
 dev-mode state guard — used to make the first read of any method throw `Cannot redefine property`