vitest-auto-spy 5.53.0 → 5.55.0

package/CHANGELOG.md

@@ -10,6 +10,33 @@ The latest released version here must always match the one published on
 
 ## [Unreleased]
 
+## [5.55.0] - 2026-09-30
+
+### Fixed
+
+- **`perf-import` no longer names a barrel the spec cannot avoid.** A spec whose other imports —
+  usually its subject — already load the same barrel is skipped, since importing the module directly
+  would leave the graph as it is. So is a barrel that a non-wildcard tsconfig `paths` alias points at,
+  when the spec lives outside the barrel's directory: that is another package's public entry, and in
+  an Nx workspace `@nx/enforce-module-boundaries` rejects the relative import that would bypass it.
+  On a consumer Nx workspace this took the report from 7 barrel findings to 0.
+
+## [5.54.0] - 2026-09-30
+
+### Added
+
+- **`perf --json <reports> --gate` re-measures its suspects without `--command`.** The perf reporter
+  now records the Vitest config file the suite ran with (`configFile`, relative to `root`), and the
+  confirmation pass re-runs each suspect with `vitest run --config <that file>` over the suspects
+  only: one run per config when the reports came from several (`vitest.config.ts` and
+  `libs/tooling/vitest.config.ts`, say), read back as one second reading. A single slow reading on a
+  loaded runner now comes back as not reproduced instead of needing `--no-confirm` to fail anything.
+  The re-run has coverage off (`--coverage.enabled=false`), even when the first reading had it on:
+  coverage thresholds fail a run of a few files, and instrumentation is the harness's cost rather
+  than the test's, so a body over budget only because of instrumentation is not reproduced.
+  `--command` still takes precedence, and a report without `configFile` is not re-measured, as
+  before. The perf report format is version 6; versions 1–6 are read.
+
 ## [5.53.0] - 2026-09-29
 
 ### Added
