vitest-auto-spy 5.41.0 → 5.42.0

package/CHANGELOG.md

@@ -10,6 +10,108 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [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 +5692,8 @@ 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.42.0...HEAD
+[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)
@@ -998,8 +998,14 @@ 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
 known command is an error and **nothing runs** — `init --dryrun` used to write the files and
@@ -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` — −46 % on a 700-file Angular 22.2 suite. 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).
@@ -2630,7 +2657,7 @@ beforeEach(() => {
 > 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
+> (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.
@@ -4336,7 +4363,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` |
 

package/agent-docs/checklist.md

@@ -50,9 +50,16 @@ 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 (−46 % measured), 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 +140,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 <files>`
+(`@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 +185,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. 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,9 @@ 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: 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`

package/dist/angular-diagnostics.js

@@ -1,12 +1,12 @@
 import { pendingRequestsReport, assertAngularInternals, instrumentTestBed, onTestingModuleConfigured, onComponentCreated, beforeTestBedReset, verifyOnTeardown } from './chunk-JFOJFCVQ.js';
 export { disableTestBedDiagnostics, enableTestBedDiagnostics, formatSpecTiming, getTestBedTiming, instrumentTestBed, reportSpecTiming } from './chunk-JFOJFCVQ.js';
-import { failOnUnspiedProvider } from './chunk-OWDUWUAO.js';
+import { failOnUnspiedProvider } from './chunk-MHN6GMXP.js';
 import './chunk-GG7BQKEK.js';
 import './chunk-MNY4ZHEQ.js';
-import './chunk-T7EGA4G4.js';
+import './chunk-EYXARTWD.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import './chunk-HUS2MHK5.js';
+import './chunk-CENALW7R.js';
 import { isAutoSpyLike } from './chunk-Q7L4AWI7.js';
 import { count, sourceClassName, taskName } from './chunk-DYAS4OK4.js';
 import { angularPendingRequests, angularShadowedProviders, angularDeadSchemas, angularNgModuleScopesAuto } from './chunk-5FQZGJLJ.js';

package/dist/angular-doubles.d.ts

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

package/dist/angular-doubles.js

@@ -1,11 +1,11 @@
 import { describeInstance } from './chunk-XEIOGUGP.js';
-import { useVitestAdapter } from './chunk-6ZGH56G4.js';
-import './chunk-IE4NI2OQ.js';
+import { useVitestAdapter } from './chunk-J4IJCTHT.js';
+import './chunk-J2C3KRTC.js';
 import './chunk-YHDBRBGU.js';
 import './chunk-TXDBDMIL.js';
 import './chunk-FOL5RH22.js';
 import './chunk-PC3FAZT3.js';
-import { createFunctionSpy } from './chunk-HUS2MHK5.js';
+import { createFunctionSpy } from './chunk-CENALW7R.js';
 import './chunk-Q7L4AWI7.js';
 import { sourceClassName } from './chunk-DYAS4OK4.js';
 import { angularDialog } from './chunk-5FQZGJLJ.js';

package/dist/angular-router.d.ts

@@ -1,6 +1,6 @@
 import { Type, Injector, FactoryProvider, Provider } from '@angular/core';
 import { Params, Data, UrlSegment, ActivatedRoute, Route, ResolveData, Navigation, Router, Event } from '@angular/router';
-import { h as AddSpyMethodsByReturnTypes } from './types-DJ0OGc3C.js';
+import { h as AddSpyMethodsByReturnTypes } from './types-CyRUgJVd.js';
 import { SpyLocation } from '@angular/common/testing';
 import 'vitest';
 
@@ -38,6 +38,11 @@ interface ActivatedRouteChange {
     /** The matched URL segments. A string is split on `/`; pass `UrlSegment`s for matrix parameters. */
     url?: UrlSegment[] | string;
 }
+/**
+ * `ActivatedRoute.resources` where the installed `@angular/router` has it (22.2 on), `never` before —
+ * so the init key stays harmless on 20 and 21.
+ */
+type RouteResources = NonNullable<ActivatedRoute[Extract<'resources', keyof ActivatedRoute>]>;
 /** The route a spec starts from: what a navigation moves, plus what stays fixed for the route's life. */
 interface ActivatedRouteInit extends ActivatedRouteChange {
     /** The outlet the route is rendered into. Default `'primary'`. */
@@ -48,6 +53,11 @@ interface ActivatedRouteInit extends ActivatedRouteChange {
     routeConfig?: Route | null;
     /** The resolve record — the snapshot's own `_resolve`, kept apart from `data` as Angular keeps it. */
     resolve?: ResolveData;
+    /**
+     * The record a route's `resources` function returned — `route.resources` and `snapshot.resources`,
+     * the same object on every snapshot, as a navigation that keeps the route carries it over.
+     */
+    resources?: RouteResources;
     /** Child routes, each a double of its own: `route.children`, `firstChild` and a child's `parent` answer them. */
     children?: readonly ActivatedRouteInit[];
 }

package/dist/angular-router.js

@@ -1,6 +1,6 @@
 import { describeInstance } from './chunk-XEIOGUGP.js';
 import { angularInternalsError } from './chunk-GG7BQKEK.js';
-import { createFunctionSpy } from './chunk-HUS2MHK5.js';
+import { createFunctionSpy } from './chunk-CENALW7R.js';
 import './chunk-Q7L4AWI7.js';
 import { count } from './chunk-DYAS4OK4.js';
 import { angularRouteDouble, angularRouterInject, angularRouterEvents, angularLocationDouble, angularRouteWiring, angularRouterDouble } from './chunk-5FQZGJLJ.js';
@@ -110,7 +110,14 @@ function buildSnapshot(state, fixed) {
     fixed.routeConfig,
     state.resolve
   ];
-  return Reflect.construct(ActivatedRouteSnapshot, args);
+  const snapshot = Reflect.construct(ActivatedRouteSnapshot, args);
+  withResources(snapshot, fixed);
+  return snapshot;
+}
+function withResources(target, fixed) {
+  if (fixed.resources !== void 0) {
+    Reflect.set(target, "resources", fixed.resources);
+  }
 }
 function routeWiringError(member) {
   return new Error(
@@ -187,13 +194,15 @@ function constructRoute(streams, fixed, snapshot) {
     snapshot
   ]);
   route.snapshot = snapshot;
+  withResources(route, fixed);
   return route;
 }
 function buildActivatedRoute(init) {
   const fixed = {
     outlet: init.outlet ?? PRIMARY_OUTLET,
     component: init.component ?? null,
-    routeConfig: init.routeConfig ?? null
+    routeConfig: init.routeConfig ?? null,
+    resources: init.resources
   };
   let state = initialState(init);
   const streams = streamsOf(state);

package/dist/angular.d.ts

@@ -1,12 +1,12 @@
-export { u as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, v as provideAutoSpyForToken, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-DUZUFWf-.js';
-import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, s as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-DJ0OGc3C.js';
-export { H as SubjectOf } from './types-DJ0OGc3C.js';
+export { u as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowRender, f as SpyRegistry, g as StableOptions, h as createWithAutoSpies, i as flushEffects, j as hostElement, k as injectSpy, p as provideAutoSpy, v as provideAutoSpyForToken, q as queryElement, r as renderShallow, l as runEffect, s as setInputs, m as settleResource, n as stable, t as trackEffectRuns, o as trackRecomputations } from './track-signal-runs-bs2umXNE.js';
+import { o as DeepPartial, C as ClassType, m as ClassSpyConfiguration, S as Spy, s as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-CyRUgJVd.js';
+export { H as SubjectOf } from './types-CyRUgJVd.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';
-import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-CwosjG6t.js';
-export { C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, s as setEmissionTimeout } from './expect-emission-CwosjG6t.js';
+import { A as AutoMockConfiguration, D as DeepReadonly } from './expect-emission-D273986K.js';
+export { C as CallbackSubscribable, E as EmissionObserver, c as EmissionOptions, d as EmissionSource, S as SubscribableLike, h as expectAllEmissions, i as expectCompletion, j as expectEmission, k as expectEmissions, l as expectError, m as expectNoEmission, s as setEmissionTimeout } from './expect-emission-D273986K.js';
 import { TestAPI } from 'vitest';
-export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-Bp8TgLjG.js';
-export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-C8PJ-Vo8.js';
+export { I as InjectionLog, T as TrackInjectionsOptions, a as TrackedProvider, t as trackInjections } from './track-injections-BTJKOqWz.js';
+export { A as AccessorImplementations, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, e as restoreMockedProps } from './prop-mock-Cz0yKWEP.js';
 import '@angular/core/testing';
 
 /**