vitest-auto-spy 5.51.0 → 5.53.0

package/CHANGELOG.md

@@ -10,6 +10,46 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [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
+
+- **`init` says when git will not show what it wrote.** A created or updated file that is ignored
+  and not tracked (`.git/info/exclude`, a global excludes file) ends its row with _not tracked by
+  git, so `git diff` will not show this change_, and an empty `git diff` no longer reads as "nothing
+  changed".
+
+### Documentation
+
+- **When `prepareShallow` pays off**: only when the tests share non-empty `providers` or `imports`.
+  With a different `inputs` per call, or none, it only renames `renderShallow`.
+
 ## [5.51.0] - 2026-09-29
 
 ### Changed
@@ -6617,7 +6657,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.51.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.53.0...HEAD
+[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
 [5.49.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.48.0...v5.49.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/angular.md

@@ -267,6 +267,8 @@ describe renders the same component with the same providers, `prepareShallow(Com
 them once and each test calls `.create({ inputs: { … } })` — the overrides replace a key outright,
 one instance per test. `create({ providers })` replaces the prepared list; `create({ extraProviders,
 extraImports })` appends to it, so for one token the per-test provider wins (type `ShallowOverrides<T>`).
+It pays off only on shared non-empty `providers` / `imports`: when each call passes its own `inputs`
+or none, `prepareShallow(X)` only renames `renderShallow(X)` — keep `renderShallow`.
 
 ### Observers the component constructs itself
 

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/angular.d.ts

@@ -1,5 +1,5 @@
 import './vitest-mock-types-B17-xaWt.js';
-export { w as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, x as provideAutoSpyForToken, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-DDzbFmGc.js';
+export { w as AngularTokenProvider, A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, x as provideAutoSpyForToken, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-CM-leczv.js';
 import { o as DeepPartial, m as ClassType, C as ClassSpyConfiguration, S as Spy, t as OnlyMethodKeysOf, h as AddSpyMethodsByReturnTypes, r as NotAPublicKey } from './types-qYoxQi5C.js';
 export { J as SubjectOf } from './types-qYoxQi5C.js';
 import { InjectionToken, Provider, Type, WritableSignal, Signal } from '@angular/core';

package/dist/bun-angular.d.ts

@@ -4,7 +4,7 @@ export { A as AutoMockConfiguration, a as AutoMocked, b as AutoSpyDefaultEntry,
 export { c as createFunctionSpy, d as describeDuplicateCopies, g as getPackageCopies } from './package-identity-COBYU0WJ.js';
 export { A as AccessorImplementations, O as OutsideHookReaction, R as RestoreProp, c as countMockedProps, m as mockAccessorsProp, a as mockReadonlyProp, b as mockReadonlyPropGetter, d as mockValueProp, r as reportPropsOutsideHooks, e as restoreMockedProps } from './prop-mock-CE9gNMPY.js';
 export { C as CreateNestUnitOptions, N as NestUnit, a as NestUnitClass, b as NestUnitProvider, c as NestUnitSpies, d as createNestUnit } from './nest-unit-Bg6JWPgu.js';
-export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-DDzbFmGc.js';
+export { A as AngularValueProvider, a as AutoSpiedInstance, C as ComponentInputs, b as CreateWithAutoSpiesOptions, E as ElementConstructor, N as NativeElementHolder, P as PreparedShallow, R as RenderShallowOptions, c as ResourceStatusLike, d as RunCounter, S as SettleResourceOptions, e as ShallowOverrides, f as ShallowRender, g as SpyRegistry, h as StableOptions, i as createWithAutoSpies, j as flushEffects, k as hostElement, l as injectSpy, p as prepareShallow, m as provideAutoSpy, q as queryElement, r as renderShallow, n as runEffect, s as setInputs, o as settleResource, t as stable, u as trackEffectRuns, v as trackRecomputations } from './track-signal-runs-CM-leczv.js';
 import '@angular/core';
 import '@angular/core/testing';
 

package/dist/cli.js

@@ -1654,7 +1654,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.50.0";
+var EXPORT_MAP_VERSION = "5.52.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",
@@ -3853,6 +3853,13 @@ Options
   -v, --version  Print the installed version.
 
 Docs  https://asdalexey.github.io/vitest-auto-spy`;
+function ignoredByGit(cwd, paths) {
+  if (paths.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const result = spawnSync("git", ["check-ignore", "--", ...paths], { cwd, encoding: "utf8" });
+  return new Set(result.status === 0 ? result.stdout.split("\n").filter((line) => line !== "") : []);
+}
 var MARKER_BEGIN = /<!-- vitest-auto-spy:begin[^>]*-->/;
 var MARKER_END = "<!-- vitest-auto-spy:end -->";
 function digest(body) {
@@ -4305,10 +4312,20 @@ function unmatchedWarnings(only) {
     return guess === void 0 ? `--only ${entry} selects no file init writes. Known targets: ${known.join(", ")}.` : `--only ${entry} selects no file init writes. Did you mean ${guess}?`;
   });
 }
+var UNTRACKED_NOTE = "not tracked by git, so `git diff` will not show this change";
+function markUntracked(cwd, actions) {
+  const ignored = ignoredByGit(
+    cwd,
+    actions.filter((action) => action.status === "created" || action.status === "updated").map((action) => action.path)
+  );
+  return actions.map((action) => ignored.has(action.path) ? { ...action, note: `${action.note} \u2014 ${UNTRACKED_NOTE}` } : action);
+}
 var PENDING = /* @__PURE__ */ new Set(["created", "edited", "stale", "updated"]);
 function runInit(profile, version, options) {
   const plans = buildPlans(profile, version, options.only).map((plan) => options.uninstall ? uninstallPlan(plan) : guardHandEdited(plan));
-  const { actions, failures } = applyPlans(profile.cwd, plans, options);
+  const applied = applyPlans(profile.cwd, plans, options);
+  const actions = markUntracked(profile.cwd, applied.actions);
+  const { failures } = applied;
   const pending = options.check && actions.some((action) => PENDING.has(action.status));
   return {
     actions,

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/{track-signal-runs-DDzbFmGc.d.ts → track-signal-runs-CM-leczv.d.ts}

@@ -379,6 +379,9 @@ interface PreparedShallow<T> {
  * `TestBed.resetTestingModule()`, because Angular refuses a second `configureTestingModule` on an
  * already-instantiated module.
  *
+ * It pays off only when the tests share non-empty `providers` / `imports`. When each call passes its
+ * own `inputs` or none, it only renames `renderShallow(Component)`.
+ *
  * ```ts
  * const prepare = prepareShallow(TaskListComponent, { providers: [provideAutoSpy(TaskService)] });
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-auto-spy",
-  "version": "5.51.0",
+  "version": "5.53.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