vitest-auto-spy 5.52.0 → 5.54.0

package/CHANGELOG.md

@@ -10,6 +10,48 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.54.0] - 2026-09-30
+
+### Added
+
+- **`perf --json <reports> --gate` re-measures its suspects without `--command`.** The perf reporter
+  now records the Vitest config file the suite ran with (`configFile`, relative to `root`), and the
+  confirmation pass re-runs each suspect with `vitest run --config <that file>` over the suspects
+  only: one run per config when the reports came from several (`vitest.config.ts` and
+  `libs/tooling/vitest.config.ts`, say), read back as one second reading. A single slow reading on a
+  loaded runner now comes back as not reproduced instead of needing `--no-confirm` to fail anything.
+  The re-run has coverage off (`--coverage.enabled=false`), even when the first reading had it on:
+  coverage thresholds fail a run of a few files, and instrumentation is the harness's cost rather
+  than the test's, so a body over budget only because of instrumentation is not reproduced.
+  `--command` still takes precedence, and a report without `configFile` is not re-measured, as
+  before. The perf report format is version 6; versions 1–6 are read.
+
+## [5.53.0] - 2026-09-29
+
+### Added
+
+- **`no-inline-test-data`, in `recommended` as `warn`**: a data literal longer than 20 lines, or
+  the same literal written three times in one spec, belongs in a `*.mock.ts` file next to the spec.
+  `maxLines`, `repeats` and `minValues` tune it. Module wiring (`providers`, `imports`…), `it.each`
+  tables, `vi.mock` factories, literals holding a function and the mock files themselves are never
+  reported. On an 886-file Angular suite it flags 215 files at the defaults.
+  `/eslint-plugin` grows by 1.50 kB (50.96 → 52.46 kB, +2.9 %): 1.08 kB for this rule, the rest for
+  reading `externalDependencies` below.
+
+### Fixed
+
+- **`no-relative-mock-under-builder` reads `externalDependencies` of the target's `buildTarget`.** The
+  builder builds with the options `context.getTargetOptions` returns for `buildTarget` (the target's
+  options, then each named configuration over them) and leaves those specifiers out of the bundle, so
+  a `vi.mock` of such a path alias does replace the module. The rule now reports an alias only when
+  some unit-test run of the file builds without it; esbuild's matching applies (exact name, a subpath,
+  one `*`). A relative specifier is still reported: the builder throws on it whatever is external. On
+  an 886-file Angular suite that externalises its mocked utilities this removes 69 false reports.
+- **`no-outer-binding-in-mock-factory` treats an instance field initialiser as deferred.**
+  `class { listen = mockListen; }` returned from a factory reads `mockListen` when a test constructs
+  the class, not while the factory runs. A static field, a computed key and a static block still run
+  with the class declaration and are reported.
+
 ## [5.52.0] - 2026-09-29
 
 ### Added