@@ -6657,7 +6684,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.53.0...HEAD
+[Unreleased]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.55.0...HEAD
+[5.55.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.54.0...v5.55.0
+[5.54.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.53.0...v5.54.0
 [5.53.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.52.0...v5.53.0
 [5.52.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.51.0...v5.52.0
 [5.51.0]: https://github.com/ASDAlexey/vitest-auto-spy/compare/v5.50.0...v5.51.0

package/agent-docs/checklist.md

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

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { ownVersion, isDirectory, readProfile, formatFindings, outputWidth, painterFor, summarize, DOCTOR_CHECKS, writeTextFile, REPORT_SCHEMA, sortFindings, findingJson, tallyOf, ownPackageRoot, readTextFile, SCAN_CAP_ENV, scanCap, COVERAGE_MATCHING_DOCS, VITEST_5_PERF_DOCS, filterBySeverity, isSymlink, skillFrontmatter, toPosix, pathExists, NOTHING_TO_READ_DOCS, removeFile, parseJsonc, isRecord, extractSetupFiles, captures, gitignoreFilter, BARE_RUN_DOCS, MONOCHROME, findStringEnd, wrapText, listRepositoryFiles, isSkippedDirectory, versionFrom, stripColor, padStart, padEnd } from './cli-SELXGLDQ.js';
+import { ownVersion, isDirectory, readProfile, formatFindings, outputWidth, painterFor, summarize, ownPackageRoot, DOCTOR_CHECKS, writeTextFile, REPORT_SCHEMA, sortFindings, findingJson, tallyOf, readTextFile, SCAN_CAP_ENV, scanCap, COVERAGE_MATCHING_DOCS, VITEST_5_PERF_DOCS, filterBySeverity, isSymlink, skillFrontmatter, toPosix, pathExists, NOTHING_TO_READ_DOCS, removeFile, parseJsonc, isRecord, extractSetupFiles, captures, gitignoreFilter, BARE_RUN_DOCS, MONOCHROME, findStringEnd, listRepositoryFiles, wrapText, isSkippedDirectory, versionFrom, stripColor, padStart, padEnd } from './cli-SELXGLDQ.js';
 import { resolve, join, posix, relative, isAbsolute, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
@@ -1654,7 +1654,7 @@ function foreignPragmaPass() {
 }
 
 // src/cli/checks/export-map.generated.ts
-var EXPORT_MAP_VERSION = "5.52.0";
+var EXPORT_MAP_VERSION = "5.54.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",
@@ -4614,8 +4614,6 @@ function runNgTest(options, tools, io) {
   }
   return tools.spawn({ command: process.execPath, args: run, cwd: options.cwd, env: {}, shell: false }).status;
 }
-
-// src/cli/checks/barrels.ts
 var BARREL_NAME = /(?:^|\/)(?:index|public[_-]api)\.[cm]?[jt]sx?$/;
 var RE_EXPORT = /\bexport\s+(?:type\s+)?(?:\*|{[^}]*})[^;]*?\bfrom\s*["'][^"']+["']/g;
 var OWN_DECLARATION = /(?:^|\n)\s*export\s+(?:abstract\s+)?(?:default|class|function|const|let|var|enum|namespace|interface|type\s+\w+\s*=)\b/;
@@ -4625,9 +4623,9 @@ function isBarrel(file, text) {
   }
   return (text.match(RE_EXPORT) ?? []).length >= 2;
 }
-function reachOf(file, graph) {
-  const seen = /* @__PURE__ */ new Set([file]);
-  const order = [file];
+function reachableFrom(starts, graph) {
+  const seen = new Set(starts);
+  const order = [...starts];
   for (const current of order) {
     for (const edge of graph.imports.get(current) ?? []) {
       if (!seen.has(edge)) {
@@ -4636,9 +4634,33 @@ function reachOf(file, graph) {
       }
     }
   }
-  return seen.size - 1;
+  return seen;
+}
+function reachOf(file, graph) {
+  return reachableFrom([file], graph).size - 1;
+}
+function packageEntries(cwd, files) {
+  const entries = /* @__PURE__ */ new Set();
+  for (const alias of readCompilerPaths2(cwd).aliases) {
+    for (const target of alias.wildcard ? [] : alias.targets) {
+      const resolved = resolveRelative("package.json", `./${target}`, files);
+      if (resolved !== void 0) {
+        entries.add(resolved);
+      }
+    }
+  }
+  return entries;
+}
+function loadedAnyway(barrel, imported, graph) {
+  return reachableFrom(
+    imported.filter((other) => other !== barrel),
+    graph
+  ).has(barrel);
+}
+function outsidePackage(spec, barrel, entries) {
+  return entries.has(barrel) && !spec.startsWith(`${posix.dirname(barrel)}/`);
 }
-function findBarrelImports(graph) {
+function findBarrelImports(graph, entries = /* @__PURE__ */ new Set()) {
   const barrels = /* @__PURE__ */ new Map();
   const found = [];
   for (const [file, text] of graph.texts) {
@@ -4652,7 +4674,7 @@ function findBarrelImports(graph) {
     }
     for (const target of imported) {
       const reach = barrels.get(target);
-      if (reach !== void 0) {
+      if (reach !== void 0 && !outsidePackage(spec, target, entries) && !loadedAnyway(target, imported, graph)) {
         found.push({ spec, barrel: target, reach });
       }
     }
@@ -4665,8 +4687,8 @@ var PERF_OUTPUT_ENV = "VITEST_AUTO_SPY_PERF_OUT";
 var PERF_REPORTER_ENV = "VITEST_AUTO_SPY_PERF_REPORTER";
 var PERF_PROFILE_ENV = "VITEST_AUTO_SPY_PERF_PROFILE";
 var PERF_ISOLATE_ENV = "VITEST_AUTO_SPY_PERF_ISOLATE";
-var PERF_FORMAT_VERSION = 5;
-var READABLE_VERSIONS = [1, 2, 3, 4, 5];
+var PERF_FORMAT_VERSION = 6;
+var READABLE_VERSIONS = [1, 2, 3, 4, 5, 6];
 var CASE_FLOOR_MS = 100;
 var CASES_PER_FILE = 5;
 var OPTIONAL_FILE_NUMBERS = ["workerId", "lane", "start", "fetch", "setupFetch", "retries", "autoSpy"];
@@ -4811,7 +4833,8 @@ function parsePerfRun(text) {
     ...parsed["partial"] === true ? { partial: true } : {},
     ...end === "failed" || end === "interrupted" || end === "passed" ? { end } : {},
     ...parsed["hung"] === true ? { hung: true } : {},
-    ...coverage === void 0 ? {} : { coverage }
+    ...coverage === void 0 ? {} : { coverage },
+    ...typeof parsed["configFile"] === "string" && parsed["configFile"] !== "" ? { configFile: parsed["configFile"] } : {}
   };
 }
 function sumOf(run, key) {
@@ -5385,7 +5408,8 @@ function finding3(candidate, severity, tail) {
   };
 }
 var UNCONFIRMED = [
-  "Measured once and never confirmed, so it fails nothing. Run the gate where the files can be re-measured,",
+  "Measured once and never confirmed, so it fails nothing. Run the gate where the files can be re-measured \u2014",
+  "a --command with {paths}, or a report whose perf reporter recorded the Vitest config \u2014",
   "or pass --no-confirm to gate on a single reading."
 ].join(" ");
 function rowOf(candidate, outcome, again) {
@@ -7070,9 +7094,9 @@ function perfMarkdown(document) {
 
 // src/cli/perf.ts
 var QUIET_MS = 5e3;
-function barrelCandidates(graph) {
+function barrelCandidates(graph, entries) {
   const widest = /* @__PURE__ */ new Map();
-  for (const use of findBarrelImports(graph)) {
+  for (const use of findBarrelImports(graph, entries)) {
     if (!widest.has(use.spec)) {
       widest.set(use.spec, use);
     }
@@ -7082,11 +7106,11 @@ function barrelCandidates(graph) {
 function importPhase(run) {
   return run.files.length > 0 && run.files.every((file) => file.fetch !== void 0) ? "Evaluating imported modules \u2014 the wait for their transforms is counted under `transform` \u2014" : "Importing modules";
 }
-function importFindings(phases, graph, run, context) {
+function importFindings(phases, graph, profile, run, context) {
   if (shareOf(phases, "import") < DOMINATES || context.builder !== void 0) {
     return [];
   }
-  const ranked = barrelCandidates(graph);
+  const ranked = barrelCandidates(graph, packageEntries(profile.cwd, new Set(profile.files)));
   if (ranked.length === 0) {
     return [];
   }
@@ -7127,7 +7151,7 @@ function analysePerf(run, profile, failOnFlaky = false, context = perfContext(pr
     ...environmentFindings(phases, profile, graph, measured),
     ...domEngineFindings(phases, graph, run, context),
     ...transformFindings(phases, graph, run, context),
-    ...importFindings(phases, graph, run, context),
+    ...importFindings(phases, graph, profile, run, context),
     ...isolationFindings(phases, graph, profile, run, void 0, context),
     ...poolFindings(phases, graph, run, context),
     ...workerFindings(total, graph, run, void 0, context)
@@ -7450,6 +7474,11 @@ function reroot(path, from, to) {
   return rest.startsWith("/") || rest.startsWith("\\") ? `${to}${rest}` : path;
 }
 var END_ORDER = ["interrupted", "failed", "passed"];
+function sharedConfigFile(inputs) {
+  const configFiles = new Set(inputs.map((input) => input.run.configFile));
+  const [configFile] = configFiles;
+  return { shared: configFiles.size <= 1, configFile };
+}
 function mergedRun(inputs) {
   const runs2 = inputs.map((input) => input.run);
   const vitest = runs2.find((run) => run.vitest !== void 0)?.vitest;
@@ -7457,6 +7486,7 @@ function mergedRun(inputs) {
   const startups = runs2.flatMap((run) => run.startup === void 0 ? [] : [run.startup]);
   const end = END_ORDER.find((reason) => runs2.some((run) => run.end === reason));
   const coverages = runs2.flatMap((run) => run.coverage === void 0 ? [] : [run.coverage]);
+  const configFile = sharedConfigFile(inputs);
   const startup = startups.reduce((total, each) => ({ ms: total.ms + each.ms, workers: total.workers + each.workers }), {
     ms: 0,
     workers: 0
@@ -7474,7 +7504,8 @@ function mergedRun(inputs) {
     ...runs2.some((run) => run.partial === true) ? { partial: true } : {},
     ...end === void 0 ? {} : { end },
     ...runs2.some((run) => run.hung === true) ? { hung: true } : {},
-    ...coverages.length === 0 ? {} : { coverage: Math.max(...coverages) }
+    ...coverages.length === 0 ? {} : { coverage: Math.max(...coverages) },
+    ...configFile.shared && configFile.configFile !== void 0 ? { configFile: configFile.configFile } : {}
   };
 }
 function mergeRuns(inputs) {
@@ -7483,15 +7514,18 @@ function mergeRuns(inputs) {
   const carriedBy = /* @__PURE__ */ new Map();
   const empty = [];
   const offset = { workerId: 0, lane: 0 };
+  const perFile = !sharedConfigFile(inputs).shared;
   for (const input of inputs) {
     const from = trimRoot(input.run.root);
     const shift = { ...offset };
+    const configFile = perFile ? input.run.configFile : void 0;
     if (input.run.files.length === 0) {
       empty.push(input.path);
     }
     for (const file of input.run.files) {
       const path = reroot(file.file, from, root);
-      const moved = shifted(path === file.file ? file : { ...file, file: path }, shift, offset);
+      const placed2 = { ...file, file: path, ...configFile === void 0 ? {} : { configFile } };
+      const moved = shifted(placed2, shift, offset);
       const previous = kept.get(path);
       carriedBy.set(path, [...carriedBy.get(path) ?? [], input.path]);
       if (previous === void 0 || fileTotal(moved) > fileTotal(previous)) {
@@ -7726,13 +7760,22 @@ function vitestMajor3(cwd) {
 function versionFlags(cwd) {
   return (vitestMajor3(cwd) ?? 0) >= 5 ? ["--experimental.diagnostics=false"] : [];
 }
+function configArgs(config) {
+  return config === void 0 ? [] : ["--config", config, "--coverage.enabled=false"];
+}
 function fromRun(options, spawn, packageRoot) {
   const entry = join(options.cwd, "node_modules", "vitest", "vitest.mjs");
   const reporter = reporterPath(packageRoot);
-  const mismatch = bareRunWouldMeasureSomethingElse(options.profile);
+  const mismatch = options.config === void 0 ? bareRunWouldMeasureSomethingElse(options.profile) : void 0;
   if (mismatch !== void 0) {
     return failed(mismatch);
   }
+  if (options.config !== void 0 && !pathExists(resolve(options.cwd, options.config))) {
+    return failed(
+      `The report was measured with the Vitest config ${options.config}, and there is no such file in ${options.cwd}. Run the gate in the checkout the report was written for, or pass --command.
+Docs: ${NOTHING_TO_READ_DOCS}`
+    );
+  }
   if (!pathExists(entry)) {
     return failed(
       `No Vitest is installed in ${options.cwd}, so there is nothing to run. Install vitest there, then measure again.
@@ -7749,7 +7792,16 @@ Docs: ${NOTHING_TO_READ_DOCS}`
   removeFile(target);
   const spawned = timed(spawn, {
     command: process.execPath,
-    args: [entry, "run", "--reporter=default", `--reporter=${reporter}`, "--logHeapUsage", ...versionFlags(options.cwd), ...options.paths],
+    args: [
+      entry,
+      "run",
+      ...configArgs(options.config),
+      "--reporter=default",
+      `--reporter=${reporter}`,
+      "--logHeapUsage",
+      ...versionFlags(options.cwd),
+      ...options.paths
+    ],
     cwd: options.cwd,
     env: runEnv(options, target, reporter),
     shell: false
@@ -7809,15 +7861,66 @@ function readPerfRun(options, spawn = spawnProcess, packageRoot = ownPackageRoot
   const source = options.json === void 0 ? fromCommand(options, command, spawn, packageRoot) : fromFile(options.json, options.cwd);
   return source.ok ? { ...source, command } : source;
 }
-function perfRemeasure(options, spawn = spawnProcess, packageRoot = ownPackageRoot()) {
+function localRoot(root, cwd) {
+  const here = relative(cwd, root);
+  return root !== "" && !here.startsWith("..") && !isAbsolute(here) ? root : cwd;
+}
+function recordedConfigs(recorded, cwd) {
+  const root = localRoot(recorded.root, cwd);
+  const configs = /* @__PURE__ */ new Map();
+  for (const [path, file] of measuredFiles(recorded, cwd)) {
+    const configFile = file.configFile ?? recorded.configFile;
+    if (configFile !== void 0) {
+      configs.set(path, toPosix(relative(cwd, resolve(root, configFile))));
+    }
+  }
+  return configs;
+}
+function mergeMeasured(measured) {
+  return {
+    ok: true,
+    run: mergeRuns(measured.map((each, index) => ({ path: String(index), run: each.run }))).run,
+    runFailed: measured.some((each) => each.runFailed),
+    profiles: new Map(measured.flatMap((each) => [...new Map(each.profiles)]))
+  };
+}
+function underRecordedConfigs(configs, remeasure) {
+  return (paths) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      const config = configs.get(path);
+      if (config !== void 0) {
+        groups.set(config, [...groups.get(config) ?? [], path]);
+      }
+    }
+    if (groups.size === 0) {
+      return failed(
+        `None of the files to re-measure is in a report that recorded its Vitest config. Pass --command to re-measure them.
+Docs: ${NOTHING_TO_READ_DOCS}`
+      );
+    }
+    const measured = [];
+    for (const [config, group] of groups) {
+      const source = remeasure(group, config);
+      if (!source.ok) {
+        return source;
+      }
+      measured.push(source);
+    }
+    return mergeMeasured(measured);
+  };
+}
+function perfRemeasure(options, spawn = spawnProcess, packageRoot = ownPackageRoot(), recorded) {
   if (options.command !== void 0 && !commandTakesPaths(options.command)) {
     return void 0;
   }
+  const profileDir = join(options.cwd, "node_modules", ".cache", "vitest-auto-spy", `profiles-${process.pid}`);
+  const scoped = { ...options, json: void 0, out: void 0, profileDir };
   if (options.command === void 0 && options.json !== void 0) {
-    return void 0;
+    const configs = recorded === void 0 ? /* @__PURE__ */ new Map() : recordedConfigs(recorded, options.cwd);
+    return configs.size === 0 ? void 0 : underRecordedConfigs(configs, (paths, config) => readPerfRun({ ...scoped, paths, config }, spawn, packageRoot));
   }
-  const profileDir = join(options.cwd, "node_modules", ".cache", "vitest-auto-spy", `profiles-${process.pid}`);
-  return (paths) => readPerfRun({ ...options, json: void 0, out: void 0, paths, profileDir }, spawn, packageRoot);
+  return (paths) => readPerfRun({ ...scoped, paths }, spawn, packageRoot);
 }
 function perfAbIsolate(options, spawn, packageRoot = ownPackageRoot()) {
   if (options.command === void 0 && options.json !== void 0) {
@@ -7901,7 +8004,7 @@ function baselineRequest(args, cwd) {
     }
   };
 }
-var PROFILE_DIR_UNUSED = "warning  --profile-dir keeps the profiles the gate's confirmation pass records, and this run has no such pass: add --gate, without --no-confirm, on a source it can run again.\n";
+var PROFILE_DIR_UNUSED = "warning  --profile-dir keeps the profiles the gate's confirmation pass records, and this run has no such pass: add --gate, without --no-confirm, on a source it can run again \u2014 a run, a --command with {paths}, or a report that recorded its Vitest config.\n";
 function perfCommand(cwd, argv, io) {
   const args = parseArgs(argv);
   const format = formatOf(args);
@@ -7918,7 +8021,13 @@ function perfCommand(cwd, argv, io) {
     ...keepProfiles === void 0 ? {} : { keepProfiles: resolve(cwd, keepProfiles) }
   };
   const trustSingle = flagEnabled(args, "no-confirm");
-  const gate = flagEnabled(args, "gate") ? { options: gateOptions(args), remeasure: trustSingle ? void 0 : perfRemeasure(options, spawn), trustSingle } : void 0;
+  const handed = options.json === void 0 ? void 0 : readPerfRun(options, spawn);
+  const recorded = handed?.ok === true ? handed.run : void 0;
+  const gate = flagEnabled(args, "gate") ? {
+    options: gateOptions(args),
+    remeasure: trustSingle ? void 0 : perfRemeasure(options, spawn, ownPackageRoot(), recorded),
+    trustSingle
+  } : void 0;
   if (keepProfiles !== void 0 && gate?.remeasure === void 0) {
     io.err(PROFILE_DIR_UNUSED);
   }
@@ -7927,7 +8036,7 @@ function perfCommand(cwd, argv, io) {
   const minSeverity = minSeverityOf(args);
   const failOn = failOnOf(args);
   const codeQuality = flagValue(args, "code-quality");
-  return renderPerf(readPerfRun(options, spawn), profile, io, {
+  return renderPerf(handed ?? readPerfRun(options, spawn), profile, io, {
     budgets: gateOptions(args),
     ...format === "json" || format === "markdown" ? { format } : {},
     ...gate === void 0 ? {} : { gate },

package/dist/perf-reporter.d.ts

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

package/dist/perf-reporter.js

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

package/package.json

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