vitest-auto-spy 5.27.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,38 @@ 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
@@ -7796,7 +7828,8 @@ 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.27.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

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, 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';
@@ -117,15 +118,40 @@ function parseGitignore(text) {
   }
   return rules;
 }
-function isIgnoredDirectory(rules, path) {
+function isIgnoredBy(sources, path) {
   let ignored = false;
-  for (const rule of rules) {
-    if (rule.pattern.test(path)) {
-      ignored = !rule.negated;
+  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("\\")) {
@@ -252,20 +278,76 @@ function removeFile(path) {
   rmSync(path, { force: true });
 }
 function listRepositoryFiles(root, limit = scanCap()) {
-  return scan(root, limit, []).files;
+  return scan(root, limit, () => false).files;
 }
-function scanRepository(root, limit = scanCap()) {
-  return scan(root, limit, readGitignoreRules(root));
+function scanRepository(root, limit = scanCap(), filter = gitignoreFilter(root)) {
+  return scan(root, limit, filter);
 }
-function scan(root, limit, rules) {
-  const walker = { root, rules, found: [], ignored: [], limit };
+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 readGitignoreRules(root) {
-  const text = readTextFile(join(root, ".gitignore"));
+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"));
 }
@@ -298,7 +380,7 @@ function walk(walker, directory) {
 }
 function isGitignored(walker, directory) {
   const path = toPosix(relative(walker.root, directory));
-  if (!isIgnoredDirectory(walker.rules, path)) {
+  if (!walker.filter(path)) {
     return false;
   }
   walker.ignored.push(path);
@@ -733,7 +815,8 @@ function readProfile(cwd) {
   const scripts = stringMap(packageJson["scripts"]);
   const runner = detectRunner(dependencies, scripts);
   const framework = detectFramework(dependencies);
-  const scan3 = scanRepository(cwd);
+  const isIgnoredDirectory = gitignoreFilter(cwd);
+  const scan3 = scanRepository(cwd, scanCap(), isIgnoredDirectory);
   return {
     cwd,
     runner,
@@ -746,7 +829,7 @@ function readProfile(cwd) {
     scripts,
     files: scan3.files,
     filesTruncated: scan3.truncated,
-    ignoredDirectories: scan3.ignored
+    isIgnoredDirectory
   };
 }
 var PACKAGE_NAME = "vitest-auto-spy";
@@ -3005,7 +3088,7 @@ function checkForeignPragma(graph) {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.26.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",
@@ -3881,14 +3964,14 @@ function expandInclude(pattern) {
   const base = last === "*" ? trimmed2 : `${trimmed2}${last === "**" ? "/*" : "/**/*"}`;
   return IMPLIED_EXTENSIONS.map((extension) => `${base}${extension}`);
 }
-function isExemptPattern(pattern, ignoredDirectories = []) {
-  return /\.d\.[cm]?ts$/.test(pattern) || isOutsideScan(pattern, ignoredDirectories);
+function isExemptPattern(pattern, isIgnored = () => false) {
+  return /\.d\.[cm]?ts$/.test(pattern) || isOutsideScan(pattern, isIgnored);
 }
-function isOutsideScan(path, ignoredDirectories) {
+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) || ignoredDirectories.some((directory) => `${path}/`.startsWith(`${directory}/`));
+  return literal.some(isSkippedDirectory) || literal.some((_, index) => isIgnored(literal.slice(0, index + 1).join("/")));
 }
 function literalTail(pattern) {
   const last = pattern.slice(pattern.lastIndexOf("/") + 1);
@@ -3920,7 +4003,7 @@ function checkInclude(configPath, entry, profile) {
     return void 0;
   }
   const resolved = resolveFromConfig(configPath, entry);
-  if (isExemptPattern(resolved, profile.ignoredDirectories) || matchesAnyFile(resolved, files)) {
+  if (isExemptPattern(resolved, profile.isIgnoredDirectory) || matchesAnyFile(resolved, files)) {
     return void 0;
   }
   const tail = literalTail(resolved);
@@ -3950,7 +4033,7 @@ function checkOne(profile, configPath) {
   const findings = stringList(parsed["include"]).flatMap((entry) => checkInclude(configPath, entry, profile) ?? []);
   for (const entry of stringList(parsed["files"])) {
     const resolved = resolveFromConfig(configPath, entry);
-    if (!profile.files.includes(resolved) && !isOutsideScan(resolved, profile.ignoredDirectories)) {
+    if (!profile.files.includes(resolved) && !isOutsideScan(resolved, profile.isIgnoredDirectory)) {
       findings.push({
         check: "tsconfig-file-missing",
         severity: "error",
@@ -4474,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";
@@ -4484,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) => {
@@ -4536,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) {
@@ -6186,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);
@@ -7047,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.27.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",