vitest-auto-spy 5.26.0 → 5.28.0

package/AGENTS.md

@@ -4421,7 +4421,9 @@ Full reference: <https://asdalexey.github.io/vitest-auto-spy/utilities/cli>.
 - **The scan does not descend into a nested repository or a git worktree.** A tree carrying
   worktrees under it listed every file twice, so `doctor` reported each import graph in duplicate and
   `codemod --write` would have rewritten specs on another branch. A `.git` entry is a stop, whether
-  it is a directory (a nested clone) or a file (a worktree). Past 50 000 files the scan still
+  it is a directory (a nested clone) or a file (a worktree). Directories git ignores are skipped too
+  — every `.gitignore` from the scan root down, `.git/info/exclude` and the per-user
+  `core.excludesFile`, directories only, so an ignored file is still listed. Past 50 000 files the scan still
   truncates, and `doctor` reports that as a `scan-cap-reached` warning (exit 1) rather than a clean
   result; `VITEST_AUTO_SPY_SCAN_CAP` raises the cap.
 - **A path that matches no file is an error, exit 2.** _Nothing left to migrate_ off a path nobody

package/CHANGELOG.md

@@ -10,6 +10,64 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.28.0] - 2026-09-23
+
+### Changed
+
+- **The `doctor` and `codemod` repository scan honours git's exclude rules below the root, not only
+  the root `.gitignore`.** A nested `.gitignore` is read relative to its own directory and overrides a
+  shallower one; below every `.gitignore` sit the root's `.git/info/exclude` (followed through a
+  worktree's `.git` file) and the per-user `core.excludesFile` (else `$XDG_CONFIG_HOME/git/ignore`),
+  as in git. A monorepo keeping `/generated` in `libs/app/.gitignore`, or a checkout excluding local
+  directories through `info/exclude` or a global ignore, had them counted, walked and offered to
+  `codemod --write` — so a local run reported more files than CI did. Still no `git` process and no
+  dependency, and still directories only: an ignored file is listed. A `.gitignore` above the scan
+  root is not read, and `[include]` in git config is not followed.
+- **`doctor --json` and `doctor --markdown` name the flag they meant.** Both are still refused, exit 2,
+  like any unknown flag; the error now ends with ``Did you mean `--format json`?``.
+
+### Fixed
+
+- **`init --check` and `init --dry-run` no longer seem to disagree over a version-only change.** A
+  block whose marker differs only in `v=` is `unchanged` under `--check` (by design since 5.19.0: CI
+  must not go red on a release that changed no advice) and `updated` under `--dry-run`, which read as
+  a contradiction. Both now say _only the version stamp differs_ in the file's note.
+- **The `tsconfig` glob check exempts a pattern into an ignored directory that does not exist yet.**
+  `src/generated/**/*.ts` in `include`, or a `files` entry there, was reported as matching nothing or
+  missing whenever `doctor` ran before the code generator — in CI, typically — although
+  `src/generated/` is in `.gitignore`: the exemption only knew directories the scan had pruned.
+- **`prefer-create-spy-from-class` at `{ minRunnerFns: 1 }` leaves a one-member literal passed to a
+  typed parameter of a helper the same file declares alone.** `createDefaultOptions({ changeOptionsCallback:
+  callback })` over `const createDefaultOptions = (overrides?: Partial<InfoboxOptions>) => …` is
+  checked against that type already. An untyped parameter, a rest parameter, an inline object type
+  of mocks and an imported helper still report — the last is out of reach of a syntax-only rule.
+
+## [5.27.0] - 2026-09-23
+
+### Changed
+
+- **The `doctor` and `codemod` repository scan honours the root `.gitignore` for directories.** The
+  hardcoded skip list only knew the usual build and store names, so a repository's own generated or
+  local output (`src/generated/`, `/reports`, `tmp-*/`) was read as source: counted in the report,
+  walked by the import graph and offered to `codemod --write`. The file is parsed directly, with no
+  `git` process and no dependency: comments, `!` negations with the last match winning, anchored and
+  unanchored patterns, `*`, `?`, `**` and bracket classes. Only the root file and only directories
+  are honoured — an ignored file is still listed. A pattern with a `\` escape or a POSIX class is
+  dropped, which only means scanning more, and a `!` rule that cannot be read disables the whole
+  file rather than prune a directory git keeps. `perf-merge`'s report listing is unaffected.
+
+### Fixed
+
+- **The `tsconfig` glob check no longer reports a pattern it could never see matched.** A pattern
+  inside a skipped directory below the root (`libs/app/out-tsc/**/*.ts`) or inside a directory the
+  root `.gitignore` excludes is exempt, and so is a `files` entry there — both were reported as
+  matching nothing or missing, although the scan had simply not descended into them.
+- **The `prefer-create-spy-from-class` reference lists every factory whose arguments are exempt.**
+  The built-in doubles and stubs (`createComponentStub`, `createDirectiveHost`, `createWindowDouble`,
+  `provideRouterDouble` and the rest) were exempt in the rule but missing from the docs, which also
+  still said "four shapes" over a list of eleven. The Russian page gained the four exemptions it was
+  missing (`vi.hoisted`, the options bag, `createFixture`, an RxJS observer).
+
 ## [5.26.0] - 2026-09-23
 
 ### Changed
@@ -7770,7 +7828,9 @@ by hand there, in more than one place, by more than one person.
   `mockAccessorsProp`.
 - Dual ESM + CJS build with type declarations; 100% test coverage.
 
-[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.26.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.28.0...HEAD
+[5.28.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.27.0...v5.28.0
+[5.27.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.26.0...v5.27.0
 [5.26.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.25.0...v5.26.0
 [5.25.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.24.0...v5.25.0
 [5.24.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.23.0...v5.24.0

package/README.md

@@ -139,7 +139,7 @@ includes — that one import is what keeps `returnSubject()` typed as rxjs's own
   - [Which file your agent reads](#which-file-your-agent-reads)
   - [Install it in your agent](#install-it-in-your-agent)
   - [OpenAI Codex](#openai-codex)
-  - [GLM (z.ai), Kimi K2 and other Claude-compatible models](#glm-zai-kimi-k2-and-other-claude-compatible-models)
+  - [GLM (z.ai), Kimi K3 and other Claude-compatible models](#glm-zai-kimi-k3-and-other-claude-compatible-models)
   - [Gemini CLI](#gemini-cli)
   - [Claude Code plugin](#claude-code-plugin)
 - [Availability](#availability)
@@ -372,8 +372,10 @@ that matches no file is the same kind of error, because _Nothing left to migrate
 read is not a result. A red suite under `perf --gate` lands there too: a failing test is measured
 until its timeout, and 30 s of timeout looks exactly like 30 s of slow code.
 
-The repository scan behind `doctor` and `codemod` stops at a nested repository or a git worktree — a
-`.git` entry, whether it is a directory or a file. A tree carrying worktrees under it used to be
+The repository scan behind `doctor` and `codemod` skips the directories git ignores — every
+`.gitignore` from the root down, `.git/info/exclude` and the per-user `core.excludesFile`, read as
+files with no `git` process — and stops at a nested repository or a git worktree — a `.git` entry,
+whether it is a directory or a file. A tree carrying worktrees under it used to be
 listed twice, so `doctor` reported every import graph in duplicate and `codemod --write` could have
 rewritten specs on someone else's branch.
 
@@ -653,7 +655,7 @@ served — including the ones your teammates use and you do not.
 | ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
 | **Claude Code**                                                     | `CLAUDE.md` — project, `.claude/CLAUDE.md` and `~/.claude/CLAUDE.md`, all concatenated                                                                                                    | **No.** Bridge with an `@AGENTS.md` import line, or a symlink     |
 | **OpenAI Codex** — the `codex` CLI, the IDE extension, Codex cloud  | `AGENTS.md`, one per directory from the git root down to the cwd ([below](#openai-codex))                                                                                                 | native                                                            |
-| **GLM (z.ai coding plan)**, **Kimi K2**                             | whatever their client reads — inside Claude Code that is `CLAUDE.md` ([below](#glm-zai-kimi-k2-and-other-claude-compatible-models))                                                       | through the client                                                |
+| **GLM (z.ai coding plan)**, **Kimi K3**                             | whatever their client reads — inside Claude Code that is `CLAUDE.md` ([below](#glm-zai-kimi-k3-and-other-claude-compatible-models))                                                       | through the client                                                |
 | **Cursor**                                                          | root `AGENTS.md`; `.cursor/rules/*.mdc` for glob-scoped rules                                                                                                                             | native — and it applies a root `CLAUDE.md` the same always-on way |
 | **GitHub Copilot**                                                  | root `AGENTS.md`; `.github/copilot-instructions.md`                                                                                                                                       | native, coding agent included                                     |
 | **OpenCode**                                                        | `AGENTS.md`, then `CLAUDE.md`, per directory upwards                                                                                                                                      | native                                                            |
@@ -708,7 +710,7 @@ Then, per tool — everything in the right-hand column is optional on top of tho
 | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | **Claude Code**                             | `/plugin marketplace add ASDAlexey/vitest-auto-spy`, then `/plugin install vitest-auto-spy@vitest-auto-spy` — [the skill](#claude-code-plugin), no project files touched |
 | **OpenAI Codex**                            | nothing more; optionally `~/.codex/config.toml` from [below](#openai-codex)                                                                                              |
-| **GLM (z.ai)**, **Kimi K2**                 | identical to Claude Code — same client, same plugin command                                                                                                              |
+| **GLM (z.ai)**, **Kimi K3**                 | identical to Claude Code — same client, same plugin command                                                                                                              |
 | **Cursor**                                  | `.cursor/rules/vitest-auto-spy.mdc` to load it only for spec files (see below)                                                                                           |
 | **GitHub Copilot**                          | `.github/instructions/vitest-auto-spy.instructions.md` (see below)                                                                                                       |
 | **Cline**                                   | `.clinerules/vitest-auto-spy.md` — the same three lines, plus `paths: ["**/*.spec.ts","**/*.test.ts"]`                                                                   |
@@ -788,14 +790,14 @@ which is exactly why this reference ships inside the tarball rather than only on
 `node_modules/vitest-auto-spy/AGENTS.md` is on disk the moment the setup script has installed
 dependencies, so nothing has to be fetched.
 
-### GLM (z.ai), Kimi K2 and other Claude-compatible models
+### GLM (z.ai), Kimi K3 and other Claude-compatible models
 
 GLM is a **model**, not an agent — the thing that reads files is the client you run it in.
 
 The z.ai coding plan runs GLM **inside Claude Code**, by pointing `ANTHROPIC_BASE_URL` (with
 `ANTHROPIC_AUTH_TOKEN`) at z.ai's Anthropic-compatible endpoint. File discovery is untouched by
 that: `CLAUDE.md`, `.claude/skills/` and the [plugin](#claude-code-plugin) below behave exactly as
-they do on Claude, because it is the same client. Kimi K2 driven through Claude Code is the same
+they do on Claude, because it is the same client. Kimi K3 driven through Claude Code is the same
 story — and there the skill and the plugin are worth more than a pasted snippet, because they load
 only when a spec actually mentions the library and cost no context the rest of the time.
 

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { resolve, join, dirname, relative, posix, isAbsolute, sep } from 'node:path';
-import { readFileSync, statSync, mkdirSync, writeFileSync, readdirSync, existsSync, lstatSync, rmSync } from 'node:fs';
+import { resolve, join, dirname, posix, isAbsolute, relative, sep } from 'node:path';
+import { readFileSync, statSync, mkdirSync, writeFileSync, existsSync, lstatSync, rmSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
@@ -98,6 +99,109 @@ function flagEnabled(args, name) {
   }
   return value !== "false";
 }
+
+// src/cli/gitignore.ts
+function parseGitignore(text) {
+  const rules = [];
+  for (const raw of text.split("\n")) {
+    const line = raw.trimEnd();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    const negated = line.startsWith("!");
+    const pattern = toRegExp(negated ? line.slice(1) : line);
+    if (pattern !== void 0) {
+      rules.push({ negated, pattern });
+    } else if (negated) {
+      return void 0;
+    }
+  }
+  return rules;
+}
+function isIgnoredBy(sources, path) {
+  let ignored = false;
+  for (const { base, rules } of sources) {
+    if (base === "" || path.startsWith(`${base}/`)) {
+      const local = base === "" ? path : path.slice(base.length + 1);
+      for (const rule of rules) {
+        if (rule.pattern.test(local)) {
+          ignored = !rule.negated;
+        }
+      }
+    }
+  }
+  return ignored;
+}
+function excludesFileSetting(config) {
+  let section2 = "";
+  let found;
+  for (const line of config.split("\n")) {
+    const header2 = /^\s*\[\s*([\w.-]+)/.exec(line)?.[1];
+    if (header2 !== void 0) {
+      section2 = header2.toLowerCase();
+      continue;
+    }
+    const value = /^\s*excludesfile\s*=\s*(.*)$/i.exec(line)?.[1];
+    if (section2 === "core" && value !== void 0) {
+      found = configValue(value);
+    }
+  }
+  return found;
+}
+function configValue(raw) {
+  const quoted = /^"((?:[^"\\]|\\.)*)"/.exec(raw)?.[1];
+  return quoted === void 0 ? raw.replace(/\s*[#;].*$/, "").trim() : quoted.replace(/\\(.)/g, "$1");
+}
+function toRegExp(line) {
+  const body = line.replace(/\/+$/, "");
+  if (body === "" || line.includes("\\")) {
+    return void 0;
+  }
+  const anchored = body.includes("/");
+  const segments = (body.startsWith("/") ? body.slice(1) : body).split("/");
+  let source = "";
+  for (const [index, segment] of segments.entries()) {
+    const last = index === segments.length - 1;
+    if (segment === "**") {
+      source += last ? ".*" : "(?:[^/]+/)*";
+      continue;
+    }
+    const converted = segmentSource(segment);
+    if (converted === void 0) {
+      return void 0;
+    }
+    source += last ? converted : `${converted}/`;
+  }
+  try {
+    return new RegExp(`^${anchored ? "" : "(?:.*/)?"}${source}$`);
+  } catch {
+    return void 0;
+  }
+}
+function segmentSource(segment) {
+  let source = "";
+  let index = 0;
+  while (index < segment.length) {
+    const char = segment.charAt(index);
+    if (char === "[") {
+      const negated = /^[!^]/.test(segment.slice(index + 1));
+      const start = index + (negated ? 2 : 1);
+      const end = segment.indexOf("]", start + 1);
+      const members = segment.slice(start, end);
+      if (end === -1 || members.includes("[")) {
+        return void 0;
+      }
+      source += `[${negated ? "^" : ""}${members.replace(/[\]^]/g, "\\$&")}]`;
+      index = end + 1;
+      continue;
+    }
+    source += char === "*" ? "[^/]*" : char === "?" ? "[^/]" : char.replace(/[$()+.^{|}]/, "\\$&");
+    index += 1;
+  }
+  return source;
+}
+
+// src/cli/fs-scan.ts
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".angular",
   ".bun",