@@ -6631,7 +6673,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.52.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.54.0...HEAD
+[5.54.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.53.0...v5.54.0
+[5.53.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.52.0...v5.53.0
 [5.52.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.51.0...v5.52.0
 [5.51.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.50.0...v5.51.0
 [5.50.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.49.0...v5.50.0

package/README.md

@@ -48,7 +48,7 @@ replacement for [`jest-auto-spies`](https://www.npmjs.com/package/jest-auto-spie
 - **One API on every runner**: Vitest, Bun, `node:test` and Rstest; helpers for Angular, NestJS,
   React, Vue / Pinia and Svelte.
 - **Checks that make silent tests fail**: strict mode, Observable assertions, cleanup between tests,
-  56 ESLint rules.
+  57 ESLint rules.
 - **Zero runtime dependencies.**
 
 ## Contents
@@ -3515,7 +3515,7 @@ Full page: [Observer stubs](https://asdalexey.github.io/vitest-auto-spy/utilitie
 
 ## ESLint plugin
 
-`vitest-auto-spy/eslint-plugin` has 56 lint rules that catch test code which passes but checks
+`vitest-auto-spy/eslint-plugin` has 57 lint rules that catch test code which passes but checks
 nothing, or drifts from the real class. Each message links to the fix.
 
 ```js
@@ -3587,6 +3587,7 @@ Rolling it out on a large suite, and the options each rule takes:
 | [`no-outer-binding-in-mock-factory`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-outer-binding-in-mock-factory) |   `error`   | —                 | Declare what a vi.mock factory reads through vi.hoisted — vi.mock runs before the file’s declarations                                 |
 | [`no-relative-mock-under-builder`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-relative-mock-under-builder)     |   `error`   | —                 | Do not vi.mock() a relative path in a spec the Angular unit-test builder runs — the builder throws on it                              |
 | [`no-real-wait-in-test`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-real-wait-in-test)                         |   `warn`    | —                 | Do not sleep on the real clock in a spec — drive fake timers or wait for the outcome                                                  |
+| [`no-inline-test-data`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-inline-test-data)                           |   `warn`    | —                 | Keep long or repeated test data in a *.mock.ts file next to the spec                                                                  |
 | [`no-disabled-testbed-teardown`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-disabled-testbed-teardown)         |   `error`   | —                 | Keep TestBed teardown on — destroyAfterEach: false leaks every fixture into the tests after it                                        |
 | [`no-import-time-console-spies`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-import-time-console-spies)         |   `error`   | —                 | Install the console spies where the file needs them — the import installs them once per worker                                        |
 | [`no-mistyped-use-value`](https://asdalexey.github.io/vitest-auto-spy/utilities/eslint-rules#no-mistyped-use-value)                       |   `error`   | —                 | Give a primitive-typed InjectionToken a useValue of its declared type — Angular types useValue as any, so nothing else checks it      |

package/agent-docs/checklist.md

@@ -254,8 +254,11 @@ test bodies, and the gate prints the slowest tests, the share in hooks against b
 time went in the spec, in your code and by package. The report ends in two tables of what is over
 budget and nothing else. And every candidate is re-measured on its own before it may fail anything: a
 file that is fast when it has the machine to itself is reported as _not reproduced_, an `info` rather
-than a finding. Without a way to re-measure, findings are warnings that fail nothing unless
-`--no-confirm` says one reading is enough. Exit `1` is "over budget", exit `2` is "there was nothing
+than a finding. `--json` without `--command` re-measures too: the report records its Vitest config
+file, and the gate runs `vitest run --config <it>` over the suspects, one run per config when the
+reports came from several, with coverage off. Without a way to re-measure (a `--command` without
+`{paths}`, a report from before the config was recorded), findings are warnings that fail nothing
+unless `--no-confirm` says one reading is enough. Exit `1` is "over budget", exit `2` is "there was nothing
 to judge" — including a red or unfinished (`partial`) suite, which the gate will not judge at all, since a failed test is
 measured until its timeout and 30 s of timeout looks exactly like 30 s of slow code.
 

package/agent-docs/eslint.md

@@ -98,8 +98,9 @@ export default [
 | `prefer-create-mock` | `warn` | suggest | an object literal under `as SomeType` — `{ id: '1', isOffline: false } as Device`, `<Device>{ … }` too → `createMock<Device>({ … })`. A cast asks whether the two types overlap rather than whether the value is one of them, so it passes a key the type does not declare (the excess-property check is skipped) **and** a required field the fixture never sets; both type gates stay silent, and the same object is then spread into the expected payload of a call assertion. Where the literal already sits in a typed slot the first repair is to delete the cast. Silent on `as const`, `as unknown` / `as any` and the double cast built from them, on a cast of anything but a literal, and on a literal inside one of this library's own factories. `warn`, because accepting the suggestion makes a drifted fixture red on the next type-check — the finding, and a migration taken file by file |
 | `no-mock-cast` | `error` | suggest | a cast to Vitest's `Mock` / `MockInstance` over a **member access** — `TestBed.inject(S).m as Mock` → `injectSpy(S).m`, which the suggestion writes whenever the token is in view (directly, or through a `const` the file settled with a `TestBed.inject`). `Mock` with no parameters is `Mock<any>`: `mockReturnValue` takes anything and `toHaveBeenCalledWith` stops comparing arguments. `(spy.m.mockReturnValue as Mock)(…)` gets its own message — the cast is on the member that installs the answer, so neither the value nor the method's return type is checked. The name must resolve to an import from `vitest` / `@rstest/core` / `bun:test` / `jest`, or to nothing at all, so a domain `Mock` is left alone |
 | `no-outer-binding-in-mock-factory` | `error` | — | a `vi.mock(path, factory)` factory reading a top-level `const` / `let` / `var` / `class` declared outside `vi.hoisted` — the factory is hoisted above it, so the read is `Cannot access 'x' before initialization` → `const { user } = vi.hoisted(() => ({ user: … }))`. Only reads made while the factory runs count; function declarations, imports, type positions and `vi.doMock` are not reported |
-| `no-relative-mock-under-builder` | `error` | — | `vi.mock` / `doMock` / `importMock` / `unmock` / `doUnmock` with a specifier starting `.` or `/` in a spec `@angular/build:unit-test` runs — the builder throws on it → `provideAutoSpy(X)`, or `overrideComponentProvider` for a component's own provider. **Silent until** an `@angular/build:unit-test` / `@nx/angular:unit-test` target serving the file is found (the `no-redundant-mock-reset` search) or `{ builder: 'unit-test' }` says so; a tsconfig path alias slips past both the builder and the rule |
+| `no-relative-mock-under-builder` | `error` | — | `vi.mock` / `doMock` / `importMock` / `unmock` / `doUnmock` with a specifier starting `.` or `/` in a spec `@angular/build:unit-test` runs — the builder throws on it → `provideAutoSpy(X)`, or `overrideComponentProvider` for a component's own provider. **Silent until** an `@angular/build:unit-test` / `@nx/angular:unit-test` target serving the file is found (the `no-redundant-mock-reset` search) or `{ builder: 'unit-test' }` says so; a tsconfig path alias to a workspace file is reported too (the builder bundles it, so the mock silently does nothing) unless every run's `buildTarget` lists it in `externalDependencies` |
 | `no-real-wait-in-test` | `warn` | — | a sleep on the real clock — `new Promise((r) => setTimeout(r, N))` in any spelling where `resolve` reaches the timer, `setTimeout(N)` from `node:timers/promises`; a `sleep(ms)` helper once, at its definition; a missing or `0` delay is left alone → `setupFakeTimers()` + `await advanceTimers(N)`, or wait for the outcome (`vi.waitFor`, `fixture.whenStable()`) |
+| `no-inline-test-data` | `warn` | — | test data inline in a spec — a data literal over `maxLines` (20) lines, or the same literal `repeats` (3) times in one file with at least `minValues` (2) values, one spelled out → export it once from `<name>.mock.ts` next to the spec. Never reported: module wiring (`providers`, `imports`…), `it.each` tables, `vi.mock` factories, literals holding a function, and files named `*.mock.ts` / `*.fixture.ts` / under `__mocks__/` |
 | `no-disabled-testbed-teardown` | `error` | — | `destroyAfterEach: false`, in `initTestEnvironment` or one `configureTestingModule` — every fixture outlives its test, `ngOnDestroy` never runs → delete it (Angular's default since v13) and fix the test that then fails. A config scoped to `**/*.spec.ts` must add the setup file to `files` |
 | `no-redundant-mock-reset` | `error` | `--fix` / suggest | a mock reset the runner already performs between tests — `vi.clearAllMocks()` / `resetAllMocks()` / `restoreAllMocks()`, `x.mockClear()` / `mockReset()` / `mockRestore()` — standing where nothing the file wrote ran since the runner's own: the first statement of a `beforeEach` no other `beforeEach` precedes, or a clear as the last statement of an `afterEach` → delete it, and the hook with it where that is all it held. A restore or reset in `afterEach` / `afterAll` is never reported: after the last test it is what takes a spy off before the `afterAll` hooks. **Silent** until the flags are known: options `{ clearMocks, restoreMocks, mockReset }` (or `{ configFile }` naming the runner config) first, then a `vitest.config.*` / `vite.config.*` searched upwards from the file and read as text; a config that leaves `clearMocks` out counts it on from Vitest 5 (its default). Where an `@angular/build:unit-test` / `@nx/angular:unit-test` target (found in `angular.json` / `project.json` above the file) also serves the spec, a config flag counts only if that target's `runnerConfig` applies it too — without `runnerConfig` the builder runs Vitest's defaults, so `restoreMocks` / `mockReset` from `vitest.config.ts` do not make a reset dead there, while a clear stays reported on Vitest 5; the rule's inline flags are not narrowed. A config built by a factory or `mergeConfig` from another module is not read through — name its flags as `{ configFile, configFlags: { clearMocks: true } }`, read as if the file set them, so the builder narrowing still applies (`configFlags` needs `configFile`; `doctor` notes the case as `mock-reset-config-unread`). `setupAutoSpy({ restoreMocks: true })` is not the runner's `restoreMocks` (it restores in an `afterEach`, after the test) — never pass the rule a flag only the setup file sets. Flag matches call, never family — `restoreMocks` walks only the spies `vi.spyOn` installed. `--fix` only in a file whose only before-hook it is; a suggestion otherwise; never inside a test body |
 | `no-unasserted-argument` | `warn` | — | a bare `expect(spy).toHaveBeenCalled()` on evidence from the file: the same subject asserted with `toHaveBeenCalledWith(…)` in another test, or a title containing `with` over a body whose every assertion is a bare call → `toHaveBeenCalledWith(…)` / `mustBeCalledWith(…)`. `not.toHaveBeenCalled()` and the counting matchers are never reported |
@@ -110,20 +111,21 @@ export default [
 | `no-save-arguments-by-value` | `error` | — | `spy.calls.saveArgumentsByValue()` — a no-op here, so the spec silently asserts on post-mutation state |
 | `prefer-native-spy-api` | `error` | `--fix` / suggest | `.and` / `.calls` where the spy's own API says the same thing — turn it on for the last mile off the jasmine shim. The fix renames only the member (`and.returnValue` → `mockReturnValue`, `withArgs` → `calledWith`), so comments stay; a rewrite that would drop one is a suggestion |
 
-Fifty-six rules, **every one an `error` except `prefer-render-shallow`,
+Fifty-seven rules, **every one an `error` except `prefer-render-shallow`,
 `no-stub-class-double`, `no-structural-double`, `prefer-create-mock`, `no-instance-lifecycle-spy`,
 `prefer-set-inputs`, `no-unasserted-argument`, `prefer-spy-on-own-method`, `prefer-to-have-signal-value`,
-`no-unasserted-console-spy` and `no-real-wait-in-test`**; eight fix on their own, nineteen offer suggestions. Fifty-two are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
+`no-unasserted-console-spy`, `no-real-wait-in-test` and `no-inline-test-data`**; eight fix on their own, nineteen offer suggestions. Fifty-three are syntactic; `no-private-member-access`, `no-mistyped-use-value`,
 `no-unknown-use-value-key` and `prefer-to-have-signal-value` read types, and all four report nothing at all without `parserOptions.project` / `projectService`
 rather than guessing. `no-compile-components` waits the same way for a fact no file holds — which
 builder the project has — and reports nothing until `{ builder: 'inline-resources' }` states it;
 `no-relative-mock-under-builder` waits for a builder target serving the file, or `{ builder: 'unit-test' }`.
 
-The eleven `warn`s do not rank findings by importance. Each names something other than a defect: a
+The twelve `warn`s do not rank findings by importance. Each names something other than a defect: a
 cheaper render (`prefer-render-shallow`), a heuristic reading with no `provide:` to settle it
 (`no-stub-class-double`, `no-structural-double`, `no-instance-lifecycle-spy`), a repair that turns
 many files red at once (`prefer-create-mock`), a question only the author can answer
-(`no-unasserted-argument`, `no-unasserted-console-spy`, `no-real-wait-in-test`), or a preferred spelling
+(`no-unasserted-argument`, `no-unasserted-console-spy`, `no-real-wait-in-test`), a place data should
+live rather than a defect (`no-inline-test-data`), or a preferred spelling
 of working code (`prefer-spy-on-own-method`, `prefer-set-inputs`, `prefer-to-have-signal-value`). Set
 any of the `warn`s to `'error'` once the batch is done.
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { ownVersion, isDirectory, readProfile, formatFindings, outputWidth, painterFor, summarize, DOCTOR_CHECKS, writeTextFile, REPORT_SCHEMA, sortFindings, findingJson, tallyOf, ownPackageRoot, readTextFile, SCAN_CAP_ENV, scanCap, COVERAGE_MATCHING_DOCS, VITEST_5_PERF_DOCS, filterBySeverity, isSymlink, skillFrontmatter, toPosix, pathExists, NOTHING_TO_READ_DOCS, removeFile, parseJsonc, isRecord, extractSetupFiles, captures, gitignoreFilter, BARE_RUN_DOCS, MONOCHROME, findStringEnd, wrapText, listRepositoryFiles, isSkippedDirectory, versionFrom, stripColor, padStart, padEnd } from './cli-SELXGLDQ.js';
+import { ownVersion, isDirectory, readProfile, formatFindings, outputWidth, painterFor, summarize, ownPackageRoot, DOCTOR_CHECKS, writeTextFile, REPORT_SCHEMA, sortFindings, findingJson, tallyOf, readTextFile, SCAN_CAP_ENV, scanCap, COVERAGE_MATCHING_DOCS, VITEST_5_PERF_DOCS, filterBySeverity, isSymlink, skillFrontmatter, toPosix, pathExists, NOTHING_TO_READ_DOCS, removeFile, parseJsonc, isRecord, extractSetupFiles, captures, gitignoreFilter, BARE_RUN_DOCS, MONOCHROME, findStringEnd, listRepositoryFiles, wrapText, isSkippedDirectory, versionFrom, stripColor, padStart, padEnd } from './cli-SELXGLDQ.js';
 import { resolve, join, posix, relative, isAbsolute, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
@@ -1654,7 +1654,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.51.0";
+var EXPORT_MAP_VERSION = "5.53.0";
 var ENTRY_SPECIFIERS = "vitest-auto-spy vitest-auto-spy/bun vitest-auto-spy/bun-angular vitest-auto-spy/node vitest-auto-spy/rstest vitest-auto-spy/rxjs vitest-auto-spy/console vitest-auto-spy/dom-stubs vitest-auto-spy/diagnostics vitest-auto-spy/jasmine vitest-auto-spy/jasmine-compat vitest-auto-spy/observer-spy vitest-auto-spy/angular vitest-auto-spy/angular/diagnostics vitest-auto-spy/angular/doubles vitest-auto-spy/angular/matchers vitest-auto-spy/angular-http vitest-auto-spy/angular-router vitest-auto-spy/signal-forms vitest-auto-spy/nestjs vitest-auto-spy/react vitest-auto-spy/vue vitest-auto-spy/svelte vitest-auto-spy/setup vitest-auto-spy/zone vitest-auto-spy/eslint-plugin vitest-auto-spy/perf-reporter";
 var EXPORTED_BY = {
   AccessorImplementations: "0 1 2 3 4 12 20 21 22",
@@ -4665,8 +4665,8 @@ var PERF_OUTPUT_ENV = "VITEST_AUTO_SPY_PERF_OUT";
 var PERF_REPORTER_ENV = "VITEST_AUTO_SPY_PERF_REPORTER";
 var PERF_PROFILE_ENV = "VITEST_AUTO_SPY_PERF_PROFILE";
 var PERF_ISOLATE_ENV = "VITEST_AUTO_SPY_PERF_ISOLATE";
-var PERF_FORMAT_VERSION = 5;
-var READABLE_VERSIONS = [1, 2, 3, 4, 5];
+var PERF_FORMAT_VERSION = 6;
+var READABLE_VERSIONS = [1, 2, 3, 4, 5, 6];
 var CASE_FLOOR_MS = 100;
 var CASES_PER_FILE = 5;
 var OPTIONAL_FILE_NUMBERS = ["workerId", "lane", "start", "fetch", "setupFetch", "retries", "autoSpy"];
@@ -4811,7 +4811,8 @@ function parsePerfRun(text) {
     ...parsed["partial"] === true ? { partial: true } : {},
     ...end === "failed" || end === "interrupted" || end === "passed" ? { end } : {},
     ...parsed["hung"] === true ? { hung: true } : {},
-    ...coverage === void 0 ? {} : { coverage }
+    ...coverage === void 0 ? {} : { coverage },
+    ...typeof parsed["configFile"] === "string" && parsed["configFile"] !== "" ? { configFile: parsed["configFile"] } : {}
   };
 }
 function sumOf(run, key) {
@@ -5385,7 +5386,8 @@ function finding3(candidate, severity, tail) {
   };
 }
 var UNCONFIRMED = [
-  "Measured once and never confirmed, so it fails nothing. Run the gate where the files can be re-measured,",
+  "Measured once and never confirmed, so it fails nothing. Run the gate where the files can be re-measured \u2014",
+  "a --command with {paths}, or a report whose perf reporter recorded the Vitest config \u2014",
   "or pass --no-confirm to gate on a single reading."
 ].join(" ");
 function rowOf(candidate, outcome, again) {
@@ -7450,6 +7452,11 @@ function reroot(path, from, to) {
   return rest.startsWith("/") || rest.startsWith("\\") ? `${to}${rest}` : path;
 }
 var END_ORDER = ["interrupted", "failed", "passed"];
+function sharedConfigFile(inputs) {
+  const configFiles = new Set(inputs.map((input) => input.run.configFile));
+  const [configFile] = configFiles;
+  return { shared: configFiles.size <= 1, configFile };
+}
 function mergedRun(inputs) {
   const runs2 = inputs.map((input) => input.run);
   const vitest = runs2.find((run) => run.vitest !== void 0)?.vitest;
@@ -7457,6 +7464,7 @@ function mergedRun(inputs) {
   const startups = runs2.flatMap((run) => run.startup === void 0 ? [] : [run.startup]);
   const end = END_ORDER.find((reason) => runs2.some((run) => run.end === reason));
   const coverages = runs2.flatMap((run) => run.coverage === void 0 ? [] : [run.coverage]);
+  const configFile = sharedConfigFile(inputs);
   const startup = startups.reduce((total, each) => ({ ms: total.ms + each.ms, workers: total.workers + each.workers }), {
     ms: 0,
     workers: 0
@@ -7474,7 +7482,8 @@ function mergedRun(inputs) {
     ...runs2.some((run) => run.partial === true) ? { partial: true } : {},
     ...end === void 0 ? {} : { end },
     ...runs2.some((run) => run.hung === true) ? { hung: true } : {},
-    ...coverages.length === 0 ? {} : { coverage: Math.max(...coverages) }
+    ...coverages.length === 0 ? {} : { coverage: Math.max(...coverages) },
+    ...configFile.shared && configFile.configFile !== void 0 ? { configFile: configFile.configFile } : {}
   };
 }
 function mergeRuns(inputs) {
@@ -7483,15 +7492,18 @@ function mergeRuns(inputs) {
   const carriedBy = /* @__PURE__ */ new Map();
   const empty = [];
   const offset = { workerId: 0, lane: 0 };
+  const perFile = !sharedConfigFile(inputs).shared;
   for (const input of inputs) {
     const from = trimRoot(input.run.root);
     const shift = { ...offset };
+    const configFile = perFile ? input.run.configFile : void 0;
     if (input.run.files.length === 0) {
       empty.push(input.path);
     }
     for (const file of input.run.files) {
       const path = reroot(file.file, from, root);
-      const moved = shifted(path === file.file ? file : { ...file, file: path }, shift, offset);
+      const placed2 = { ...file, file: path, ...configFile === void 0 ? {} : { configFile } };
+      const moved = shifted(placed2, shift, offset);
       const previous = kept.get(path);
       carriedBy.set(path, [...carriedBy.get(path) ?? [], input.path]);
       if (previous === void 0 || fileTotal(moved) > fileTotal(previous)) {
@@ -7726,13 +7738,22 @@ function vitestMajor3(cwd) {
 function versionFlags(cwd) {
   return (vitestMajor3(cwd) ?? 0) >= 5 ? ["--experimental.diagnostics=false"] : [];
 }
+function configArgs(config) {
+  return config === void 0 ? [] : ["--config", config, "--coverage.enabled=false"];
+}
 function fromRun(options, spawn, packageRoot) {
   const entry = join(options.cwd, "node_modules", "vitest", "vitest.mjs");
   const reporter = reporterPath(packageRoot);
-  const mismatch = bareRunWouldMeasureSomethingElse(options.profile);
+  const mismatch = options.config === void 0 ? bareRunWouldMeasureSomethingElse(options.profile) : void 0;
   if (mismatch !== void 0) {
     return failed(mismatch);
   }
+  if (options.config !== void 0 && !pathExists(resolve(options.cwd, options.config))) {
+    return failed(
+      `The report was measured with the Vitest config ${options.config}, and there is no such file in ${options.cwd}. Run the gate in the checkout the report was written for, or pass --command.
+Docs: ${NOTHING_TO_READ_DOCS}`
+    );
+  }
   if (!pathExists(entry)) {
     return failed(
       `No Vitest is installed in ${options.cwd}, so there is nothing to run. Install vitest there, then measure again.
@@ -7749,7 +7770,16 @@ Docs: ${NOTHING_TO_READ_DOCS}`
   removeFile(target);
   const spawned = timed(spawn, {
     command: process.execPath,
-    args: [entry, "run", "--reporter=default", `--reporter=${reporter}`, "--logHeapUsage", ...versionFlags(options.cwd), ...options.paths],
+    args: [
+      entry,
+      "run",
+      ...configArgs(options.config),
+      "--reporter=default",
+      `--reporter=${reporter}`,
+      "--logHeapUsage",
+      ...versionFlags(options.cwd),
+      ...options.paths
+    ],
     cwd: options.cwd,
     env: runEnv(options, target, reporter),
     shell: false
@@ -7809,15 +7839,66 @@ function readPerfRun(options, spawn = spawnProcess, packageRoot = ownPackageRoot
   const source = options.json === void 0 ? fromCommand(options, command, spawn, packageRoot) : fromFile(options.json, options.cwd);
   return source.ok ? { ...source, command } : source;
 }
-function perfRemeasure(options, spawn = spawnProcess, packageRoot = ownPackageRoot()) {
+function localRoot(root, cwd) {
+  const here = relative(cwd, root);
+  return root !== "" && !here.startsWith("..") && !isAbsolute(here) ? root : cwd;
+}
+function recordedConfigs(recorded, cwd) {
+  const root = localRoot(recorded.root, cwd);
+  const configs = /* @__PURE__ */ new Map();
+  for (const [path, file] of measuredFiles(recorded, cwd)) {
+    const configFile = file.configFile ?? recorded.configFile;
+    if (configFile !== void 0) {
+      configs.set(path, toPosix(relative(cwd, resolve(root, configFile))));
+    }
+  }
+  return configs;
+}
+function mergeMeasured(measured) {
+  return {
+    ok: true,
+    run: mergeRuns(measured.map((each, index) => ({ path: String(index), run: each.run }))).run,
+    runFailed: measured.some((each) => each.runFailed),
+    profiles: new Map(measured.flatMap((each) => [...new Map(each.profiles)]))
+  };
+}
+function underRecordedConfigs(configs, remeasure) {
+  return (paths) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      const config = configs.get(path);
+      if (config !== void 0) {
+        groups.set(config, [...groups.get(config) ?? [], path]);
+      }
+    }
+    if (groups.size === 0) {
+      return failed(
+        `None of the files to re-measure is in a report that recorded its Vitest config. Pass --command to re-measure them.
+Docs: ${NOTHING_TO_READ_DOCS}`
+      );
+    }
+    const measured = [];
+    for (const [config, group] of groups) {
+      const source = remeasure(group, config);
+      if (!source.ok) {
+        return source;
+      }
+      measured.push(source);
+    }
+    return mergeMeasured(measured);
+  };
+}
+function perfRemeasure(options, spawn = spawnProcess, packageRoot = ownPackageRoot(), recorded) {
   if (options.command !== void 0 && !commandTakesPaths(options.command)) {
     return void 0;
   }
+  const profileDir = join(options.cwd, "node_modules", ".cache", "vitest-auto-spy", `profiles-${process.pid}`);
+  const scoped = { ...options, json: void 0, out: void 0, profileDir };
   if (options.command === void 0 && options.json !== void 0) {
-    return void 0;
+    const configs = recorded === void 0 ? /* @__PURE__ */ new Map() : recordedConfigs(recorded, options.cwd);
+    return configs.size === 0 ? void 0 : underRecordedConfigs(configs, (paths, config) => readPerfRun({ ...scoped, paths, config }, spawn, packageRoot));
   }
-  const profileDir = join(options.cwd, "node_modules", ".cache", "vitest-auto-spy", `profiles-${process.pid}`);
-  return (paths) => readPerfRun({ ...options, json: void 0, out: void 0, paths, profileDir }, spawn, packageRoot);
+  return (paths) => readPerfRun({ ...scoped, paths }, spawn, packageRoot);
 }
 function perfAbIsolate(options, spawn, packageRoot = ownPackageRoot()) {
   if (options.command === void 0 && options.json !== void 0) {
@@ -7901,7 +7982,7 @@ function baselineRequest(args, cwd) {
     }
   };
 }
-var PROFILE_DIR_UNUSED = "warning  --profile-dir keeps the profiles the gate's confirmation pass records, and this run has no such pass: add --gate, without --no-confirm, on a source it can run again.\n";
+var PROFILE_DIR_UNUSED = "warning  --profile-dir keeps the profiles the gate's confirmation pass records, and this run has no such pass: add --gate, without --no-confirm, on a source it can run again \u2014 a run, a --command with {paths}, or a report that recorded its Vitest config.\n";
 function perfCommand(cwd, argv, io) {
   const args = parseArgs(argv);
   const format = formatOf(args);
@@ -7918,7 +7999,13 @@ function perfCommand(cwd, argv, io) {
     ...keepProfiles === void 0 ? {} : { keepProfiles: resolve(cwd, keepProfiles) }
   };
   const trustSingle = flagEnabled(args, "no-confirm");
-  const gate = flagEnabled(args, "gate") ? { options: gateOptions(args), remeasure: trustSingle ? void 0 : perfRemeasure(options, spawn), trustSingle } : void 0;
+  const handed = options.json === void 0 ? void 0 : readPerfRun(options, spawn);
+  const recorded = handed?.ok === true ? handed.run : void 0;
+  const gate = flagEnabled(args, "gate") ? {
+    options: gateOptions(args),
+    remeasure: trustSingle ? void 0 : perfRemeasure(options, spawn, ownPackageRoot(), recorded),
+    trustSingle
+  } : void 0;
   if (keepProfiles !== void 0 && gate?.remeasure === void 0) {
     io.err(PROFILE_DIR_UNUSED);
   }
@@ -7927,7 +8014,7 @@ function perfCommand(cwd, argv, io) {
   const minSeverity = minSeverityOf(args);
   const failOn = failOnOf(args);
   const codeQuality = flagValue(args, "code-quality");
-  return renderPerf(readPerfRun(options, spawn), profile, io, {
+  return renderPerf(handed ?? readPerfRun(options, spawn), profile, io, {
     budgets: gateOptions(args),
     ...format === "json" || format === "markdown" ? { format } : {},
     ...gate === void 0 ? {} : { gate },

package/dist/eslint-plugin.cjs

@@ -109,14 +109,14 @@ function rootCall(node) {
   }
   return current;
 }
-function isRunnerCall(node, members) {
-  return isMemberCall(node, RUNNERS, members);
+function isRunnerCall(node, members2) {
+  return isMemberCall(node, RUNNERS, members2);
 }
-function isMemberCall(node, objects, members) {
+function isMemberCall(node, objects, members2) {
   if (!isCallExpression(node) || !isMemberExpression(node.callee) || !isIdentifier(node.callee.object) || !isIdentifier(node.callee.property)) {
     return false;
   }
-  return objects.has(node.callee.object.name) && members.has(node.callee.property.name);
+  return objects.has(node.callee.object.name) && members2.has(node.callee.property.name);
 }
 var FUNCTION_TYPES = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression"]);
 function isFunctionNode(node) {
@@ -887,24 +887,44 @@ function configOf(value, projectRoot, workspaceRoot) {
   }
   return typeof value === "string" ? node_path.resolve(workspaceRoot, value) : void 0;
 }
-function targetConfigs(target, name, defaults, projectRoot, workspaceRoot) {
-  const byName = recordAt(defaults, name);
+function targetsOf(project) {
+  return recordAt(project, "architect") ?? recordAt(project, "targets") ?? {};
+}
+function stringsAt(value, key) {
+  const found = value?.[key];
+  return Array.isArray(found) ? found.filter((entry) => typeof entry === "string") : [];
+}
+function externalsOf(buildTarget, workspace) {
+  if (typeof buildTarget !== "string") {
+    return [];
+  }
+  const [projectName, targetName = "", configurationNames = ""] = buildTarget.split(":");
+  const target = recordAt(targetsOf(workspace.projects.get(projectName)), targetName);
+  const configurations = recordAt(target, "configurations");
+  return [recordAt(target, "options"), ...configurationNames.split(",").map((name) => recordAt(configurations, name.trim()))].reduce(
+    (externals, block) => block !== void 0 && "externalDependencies" in block ? stringsAt(block, "externalDependencies") : externals,
+    []
+  );
+}
+function lastSet(blocks, key, fallback) {
+  return blocks.reduce((value, block) => block !== void 0 && key in block ? block[key] : value, fallback);
+}
+function targetRuns(target, name, projectRoot, workspace) {
+  const byName = recordAt(workspace.defaults, name);
   const builder = target["builder"] ?? target["executor"] ?? byName?.["executor"];
   if (typeof builder !== "string" || !UNIT_TEST_BUILDERS.has(builder)) {
     return [];
   }
-  const blocks = [recordAt(recordAt(defaults, builder), "options"), recordAt(byName, "options"), recordAt(target, "options")];
-  const base = blocks.reduce(
-    (value, block) => block !== void 0 && "runnerConfig" in block ? block["runnerConfig"] : value,
-    false
-  );
-  const overrides = Object.values(recordAt(target, "configurations") ?? {}).filter(isJson).filter((configuration) => "runnerConfig" in configuration).map((configuration) => configuration["runnerConfig"]);
-  return [base, ...overrides].map((value) => configOf(value, projectRoot, workspaceRoot));
+  const blocks = [recordAt(recordAt(workspace.defaults, builder), "options"), recordAt(byName, "options"), recordAt(target, "options")];
+  const overrides = Object.values(recordAt(target, "configurations") ?? {}).filter(isJson).filter((configuration) => "runnerConfig" in configuration || "buildTarget" in configuration);
+  return [blocks, ...overrides.map((configuration) => [...blocks, configuration])].map((chain) => ({
+    config: configOf(lastSet(chain, "runnerConfig", false), projectRoot, workspace.root),
+    externals: externalsOf(lastSet(chain, "buildTarget", void 0), workspace)
+  }));
 }
-function projectConfigs(project, defaults, projectRoot, workspaceRoot) {
-  const targets = recordAt(project, "architect") ?? recordAt(project, "targets") ?? {};
-  return Object.entries(targets).flatMap(
-    ([name, target]) => isJson(target) ? targetConfigs(target, name, defaults, projectRoot, workspaceRoot) : []
+function projectRuns(project, projectRoot, workspace) {
+  return Object.entries(targetsOf(project)).flatMap(
+    ([name, target]) => isJson(target) ? targetRuns(target, name, projectRoot, workspace) : []
   );
 }
 function locate(directory) {
@@ -926,18 +946,27 @@ function runsFor(directory) {
   if (workspaceRoot === void 0) {
     return [];
   }
-  const defaults = recordAt(readJson(node_path.join(workspaceRoot, "nx.json")), "targetDefaults");
   const projects = WORKSPACE_FILES.map((name) => recordAt(readJson(node_path.join(workspaceRoot, name)), "projects")).find(
     (found) => found !== void 0
   );
+  const ownProject = projectDir === void 0 ? void 0 : readJson(node_path.join(projectDir, "project.json")) ?? {};
+  const byName = new Map(Object.entries(projects ?? {}).filter((entry) => isJson(entry[1])));
+  if (ownProject !== void 0 && typeof ownProject["name"] === "string" && !byName.has(ownProject["name"])) {
+    byName.set(ownProject["name"], ownProject);
+  }
+  const workspace = {
+    root: workspaceRoot,
+    defaults: recordAt(readJson(node_path.join(workspaceRoot, "nx.json")), "targetDefaults"),
+    projects: byName
+  };
   const fromWorkspace = Object.values(projects ?? {}).filter(isJson).flatMap((project) => {
     const root = node_path.resolve(workspaceRoot, typeof project["root"] === "string" ? project["root"] : "");
-    return contains(root, directory) ? projectConfigs(project, defaults, root, workspaceRoot) : [];
+    return contains(root, directory) ? projectRuns(project, root, workspace) : [];
   });
-  const fromProject = projectDir === void 0 ? [] : projectConfigs(readJson(node_path.join(projectDir, "project.json")) ?? {}, defaults, projectDir, workspaceRoot);
+  const fromProject = projectDir === void 0 || ownProject === void 0 ? [] : projectRuns(ownProject, projectDir, workspace);
   return [...fromWorkspace, ...fromProject];
 }
-function builderConfigs(filename) {
+function builderRuns(filename) {
   const directory = node_path.resolve(node_path.dirname(filename));
   const cached = runsCache.get(directory);
   if (cached !== void 0) {
@@ -947,6 +976,9 @@ function builderConfigs(filename) {
   runsCache.set(directory, runs);
   return runs;
 }
+function builderConfigs(filename) {
+  return builderRuns(filename).map((run) => run.config);
+}
 
 // src/lib/jsonc.ts
 function parseJsonc(text) {
@@ -1116,7 +1148,19 @@ var VITEST = /* @__PURE__ */ new Set(["vi", "vitest"]);
 var PATCHED = /* @__PURE__ */ new Set(["mock", "doMock", "importMock", "unmock", "doUnmock"]);
 var BLOCKED_SPECIFIER = /^[./]/;
 function runsUnderBuilder(context) {
-  return Reflect.get(Object(context.options[0]), "builder") === "unit-test" || builderConfigs(context.filename).length > 0;
+  return Reflect.get(Object(context.options[0]), "builder") === "unit-test" || builderRuns(context.filename).length > 0;
+}
+function matchesExternal(specifier, external) {
+  const star = external.indexOf("*");
+  if (star === -1) {
+    return specifier === external || specifier.startsWith(`${external}/`);
+  }
+  const prefix = external.slice(0, star);
+  const suffix = external.slice(star + 1);
+  return specifier.length >= prefix.length + suffix.length && specifier.startsWith(prefix) && specifier.endsWith(suffix);
+}
+function externalInEveryRun(runs, specifier) {
+  return runs.length > 0 && runs.every((run) => run.externals.some((external) => matchesExternal(specifier, external)));
 }
 function specifierOf(node) {
   if (node?.type === "ImportExpression") {
@@ -1135,7 +1179,7 @@ var noRelativeMockUnderBuilder = defineRule({
   schema: [{ type: "object", properties: { builder: { enum: ["unit-test"] } }, additionalProperties: false }],
   messages: {
     noRelativeMockUnderBuilder: "`vi.{{method}}('{{specifier}}')` throws under `@angular/build:unit-test`: the builder patches `vi.{{method}}` to reject every relative specifier (`The \"vi.mock\" and related methods are not supported for relative imports`), and no option lifts it. Replace the dependency through TestBed instead \u2014 `provideAutoSpy(Service)`, or `overrideComponentProvider` for a component\u2019s own provider.",
-    aliasMockUnderBuilder: "`vi.{{method}}('{{specifier}}')` does nothing under `@angular/build:unit-test`: `{{specifier}}` is the tsconfig path alias `{{alias}}` for a file of this workspace, which the builder compiles into the test bundle before Vitest could replace it \u2014 no error, and the real module runs. Replace the dependency through TestBed instead \u2014 `provideAutoSpy(Service)`, or `overrideComponentProvider` for a component\u2019s own provider."
+    aliasMockUnderBuilder: "`vi.{{method}}('{{specifier}}')` does nothing under `@angular/build:unit-test`: `{{specifier}}` is the tsconfig path alias `{{alias}}` for a file of this workspace, so the builder bundles it before Vitest can replace it, and the real module runs without an error. List it in `externalDependencies` of the `buildTarget`, or replace it through TestBed: `provideAutoSpy(Service)`, or `overrideComponentProvider` for a component\u2019s own provider."
   },
   create: (context) => runsUnderBuilder(context) ? {
     CallExpression: (node) => {
@@ -1149,7 +1193,7 @@ var noRelativeMockUnderBuilder = defineRule({
         return;
       }
       const alias = localAliasOf(context.filename, specifier);
-      if (alias !== void 0) {
+      if (alias !== void 0 && !externalInEveryRun(builderRuns(context.filename), specifier)) {
         context.report({ node, messageId: "aliasMockUnderBuilder", data: { method, specifier, alias: alias.pattern } });
       }
     }
@@ -2697,6 +2741,150 @@ var noHandAssignedGlobal = defineRule({
   }
 });
 
+// src/lib/eslint/inline-test-data.ts
+var DEFAULT_MAX_LINES = 20;
+var DEFAULT_REPEATS = 3;
+var DEFAULT_MIN_VALUES = 2;
+var MOCK_FILE = /(?:^|[/\\])__mocks__[/\\]|\.(?:fixtures?|mocks?)\.[cm]?[jt]sx?$/;
+var WIRING_KEYS = /* @__PURE__ */ new Set([
+  "bootstrap",
+  "declarations",
+  "exports",
+  "extraImports",
+  "extraProviders",
+  "imports",
+  "providers",
+  "schemas",
+  "viewProviders"
+]);
+var MOCK_FACTORIES = /* @__PURE__ */ new Set(["doMock", "mock"]);
+var WRAPPERS = /* @__PURE__ */ new Set(["TSAsExpression", "TSNonNullExpression", "TSSatisfiesExpression", "TSTypeAssertion"]);
+function isLiteral(node) {
+  return isObjectExpression(node) || isArrayExpression(node);
+}
+function members(node) {
+  return isObjectExpression(node) ? node.properties : node.elements.filter((element) => element !== null);
+}
+function container(node) {
+  let current = node.parent;
+  while (WRAPPERS.has(current.type) || current.type === "Property" || current.type === "SpreadElement") {
+    current = current.parent;
+  }
+  return current;
+}
+function isWiring(node) {
+  return WIRING_KEYS.has(propertyName(node) ?? "");
+}
+function isEachTable(node) {
+  return isCallExpression(node) && memberName(node.callee) === "each";
+}
+function isInMockFactory(node) {
+  return isFunctionNode(node) && isCallExpression(node.parent) && isRunnerCall(node.parent, MOCK_FACTORIES);
+}
+function holdsBehaviour(node) {
+  return members(node).some((member) => {
+    const value = propertyName(member) === void 0 ? member : propertyValue(member);
+    return Reflect.get(member, "method") === true || isFunctionNode(value) || isLiteral(value) && holdsBehaviour(value);
+  });
+}
+function isData(node) {
+  return members(node).length > 0 && !members(node).some(isWiring) && !holdsBehaviour(node) && !hasAncestor(node.parent, (ancestor) => isWiring(ancestor) || isEachTable(ancestor) || isInMockFactory(ancestor));
+}
+function leaves(node) {
+  return members(node).flatMap((member) => {
+    const value = propertyName(member) === void 0 ? member : propertyValue(member);
+    return isLiteral(value) ? leaves(value) : [value];
+  });
+}
+var isPrimitive = (node) => node.type === "Literal" || node.type === "UnaryExpression" && Reflect.get(Object(Reflect.get(node, "argument")), "type") === "Literal";
+function isRecord(node, minValues) {
+  const values = leaves(node);
+  return values.length >= minValues && values.some(isPrimitive);
+}
+function limits(context) {
+  const option = (name, fallback) => {
+    const value = Reflect.get(Object(context.options[0]), name);
+    return typeof value === "number" ? value : fallback;
+  };
+  return {
+    maxLines: option("maxLines", DEFAULT_MAX_LINES),
+    repeats: option("repeats", DEFAULT_REPEATS),
+    minValues: option("minValues", DEFAULT_MIN_VALUES)
+  };
+}
+var lineCount = (node) => node.loc.end.line - node.loc.start.line + 1;
+var within = (node, outer) => node.range[0] >= outer.range[0] && node.range[1] <= outer.range[1];
+var span = (node) => node.range[1] - node.range[0];
+var noInlineTestData = defineRule({
+  name: "no-inline-test-data",
+  description: "Keep long or repeated test data in a *.mock.ts file next to the spec",
+  schema: [
+    {
+      type: "object",
+      properties: {
+        maxLines: { type: "integer", minimum: 1 },
+        repeats: { type: "integer", minimum: 2 },
+        minValues: { type: "integer", minimum: 1 }
+      },
+      additionalProperties: false
+    }
+  ],
+  messages: {
+    longLiteral: "This literal spans {{lines}} lines of test data (the limit is {{max}}). Move it to a `*.mock.ts` file next to the spec and import it, so the test shows what it checks rather than the data it feeds in.",
+    repeatedLiteral: "`{{literal}}` is written {{count}} times in this file (first at line {{first}}). Export it once from a `*.mock.ts` file next to the spec and import it, so one edit reaches every test that uses it."
+  },
+  create: (context) => {
+    if (MOCK_FILE.test(context.filename)) {
+      return {};
+    }
+    const { maxLines, repeats, minValues } = limits(context);
+    const seen = /* @__PURE__ */ new Map();
+    const visit = (node) => {
+      if (isLiteral(container(node)) || !isData(node)) {
+        return;
+      }
+      if (lineCount(node) > maxLines) {
+        context.report({ node, messageId: "longLiteral", data: { lines: String(lineCount(node)), max: String(maxLines) } });
+      }
+    };
+    const collect = (node) => {
+      if (!isData(node) || !isRecord(node, minValues)) {
+        return;
+      }
+      const key = context.sourceCode.getText(node).replace(/\s+/g, "");
+      const group = seen.get(key);
+      if (group) {
+        group.rest.push(node);
+      } else {
+        seen.set(key, { first: node, rest: [] });
+      }
+    };
+    return {
+      "ObjectExpression, ArrayExpression": (node) => {
+        visit(node);
+        collect(node);
+      },
+      "Program:exit": () => {
+        const reported = [];
+        const groups = [...seen.values()].filter((group) => group.rest.length + 1 >= repeats).sort((a, b) => span(b.first) - span(a.first));
+        for (const { first, rest } of groups) {
+          if (reported.some((outer) => within(first, outer))) {
+            continue;
+          }
+          reported.push(first, ...rest);
+          for (const node of rest) {
+            context.report({
+              node,
+              messageId: "repeatedLiteral",
+              data: { literal: excerpt(context, node, 40), count: String(rest.length + 1), first: String(first.loc.start.line) }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/lib/eslint/jasmine-compat.ts
 var PACKAGES = ["vitest-auto-spy", "vitest-auto-spies"];
 function entries(...subpaths) {
@@ -3228,20 +3416,23 @@ function initialisedLate(variable) {
   const declarator = definition.node;
   return isTopLevel(declarator.parent) && !isHoisted(declarator.init);
 }
+function isInstanceFieldValue(node, child) {
+  return (node.type === "PropertyDefinition" || node.type === "AccessorProperty") && Reflect.get(node, "static") !== true && Reflect.get(node, "value") === child;
+}
 function isDeferred(identifier, factory) {
-  for (let current = identifier.parent; current !== factory; current = current.parent) {
-    if (isFunctionNode(current)) {
+  for (let child = identifier, current = identifier.parent; current !== factory; child = current, current = current.parent) {
+    if (isFunctionNode(current) || isInstanceFieldValue(current, child)) {
       return true;
     }
   }
   return false;
 }
-function within(node, container) {
-  return node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
+function within2(node, container2) {
+  return node.range[0] >= container2.range[0] && node.range[1] <= container2.range[1];
 }
 function eagerRead(variable, factory) {
   return variable.references.find(
-    (reference) => !reference.writeExpr && Reflect.get(reference, "isValueReference") !== false && within(reference.identifier, factory) && !isDeferred(reference.identifier, factory)
+    (reference) => !reference.writeExpr && Reflect.get(reference, "isValueReference") !== false && within2(reference.identifier, factory) && !isDeferred(reference.identifier, factory)
   )?.identifier;
 }
 function outerScopes(context, factory) {
@@ -3605,11 +3796,11 @@ function isTestCallbackParameter(context, node, callbacks) {
 function readsTheTestContext(context, callback, parameter) {
   const scope = context.sourceCode.getScope(callback);
   const references = scope.variables.flatMap((variable) => variable.name === parameter.name ? variable.references : []);
-  const members = references.flatMap(({ identifier }) => {
+  const members2 = references.flatMap(({ identifier }) => {
     const member = identifier.parent;
     return isMemberExpression(member) && member.object === identifier ? [memberName(member)] : [];
   });
-  return members.length > 0 && !members.includes("fail") && !references.some(({ identifier }) => isCallee(identifier));
+  return members2.length > 0 && !members2.includes("fail") && !references.some(({ identifier }) => isCallee(identifier));
 }
 var noDoneCallback = defineRule({
   name: "no-done-callback",
@@ -3813,13 +4004,13 @@ var OVERRIDES = /* @__PURE__ */ new Set([
   "overrideTemplateUsingTestingModule"
 ]);
 var RESETS = /* @__PURE__ */ new Set(["resetTestingModule"]);
-function testBedCall(members) {
-  return `CallExpression[callee.object.name="TestBed"][callee.property.name=/^(${[...members].join("|")})$/]`;
+function testBedCall(members2) {
+  return `CallExpression[callee.object.name="TestBed"][callee.property.name=/^(${[...members2].join("|")})$/]`;
 }
 var OVERRIDES_THE_MODULE = `${testBedCall(OVERRIDES)},CallExpression[callee.type="Identifier"][callee.name="overrideComponentProvider"]`;
 var RESETS_THE_MODULE = testBedCall(RESETS);
-function within2(node, container) {
-  return node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
+function within3(node, container2) {
+  return node.range[0] >= container2.range[0] && node.range[1] <= container2.range[1];
 }
 var HOOKS4 = /* @__PURE__ */ new Set(["beforeAll", "beforeEach"]);
 var SUITES = /* @__PURE__ */ new Set(["describe", "suite"]);
@@ -3851,10 +4042,10 @@ function runsBeforeEveryTest(node) {
   return enclosing !== void 0 && isNamedCall(enclosing.parent, HOOKS4);
 }
 function resetsTheTestingModule(resets, suite) {
-  return resets.some((reset) => within2(reset, suite));
+  return resets.some((reset) => within3(reset, suite));
 }
 function runsFirst(override, injection, hook) {
-  return within2(override, injection) || within2(override, hook) && override.range[1] < injection.range[0];
+  return within3(override, injection) || within3(override, hook) && override.range[1] < injection.range[0];
 }
 function enclosingBeforeCreate(node) {
   const setup = enclosingFunction(node);
@@ -3862,7 +4053,7 @@ function enclosingBeforeCreate(node) {
 }
 function injectsBeforeSetupOverride(injection, { overrides }) {
   const setup = enclosingBeforeCreate(injection);
-  return setup !== void 0 && overrides.some((override) => within2(override, setup) && override.range[0] > injection.range[1]);
+  return setup !== void 0 && overrides.some((override) => within3(override, setup) && override.range[0] > injection.range[1]);
 }
 function breaksAnOverride(injection, { overrides, resets }) {
   const hook = enclosingCallOf(injection, HOOKS4);
@@ -3873,7 +4064,7 @@ function breaksAnOverride(injection, { overrides, resets }) {
   if (resetsTheTestingModule(resets, suite)) {
     return false;
   }
-  return overrides.some((override) => within2(override, suite) && !runsFirst(override, injection, hook));
+  return overrides.some((override) => within3(override, suite) && !runsFirst(override, injection, hook));
 }
 
 // src/lib/eslint/no-inject-before-override.ts
@@ -5934,18 +6125,18 @@ var SKIPPED_MEMBERS = /* @__PURE__ */ new Set(["skip", "todo"]);
 var EXISTS = /* @__PURE__ */ new Set(["toBeDefined", "toBeInstanceOf", "toBeTruthy"]);
 var MISSING = /* @__PURE__ */ new Set(["toBeFalsy", "toBeNull", "toBeUndefined"]);
 function calleeChain(node) {
-  const members = [];
+  const members2 = [];
   let current = node.callee;
   for (; ; ) {
     if (isIdentifier(current)) {
-      return { members, root: current.name };
+      return { members: members2, root: current.name };
     }
     if (isMemberExpression(current)) {
       const name = memberName(current);
       if (name === void 0) {
         return void 0;
       }
-      members.unshift(name);
+      members2.unshift(name);
       current = current.object;
       continue;
     }
@@ -6291,9 +6482,9 @@ function variableRewrite(context, call, id, method) {
   }
   const declaration = declarator.parent;
   const writes = variable.references.filter((reference) => reference.writeExpr);
-  const members = variable.references.flatMap((reference) => reference.writeExpr ? [] : [reference.identifier.parent]);
-  const reads = members.filter((member) => isMemberExpression(member) && readsMethod(member, method));
-  if (writes.length !== 1 || !writes.every((write) => write.writeExpr === call) || reads.length !== members.length || !DECLARATION_KINDS.has(String(Reflect.get(declaration, "kind"))) || declaration.parent.type === "ExportNamedDeclaration") {
+  const members2 = variable.references.flatMap((reference) => reference.writeExpr ? [] : [reference.identifier.parent]);
+  const reads = members2.filter((member) => isMemberExpression(member) && readsMethod(member, method));
+  if (writes.length !== 1 || !writes.every((write) => write.writeExpr === call) || reads.length !== members2.length || !DECLARATION_KINDS.has(String(Reflect.get(declaration, "kind"))) || declaration.parent.type === "ExportNamedDeclaration") {
     return void 0;
   }
   const annotation = annotationEdit(context, declarator.id, method);
@@ -6725,6 +6916,7 @@ var rules = {
   "no-relative-mock-under-builder": noRelativeMockUnderBuilder,
   "no-real-wait-in-test": noRealWaitInTest,
   "no-disabled-testbed-teardown": noDisabledTestbedTeardown,
+  "no-inline-test-data": noInlineTestData,
   ...jasmineRules
 };
 
@@ -6786,7 +6978,8 @@ var recommendedRules = {
   [`${PLUGIN_NAME}/no-outer-binding-in-mock-factory`]: "error",
   [`${PLUGIN_NAME}/no-relative-mock-under-builder`]: "error",
   [`${PLUGIN_NAME}/no-real-wait-in-test`]: "warn",
-  [`${PLUGIN_NAME}/no-disabled-testbed-teardown`]: "error"
+  [`${PLUGIN_NAME}/no-disabled-testbed-teardown`]: "error",
+  [`${PLUGIN_NAME}/no-inline-test-data`]: "warn"
 };
 var typeErrorRules = {
   [`${PLUGIN_NAME}/prefer-as-spy`]: "error",

package/dist/perf-reporter.d.ts

@@ -64,6 +64,8 @@ interface PerfFile {
     readonly setupFetch?: number;
     /** Failed attempts before a pass, summed over the file's tests. */
     readonly retries?: number;
+    /** Set only by `mergeRuns`, when the merged reports ran different configs: this file's, as `PerfRun.configFile`. */
+    readonly configFile?: string;
 }
 /** What the run was configured with, read from Vitest's resolved config rather than the config text. */
 interface PerfConfig {
@@ -108,6 +110,8 @@ interface PerfRun {
     readonly hung?: boolean;
     /** Milliseconds coverage took after the last file: generating the map, then writing the reports. */
     readonly coverage?: number;
+    /** The Vitest config file the run loaded, relative to `root` with `/` separators; absent without one. */
+    readonly configFile?: string;
 }
 
 interface PerfDiagnostic {
@@ -208,6 +212,12 @@ interface PerfVitest {
         readonly workersSpawned?: number;
     };
     readonly projects?: readonly PerfProject[];
+    /** Vite's resolved config holds the file Vitest loaded, on Vitest 4 and 5 alike; `configFile` is unset without one. */
+    readonly vite?: {
+        readonly config?: {
+            readonly configFile?: string | undefined;
+        };
+    };
 }
 declare class PerfReporter {
     #private;

package/dist/perf-reporter.js

@@ -1,4 +1,4 @@
-import { join, dirname, sep, basename } from 'node:path';
+import { join, dirname, relative, sep, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { mkdirSync, writeFileSync, renameSync, rmSync, realpathSync, statSync } from 'node:fs';
 
@@ -39,7 +39,7 @@ var PERF_OUTPUT_ENV = "VITEST_AUTO_SPY_PERF_OUT";
 var PERF_PROFILE_ENV = "VITEST_AUTO_SPY_PERF_PROFILE";
 var PERF_ISOLATE_ENV = "VITEST_AUTO_SPY_PERF_ISOLATE";
 var AUTO_SPY_META_KEY = "autoSpyMs";
-var PERF_FORMAT_VERSION = 5;
+var PERF_FORMAT_VERSION = 6;
 var CASE_FLOOR_MS = 100;
 var CASES_PER_FILE = 5;
 
@@ -208,6 +208,10 @@ function configOf(vitest) {
     ...provided === void 0 ? {} : { provided: Object.keys(provided).filter((key) => provided[key] === true) }
   };
 }
+function configFileOf(vitest) {
+  const file = vitest.vite?.config?.configFile;
+  return file === void 0 ? void 0 : toPosix(relative(vitest.config.root, file));
+}
 function startupOf(vitest) {
   const { startupTime, workersSpawned } = vitest.state;
   return startupTime === void 0 || workersSpawned === void 0 ? void 0 : { ms: startupTime, workers: workersSpawned };
@@ -232,9 +236,11 @@ var PerfReporter = class {
   #ended;
   #coverage;
   #hung = false;
+  #configFile;
   onInit(vitest) {
     this.#vitest = vitest;
     this.#start = Date.now();
+    this.#configFile = configFileOf(vitest);
     if (target() === void 0 && !profiling()) {
       return;
     }
@@ -349,7 +355,8 @@ var PerfReporter = class {
       ...partial ? { partial: true } : {},
       ...end === void 0 ? {} : { end },
       ...this.#hung ? { hung: true } : {},
-      ...this.#coverage === void 0 ? {} : { coverage: this.#coverage }
+      ...this.#coverage === void 0 ? {} : { coverage: this.#coverage },
+      ...this.#configFile === void 0 ? {} : { configFile: this.#configFile }
     };
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.52.0",
+  "version": "5.54.0",
   "description": "Auto-generate fully-typed test spies from a class — across Vitest, Bun, node:test and Rstest, with Angular/NestJS/React/Vue/Svelte recipes. Drop-in replacement for jest-auto-spies and jasmine-auto-spies.",
   "keywords": [
     "auto-mock",
@@ -302,6 +302,8 @@
     "test:happy-dom": "vitest run --config vitest.happy-dom.config.mts",
     "test:invariants": "vitest run --config vitest.invariants.config.mts",
     "test:types": "vitest run --config vitest.types.config.mts",
+    "test:mutation": "stryker run --incremental",
+    "test:mutation:survivors": "node scripts/mutation-survivors.mjs",
     "types:budget": "node scripts/check-type-budget.mjs",
     "test:node": "node --import ./scripts/node-ts-resolve.mjs --test \"src/node-tests/*.node.test.ts\"",
     "test:bun": "bun test ./src/bun-tests/core.bun.test.ts ./src/bun-tests/rxjs.bun.test.ts ./src/bun-tests/jasmine.bun.test.ts ./src/bun-tests/console-nest.bun.test.ts ./src/bun-tests/adopt-mock.bun.test.ts ./src/bun-tests/adapter-contract.bun.test.ts",
@@ -388,6 +390,9 @@
     "@eslint/js": "^10.0.1",
     "@happy-dom/global-registrator": "^20.14.0",
     "@rstest/core": "^0.11.12",
+    "@stryker-mutator/api": "10.0.0",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/jsdom": "^30.0.0",
     "@types/node": "^24.13.3",

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

@@ -501,7 +501,7 @@ npx vitest-auto-spy codemod --verify  # after a migration: anything the transfor
 Most of this library's guarantees are type-level, so a green run that does not type-check is not
 done. Report failures with their output rather than describing them as passing.
 
-**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The fifty-six rules in
+**After any `eslint --fix` over specs, run `npx tsc --noEmit`.** The fifty-seven rules in
 `vitest-auto-spy/eslint-plugin` are lint, not typecheck: `no-mocked-for-spy` rewrites a declaration
 to `Spy<T>` and cannot see what the name is assigned two lines below, so a clean lint pass is not
 evidence that the types still hold. Where it cannot prove the rename it downgrades to a suggestion —
@@ -540,6 +540,8 @@ with `createMock<…>()`. A value outside the declared type on purpose keeps the
 `// eslint-disable-next-line vitest-auto-spy/no-ts-expect-error-on-double -- <why>`.
 `no-constant-expect` reports `expect(true).toBe(true)` and its relatives — assert on what the code
 produced, or `expect.fail(…)` for a branch the test must not reach.
+`no-inline-test-data` (`warn`) reports a data literal over 20 lines, or the same literal three times
+in one spec — export it once from `<name>.mock.ts` next to the spec and import it there.
 `no-redundant-smoke-test` reports the generated `it('should create', () => expect(x).toBeTruthy())`
 where the block — its nested `describe`s counted — already has tests that run the same `beforeEach`:
 they fail first on a subject that came back nullish, and say what they were doing. Delete it; keep it