@@ -174,18 +278,81 @@ function removeFile(path) {
   rmSync(path, { force: true });
 }
 function listRepositoryFiles(root, limit = scanCap()) {
-  return scanRepository(root, limit).files;
+  return scan(root, limit, () => false).files;
 }
-function scanRepository(root, limit = scanCap()) {
-  const found = [];
-  const truncated = walk(root, root, found, limit);
-  return { files: found.sort(), truncated };
+function scanRepository(root, limit = scanCap(), filter = gitignoreFilter(root)) {
+  return scan(root, limit, filter);
+}
+function scan(root, limit, filter) {
+  const walker = { root, filter, found: [], ignored: [], limit };
+  const truncated = walk(walker, root);
+  return { files: walker.found.sort(), ignored: walker.ignored.sort(), truncated };
+}
+function gitignoreFilter(root) {
+  const gitDirectory = commonGitDirectory(root);
+  const excludes = [
+    { base: "", rules: rulesOf(readTextFile(resolve(root, globalExcludesFile(gitDirectory)))) },
+    { base: "", rules: rulesOf(gitDirectory === void 0 ? void 0 : readTextFile(join(gitDirectory, "info", "exclude"))) }
+  ];
+  const files = /* @__PURE__ */ new Map();
+  const verdicts = /* @__PURE__ */ new Map();
+  const sourceIn = (directory) => {
+    const cached = files.get(directory) ?? { base: directory, rules: rulesOf(readTextFile(join(root, directory, ".gitignore"))) };
+    files.set(directory, cached);
+    return cached;
+  };
+  const isIgnored = (path) => {
+    if (path === "" || path === ".." || path.startsWith("../")) {
+      return false;
+    }
+    const cached = verdicts.get(path);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const segments = path.split("/");
+    const parents = segments.slice(0, -1).map((_, index) => segments.slice(0, index + 1).join("/"));
+    const verdict = isIgnored(parents.at(-1) ?? "") || isIgnoredBy([...excludes, sourceIn(""), ...parents.map(sourceIn)], path);
+    verdicts.set(path, verdict);
+    return verdict;
+  };
+  return isIgnored;
+}
+function rulesOf(text) {
+  return (text === void 0 ? void 0 : parseGitignore(text)) ?? [];
+}
+function commonGitDirectory(root) {
+  const dotGit = join(root, ".git");
+  const gitDirectory = isDirectory(dotGit) ? dotGit : linkedGitDirectory(root, dotGit);
+  if (gitDirectory === void 0) {
+    return void 0;
+  }
+  const common = readTextFile(join(gitDirectory, "commondir"))?.trim();
+  return common ? resolve(gitDirectory, common) : gitDirectory;
+}
+function linkedGitDirectory(root, dotGit) {
+  const [target] = captures(readTextFile(dotGit) ?? "", /^gitdir:\s*(.+?)\s*$/m);
+  return target === void 0 ? void 0 : resolve(root, target);
+}
+function setting(name) {
+  const value = process.env[name];
+  return value === "" ? void 0 : value;
+}
+function globalExcludesFile(gitDirectory) {
+  const home = setting("HOME") ?? homedir();
+  const xdg = setting("XDG_CONFIG_HOME") ?? join(home, ".config");
+  const override = process.env["GIT_CONFIG_GLOBAL"];
+  const configs = [
+    ...override === void 0 ? [join(xdg, "git", "config"), join(home, ".gitconfig")] : [override],
+    ...gitDirectory === void 0 ? [] : [join(gitDirectory, "config")]
+  ];
+  const configured = configs.flatMap((config) => excludesFileSetting(readTextFile(config) ?? "") ?? []).at(-1);
+  return configured === void 0 ? join(xdg, "git", "ignore") : configured.replace(/^~(?=\/|$)/, home);
 }
 function isRepositoryRoot(directory) {
   return existsSync(join(directory, ".git"));
 }
-function walk(root, directory, found, limit) {
-  if (found.length >= limit) {
+function walk(walker, directory) {
+  if (walker.found.length >= walker.limit) {
     return true;
   }
   let entries;
@@ -195,22 +362,30 @@ function walk(root, directory, found, limit) {
     return false;
   }
   for (const entry of entries) {
-    if (found.length >= limit) {
+    if (walker.found.length >= walker.limit) {
       return true;
     }
     const full = join(directory, entry.name);
     if (entry.isDirectory()) {
-      if (!isSkippedDirectory(entry.name) && !isRepositoryRoot(full) && walk(root, full, found, limit)) {
+      if (!isSkippedDirectory(entry.name) && !isRepositoryRoot(full) && !isGitignored(walker, full) && walk(walker, full)) {
         return true;
       }
       continue;
     }
     if (entry.isFile()) {
-      found.push(toPosix(relative(root, full)));
+      walker.found.push(toPosix(relative(walker.root, full)));
     }
   }
   return false;
 }
+function isGitignored(walker, directory) {
+  const path = toPosix(relative(walker.root, directory));
+  if (!walker.filter(path)) {
+    return false;
+  }
+  walker.ignored.push(path);
+  return true;
+}
 function parseJsonc(text) {
   try {
     return JSON.parse(stripJsonComments(text));
@@ -640,7 +815,8 @@ function readProfile(cwd) {
   const scripts = stringMap(packageJson["scripts"]);
   const runner = detectRunner(dependencies, scripts);
   const framework = detectFramework(dependencies);
-  const scan2 = scanRepository(cwd);
+  const isIgnoredDirectory = gitignoreFilter(cwd);
+  const scan3 = scanRepository(cwd, scanCap(), isIgnoredDirectory);
   return {
     cwd,
     runner,
@@ -651,8 +827,9 @@ function readProfile(cwd) {
     setupFiles: detectSetupFiles(cwd),
     dependencies,
     scripts,
-    files: scan2.files,
-    filesTruncated: scan2.truncated
+    files: scan3.files,
+    filesTruncated: scan3.truncated,
+    isIgnoredDirectory
   };
 }
 var PACKAGE_NAME = "vitest-auto-spy";
@@ -1059,7 +1236,7 @@ function textOf(context, range) {
 function group(groups, position) {
   return groups.slice(position, position + 1).join("");
 }
-function scan(masked, pattern) {
+function scan2(masked, pattern) {
   return [...masked.matchAll(pattern)].map((match) => ({ index: match.index, whole: group(match, 0), groups: [...match] }));
 }
 
@@ -1139,7 +1316,7 @@ function replacement(start, end, text) {
 function replacements(context, pattern, text) {
   return {
     ...EMPTY_OUTPUT,
-    edits: scan(context.masked, pattern).map((match) => ({
+    edits: scan2(context.masked, pattern).map((match) => ({
       start: match.index,
       end: match.index + match.whole.length,
       text: text(match)
@@ -1182,7 +1359,7 @@ var jasmineStrategies = {
 function withArgsOutput(context) {
   const closes = spyOnCloses(context);
   return mergeOutputs(
-    scan(context.masked, WITH_ARGS).map(
+    scan2(context.masked, WITH_ARGS).map(
       (match) => closes.has(lastCodeBefore(context.masked, match.index)) ? { ...EMPTY_OUTPUT, notes: [withArgsOnSpyOnNote(context, match.index)] } : replacement(match.index, match.index + match.whole.length, ".calledWith(")
     )
   );
@@ -1205,7 +1382,7 @@ function lastCodeBefore(masked, index) {
 }
 function strategyOutputs(context) {
   return mergeOutputs(
-    scan(context.masked, AND_STRATEGY).flatMap((match) => {
+    scan2(context.masked, AND_STRATEGY).flatMap((match) => {
       const name = group(match.groups, 1);
       return HELPER_NAMES.has(name) ? [] : [strategyOutput(context, match, name)];
     })
@@ -1279,12 +1456,12 @@ var jasmineSpyOn = {
   residue: /(?:^|[^\w$.])spyOn(?:Property)?\s*\(/,
   run: (context) => ({
     ...EMPTY_OUTPUT,
-    edits: scan(context.masked, SPY_ON).flatMap((match) => spyOnEdits(context, match))
+    edits: scan2(context.masked, SPY_ON).flatMap((match) => spyOnEdits(context, match))
   })
 };
 function spyOnCloses(context) {
   return new Set(
-    scan(context.masked, SPY_ON).flatMap((match) => {
+    scan2(context.masked, SPY_ON).flatMap((match) => {
       const range = spyOnRange(context, match);
       return range === void 0 ? [] : [range[1]];
     })
@@ -1517,7 +1694,7 @@ var jasmineGlobals = {
   // leftover `jasmine.SpyObj` reported twice would name a transform that never intended to touch it.
   residue: /\bjasmine\s*\.\s*(?!Spy(?:Obj)?\b)/,
   run: (context) => mergeOutputs(
-    scan(context.masked, MEMBER).flatMap((match) => {
+    scan2(context.masked, MEMBER).flatMap((match) => {
       const name = group(match.groups, 1);
       return TYPE_TARGETS[name] === void 0 ? [globalOutput(context, match, name)] : [];
     })
@@ -1592,7 +1769,7 @@ var jasmineTypes = {
   summary: "jasmine.Spy \u2192 Mock from vitest, and jasmine.SpyObj<T> \u2192 Spy<T> from this package.",
   residue: /\bjasmine\s*\.\s*Spy(?:Obj)?\b/,
   run: (context) => mergeOutputs(
-    scan(context.masked, MEMBER).flatMap((match) => {
+    scan2(context.masked, MEMBER).flatMap((match) => {
       const target = TYPE_TARGETS[group(match.groups, 1)];
       return target === void 0 ? [] : [typeOutput(context, match, target)];
     })
@@ -1630,11 +1807,11 @@ var jasmineMatchers = {
       ([from, to]) => replacements(context, new RegExp(String.raw`\.\s*${from}\s*\(`, "g"), () => `.${to}(`)
     ),
     { ...EMPTY_OUTPUT, edits: failEdits(context) },
-    { ...EMPTY_OUTPUT, edits: scan(context.masked, EXPECT).flatMap((match) => withContextEdits(context, match)) }
+    { ...EMPTY_OUTPUT, edits: scan2(context.masked, EXPECT).flatMap((match) => withContextEdits(context, match)) }
   ])
 };
 function failEdits(context) {
-  return scan(context.masked, FAIL).filter((match) => isCallPosition(context.masked, match.index + match.whole.length - 1)).map((match) => ({
+  return scan2(context.masked, FAIL).filter((match) => isCallPosition(context.masked, match.index + match.whole.length - 1)).map((match) => ({
     start: match.index,
     end: match.index + match.whole.length,
     text: `${group(match.groups, 1)}expect.fail(`
@@ -1775,7 +1952,7 @@ var jestNamespace = {
   summary: "jest.<member> \u2192 vi.<member>, reporting the members with no vi twin instead of renaming them.",
   residue: /\bjest\s*\./,
   run: (context) => collect(
-    scan(context.masked, MEMBER2).flatMap((match) => {
+    scan2(context.masked, MEMBER2).flatMap((match) => {
       const name = group(match.groups, 1);
       return TYPE_NAMES[name] === void 0 ? [memberOutput(context, match, name)] : [];
     })
@@ -1847,7 +2024,7 @@ var jestTypes = {
   run: (context) => {
     const functionFirst = importsJestGlobals(context);
     return collect([
-      ...scan(context.masked, MEMBER2).flatMap((match) => {
+      ...scan2(context.masked, MEMBER2).flatMap((match) => {
         const name = group(match.groups, 1);
         const target = TYPE_NAMES[name];
         return target === void 0 ? [] : [typeOutput2(context, match, name, target, functionFirst)];
@@ -1863,7 +2040,7 @@ var GENERIC_CALL = /\bjest\s*\.\s*(fn|spyOn)\s*</g;
 function genericCallNotes(context) {
   return {
     ...EMPTY_OUTPUT,
-    notes: scan(context.masked, GENERIC_CALL).map((match) => unreadableTypeArguments(context, match.index, group(match.groups, 1)))
+    notes: scan2(context.masked, GENERIC_CALL).map((match) => unreadableTypeArguments(context, match.index, group(match.groups, 1)))
   };
 }
 var NO_ARGUMENT = /\.\s*(mockImplementation(?:Once)?)\s*\(\s*\)/g;
@@ -1874,7 +2051,7 @@ var mockImplementationArity = {
   residue: /\.\s*mockImplementation(?:Once)?\s*\(\s*\)/,
   run: (context) => ({
     ...EMPTY_OUTPUT,
-    edits: scan(context.masked, NO_ARGUMENT).map((match) => ({
+    edits: scan2(context.masked, NO_ARGUMENT).map((match) => ({
       start: match.index,
       end: match.index + match.whole.length,
       text: `.${group(match.groups, 1)}(() => undefined)`
@@ -1890,7 +2067,7 @@ var jasmineAliases = {
   run: (context) => ({
     ...EMPTY_OUTPUT,
     edits: Object.entries(JASMINE_ALIASES).flatMap(
-      ([alias, replacement2]) => scan(context.masked, new RegExp(`(^|[^\\w$.])${alias}\\s*\\(`, "g")).filter((match) => isCallPosition(context.masked, match.index + match.whole.length - 1)).map((match) => {
+      ([alias, replacement2]) => scan2(context.masked, new RegExp(`(^|[^\\w$.])${alias}\\s*\\(`, "g")).filter((match) => isCallPosition(context.masked, match.index + match.whole.length - 1)).map((match) => {
         const start = match.index + group(match.groups, 1).length;
         return { start, end: start + alias.length, text: replacement2 };
       })
@@ -1911,7 +2088,7 @@ var jestGlobalsImport = {
 function globalsEdits(context, statement) {
   const specifierAt = context.source.indexOf(JEST_GLOBALS, statement.start);
   const [open, close] = statement.braces ?? [statement.start, statement.start];
-  const renames = scan(context.masked.slice(open, close), /\bjest\b/g).map((match) => ({
+  const renames = scan2(context.masked.slice(open, close), /\bjest\b/g).map((match) => ({
     start: open + match.index,
     end: open + match.index + "jest".length,
     text: "vi"
@@ -2112,7 +2289,7 @@ var injectCast = {
   residue: /\bas\s+Spy\s*</,
   run: (context) => {
     const helper = context.entries === void 0 ? void 0 : entryFor(context.entries, "asSpy", context.preferredEntry);
-    const casts = scan(context.masked, INJECT).flatMap((match) => {
+    const casts = scan2(context.masked, INJECT).flatMap((match) => {
       const cast = castAt(context, match.index, match.whole.length);
       return cast === void 0 ? [] : [cast];
     });
@@ -2124,7 +2301,7 @@ var injectCast = {
 };
 function withHelper(context, casts, need) {
   const covered = new Set(casts.map((cast) => cast.angle));
-  const strays = scan(context.masked, ANY_SPY_CAST).filter((match) => !covered.has(match.index + match.whole.length - 1)).map((match) => castNote(context, match.index));
+  const strays = scan2(context.masked, ANY_SPY_CAST).filter((match) => !covered.has(match.index + match.whole.length - 1)).map((match) => castNote(context, match.index));
   return {
     edits: casts.map((cast) => cast.edit),
     needs: casts.length === 0 ? [] : [need],
@@ -2152,7 +2329,7 @@ var TRANSFORMS = [
 function residueOf(file, text, transforms) {
   const masked = maskComments(text);
   return transforms.flatMap(
-    (transform) => scan(masked, new RegExp(transform.residue.source, `${transform.residue.flags.replace("g", "")}g`)).filter((match) => transform.residueIgnores?.(masked, match) !== true).map((match) => residueNote(file, text, match, transform))
+    (transform) => scan2(masked, new RegExp(transform.residue.source, `${transform.residue.flags.replace("g", "")}g`)).filter((match) => transform.residueIgnores?.(masked, match) !== true).map((match) => residueNote(file, text, match, transform))
   );
 }
 function residueNote(file, text, match, transform) {
@@ -2911,7 +3088,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.25.0";
+var EXPORT_MAP_VERSION = "5.27.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",
@@ -3787,10 +3964,14 @@ function expandInclude(pattern) {
   const base = last === "*" ? trimmed2 : `${trimmed2}${last === "**" ? "/*" : "/**/*"}`;
   return IMPLIED_EXTENSIONS.map((extension) => `${base}${extension}`);
 }
-function isExemptPattern(pattern) {
-  const slash = pattern.indexOf("/");
-  const root = slash === -1 ? pattern : pattern.slice(0, slash);
-  return /\.d\.[cm]?ts$/.test(pattern) || isSkippedDirectory(root);
+function isExemptPattern(pattern, isIgnored = () => false) {
+  return /\.d\.[cm]?ts$/.test(pattern) || isOutsideScan(pattern, isIgnored);
+}
+function isOutsideScan(path, isIgnored) {
+  const segments = path.split("/");
+  const wildcard = segments.findIndex((segment) => /[*?[]/.test(segment));
+  const literal = wildcard === -1 ? segments : segments.slice(0, wildcard);
+  return literal.some(isSkippedDirectory) || literal.some((_, index) => isIgnored(literal.slice(0, index + 1).join("/")));
 }
 function literalTail(pattern) {
   const last = pattern.slice(pattern.lastIndexOf("/") + 1);
@@ -3816,12 +3997,13 @@ function stringList(value) {
 function resolveFromConfig(configPath, entry) {
   return posix.normalize(posix.join(posix.dirname(configPath), entry)).replace(/^\.\//, "");
 }
-function checkInclude(configPath, entry, files) {
+function checkInclude(configPath, entry, profile) {
+  const files = profile.files;
   if (entry.includes("${") || entry.startsWith("/")) {
     return void 0;
   }
   const resolved = resolveFromConfig(configPath, entry);
-  if (isExemptPattern(resolved) || matchesAnyFile(resolved, files)) {
+  if (isExemptPattern(resolved, profile.isIgnoredDirectory) || matchesAnyFile(resolved, files)) {
     return void 0;
   }
   const tail = literalTail(resolved);
@@ -3842,16 +4024,16 @@ function checkInclude(configPath, entry, files) {
     fix: "A pattern that matches nothing type-checks nothing, and `tsc --noEmit` still reports zero errors. Fix the glob or delete the entry."
   };
 }
-function checkOne(cwd, configPath, files) {
-  const text = readTextFile(join(cwd, configPath));
+function checkOne(profile, configPath) {
+  const text = readTextFile(join(profile.cwd, configPath));
   const parsed = text === void 0 ? void 0 : parseJsonc(text);
   if (!isRecord(parsed)) {
     return [];
   }
-  const findings = stringList(parsed["include"]).flatMap((entry) => checkInclude(configPath, entry, files) ?? []);
+  const findings = stringList(parsed["include"]).flatMap((entry) => checkInclude(configPath, entry, profile) ?? []);
   for (const entry of stringList(parsed["files"])) {
     const resolved = resolveFromConfig(configPath, entry);
-    if (!files.includes(resolved)) {
+    if (!profile.files.includes(resolved) && !isOutsideScan(resolved, profile.isIgnoredDirectory)) {
       findings.push({
         check: "tsconfig-file-missing",
         severity: "error",
@@ -3865,7 +4047,7 @@ function checkOne(cwd, configPath, files) {
 }
 function checkTsconfigGlobs(profile) {
   const configs = profile.files.filter((file) => TSCONFIG_NAME2.test(file));
-  return configs.flatMap((config) => checkOne(profile.cwd, config, profile.files));
+  return configs.flatMap((config) => checkOne(profile, config));
 }
 
 // src/cli/checks/unawaited-helper.ts
@@ -4375,6 +4557,10 @@ function planFor(target, content, profile, version, facts) {
   }
   return { target, existing, desired: applyManaged(existing ?? "", managedBlock(profile, version, facts)), note: note2 };
 }
+function isStampOnly(plan) {
+  return plan.existing !== void 0 && plan.desired !== void 0 && plan.existing !== plan.desired && withoutVersion(plan.existing) === withoutVersion(plan.desired);
+}
+var STAMP_ONLY_NOTE = "only the version stamp differs, which `--check` does not count; a plain `init` refreshes it";
 function statusOf(plan, check) {
   if (plan.desired === void 0) {
     return "skipped";
@@ -4385,7 +4571,7 @@ function statusOf(plan, check) {
   if (plan.existing === plan.desired) {
     return "unchanged";
   }
-  return check && withoutVersion(plan.existing) === withoutVersion(plan.desired) ? "unchanged" : "updated";
+  return check && isStampOnly(plan) ? "unchanged" : "updated";
 }
 function isSelected(path, only) {
   return only === void 0 || only.some((entry) => {
@@ -4437,15 +4623,16 @@ function uninstallPlan(plan) {
 function applyPlan(cwd, plan, options) {
   const status = options.uninstall ? uninstallStatus(plan) : statusOf(plan, options.check);
   const path = plan.target.path;
+  const note2 = !options.uninstall && isStampOnly(plan) ? `${plan.note} \u2014 ${STAMP_ONLY_NOTE}` : plan.note;
   if (options.check || options.dryRun || plan.desired === void 0 || status === "unchanged") {
-    return { path, status, note: plan.note };
+    return { path, status, note: note2 };
   }
   if (plan.desired === "") {
     removeFile(join(cwd, path));
   } else {
     writeTextFile(join(cwd, path), plan.desired);
   }
-  return { path, status, note: plan.note };
+  return { path, status, note: note2 };
 }
 function uninstallStatus(plan) {
   if (plan.desired === void 0 || plan.desired === plan.existing) {
@@ -6087,8 +6274,8 @@ function configCode(graph) {
   }
   return configs;
 }
-function configDeclares(graph, setting) {
-  return configCode(graph).some((code) => setting.test(code));
+function configDeclares(graph, setting2) {
+  return configCode(graph).some((code) => setting2.test(code));
 }
 function declaresNoIsolation(graph) {
   return configDeclares(graph, NO_ISOLATION);
@@ -6948,6 +7135,10 @@ function rejectFlags(args, command, io) {
   io.err(
     `\`${command}\` accepts ${[...accepted, ...COMMON_FLAGS].sort((a, b) => a.localeCompare(b)).map((name) => `--${name}`).join(", ")}.`
   );
+  const formats = unknown.filter((name) => accepted.includes("format") && (name === "json" || name === "markdown"));
+  if (formats.length > 0) {
+    io.err(`Did you mean ${formats.map((name) => `\`--format ${name}\``).join(", ")}?`);
+  }
   return true;
 }
 function guardBrokenPipe(stream, quit) {

package/dist/eslint-plugin.cjs

@@ -1406,6 +1406,30 @@ function declaredTypeOf(context, node) {
   const declared = definition && isVariableDeclarator(definition) ? definition.id : void 0;
   return declared && isIdentifier(declared) ? declared.typeAnnotation?.typeAnnotation : void 0;
 }
+function localFunction2(context, callee) {
+  const scope = context.sourceCode.getScope(callee);
+  const declared = findBinding(scope, callee.name)?.defs.map((definition) => definition.node).find(isFunctionNode);
+  const bound = declared ?? boundValueOf(scope, callee);
+  return bound && isFunctionNode(bound) ? bound : void 0;
+}
+function isAssignmentPattern(node) {
+  return node.type === "AssignmentPattern";
+}
+function isAnnotatedParameter(node) {
+  return node.type === "Identifier" || node.type === "ObjectPattern";
+}
+function parameterType(parameter) {
+  const target = parameter && isAssignmentPattern(parameter) ? parameter.left : parameter;
+  return target && isAnnotatedParameter(target) ? target.typeAnnotation?.typeAnnotation : void 0;
+}
+function declaredParameterTypeOf(context, node) {
+  const call = node.parent;
+  if (!isCallExpression(call) || !isIdentifier(call.callee)) {
+    return void 0;
+  }
+  const helper = localFunction2(context, call.callee);
+  return parameterType(helper?.params[call.arguments.indexOf(node)]);
+}
 function outermostData(node) {
   let current = node;
   for (; ; ) {
@@ -1426,7 +1450,7 @@ function isMemberStubValue(node) {
 }
 function isCheckedByDeclaration(context, node) {
   const data = outermostData(node);
-  const declared = declaredTypeOf(context, data);
+  const declared = declaredTypeOf(context, data) ?? declaredParameterTypeOf(context, data);
   return isMemberStubValue(data) || declared !== void 0 && declared.type !== "TSTypeLiteral";
 }
 var SIGNAL_WRITERS = /* @__PURE__ */ new Set(["set", "update"]);

package/dist/perf-profiler.js

@@ -19,8 +19,8 @@ function isRecord(value) {
 var PERF_PROFILE_ENV = "VITEST_AUTO_SPY_PERF_PROFILE";
 var SAMPLING_MICROSECONDS = 500;
 function send(session, method, params = {}) {
-  return new Promise((resolve, reject) => {
-    session.post(method, params, (error, result) => error === null ? resolve(result) : reject(error));
+  return new Promise((resolve2, reject) => {
+    session.post(method, params, (error, result) => error === null ? resolve2(result) : reject(error));
   });
 }
 var written = 0;

package/package.json

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