@hublo/sentinel 1.4.0-alpha.26 → 1.4.0-alpha.28

package/dist/{chunk-ATDETQX5.js → chunk-J3MDCYSX.js}

@@ -1,9 +1,32 @@
+import {
+  JEST_CONFIG_FILES,
+  SENTINEL_OWNED_TEST_PACKAGES,
+  SENTINEL_TEST_COMMAND,
+  TEST_SCRIPT_NAME,
+  adoptedPackageName,
+  binFromOwnInstall,
+  binSearchPath,
+  hasReference,
+  listTestFiles,
+  manifestOperation,
+  manifestTargets,
+  moduleScripts,
+  readTestAdoption,
+  readTestConfigSource,
+  resolveBin,
+  resolveVitest,
+  rewriteVitestScript,
+  selfCommand,
+  suiteOf,
+  testConfigFile,
+  testTarget,
+  testToolchain
+} from "./chunk-WYWE4VIL.js";
 import {
   DEFAULT_MAX_DIAGNOSTICS,
   WORKSPACE_ROOT_MARKER,
   findWorkspaceRoot,
   moduleName,
-  readNxProjectName,
   readOwnPackage,
   readProjectPackageJson
 } from "./chunk-NW6UHNYX.js";
@@ -91,7 +114,7 @@ var BaseAdapter = class {
 };
 
 // src/core/domain.ts
-var VERBS = ["run", "inspect", "init", "migrate", "report", "status"];
+var VERBS = ["run", "inspect", "init", "migrate", "validate", "report", "status"];
 var TARGETS = [
   "lint",
   "format",
@@ -196,8 +219,8 @@ function workspaceRootHops(cwd, target) {
 }
 
 // src/roles/build/read-adoption.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
 
 // src/core/config/module-type.ts
 function esmReadiness(fileName, packageType) {
@@ -210,68 +233,14 @@ function esmReadiness(fileName, packageType) {
   };
 }
 
-// src/core/config/manifest.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { basename, join as join2 } from "node:path";
-function moduleScripts(cwd) {
-  try {
-    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
-    return pkg.scripts ?? {};
-  } catch {
-    return {};
-  }
-}
-function manifestTargets(cwd) {
-  try {
-    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
-    return pkg.nx?.targets ?? {};
-  } catch {
-    return {};
-  }
-}
-function moduleName2(cwd) {
-  try {
-    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
-    return pkg.name;
-  } catch {
-    return void 0;
-  }
-}
-function isSelfAdoption(cwd) {
-  return moduleName2(cwd) === readOwnPackage().name;
-}
-function selfCommand(cwd, flags) {
-  const own = readOwnPackage();
-  if (!isSelfAdoption(cwd) || !own.bin) return void 0;
-  return `node ${own.bin.replace(/^\.\//, "")} ${flags}`;
-}
-function adoptedPackageName(cwd) {
-  return readProjectPackageJson(cwd).name ?? readNxProjectName(cwd) ?? basename(cwd);
-}
-function manifestOperation(cwd, scripts) {
-  const own = readOwnPackage();
-  const value = {
-    scripts,
-    devDependencies: { [own.name]: isSelfAdoption(cwd) ? "link:." : own.version }
-  };
-  if (existsSync2(join2(cwd, "package.json"))) {
-    return { kind: "merge-json", path: "package.json", value };
-  }
-  return {
-    kind: "merge-json",
-    path: "package.json",
-    value: { name: adoptedPackageName(cwd), private: true, ...value }
-  };
-}
-
 // src/core/config/project-json.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 function projectTargets(cwd) {
-  const path = join3(cwd, "project.json");
-  if (!existsSync3(path)) return void 0;
+  const path = join2(cwd, "project.json");
+  if (!existsSync2(path)) return void 0;
   try {
-    return JSON.parse(readFileSync3(path, "utf8")).targets;
+    return JSON.parse(readFileSync2(path, "utf8")).targets;
   } catch {
     return void 0;
   }
@@ -374,12 +343,12 @@ var DEV_SCRIPT_NAME = "serve";
 var SENTINEL_DEV_COMMAND = "sentinel --run --dev";
 var BUILD_OUTPUT_CANDIDATES = ["dist", ".output", "build"];
 function buildTarget(options) {
-  const { moduleName: moduleName3, configFiles = BUILD_CONFIG_FILES, outputs } = options;
+  const { moduleName: moduleName2, configFiles = BUILD_CONFIG_FILES, outputs } = options;
   return {
     [BUILD_SCRIPT_NAME]: {
       executor: "nx:run-commands",
       options: {
-        command: `pnpm --filter ${moduleName3} run ${BUILD_SCRIPT_NAME}`,
+        command: `pnpm --filter ${moduleName2} run ${BUILD_SCRIPT_NAME}`,
         forwardAllArgs: false
       },
       cache: true,
@@ -454,7 +423,7 @@ var NOT_ADOPTED = (configFile, unreadable = null) => ({
   unreadable
 });
 function buildConfigFile(cwd) {
-  return BUILD_CONFIG_FILES.find((name) => existsSync4(join4(cwd, name)));
+  return BUILD_CONFIG_FILES.find((name) => existsSync3(join3(cwd, name)));
 }
 function importsSpecifier(source, specifier) {
   const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -480,7 +449,7 @@ function readBuildConfigSource(cwd) {
   const configFile = buildConfigFile(cwd);
   if (!configFile) return void 0;
   try {
-    return readFileSync4(join4(cwd, configFile), "utf8");
+    return readFileSync3(join3(cwd, configFile), "utf8");
   } catch {
     return void 0;
   }
@@ -490,7 +459,7 @@ function readBuildAdoption(cwd) {
   if (!configFile) return NOT_ADOPTED(null);
   let source;
   try {
-    source = readFileSync4(join4(cwd, configFile), "utf8");
+    source = readFileSync3(join3(cwd, configFile), "utf8");
   } catch (error) {
     return NOT_ADOPTED(configFile, error instanceof Error ? error.message : String(error));
   }
@@ -526,7 +495,7 @@ function readBuildAdoption(cwd) {
 import { spawnSync } from "node:child_process";
 
 // src/core/config/tool-args.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { isAbsolute, resolve as resolve2 } from "node:path";
 function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
   const takesValue = new Set(valueFlags);
@@ -536,53 +505,20 @@ function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
   for (const arg of toolArgs) {
     const looksLikeOption = arg.startsWith("-");
     const target = isAbsolute(arg) ? arg : resolve2(cwd, arg);
-    if (!previousTakesValue && !looksLikeOption && existsSync5(target)) paths.push(arg);
+    if (!previousTakesValue && !looksLikeOption && existsSync4(target)) paths.push(arg);
     else options.push(arg);
     previousTakesValue = !arg.includes("=") && takesValue.has(arg);
   }
   return { options, paths };
 }
 
-// src/shared/resolve-bin.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { createRequire } from "node:module";
-import { delimiter, dirname, join as join5 } from "node:path";
-var require2 = createRequire(import.meta.url);
-function resolveBin(fromDir, name) {
-  let dir = fromDir;
-  for (; ; ) {
-    const candidate = join5(dir, "node_modules", ".bin", name);
-    if (existsSync6(candidate)) return candidate;
-    const parent = dirname(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function binFromOwnInstall(packageName, binName) {
-  try {
-    const manifest = require2.resolve(`${packageName}/package.json`);
-    const bin = require2(manifest).bin;
-    const relative9 = typeof bin === "string" ? bin : bin?.[binName];
-    if (!relative9) return void 0;
-    const executable = join5(dirname(manifest), relative9);
-    return existsSync6(executable) ? executable : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function binSearchPath(cwd) {
-  return [`${cwd}${delimiter}node_modules/.bin (and parents)`, "sentinel's own install"].join(
-    " then "
-  );
-}
-
 // src/roles/build/plan.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/core/config/existing-command.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
 
 // src/shared/jsonc.ts
 import { parse, printParseErrorCode } from "jsonc-parser";
@@ -601,7 +537,7 @@ function nxTargetCommand(cwd, target) {
   let project;
   try {
     project = parseJsonc(
-      readFileSync5(join6(cwd, "project.json"), "utf8"),
+      readFileSync4(join4(cwd, "project.json"), "utf8"),
       "project.json"
     );
   } catch {
@@ -632,8 +568,8 @@ function existingCommand(cwd, target) {
 }
 
 // src/core/config/nx-target.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 function nxTargetMetadataOperations(options) {
   const { targets } = options;
   if (Object.keys(targets).length === 0) return [];
@@ -644,7 +580,7 @@ function nxTargetOperations(options) {
   const names = Object.keys(targets);
   if (names.length === 0) return [];
   const operations = [];
-  if (existsSync7(join7(cwd, "project.json"))) {
+  if (existsSync5(join5(cwd, "project.json"))) {
     operations.push({
       kind: "remove-json-keys",
       path: "project.json",
@@ -698,8 +634,8 @@ function keepsOtherCommands(script, sentinelCommand) {
 }
 
 // src/roles/format/read-adoption.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // src/roles/format/config-policy.ts
 var FORMAT_CONFIG_FILE = ".oxfmtrc.json";
@@ -805,11 +741,11 @@ function sameValue(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
 }
 function readFormatAdoption(cwd) {
-  const path = join8(cwd, FORMAT_CONFIG_FILE);
-  if (!existsSync8(path)) return NOT_ADOPTED2(null);
+  const path = join6(cwd, FORMAT_CONFIG_FILE);
+  if (!existsSync6(path)) return NOT_ADOPTED2(null);
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync6(path, "utf8"), FORMAT_CONFIG_FILE);
+    parsed = parseJsonc(readFileSync5(path, "utf8"), FORMAT_CONFIG_FILE);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return NOT_ADOPTED2(FORMAT_CONFIG_FILE, `${FORMAT_CONFIG_FILE} could not be parsed (${reason})`);
@@ -910,8 +846,8 @@ function devTargetOperations(cwd, devScript) {
 }
 
 // src/roles/build/nest/adopt.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 var NEST_CONFIG_FILE = "vite.config.mts";
 function asSource(value, depth) {
   const pad = "  ".repeat(depth);
@@ -960,9 +896,9 @@ function nestBuildOutputs(target) {
 }
 var OUT_DIR_IN_CONFIG = /^\s*outDir:\s*'([^']+)'/m;
 function nestOutputsFromConfig(cwd) {
-  const configPath = join9(cwd, NEST_CONFIG_FILE);
-  if (!existsSync9(configPath)) return void 0;
-  const outDir = OUT_DIR_IN_CONFIG.exec(readFileSync7(configPath, "utf8"))?.[1];
+  const configPath = join7(cwd, NEST_CONFIG_FILE);
+  if (!existsSync7(configPath)) return void 0;
+  const outDir = OUT_DIR_IN_CONFIG.exec(readFileSync6(configPath, "utf8"))?.[1];
   return outDir === void 0 ? void 0 : [`{workspaceRoot}/${outDir}`];
 }
 function nestAdoptionOperations(cwd, target) {
@@ -1267,9 +1203,9 @@ function planNestService(context, webpackTarget) {
   };
 }
 function readConfigSource(cwd, configFile) {
-  if (!existsSync10(join10(cwd, configFile))) return "";
+  if (!existsSync8(join8(cwd, configFile))) return "";
   try {
-    return readFileSync8(join10(cwd, configFile), "utf8");
+    return readFileSync7(join8(cwd, configFile), "utf8");
   } catch {
     return "";
   }
@@ -1454,21 +1390,21 @@ var ViteDevAdapter = class extends ViteRoleAdapter {
 };
 
 // src/roles/build/declared-outputs.ts
-import { existsSync as existsSync11, rmSync, statSync, writeFileSync } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync9, rmSync, statSync, writeFileSync } from "node:fs";
+import { join as join9 } from "node:path";
 function declaredBuildTarget(cwd) {
   return readProjectPackageJson(cwd).nx?.targets?.[BUILD_SCRIPT_NAME];
 }
 function resolveOutputToken(token, cwd) {
-  if (token.startsWith("{projectRoot}/")) return join11(cwd, token.slice("{projectRoot}/".length));
+  if (token.startsWith("{projectRoot}/")) return join9(cwd, token.slice("{projectRoot}/".length));
   if (token.startsWith("{workspaceRoot}/")) {
     const root = findWorkspaceRoot(cwd);
-    return root === void 0 ? void 0 : join11(root, token.slice("{workspaceRoot}/".length));
+    return root === void 0 ? void 0 : join9(root, token.slice("{workspaceRoot}/".length));
   }
-  return join11(cwd, token);
+  return join9(cwd, token);
 }
 function buildStamp(cwd) {
-  const marker = join11(cwd, `.sentinel-build-stamp-${process.pid}`);
+  const marker = join9(cwd, `.sentinel-build-stamp-${process.pid}`);
   try {
     writeFileSync(marker, "");
     const stamp = statSync(marker).mtimeMs;
@@ -1479,7 +1415,7 @@ function buildStamp(cwd) {
   }
 }
 function writtenSince(path, startedAt) {
-  if (!existsSync11(path)) return false;
+  if (!existsSync9(path)) return false;
   try {
     return statSync(path).mtimeMs >= startedAt;
   } catch {
@@ -1628,12 +1564,12 @@ function registerBuild() {
 
 // src/roles/format/adapters/oxfmt/oxfmt.adapter.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/core/config/has-source.ts
 import { readdirSync } from "node:fs";
-import { extname, join as join12, relative as relative2 } from "node:path";
+import { extname, join as join10, relative as relative2 } from "node:path";
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1684,7 +1620,7 @@ function hasSourceFiles(cwd, extensions) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!SKIP_DIRECTORIES.has(entry.name)) queue.push(join12(dir, entry.name));
+        if (!SKIP_DIRECTORIES.has(entry.name)) queue.push(join10(dir, entry.name));
         continue;
       }
       if (wanted.has(extname(entry.name))) return true;
@@ -1705,7 +1641,7 @@ function listSourceFiles(cwd, extensions) {
       continue;
     }
     for (const entry of entries) {
-      const full = join12(dir, entry.name);
+      const full = join10(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRECTORIES.has(entry.name)) queue.push(full);
         continue;
@@ -1751,8 +1687,8 @@ function writesWhenRewritten(name, command) {
 var CHECK_SCRIPT_NAMES = /* @__PURE__ */ new Set(["lint", "format", "check", "test", "typecheck", "verify"]);
 
 // src/roles/format/inherited-ignores.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 var ROOT_IGNORE_FILE = ".prettierignore";
 function isPattern(line) {
   const trimmed = line.trim();
@@ -1768,11 +1704,11 @@ function toModulePattern(pattern) {
 }
 function inheritedIgnorePatterns(workspaceRoot) {
   if (!workspaceRoot) return [];
-  const path = join13(workspaceRoot, ROOT_IGNORE_FILE);
-  if (!existsSync12(path)) return [];
+  const path = join11(workspaceRoot, ROOT_IGNORE_FILE);
+  if (!existsSync10(path)) return [];
   let contents;
   try {
-    contents = readFileSync9(path, "utf8");
+    contents = readFileSync8(path, "utf8");
   } catch {
     return [];
   }
@@ -1817,13 +1753,13 @@ function needsSvelteCompiler(output) {
 }
 
 // src/roles/format/prettier-config.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
+import { join as join13 } from "node:path";
 
 // src/roles/format/resolve-oxfmt.ts
-import { readFileSync as readFileSync10 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname2, join as join14 } from "node:path";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join as join12 } from "node:path";
 function resolveOxfmt(cwd) {
   return resolveBin(cwd, "oxfmt") ?? binFromOwnInstall("oxfmt", "oxfmt");
 }
@@ -1851,9 +1787,9 @@ function configSchema() {
 }
 function readConfigSchema() {
   try {
-    const manifest = createRequire2(import.meta.url).resolve("oxfmt/package.json");
-    const schemaPath = join14(dirname2(manifest), "configuration_schema.json");
-    return JSON.parse(readFileSync10(schemaPath, "utf8"));
+    const manifest = createRequire(import.meta.url).resolve("oxfmt/package.json");
+    const schemaPath = join12(dirname(manifest), "configuration_schema.json");
+    return JSON.parse(readFileSync9(schemaPath, "utf8"));
   } catch {
     return void 0;
   }
@@ -1884,14 +1820,14 @@ function toOxfmtOverrides(value) {
   return { overrides, unresolved };
 }
 function readPrettierSettings(cwd) {
-  const file = PRETTIER_CONFIG_FILES.find((name) => existsSync13(join15(cwd, name)));
+  const file = PRETTIER_CONFIG_FILES.find((name) => existsSync11(join13(cwd, name)));
   if (!file) return { options: {}, unresolved: [] };
   if (/\.(js|cjs|mjs)$/.test(file)) {
     return { options: {}, file, unresolved: [`${file} is JavaScript, so it was not executed`] };
   }
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync11(join15(cwd, file), "utf8"), file);
+    parsed = parseJsonc(readFileSync10(join13(cwd, file), "utf8"), file);
   } catch {
     return { options: {}, file, unresolved: [`${file} could not be parsed`] };
   }
@@ -2002,7 +1938,7 @@ var OxfmtAdapter = class extends BaseAdapter {
       manifestOperation(context.cwd, this.formatScripts(context.cwd))
     ];
     const prettierConfigs = PRETTIER_CONFIG_FILES.filter(
-      (name) => existsSync14(join16(context.cwd, name))
+      (name) => existsSync12(join14(context.cwd, name))
     );
     for (const name of prettierConfigs) operations.push({ kind: "delete", path: name });
     const removableDeps = this.modulePrettierDependencies(context.cwd);
@@ -2242,7 +2178,7 @@ var OxfmtAdapter = class extends BaseAdapter {
   modulePrettierDependencies(cwd) {
     const isPrettierPackage = (name) => name === "prettier" || name.startsWith("prettier-plugin-") || name.startsWith("@prettier/");
     try {
-      const manifest = JSON.parse(readFileSync12(join16(cwd, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync11(join14(cwd, "package.json"), "utf8"));
       return Object.keys(manifest.devDependencies ?? {}).filter(isPrettierPackage).map((name) => ["devDependencies", name]);
     } catch {
       return [];
@@ -2324,8 +2260,8 @@ function registerFormat() {
 
 // src/roles/lint/adapters/oxlint/oxlint.adapter.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync20, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join24 } from "node:path";
 
 // src/core/config/deferred-rules.ts
 function deferredRuleNames(rules) {
@@ -2334,7 +2270,7 @@ function deferredRuleNames(rules) {
 
 // src/core/fix-report.ts
 import { statSync as statSync2 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join15 } from "node:path";
 var CONFIG_REFUSED = /failed to parse .*config|invalid config file/i;
 function readFailure(output) {
   const lines = output.split("\n").map((line2) => line2.trim());
@@ -2354,7 +2290,7 @@ function fingerprint(path) {
 function snapshotFiles(cwd, extensions) {
   const snapshot = /* @__PURE__ */ new Map();
   for (const file of listSourceFiles(cwd, extensions)) {
-    const mark = fingerprint(join17(cwd, file));
+    const mark = fingerprint(join15(cwd, file));
     if (mark !== void 0) snapshot.set(file, mark);
   }
   return snapshot;
@@ -2362,7 +2298,7 @@ function snapshotFiles(cwd, extensions) {
 function changedSince(cwd, before, extensions) {
   const changed = [];
   for (const file of listSourceFiles(cwd, extensions)) {
-    const now = fingerprint(join17(cwd, file));
+    const now = fingerprint(join15(cwd, file));
     if (now === void 0) continue;
     if (before.get(file) !== now) changed.push(file);
   }
@@ -2385,8 +2321,8 @@ function describeFixOutcome(outcome, toolLabel) {
 }
 
 // src/roles/lint/module-baseline.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } from "node:fs";
+import { join as join16 } from "node:path";
 var LINT_BASELINE_FILE = ".oxlintrc.baseline.json";
 var LINT_MEASURE_FILE = ".oxlintrc.measure.json";
 var LINT_BASELINE_SPECIFIER = `./${LINT_BASELINE_FILE}`;
@@ -2430,11 +2366,11 @@ function describeHolds(holds) {
   return `held ${holds.length} rule(s) at \`warn\` for this module, covering ${total} violation(s) that were already there: ${listed}${rest}. They are written to ${LINT_BASELINE_FILE}, they still report, and they return to \`error\` once fixed and re-initialized`;
 }
 function heldRules(cwd) {
-  const path = join18(cwd, LINT_BASELINE_FILE);
-  if (!existsSync15(path)) return [];
+  const path = join16(cwd, LINT_BASELINE_FILE);
+  if (!existsSync13(path)) return [];
   try {
     const parsed = parseJsonc(
-      readFileSync13(path, "utf8"),
+      readFileSync12(path, "utf8"),
       LINT_BASELINE_FILE
     );
     return Object.keys(parsed.rules ?? {});
@@ -4260,14 +4196,14 @@ function downgradedRulesFor(preset) {
 }
 
 // src/roles/lint/extra-layers.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join19, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync13 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join17, resolve as resolve3 } from "node:path";
 function ruleCount(cwd, specifier) {
   const path = isAbsolute2(specifier) ? specifier : resolve3(cwd, specifier);
-  if (!existsSync16(path)) return void 0;
+  if (!existsSync14(path)) return void 0;
   try {
     const parsed = parseJsonc(
-      readFileSync14(path, "utf8"),
+      readFileSync13(path, "utf8"),
       specifier
     );
     return Object.keys(parsed.rules ?? {}).length;
@@ -4287,7 +4223,7 @@ function extraLayers(cwd, extendsList) {
 function committedExtendsList(cwd, configFile) {
   try {
     const parsed = parseJsonc(
-      readFileSync14(join19(cwd, configFile), "utf8"),
+      readFileSync13(join17(cwd, configFile), "utf8"),
       configFile
     );
     return Array.isArray(parsed.extends) ? parsed.extends.filter((entry) => typeof entry === "string") : [];
@@ -4346,8 +4282,8 @@ function errorCountsByConfigRule(stdout) {
 }
 
 // src/core/config/read-adoption.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "node:fs";
+import { join as join19 } from "node:path";
 
 // src/core/config/owned-keys.ts
 function presetOwnedKeys(config, permitted, presetSets) {
@@ -4362,12 +4298,12 @@ function localOnlyKeys(config, permitted, presetSets) {
 }
 
 // src/core/config/resolve-config-target.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "node:fs";
+import { join as join18 } from "node:path";
 function readExtends(absolutePath) {
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync15(absolutePath, "utf8"), absolutePath);
+    parsed = parseJsonc(readFileSync14(absolutePath, "utf8"), absolutePath);
   } catch {
     return [];
   }
@@ -4381,8 +4317,8 @@ function resolveConfigTarget(moduleDir, { candidates, markers, fallback }) {
   let existing;
   let existingExtendsSomething = false;
   for (const candidate of candidates) {
-    const absolutePath = join20(moduleDir, candidate);
-    if (!existsSync17(absolutePath)) continue;
+    const absolutePath = join18(moduleDir, candidate);
+    if (!existsSync15(absolutePath)) continue;
     const chain = readExtends(absolutePath);
     if (existing === void 0) {
       existing = candidate;
@@ -4415,12 +4351,12 @@ var NOT_ADOPTED3 = (configFile, unreadable = null) => ({
 });
 function readAdoption(cwd, options) {
   const target = resolveConfigTarget(cwd, options);
-  if (target.reason === "none" || !existsSync18(join21(cwd, target.path))) {
+  if (target.reason === "none" || !existsSync16(join19(cwd, target.path))) {
     return NOT_ADOPTED3(target.reason === "none" ? null : target.path);
   }
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync16(join21(cwd, target.path), "utf8"), target.path);
+    parsed = parseJsonc(readFileSync15(join19(cwd, target.path), "utf8"), target.path);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return NOT_ADOPTED3(target.path, `${target.path} could not be parsed (${reason})`);
@@ -4454,15 +4390,15 @@ function readLintAdoption(cwd) {
 }
 
 // src/roles/lint/resolve-oxlint.ts
-import { existsSync as existsSync19 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import { delimiter as delimiter2, dirname as dirname3, join as join22 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { delimiter, dirname as dirname2, join as join20 } from "node:path";
 import { fileURLToPath } from "node:url";
 var PACKAGE_OF = {
   oxlint: "oxlint",
   tsgolint: "oxlint-tsgolint"
 };
-var require3 = createRequire3(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 function resolveOxlint(cwd, name = "oxlint") {
   return resolveBin(cwd, name) ?? binFromOwnInstall(PACKAGE_OF[name], name);
 }
@@ -4472,7 +4408,7 @@ function canRunTypeAware(cwd) {
 function oxlintPath(cwd, env) {
   const shim = tsgolintShim(cwd);
   if (!shim) return env.PATH;
-  return [dirname3(shim), env.PATH].filter(Boolean).join(delimiter2);
+  return [dirname2(shim), env.PATH].filter(Boolean).join(delimiter);
 }
 function tsgolintShim(cwd) {
   const fromModule = resolveBin(cwd, "tsgolint");
@@ -4480,31 +4416,31 @@ function tsgolintShim(cwd) {
   const candidates = [];
   for (const owner of ["oxlint-tsgolint", "oxlint"]) {
     try {
-      const packageDir = dirname3(require3.resolve(`${owner}/package.json`));
-      candidates.push(join22(packageDir, "node_modules", ".bin", "tsgolint"));
-      candidates.push(join22(packageDir, "..", ".bin", "tsgolint"));
+      const packageDir = dirname2(require2.resolve(`${owner}/package.json`));
+      candidates.push(join20(packageDir, "node_modules", ".bin", "tsgolint"));
+      candidates.push(join20(packageDir, "..", ".bin", "tsgolint"));
     } catch {
     }
   }
   try {
-    const ownRoot = dirname3(require3.resolve("@hublo/sentinel/package.json"));
-    candidates.push(join22(ownRoot, "node_modules", ".bin", "tsgolint"));
+    const ownRoot = dirname2(require2.resolve("@hublo/sentinel/package.json"));
+    candidates.push(join20(ownRoot, "node_modules", ".bin", "tsgolint"));
   } catch {
-    candidates.push(resolveBin(dirname3(fileURLToPath(import.meta.url)), "tsgolint") ?? "");
+    candidates.push(resolveBin(dirname2(fileURLToPath(import.meta.url)), "tsgolint") ?? "");
   }
-  return candidates.find((candidate) => candidate !== "" && existsSync19(candidate));
+  return candidates.find((candidate) => candidate !== "" && existsSync17(candidate));
 }
 function oxlintSearchPath(cwd) {
   return binSearchPath(cwd);
 }
 
 // src/roles/lint/adapters/oxlint/plan.ts
-import { existsSync as existsSync21, readFileSync as readFileSync19 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
+import { join as join23 } from "node:path";
 
 // src/roles/lint/eslint-ignores.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
+import { join as join21 } from "node:path";
 import { parseSync as parseSync2 } from "oxc-parser";
 
 // src/shared/ast.ts
@@ -4533,11 +4469,11 @@ function readRootEslintIgnores(root) {
   return { patterns: patterns.filter((pattern) => pattern.startsWith("**/")), unresolved };
 }
 function readEslintIgnores(cwd) {
-  const config = ESLINT_CONFIG_FILES.map((name) => join23(cwd, name)).find((path) => existsSync20(path));
+  const config = ESLINT_CONFIG_FILES.map((name) => join21(cwd, name)).find((path) => existsSync18(path));
   if (!config) return { patterns: [], unresolved: [] };
   let source;
   try {
-    source = readFileSync17(config, "utf8");
+    source = readFileSync16(config, "utf8");
   } catch {
     return { patterns: [], unresolved: [] };
   }
@@ -4628,8 +4564,8 @@ function lintPresetFor(preset) {
 }
 
 // src/roles/lint/rename-suppressions.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync3 } from "node:fs";
-import { join as join24, relative as relative3 } from "node:path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync17, statSync as statSync3 } from "node:fs";
+import { join as join22, relative as relative3 } from "node:path";
 var SOURCE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -4676,7 +4612,7 @@ function* sourceFiles(dir) {
     return;
   }
   for (const entry of entries) {
-    const full = join24(dir, entry);
+    const full = join22(dir, entry);
     let isDirectory;
     try {
       isDirectory = statSync3(full).isDirectory();
@@ -4696,7 +4632,7 @@ function findSuppressionRenames(cwd, renames) {
   for (const file of sourceFiles(cwd)) {
     let content;
     try {
-      content = readFileSync18(file, "utf8");
+      content = readFileSync17(file, "utf8");
     } catch {
       continue;
     }
@@ -4824,7 +4760,7 @@ function plan2(context) {
       keys: removableDeps
     });
   }
-  const eslintConfigs = ESLINT_CONFIG_FILES.filter((name) => existsSync21(join25(context.cwd, name)));
+  const eslintConfigs = ESLINT_CONFIG_FILES.filter((name) => existsSync19(join23(context.cwd, name)));
   for (const name of eslintConfigs) operations.push({ kind: "delete", path: name });
   operations.push(
     ...nxTargetOperations({
@@ -4922,7 +4858,7 @@ function lintScripts(cwd) {
 function committedExtends(cwd) {
   try {
     const parsed = parseJsonc(
-      readFileSync19(join25(cwd, LINT_CONFIG_FILE), "utf8"),
+      readFileSync18(join23(cwd, LINT_CONFIG_FILE), "utf8"),
       LINT_CONFIG_FILE
     );
     return Array.isArray(parsed.extends) ? parsed.extends.filter((entry) => typeof entry === "string") : [];
@@ -4933,7 +4869,7 @@ function committedExtends(cwd) {
 function committedIgnorePatterns(cwd) {
   try {
     const parsed = parseJsonc(
-      readFileSync19(join25(cwd, LINT_CONFIG_FILE), "utf8"),
+      readFileSync18(join23(cwd, LINT_CONFIG_FILE), "utf8"),
       LINT_CONFIG_FILE
     );
     return Array.isArray(parsed.ignorePatterns) ? parsed.ignorePatterns.filter((entry) => typeof entry === "string") : [];
@@ -4945,7 +4881,7 @@ function moduleEslintDependencies(cwd) {
   const isEslintPackage = (name) => name === "eslint" || name === "@types/eslint" || name === "typescript-eslint" || name.startsWith("@typescript-eslint/") || name.startsWith("eslint-plugin-") || name.startsWith("eslint-config-") || name.startsWith("@eslint/");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync19(join25(cwd, "package.json"), "utf8"));
+    manifest = JSON.parse(readFileSync18(join23(cwd, "package.json"), "utf8"));
   } catch {
     return [];
   }
@@ -5079,20 +5015,20 @@ ${result.stderr ?? ""}`);
    * build the developer can see, rather than a silent half-adoption they cannot.
    */
   writeModuleBaseline(ctx, oxlint, env) {
-    const configPath = join26(ctx.cwd, LINT_CONFIG_FILE);
-    const baselinePath = join26(ctx.cwd, LINT_BASELINE_FILE);
-    if (!existsSync22(configPath)) return;
+    const configPath = join24(ctx.cwd, LINT_CONFIG_FILE);
+    const baselinePath = join24(ctx.cwd, LINT_BASELINE_FILE);
+    if (!existsSync20(configPath)) return;
     let config;
     try {
       config = parseJsonc(
-        readFileSync20(configPath, "utf8"),
+        readFileSync19(configPath, "utf8"),
         LINT_CONFIG_FILE
       );
     } catch {
       return;
     }
     const current = Array.isArray(config.extends) ? config.extends : [];
-    const measurePath = join26(ctx.cwd, LINT_MEASURE_FILE);
+    const measurePath = join24(ctx.cwd, LINT_MEASURE_FILE);
     let measured;
     try {
       writeFileSync2(
@@ -5140,7 +5076,7 @@ ${result.stderr ?? ""}`);
     }
   }
   async run(ctx) {
-    if (!existsSync22(join26(ctx.cwd, LINT_CONFIG_FILE))) {
+    if (!existsSync20(join24(ctx.cwd, LINT_CONFIG_FILE))) {
       process.stderr.write(
         `sentinel lint(oxlint): no ${LINT_CONFIG_FILE} in this module; run \`sentinel --init --lint\` to adopt.
 `
@@ -5288,7 +5224,7 @@ ${result.stderr ?? ""}`);
     let stub;
     try {
       stub = parseJsonc(
-        readFileSync20(join26(cwd, LINT_CONFIG_FILE), "utf8"),
+        readFileSync19(join24(cwd, LINT_CONFIG_FILE), "utf8"),
         LINT_CONFIG_FILE
       );
     } catch {
@@ -5298,7 +5234,7 @@ ${result.stderr ?? ""}`);
     for (const entry of stub.extends ?? []) {
       try {
         const preset = parseJsonc(
-          readFileSync20(join26(cwd, entry), "utf8"),
+          readFileSync19(join24(cwd, entry), "utf8"),
           entry
         );
         for (const rule of Object.keys(preset.rules ?? {})) names.add(rule);
@@ -5368,14 +5304,14 @@ ${result.stderr ?? ""}`);
     let parsed;
     try {
       parsed = parseJsonc(
-        readFileSync20(join26(cwd, LINT_CONFIG_FILE), "utf8"),
+        readFileSync19(join24(cwd, LINT_CONFIG_FILE), "utf8"),
         LINT_CONFIG_FILE
       );
     } catch {
       return void 0;
     }
     const targets = Array.isArray(parsed.extends) ? parsed.extends.filter((entry) => typeof entry === "string") : typeof parsed.extends === "string" ? [parsed.extends] : [];
-    return targets.find((target) => !existsSync22(join26(cwd, target)));
+    return targets.find((target) => !existsSync20(join24(cwd, target)));
   }
   /** Announce what is not enforced, so reduced coverage is never silent. */
   announceDisabled(preset) {
@@ -5407,103 +5343,29 @@ function registerLint() {
 
 // src/roles/test/adapters/vitest/vitest.adapter.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { isAbsolute as isAbsolute3, resolve as resolve9 } from "node:path";
-
-// src/roles/test/presets/toolchain.json
-var toolchain_default2 = {
-  $comment: "The test toolchain sentinel owns. Same shape and same rule as the build one: a single table drives what `--init` removes from a module's package.json, which import specifiers move, and the name each default import is re-exported under, so the three cannot disagree.",
-  owned: [
-    {
-      package: "vitest",
-      specifier: "vitest/config",
-      named: ["defineConfig", "mergeConfig"],
-      types: ["ConfigEnv", "TestUserConfig", "ViteUserConfig"],
-      why: "the runner itself, declared at the workspace ROOT today, which is what stops a module being testable on its own. Note the package is `vitest` and the specifier is `vitest/config`: the same split as nitro on the build side, and the reason one table holds both."
-    },
-    {
-      package: "vite",
-      specifier: "vite",
-      named: ["loadEnv"],
-      why: "`loadEnv` has no equivalent in `vitest/config`, and two of the six configs import it from vite to build their test env. Re-exported here rather than claimed: the BUILD role owns the `vite` package, and two roles owning one package is how a version conflict gets written down twice."
-    }
-  ]
-};
-
-// src/roles/test/preset-data.ts
-var OWNED_TEST_PACKAGES = toolchain_default2.owned;
-
-// src/roles/test/config-policy.ts
-var TEST_PRESET_SPECIFIERS = {
-  react: "@hublo/sentinel/test/react",
-  nest: "@hublo/sentinel/test/nest"
-};
-function testPresetSpecifier(preset) {
-  return TEST_PRESET_SPECIFIERS[preset] ?? TEST_PRESET_SPECIFIERS.react;
-}
-var ALL_TEST_PRESET_SPECIFIERS = Object.values(TEST_PRESET_SPECIFIERS);
-var TEST_PRESET_SPECIFIER = TEST_PRESET_SPECIFIERS.react;
-var TEST_CONFIG_FILES = [
-  "vitest.config.ts",
-  "vitest.config.mts",
-  "vitest.config.js",
-  "vitest.config.mjs"
-];
-var TEST_OWNED_PACKAGES = OWNED_TEST_PACKAGES;
-var SENTINEL_OWNED_TEST_PACKAGES = TEST_OWNED_PACKAGES.filter(
-  (entry) => entry.package !== "vite"
-).map((entry) => entry.package);
-function testToolchain(preset) {
-  return { presetSpecifier: testPresetSpecifier(preset), owned: TEST_OWNED_PACKAGES };
-}
-var TEST_SCRIPT_NAME = "test";
-var SENTINEL_TEST_COMMAND = "sentinel --run --test --";
-var VITEST_INVOCATION = /(^|&&\s*|\|\|\s*|;\s*)(?:npx\s+|pnpm\s+(?:exec\s+|dlx\s+)?)?vitest\b([^&|;]*)/g;
-function rewriteVitestScript(command) {
-  return command.replace(VITEST_INVOCATION, (_match, lead, tail) => {
-    const args = tail.trim().split(/\s+/).filter(Boolean);
-    const oneShot = args[0] === "run" || args.includes("--run");
-    const rest = args.filter((arg, index) => !(index === 0 && arg === "run") && arg !== "--run");
-    const passthrough = oneShot ? rest : ["--watch", ...rest];
-    const suffix = passthrough.length > 0 ? ` -- ${passthrough.join(" ")}` : "";
-    const trailing = /\s$/.test(tail) ? " " : "";
-    return `${lead}sentinel --run --test${suffix}${trailing}`;
-  });
-}
-function testTarget(options) {
-  const { name, configFiles, outputs, dependsOn, configurations } = options;
-  const cached = outputs !== void 0 && outputs.length > 0;
-  return {
-    [name ?? TEST_SCRIPT_NAME]: {
-      cache: cached,
-      inputs: ["default", "^default", ...configFiles.map((name2) => `{projectRoot}/${name2}`)],
-      ...cached ? { outputs: [...outputs] } : {},
-      ...dependsOn !== void 0 && dependsOn.length > 0 ? { dependsOn: [...dependsOn] } : {},
-      ...configurations !== void 0 && Object.keys(configurations).length > 0 ? { configurations: { ...configurations } } : {}
-    }
-  };
-}
+import { isAbsolute as isAbsolute3, resolve as resolve8 } from "node:path";
 
 // src/roles/test/jest-migration.ts
-import { existsSync as existsSync32, readFileSync as readFileSync31, readdirSync as readdirSync8 } from "node:fs";
-import { createRequire as createRequire6 } from "node:module";
-import { dirname as dirname11, join as join40, relative as relative8 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync29, readdirSync as readdirSync7 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
+import { dirname as dirname10, join as join37, relative as relative7 } from "node:path";
 
 // src/roles/test/codemod/migrate-module.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync28, statSync as statSync6 } from "node:fs";
-import { join as join35 } from "node:path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync26, statSync as statSync6 } from "node:fs";
+import { join as join32 } from "node:path";
 import { parseSync as parseSync8 } from "oxc-parser";
 
 // src/roles/test/msw-lifecycle.ts
-import { existsSync as existsSync23, readFileSync as readFileSync21 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync20 } from "node:fs";
+import { join as join25 } from "node:path";
 var ROOT_SETUP = "jest.setup.after.env.js";
 function ownsMswLifecycle(cwd, setupFiles) {
   for (const raw of setupFiles) {
     if (raw.endsWith(ROOT_SETUP)) continue;
-    const file = join27(cwd, raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", "."));
-    if (!existsSync23(file)) continue;
+    const file = join25(cwd, raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", "."));
+    if (!existsSync21(file)) continue;
     try {
-      if (/\.listen\s*\(/.test(readFileSync21(file, "utf8"))) return true;
+      if (/\.listen\s*\(/.test(readFileSync20(file, "utf8"))) return true;
     } catch {
       continue;
     }
@@ -5511,141 +5373,19 @@ function ownsMswLifecycle(cwd, setupFiles) {
   return false;
 }
 
-// src/roles/test/read-adoption.ts
-import { existsSync as existsSync24, readFileSync as readFileSync22, readdirSync as readdirSync3 } from "node:fs";
-import { join as join28, relative as relative4 } from "node:path";
-var JEST_CONFIG_FILES = [
-  "jest.config.ts",
-  "jest.config.js",
-  "jest.prisma.config.ts",
-  "jest.functional.config.ts",
-  "jest.integration-config.ts"
-];
-function testConfigFile(cwd) {
-  return TEST_CONFIG_FILES.find((name) => existsSync24(join28(cwd, name)));
-}
-function jestConfigFiles(cwd) {
-  return JEST_CONFIG_FILES.filter((name) => existsSync24(join28(cwd, name)));
-}
-function rootJestConfigFiles(cwd) {
-  const root = findWorkspaceRoot(cwd);
-  if (root === void 0 || root === cwd) return [];
-  return JEST_CONFIG_FILES.filter((name) => existsSync24(join28(root, name)));
-}
-var TEST_FILE = /[.-](spec|test)\.[cm]?[jt]sx?$/;
-var NOT_WALKED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".nx", ".turbo"]);
-function hasTestFiles(cwd) {
-  return walkTestFiles(cwd, true).length > 0;
-}
-function listTestFiles(cwd) {
-  return walkTestFiles(cwd, false).sort();
-}
-function walkTestFiles(cwd, stopAtFirst) {
-  const found = [];
-  const stack = [cwd];
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    let entries;
-    try {
-      entries = readdirSync3(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (!NOT_WALKED.has(entry.name)) stack.push(join28(dir, entry.name));
-      } else if (TEST_FILE.test(entry.name)) {
-        found.push(relative4(cwd, join28(dir, entry.name)).replaceAll("\\", "/"));
-        if (stopAtFirst) return found;
-      }
-    }
-  }
-  return found;
-}
-function readTestConfigSource(cwd, fileName) {
-  try {
-    return readFileSync22(join28(cwd, fileName), "utf8");
-  } catch {
-    return "";
-  }
-}
-function importsPreset2(source) {
-  return ALL_TEST_PRESET_SPECIFIERS.some((specifier) => {
-    const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(String.raw`(?:from|import)\s*\(?\s*['"]${escaped}['"]`).test(source);
-  });
-}
-function readTestAdoption(cwd) {
-  const manifest = readProjectPackageJson(cwd);
-  const jestConfigs = jestConfigFiles(cwd);
-  const configFile = testConfigFile(cwd);
-  const declared = { ...manifest.dependencies, ...manifest.devDependencies };
-  const ownDeclarations = ["vitest", "jest", "@nx/jest", "jest-mock-extended", "@swc/jest"].filter((name) => declared[name] !== void 0).map((name) => ({ name, version: declared[name] }));
-  if (configFile === void 0) {
-    const hasTests = hasTestFiles(cwd);
-    const inheritsRootConfig = hasTests && jestConfigs.length === 0 && rootJestConfigFiles(cwd).length > 0;
-    return {
-      configFile: null,
-      preset: null,
-      adopted: false,
-      conformant: false,
-      drift: [],
-      unreadable: null,
-      state: hasTests ? "jest" : "no-tests",
-      runner: hasTests ? "jest" : "none",
-      jestConfigs,
-      inheritsRootConfig,
-      ownDeclarations
-    };
-  }
-  const source = readTestConfigSource(cwd, configFile);
-  if (source === "") {
-    return {
-      configFile,
-      preset: null,
-      adopted: false,
-      conformant: false,
-      drift: [],
-      unreadable: `${configFile} could not be read`,
-      state: "vitest-own-toolchain",
-      runner: "vitest",
-      jestConfigs,
-      inheritsRootConfig: false,
-      // it has a config of its own, readable or not
-      ownDeclarations
-    };
-  }
-  const adopted = importsPreset2(source);
-  const script = moduleScripts(cwd)["test"];
-  return {
-    configFile,
-    preset: adopted ? "react" : null,
-    adopted,
-    conformant: adopted && script !== void 0 && jestConfigs.length === 0,
-    drift: [],
-    unreadable: null,
-    state: adopted ? "adopted" : "vitest-own-toolchain",
-    runner: "vitest",
-    jestConfigs,
-    inheritsRootConfig: false,
-    // local always wins: this module is out of the root's reach
-    ownDeclarations
-  };
-}
-
 // src/roles/test/support-file-name.ts
 var JEST_PREFIX = "jest.";
 var VITEST_PREFIX = "vitest.";
-function vitestSupportName(relative9) {
-  const cut = relative9.lastIndexOf("/");
-  const directory = cut === -1 ? "" : relative9.slice(0, cut + 1);
-  const base = relative9.slice(cut + 1);
-  if (!base.startsWith(JEST_PREFIX)) return relative9;
+function vitestSupportName(relative8) {
+  const cut = relative8.lastIndexOf("/");
+  const directory = cut === -1 ? "" : relative8.slice(0, cut + 1);
+  const base = relative8.slice(cut + 1);
+  if (!base.startsWith(JEST_PREFIX)) return relative8;
   return `${directory}${VITEST_PREFIX}${base.slice(JEST_PREFIX.length)}`;
 }
 
 // src/roles/test/codemod/migrate-file.ts
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 import { parseSync as parseSync7 } from "oxc-parser";
 
 // src/roles/test/codemod/assertion-return-value.ts
@@ -5774,12 +5514,38 @@ function rewriteAssertionReturnValue(source, program) {
   return { source: result, rewritten: captures.length - refusals.length, refusals };
 }
 
-// src/roles/test/codemod/constructible-mocks.ts
+// src/roles/test/codemod/bare-mock-factory.ts
 var MEMBER_TYPES2 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function isMockFactory(node) {
+  if (node === void 0 || !MEMBER_TYPES2.has(node.type)) return false;
+  const object = node.object;
+  const property = node.property;
+  if (object?.type !== "Identifier") return false;
+  if (object.name !== "vi" && object.name !== "jest") return false;
+  return property?.type === "Identifier" && property.name === "fn";
+}
+function invokeBareMockFactories(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    for (const argument of node.arguments ?? []) {
+      if (isMockFactory(argument)) edits.push(argument.end);
+    }
+  });
+  if (edits.length === 0) return { source, rewritten: 0 };
+  let result = source;
+  for (const end of [...edits].sort((left, right) => right - left)) {
+    result = `${result.slice(0, end)}()${result.slice(end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
+// src/roles/test/codemod/constructible-mocks.ts
+var MEMBER_TYPES3 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 function mockImplementationArrow(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES2.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES3.has(callee.type)) return void 0;
   const property = callee.property;
   if (property?.type !== "Identifier" || property.name !== "mockImplementation") return void 0;
   const [argument] = node.arguments ?? [];
@@ -5788,7 +5554,7 @@ function mockImplementationArrow(node) {
 function assertedMockedClass(source, node) {
   if (node.type !== "CallExpression") return false;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES2.has(callee.type)) return false;
+  if (callee === void 0 || !MEMBER_TYPES3.has(callee.type)) return false;
   const object = callee.object;
   if (object === void 0) return false;
   return /\bMockedClass\b/.test(source.slice(object.start, object.end));
@@ -5864,16 +5630,16 @@ function normaliseDeepImports(source) {
 }
 
 // src/roles/test/codemod/each-table-rows.ts
-var MEMBER_TYPES3 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES4 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var RUNNERS = /* @__PURE__ */ new Set(["it", "test", "describe"]);
 function eachTable(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES3.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES4.has(callee.type)) return void 0;
   const property = callee.property;
   if (property?.type !== "Identifier" || property.name !== "each") return void 0;
   let object = callee.object;
-  while (object !== void 0 && MEMBER_TYPES3.has(object.type)) {
+  while (object !== void 0 && MEMBER_TYPES4.has(object.type)) {
     object = object.object;
   }
   if (object?.type !== "Identifier" || !RUNNERS.has(object.name)) return void 0;
@@ -5900,13 +5666,13 @@ function rewriteEachTableRows(source, program) {
 }
 
 // src/roles/test/codemod/each-title.ts
-var MEMBER_TYPES4 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES5 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 function eachTitle(node) {
   if (node.type !== "CallExpression") return void 0;
   const inner = node.callee;
   if (inner?.type !== "CallExpression") return void 0;
   const member = inner.callee;
-  if (member === void 0 || !MEMBER_TYPES4.has(member.type)) return void 0;
+  if (member === void 0 || !MEMBER_TYPES5.has(member.type)) return void 0;
   const property = member.property;
   if (property?.type !== "Identifier" || property.name !== "each") return void 0;
   const [title] = node.arguments ?? [];
@@ -5959,14 +5725,14 @@ function rewriteEachTitles(source, program) {
 
 // src/roles/test/codemod/empty-mock-implementation.ts
 var METHODS = /* @__PURE__ */ new Set(["mockImplementation", "mockImplementationOnce"]);
-var MEMBER_TYPES5 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES6 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 function rewriteEmptyMockImplementation(source, program) {
   const insertAt = [];
   walk(program, (node) => {
     if (node.type !== "CallExpression") return;
     if ((node.arguments ?? []).length > 0) return;
     const callee = node.callee;
-    if (callee === void 0 || !MEMBER_TYPES5.has(callee.type)) return;
+    if (callee === void 0 || !MEMBER_TYPES6.has(callee.type)) return;
     const property = callee.property;
     if (property?.type !== "Identifier" || !METHODS.has(property.name)) return;
     insertAt.push(node.end - 1);
@@ -5979,12 +5745,12 @@ function rewriteEmptyMockImplementation(source, program) {
 }
 
 // src/roles/test/codemod/fake-timer-options.ts
-var MEMBER_TYPES6 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES7 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var TIMER_CALLS = /* @__PURE__ */ new Set(["useFakeTimers"]);
 function timerOptions(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES6.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES7.has(callee.type)) return void 0;
   const object = callee.object;
   const property = callee.property;
   if (object?.type !== "Identifier") return void 0;
@@ -6328,7 +6094,7 @@ function hoistCapturedBindings(source, program, factories, bindings, imported) {
 
 // src/roles/test/codemod/hook-return-value.ts
 var HOOKS = /* @__PURE__ */ new Set(["beforeEach", "afterEach", "beforeAll", "afterAll"]);
-var MEMBER_TYPES7 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES8 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 function hookCallback(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
@@ -6339,7 +6105,7 @@ function hookCallback(node) {
 function configuresAMock(body) {
   if (body.type !== "CallExpression") return false;
   const callee = body.callee;
-  if (callee === void 0 || !MEMBER_TYPES7.has(callee.type)) return false;
+  if (callee === void 0 || !MEMBER_TYPES8.has(callee.type)) return false;
   const property = callee.property;
   return property?.type === "Identifier" && /^mock[A-Z]/.test(property.name);
 }
@@ -6524,37 +6290,37 @@ ${source}`;
 }
 
 // src/roles/test/codemod/named-rules.ts
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "node:fs";
-import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname4, join as join29 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync21 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname3, join as join26 } from "node:path";
 function isCommonJsPackage(fromFile, specifier) {
   if (specifier.startsWith(".") || specifier.startsWith("/")) return false;
   let resolved;
   try {
-    resolved = createRequire4(fromFile).resolve(specifier);
+    resolved = createRequire3(fromFile).resolve(specifier);
   } catch {
     return false;
   }
   if (!resolved.includes(`${"/"}node_modules${"/"}`)) return false;
   if (resolved.endsWith(".mjs")) return false;
   if (resolved.endsWith(".cjs")) return true;
-  let dir = dirname4(resolved);
+  let dir = dirname3(resolved);
   for (let depth = 0; depth < 12; depth += 1) {
-    const manifest = join29(dir, "package.json");
-    if (existsSync25(manifest)) {
+    const manifest = join26(dir, "package.json");
+    if (existsSync22(manifest)) {
       try {
-        return JSON.parse(readFileSync23(manifest, "utf8")).type !== "module";
+        return JSON.parse(readFileSync21(manifest, "utf8")).type !== "module";
       } catch {
         return false;
       }
     }
-    const parent = dirname4(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return false;
 }
-var MEMBER_TYPES8 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES9 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var ASYNC_REPLACEMENTS = {
   requireActual: "importActual",
   requireMock: "importMock"
@@ -6564,7 +6330,7 @@ function mockedSpecifiers(program) {
   walk(program, (node) => {
     if (node.type !== "CallExpression") return;
     const callee = node.callee;
-    if (callee === void 0 || !MEMBER_TYPES8.has(callee.type)) return;
+    if (callee === void 0 || !MEMBER_TYPES9.has(callee.type)) return;
     const object = callee.object;
     const property = callee.property;
     if (object?.type !== "Identifier") return;
@@ -6601,7 +6367,7 @@ function bareRequire(node) {
 function mockFactoryReturn(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES8.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES9.has(callee.type)) return void 0;
   const object = callee.object;
   const property = callee.property;
   if (object?.type !== "Identifier") return void 0;
@@ -6711,7 +6477,7 @@ function applyNamedRules(source, program, fileName = "") {
       }
       return;
     }
-    if (!MEMBER_TYPES8.has(node.type)) return;
+    if (!MEMBER_TYPES9.has(node.type)) return;
     const object = node.object;
     if (object !== void 0) readsANameOffIt.add(object);
   });
@@ -6782,13 +6548,13 @@ function applyNamedRules(source, program, fileName = "") {
 }
 
 // src/roles/test/codemod/isolate-modules.ts
-var MEMBER_TYPES9 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES10 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var ISOLATORS = /* @__PURE__ */ new Set(["isolateModules", "isolateModulesAsync"]);
 var FUNCTIONS2 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression"]);
 function isolatingCall(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES9.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES10.has(callee.type)) return void 0;
   const object = callee.object;
   const property = callee.property;
   if (object?.type !== "Identifier" || object.name !== "jest") return void 0;
@@ -6799,7 +6565,7 @@ function isolatingCall(node) {
 function unusableIsolatingCall(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES9.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES10.has(callee.type)) return void 0;
   const object = callee.object;
   const property = callee.property;
   if (object?.type !== "Identifier" || object.name !== "jest") return void 0;
@@ -6850,11 +6616,11 @@ ${indent}await (${callback})()`
 }
 
 // src/roles/test/codemod/mock-as-value.ts
-var MEMBER_TYPES10 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES11 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 function isViMockCall(node) {
   if (node?.type !== "CallExpression") return false;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES10.has(callee.type)) return false;
+  if (callee === void 0 || !MEMBER_TYPES11.has(callee.type)) return false;
   const object = callee.object;
   const property = callee.property;
   return object?.type === "Identifier" && object.name === "vi" && property?.type === "Identifier" && (property.name === "mock" || property.name === "doMock");
@@ -6879,7 +6645,7 @@ function rewriteMockAsValue(source, program) {
   const memberUses = /* @__PURE__ */ new Map();
   const otherUses = /* @__PURE__ */ new Map();
   walk(program, (node) => {
-    if (MEMBER_TYPES10.has(node.type)) {
+    if (MEMBER_TYPES11.has(node.type)) {
       const object = node.object;
       if (object?.type === "Identifier" && bindings.has(object.name)) {
         const list = memberUses.get(object.name) ?? [];
@@ -6925,12 +6691,12 @@ function rewriteMockAsValue(source, program) {
 }
 
 // src/roles/test/codemod/mock-factory-default.ts
-var MEMBER_TYPES11 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES12 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var BINDING = "sentinelMockedModule";
 function mockCall(node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES11.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES12.has(callee.type)) return void 0;
   const property = callee.property;
   if (property?.type !== "Identifier" || property.name !== "mock") return void 0;
   const object = callee.object;
@@ -7043,7 +6809,7 @@ function rewriteMockFactoryDefault(source, program, defaultImported) {
 
 // src/roles/test/codemod/mock-promise-resolve.ts
 var MOCK_FACTORY = /* @__PURE__ */ new Set(["fn", "spyOn"]);
-function isMockFactory(source, node) {
+function isMockFactory2(source, node) {
   if (node.type !== "CallExpression") return false;
   const callee = node.callee;
   if (callee?.type !== "MemberExpression") return false;
@@ -7086,7 +6852,7 @@ function resolvedValue(source, executor) {
 function rewriteMockPromiseResolve(source, program) {
   const edits = [];
   walk(program, (node) => {
-    if (!isMockFactory(source, node)) return;
+    if (!isMockFactory2(source, node)) return;
     for (const argument of node.arguments ?? []) {
       walk(argument, (inner) => {
         if (inner.type !== "NewExpression") return;
@@ -7114,11 +6880,11 @@ function rewriteMockPromiseResolve(source, program) {
 }
 
 // src/roles/test/codemod/mocked-module-binding.ts
-var MEMBER_TYPES12 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES13 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 function mockedSpecifier(source, node) {
   if (node.type !== "CallExpression") return void 0;
   const callee = node.callee;
-  if (callee === void 0 || !MEMBER_TYPES12.has(callee.type)) return void 0;
+  if (callee === void 0 || !MEMBER_TYPES13.has(callee.type)) return void 0;
   const object = callee.object;
   const property = callee.property;
   if (object?.type !== "Identifier") return void 0;
@@ -7176,7 +6942,7 @@ function annotateMockedBindings(source, program) {
 // src/roles/test/codemod/propagate-await.ts
 import { parseSync as parseSync5 } from "oxc-parser";
 var FUNCTIONS3 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
-var MEMBER_TYPES13 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var MEMBER_TYPES14 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var ALREADY_A_PROMISE = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
 function asyncFunctionNames(program) {
   const names = /* @__PURE__ */ new Set();
@@ -7250,7 +7016,7 @@ function alreadyHandled(call, parent) {
   if (parent === void 0) return false;
   if (parent.type === "AwaitExpression") return true;
   if (parent.type === "ReturnStatement" || parent.type === "ArrowFunctionExpression") return true;
-  if (MEMBER_TYPES13.has(parent.type) && parent.object === call) {
+  if (MEMBER_TYPES14.has(parent.type) && parent.object === call) {
     const property = parent.property;
     return property?.type === "Identifier" && ALREADY_A_PROMISE.has(property.name);
   }
@@ -7300,10 +7066,10 @@ function propagateAwait(fileName, source, original, elsewhere = /* @__PURE__ */
 }
 
 // src/roles/test/codemod/reexport-barrel-mock.ts
-import { readFileSync as readFileSync24, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
-import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname5, join as join30 } from "node:path";
-var MEMBER_TYPES14 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+import { readFileSync as readFileSync22, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import { dirname as dirname4, join as join27 } from "node:path";
+var MEMBER_TYPES15 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
 var PACKAGE_SUBPATH = /^(@[^/]+\/[^/]+|[^@.][^/]*)\/(.+)$/;
 var PURE_REEXPORT = /^module\.exports\s*=\s*require\(\s*(['"])([^'"]+)\1\s*\)\s*;?$/;
 function mockCalls(program) {
@@ -7311,7 +7077,7 @@ function mockCalls(program) {
   walk(program, (node) => {
     if (node.type !== "CallExpression") return;
     const callee = node.callee;
-    if (callee === void 0 || !MEMBER_TYPES14.has(callee.type)) return;
+    if (callee === void 0 || !MEMBER_TYPES15.has(callee.type)) return;
     const object = callee.object;
     const property = callee.property;
     if (object?.type !== "Identifier") return;
@@ -7331,14 +7097,14 @@ function mockCalls(program) {
 }
 function packageRoot(fromFile, name) {
   try {
-    return dirname5(createRequire5(fromFile).resolve(`${name}/package.json`));
+    return dirname4(createRequire4(fromFile).resolve(`${name}/package.json`));
   } catch {
     return void 0;
   }
 }
 function resolveFrom(fromFile, specifier) {
   try {
-    return createRequire5(fromFile).resolve(specifier);
+    return createRequire4(fromFile).resolve(specifier);
   } catch {
     return void 0;
   }
@@ -7348,18 +7114,18 @@ function barrelsFor(fromFile, name, target) {
   if (root === void 0) return [];
   let entries;
   try {
-    entries = readdirSync4(root);
+    entries = readdirSync3(root);
   } catch {
     return [];
   }
   const aliases = [];
   for (const entry of entries) {
     if (!entry.endsWith(".js")) continue;
-    const path = join30(root, entry);
+    const path = join27(root, entry);
     let body;
     try {
       if (!statSync4(path).isFile()) continue;
-      body = readFileSync24(path, "utf8");
+      body = readFileSync22(path, "utf8");
     } catch {
       continue;
     }
@@ -7438,17 +7204,17 @@ function repointMswServer(fileName, source) {
 }
 
 // src/roles/test/codemod/setup-static-imports.ts
-import { dirname as dirname7, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, resolve as resolve6 } from "node:path";
 
 // src/core/context.ts
-import { existsSync as existsSync26 } from "node:fs";
-import { dirname as dirname6, join as join32, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { dirname as dirname5, join as join29, resolve as resolve4 } from "node:path";
 
 // src/core/discover-modules.ts
 import { execFileSync } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync25, rmSync as rmSync3 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync23, rmSync as rmSync3 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join31 } from "node:path";
+import { join as join28 } from "node:path";
 function runNx(cwd, args) {
   const nx = resolveBin(cwd, "nx") ?? "nx";
   try {
@@ -7466,11 +7232,11 @@ function runNx(cwd, args) {
   }
 }
 function readGraph(cwd) {
-  const dir = mkdtempSync(join31(tmpdir(), "sentinel-nx-"));
-  const file = join31(dir, "graph.json");
+  const dir = mkdtempSync(join28(tmpdir(), "sentinel-nx-"));
+  const file = join28(dir, "graph.json");
   try {
     runNx(cwd, ["graph", "--file", file]);
-    const parsed = JSON.parse(readFileSync25(file, "utf8"));
+    const parsed = JSON.parse(readFileSync23(file, "utf8"));
     const nodes = parsed.graph?.nodes;
     if (!nodes || typeof nodes !== "object") {
       throw new Error(
@@ -7479,7 +7245,7 @@ function readGraph(cwd) {
     }
     return Object.entries(nodes).map(([name, node]) => ({
       name,
-      root: join31(cwd, node.data.root)
+      root: join28(cwd, node.data.root)
     }));
   } finally {
     rmSync3(dir, { recursive: true, force: true });
@@ -7497,20 +7263,20 @@ function discoverModules(cwd, options = {}) {
 // src/core/context.ts
 var MODULE_MARKERS = ["package.json", "project.json"];
 function isModuleDir(cwd) {
-  return MODULE_MARKERS.some((marker) => existsSync26(join32(cwd, marker)));
+  return MODULE_MARKERS.some((marker) => existsSync23(join29(cwd, marker)));
 }
 function findModuleRoot(startDir, workspaceRoot) {
   let dir = resolve4(startDir);
   for (; ; ) {
     if (workspaceRoot !== void 0 && dir === resolve4(workspaceRoot)) return void 0;
     if (isModuleDir(dir)) return dir;
-    const parent = dirname6(dir);
+    const parent = dirname5(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 function resolveContext(cwd, opts) {
-  const atRoot = existsSync26(join32(cwd, WORKSPACE_ROOT_MARKER));
+  const atRoot = existsSync23(join29(cwd, WORKSPACE_ROOT_MARKER));
   if (!atRoot && isModuleDir(cwd)) {
     if (opts.module) {
       throw new Error(
@@ -7538,16 +7304,16 @@ function resolveContext(cwd, opts) {
 }
 
 // src/roles/test/codemod/workspace-specifier.ts
-import { existsSync as existsSync27, readFileSync as readFileSync26 } from "node:fs";
-import { join as join33, relative as relative5, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync24 } from "node:fs";
+import { join as join30, relative as relative4, resolve as resolve5 } from "node:path";
 var EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", "/index.ts", "/index.js"];
 function pathEntries(workspaceRoot) {
-  const file = join33(workspaceRoot, "tsconfig.base.json");
-  if (!existsSync27(file)) return [];
+  const file = join30(workspaceRoot, "tsconfig.base.json");
+  if (!existsSync24(file)) return [];
   let paths;
   try {
     paths = parseJsonc(
-      readFileSync26(file, "utf8"),
+      readFileSync24(file, "utf8"),
       "tsconfig.base.json"
     )?.compilerOptions?.paths;
   } catch {
@@ -7575,7 +7341,7 @@ function workspaceSpecifier(workspaceRoot, file) {
       }
       continue;
     }
-    const rest = relative5(entry.target, absolute);
+    const rest = relative4(entry.target, absolute);
     if (rest === "" || rest.startsWith("..") || rest.startsWith("/")) continue;
     const named = rest.replace(/\\/g, "/").replace(/\.(m|c)?(j|t)sx?$/, "");
     return `${entry.key}/${named}`;
@@ -7596,7 +7362,7 @@ function requireCall(source, node) {
 }
 function importable(written, fileName, workspaceRoot) {
   if (!written.startsWith(".")) return written;
-  const fileDir = dirname7(fileName);
+  const fileDir = dirname6(fileName);
   const moduleRoot = findModuleRoot(fileDir, workspaceRoot) ?? fileDir;
   const target = resolve6(fileDir, written);
   if (target.startsWith(`${moduleRoot}/`)) return written;
@@ -7742,7 +7508,7 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
     fileName,
     source,
     beforeStatic,
-    findWorkspaceRoot(dirname8(fileName))
+    findWorkspaceRoot(dirname7(fileName))
   );
   source = statics.source;
   const original = statics.rewritten === 0 ? beforeStatic : parse2(fileName, source);
@@ -7804,7 +7570,10 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
   const afterHoist = parse2(fileName, hoist.source);
   if (afterHoist === void 0) return unparsable("hoisting captured bindings");
   const mockedBindings = annotateMockedBindings(hoist.source, afterHoist);
-  const withImport = injectTypeImport(fileName, mockedBindings.source, [
+  const afterBindings = parse2(fileName, mockedBindings.source);
+  if (afterBindings === void 0) return unparsable("mocked module bindings");
+  const bareFactories = invokeBareMockFactories(mockedBindings.source, afterBindings);
+  const withImport = injectTypeImport(fileName, bareFactories.source, [
     ...renamed.typeImports,
     ...spyTypes.typeImports,
     ...mockedBindings.typeImports
@@ -7831,6 +7600,7 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
       ...hooks.rewritten > 0 ? ["hook body, so it does not return its mock"] : [],
       ...spyTypes.rewritten > 0 ? ["SpyInstance<T> as a signature, not a return type"] : [],
       ...mockedBindings.rewritten > 0 ? ["a mocked module binding, typed as mocked"] : [],
+      ...bareFactories.rewritten > 0 ? ["vi.fn passed as a value, invoked"] : [],
       ...awaited.rewritten > 0 ? ["await propagated to a helper that became async"] : [],
       ...barrels.added.map((alias) => `mock carried to ${alias}, which re-exports the mocked file`),
       ...fakeTimers.translated
@@ -7858,10 +7628,10 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
 }
 
 // src/roles/test/codemod/test-support-files.ts
-import { existsSync as existsSync28, readFileSync as readFileSync27, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
-import { dirname as dirname9, join as join34, relative as relative6, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync25, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
+import { dirname as dirname8, join as join31, relative as relative5, resolve as resolve7 } from "node:path";
 var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".vite"]);
-var TEST_FILE2 = /\.(spec|test)\.[cm]?[jt]sx?$/;
+var TEST_FILE = /\.(spec|test)\.[cm]?[jt]sx?$/;
 var SOURCE_FILE = /\.[cm]?[jt]sx?$/;
 var EXTENSIONS2 = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"];
 function relativeSpecifiers(source) {
@@ -7878,14 +7648,14 @@ function relativeSpecifiers(source) {
   return found;
 }
 function resolveSpecifier(fromFile, specifier) {
-  const base = resolve7(dirname9(fromFile), specifier);
-  if (existsSync28(base) && statSync5(base).isFile()) return base;
+  const base = resolve7(dirname8(fromFile), specifier);
+  if (existsSync25(base) && statSync5(base).isFile()) return base;
   for (const extension of EXTENSIONS2) {
-    if (existsSync28(`${base}${extension}`)) return `${base}${extension}`;
+    if (existsSync25(`${base}${extension}`)) return `${base}${extension}`;
   }
   for (const extension of EXTENSIONS2) {
-    const index = join34(base, `index${extension}`);
-    if (existsSync28(index)) return index;
+    const index = join31(base, `index${extension}`);
+    if (existsSync25(index)) return index;
   }
   return void 0;
 }
@@ -7896,15 +7666,15 @@ function moduleSources(cwd) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync5(dir, { withFileTypes: true });
+      entries = readdirSync4(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!SKIPPED.has(entry.name)) stack.push(join34(dir, entry.name));
+        if (!SKIPPED.has(entry.name)) stack.push(join31(dir, entry.name));
       } else if (SOURCE_FILE.test(entry.name)) {
-        found.push(join34(dir, entry.name));
+        found.push(join31(dir, entry.name));
       }
     }
   }
@@ -7912,7 +7682,7 @@ function moduleSources(cwd) {
 }
 function read(path) {
   try {
-    return readFileSync27(path, "utf8");
+    return readFileSync25(path, "utf8");
   } catch {
     return void 0;
   }
@@ -7922,9 +7692,9 @@ function setupFilesInside(cwd, named) {
   for (const raw of named) {
     const withoutToken = raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", ".");
     const full = resolve7(cwd, withoutToken);
-    const inside = relative6(cwd, full);
+    const inside = relative5(cwd, full);
     if (inside.startsWith("..") || inside === "") continue;
-    if (!existsSync28(full)) continue;
+    if (!existsSync25(full)) continue;
     kept.push(inside.replaceAll("\\", "/"));
   }
   return kept;
@@ -7945,21 +7715,21 @@ function listTestSupportFiles(cwd, setupFiles = []) {
     }
   }
   const testOnly = /* @__PURE__ */ new Set();
-  const queue = sources.filter((file) => TEST_FILE2.test(file));
+  const queue = sources.filter((file) => TEST_FILE.test(file));
   const isTestOnly = (file) => (importedBy.get(file) ?? []).every(
-    (importer) => TEST_FILE2.test(importer) || testOnly.has(importer)
+    (importer) => TEST_FILE.test(importer) || testOnly.has(importer)
   );
   while (queue.length > 0) {
     const file = queue.shift();
     for (const specifier of relativeSpecifiers(contents.get(file) ?? "")) {
       const target = resolveSpecifier(file, specifier);
-      if (target === void 0 || TEST_FILE2.test(target) || testOnly.has(target)) continue;
+      if (target === void 0 || TEST_FILE.test(target) || testOnly.has(target)) continue;
       if (!isTestOnly(target)) continue;
       testOnly.add(target);
       queue.push(target);
     }
   }
-  const reachable = [...testOnly].filter((file) => /\brequire\s*\(/.test(contents.get(file) ?? "")).map((file) => relative6(cwd, file).replaceAll("\\", "/"));
+  const reachable = [...testOnly].filter((file) => /\brequire\s*\(/.test(contents.get(file) ?? "")).map((file) => relative5(cwd, file).replaceAll("\\", "/"));
   return [.../* @__PURE__ */ new Set([...reachable, ...setupFilesInside(cwd, setupFiles)])].sort();
 }
 
@@ -7970,7 +7740,7 @@ function parse3(source) {
 }
 function read2(path) {
   try {
-    return readFileSync28(path, "utf8");
+    return readFileSync26(path, "utf8");
   } catch {
     return void 0;
   }
@@ -7982,13 +7752,13 @@ function defaultImportedSpecifiers(cwd) {
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync6(dir);
+      entries = readdirSync5(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (SKIPPED2.has(entry)) continue;
-      const path = join35(dir, entry);
+      const path = join32(dir, entry);
       let directory;
       try {
         directory = statSync6(path).isDirectory();
@@ -8018,22 +7788,22 @@ function migrateModuleTests(cwd, setupFiles = []) {
   let hoisted = 0;
   const defaultImported = defaultImportedSpecifiers(cwd);
   const asyncHelpers = /* @__PURE__ */ new Set();
-  for (const relative9 of listTestSupportFiles(cwd, setupFiles)) {
-    const source = read2(join35(cwd, relative9));
+  for (const relative8 of listTestSupportFiles(cwd, setupFiles)) {
+    const source = read2(join32(cwd, relative8));
     if (source === void 0) {
-      blockers.push({ file: relative9, reason: "this file could not be read" });
+      blockers.push({ file: relative8, reason: "this file could not be read" });
       continue;
     }
     const migrated = migrateTestFile(
-      join35(cwd, relative9),
+      join32(cwd, relative8),
       source,
       defaultImported,
       /* @__PURE__ */ new Set(),
       modulesOwnMsw
     );
-    const renamedTo = vitestSupportName(relative9);
-    if (!migrated.changed && renamedTo === relative9) continue;
-    if (renamedTo !== relative9) operations.push({ kind: "delete", path: relative9 });
+    const renamedTo = vitestSupportName(relative8);
+    if (!migrated.changed && renamedTo === relative8) continue;
+    if (renamedTo !== relative8) operations.push({ kind: "delete", path: relative8 });
     const before = parse3(source);
     const after = parse3(migrated.source);
     if (before !== void 0 && after !== void 0) {
@@ -8046,14 +7816,14 @@ function migrateModuleTests(cwd, setupFiles = []) {
     renamed += migrated.renamed;
     operations.push({ kind: "write", path: renamedTo, contents: migrated.source });
   }
-  for (const relative9 of listTestFiles(cwd)) {
-    const source = read2(join35(cwd, relative9));
+  for (const relative8 of listTestFiles(cwd)) {
+    const source = read2(join32(cwd, relative8));
     if (source === void 0) {
-      blockers.push({ file: relative9, reason: "this file could not be read" });
+      blockers.push({ file: relative8, reason: "this file could not be read" });
       continue;
     }
     const migrated = migrateTestFile(
-      join35(cwd, relative9),
+      join32(cwd, relative8),
       source,
       defaultImported,
       asyncHelpers,
@@ -8061,27 +7831,27 @@ function migrateModuleTests(cwd, setupFiles = []) {
     );
     for (const member of migrated.unhandled) {
       blockers.push({
-        file: `${relative9}:${member.line}`,
+        file: `${relative8}:${member.line}`,
         reason: member.rule === void 0 ? `${member.member} has no rule, and guessing one is how a suite goes green for the wrong reason` : `${member.member} needs ${member.rule}`
       });
     }
     collected.push(...migrated.warnings);
     for (const refusal of migrated.refusals) {
-      blockers.push({ file: relative9, reason: refusal.reason });
+      blockers.push({ file: relative8, reason: refusal.reason });
     }
     if (!migrated.changed) continue;
     files++;
     renamed += migrated.renamed;
     if (migrated.hoisted.length > 0) hoisted++;
-    operations.push({ kind: "write", path: relative9, contents: migrated.source });
+    operations.push({ kind: "write", path: relative8, contents: migrated.source });
   }
   const warnings = [...new Set(collected)];
   return blockers.length > 0 ? { operations: [], files, renamed, hoisted, blockers, warnings } : { operations, files, renamed, hoisted, blockers: [], warnings };
 }
 
 // src/roles/test/nest/generate-config.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync29, statSync as statSync7 } from "node:fs";
-import { join as join36, relative as relative7 } from "node:path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync27, statSync as statSync7 } from "node:fs";
+import { join as join33, relative as relative6 } from "node:path";
 var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/nest";
 var REACT_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/react";
 function flavourOf(reading) {
@@ -8091,7 +7861,7 @@ var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/jest-parity";
 var SENTINEL_MSW_SETUP = "@hublo/sentinel/test/setup/msw-lifecycle";
 var SENTINEL_WORKSPACE_SETUP = "@hublo/sentinel/test/setup/workspace";
 function hopsToRoot(cwd, workspaceRoot) {
-  const up = relative7(cwd, workspaceRoot).replaceAll("\\", "/");
+  const up = relative6(cwd, workspaceRoot).replaceAll("\\", "/");
   return up === "" ? "." : up;
 }
 function inlineBlock(packages) {
@@ -8119,13 +7889,13 @@ function readModuleTraits(cwd) {
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = readdirSync7(dir);
+      entries = readdirSync6(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (SKIPPED3.has(entry)) continue;
-      const path = join36(dir, entry);
+      const path = join33(dir, entry);
       let directory;
       try {
         directory = statSync7(path).isDirectory();
@@ -8139,7 +7909,7 @@ function readModuleTraits(cwd) {
       if (!/\.tsx?$/.test(entry)) continue;
       let source;
       try {
-        source = readFileSync29(path, "utf8");
+        source = readFileSync27(path, "utf8");
       } catch {
         continue;
       }
@@ -8270,8 +8040,8 @@ ${overrides.join("\n")}
 }
 
 // src/roles/test/nest/read-jest-config.ts
-import { existsSync as existsSync29, readFileSync as readFileSync30 } from "node:fs";
-import { join as join37 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync28 } from "node:fs";
+import { join as join34 } from "node:path";
 var CARRIED = [
   "testEnvironment",
   "coverageDirectory",
@@ -8461,7 +8231,7 @@ function extendedConfig(source, cwd) {
       (name) => name.replace(/^\.\//, "")
     );
     const file = candidates.find(
-      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync29(join37(cwd, name))
+      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync26(join34(cwd, name))
     );
     if (file === void 0) continue;
     if (!new RegExp(String.raw`\{\s*\.\.\.${binding}\b`).test(source)) continue;
@@ -8488,11 +8258,11 @@ function sideEffects(source, extended) {
   return found;
 }
 function readJestConfig(cwd, named) {
-  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync29(join37(cwd, name)));
-  if (file === void 0 || !existsSync29(join37(cwd, file))) return void 0;
+  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync26(join34(cwd, name)));
+  if (file === void 0 || !existsSync26(join34(cwd, file))) return void 0;
   let source;
   try {
-    source = readFileSync30(join37(cwd, file), "utf8");
+    source = readFileSync28(join34(cwd, file), "utf8");
   } catch {
     return { file, refusals: [`${file} could not be read`], notes: [] };
   }
@@ -8573,13 +8343,13 @@ function readJestConfig(cwd, named) {
 }
 
 // src/roles/test/nest/run-modes.ts
-import { existsSync as existsSync30 } from "node:fs";
-import { basename as basename2, join as join38 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { basename, join as join35 } from "node:path";
 var JEST_EXECUTOR = "@nx/jest:jest";
 var PRIMARY_CONFIG_FILE = "vitest.config.mts";
 var PRIMARY_TARGET = "test";
 function configName(declared) {
-  return basename2(declared.replaceAll("\\", "/"));
+  return basename(declared.replaceAll("\\", "/"));
 }
 function configFileFor(target) {
   if (target === PRIMARY_TARGET) return PRIMARY_CONFIG_FILE;
@@ -8595,7 +8365,7 @@ function runModes(cwd, fallback) {
     const jestConfig = entry.options?.jestConfig;
     if (jestConfig === void 0) continue;
     const name = configName(jestConfig);
-    if (!existsSync30(join38(cwd, name))) continue;
+    if (!existsSync27(join35(cwd, name))) continue;
     declared.push({
       target,
       jestConfig: name,
@@ -8620,8 +8390,8 @@ function runModes(cwd, fallback) {
 }
 
 // src/roles/test/written-file-formatter.ts
-import { existsSync as existsSync31 } from "node:fs";
-import { dirname as dirname10, join as join39 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
+import { dirname as dirname9, join as join36 } from "node:path";
 var PRETTIER_CONFIGS = [
   ".prettierrc",
   ".prettierrc.json",
@@ -8640,9 +8410,9 @@ function prettierConfigFrom(cwd) {
   let dir = cwd;
   for (; ; ) {
     for (const name of PRETTIER_CONFIGS) {
-      if (existsSync31(join39(dir, name))) return join39(dir, name);
+      if (existsSync28(join36(dir, name))) return join36(dir, name);
     }
-    const parent = dirname10(dir);
+    const parent = dirname9(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -8670,12 +8440,12 @@ function writtenFileFormatter(cwd) {
 var SPEC_TSCONFIG = "tsconfig.spec.json";
 var VITEST_GLOBAL_TYPES = "vitest/globals";
 function specTypesOperation(cwd) {
-  const path = join40(cwd, SPEC_TSCONFIG);
-  if (!existsSync32(path)) return void 0;
+  const path = join37(cwd, SPEC_TSCONFIG);
+  if (!existsSync29(path)) return void 0;
   let config;
   try {
     config = parseJsonc(
-      readFileSync31(path, "utf8"),
+      readFileSync29(path, "utf8"),
       SPEC_TSCONFIG
     );
   } catch {
@@ -8695,10 +8465,10 @@ function specTypesOperation(cwd) {
 }
 function shippedTypesPath(cwd, declaration) {
   try {
-    const manifest = createRequire6(join40(cwd, "noop.cjs")).resolve("@hublo/sentinel/package.json");
-    const file = join40(dirname11(manifest), declaration);
-    if (existsSync32(file)) {
-      const path = relative8(cwd, file);
+    const manifest = createRequire5(join37(cwd, "noop.cjs")).resolve("@hublo/sentinel/package.json");
+    const file = join37(dirname10(manifest), declaration);
+    if (existsSync29(file)) {
+      const path = relative7(cwd, file);
       return path.startsWith(".") ? path : `./${path}`;
     }
   } catch {
@@ -8709,7 +8479,7 @@ function tsconfigFileListOperations(cwd) {
   const operations = [];
   let names;
   try {
-    names = readdirSync8(cwd).filter((name) => TSCONFIG_FILE.test(name));
+    names = readdirSync7(cwd).filter((name) => TSCONFIG_FILE.test(name));
   } catch {
     return operations;
   }
@@ -8717,7 +8487,7 @@ function tsconfigFileListOperations(cwd) {
     let config;
     try {
       config = parseJsonc(
-        readFileSync31(join40(cwd, name), "utf8"),
+        readFileSync29(join37(cwd, name), "utf8"),
         name
       );
     } catch {
@@ -9007,117 +8777,7 @@ function plan3(context) {
   return { operations, notes };
 }
 
-// src/roles/test/reference.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync as existsSync33, mkdirSync, mkdtempSync as mkdtempSync2, readFileSync as readFileSync32, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join41, resolve as resolve8 } from "node:path";
-
-// src/roles/test/baseline.ts
-function readSnapshot(report) {
-  const files = report?.testResults ?? [];
-  const passing = [];
-  const failing = [];
-  const unloadable = [];
-  for (const file of files) {
-    const assertions = file?.assertionResults ?? [];
-    if (file?.status === "failed" && assertions.length === 0) {
-      unloadable.push(typeof file.name === "string" ? file.name : "an unnamed file");
-    }
-    for (const assertion of assertions) {
-      const name = assertion?.fullName;
-      if (typeof name !== "string" || name === "") continue;
-      if (assertion.status === "passed") passing.push(name);
-      else if (assertion.status === "failed") failing.push(name);
-    }
-  }
-  const claimed = report?.numFailedTests;
-  return {
-    files: files.length,
-    passing: passing.sort(),
-    failing: failing.sort(),
-    unloadable: unloadable.sort(),
-    claimedFailing: typeof claimed === "number" ? claimed : failing.length
-  };
-}
-function unusableAsBaseline(snapshot) {
-  if (snapshot.unloadable.length > 0) {
-    return `${snapshot.unloadable.length} file(s) in the reference run did not load, so they reported no test at all and the run is short by however many they hold: ${snapshot.unloadable.slice(0, 3).join(", ")}. A reference that quietly lost tests cannot prove anything about the run after it`;
-  }
-  if (snapshot.claimedFailing > snapshot.failing.length) {
-    return `the reference run says ${snapshot.claimedFailing} test(s) failed and names only ${snapshot.failing.length} of them, so the comparison has nothing to pair the rest against and would report them as invented by the migration`;
-  }
-  if (snapshot.passing.length === 0) {
-    return `the reference run reports no passing test at all, so a green run after would prove nothing: there is no claim to preserve`;
-  }
-  return void 0;
-}
-
-// src/roles/test/reference.ts
-function referencePath(cwd) {
-  const key = createHash("sha256").update(resolve8(cwd)).digest("hex").slice(0, 16);
-  return join41(tmpdir2(), "sentinel-test-reference", `${key}.json`);
-}
-function runJest(cwd, config) {
-  const bin = resolveBin(cwd, "jest");
-  if (bin === void 0) return void 0;
-  const root = findWorkspaceRoot(cwd) ?? cwd;
-  const out = join41(mkdtempSync2(join41(tmpdir2(), "sentinel-reference-")), "jest.json");
-  try {
-    execFileSync2(bin, ["-c", join41(cwd, config), "--json", `--outputFile=${out}`, "--silent"], {
-      cwd: root,
-      stdio: ["ignore", "ignore", "ignore"],
-      maxBuffer: 1 << 28
-    });
-  } catch {
-  }
-  if (!existsSync33(out)) return void 0;
-  try {
-    return JSON.parse(readFileSync32(out, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function captureReference(cwd, config) {
-  const report = runJest(cwd, config);
-  if (report === void 0) {
-    return {
-      captured: false,
-      message: `could not run jest to record a reference, so this migration cannot be PROVED. It is still applied: a module whose jest run is broken can move, it just cannot be compared.`
-    };
-  }
-  const snapshot = readSnapshot(report);
-  const unusable = unusableAsBaseline(snapshot);
-  if (unusable !== void 0) {
-    return {
-      captured: false,
-      message: `no reference recorded: ${unusable} The migration is applied anyway, unproved.`
-    };
-  }
-  const stored = {
-    runner: "jest",
-    config,
-    takenAt: (/* @__PURE__ */ new Date()).toISOString(),
-    snapshot
-  };
-  const path = referencePath(cwd);
-  mkdirSync(join41(path, ".."), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(stored, void 0, 2)}
-`);
-  return {
-    captured: true,
-    message: `recorded ${snapshot.passing.length} passing test name(s) from ${config} as the reference. The next \`sentinel --run --test\` compares against it.`
-  };
-}
-
 // src/roles/test/adapters/vitest/vitest.adapter.ts
-function resolveVitest(cwd) {
-  const fromSentinel = binFromOwnInstall("vitest", "vitest");
-  if (fromSentinel !== void 0) return { bin: fromSentinel, origin: "sentinel" };
-  const fromModule = resolveBin(cwd, "vitest");
-  return fromModule !== void 0 ? { bin: fromModule, origin: "module" } : { bin: void 0, origin: "module" };
-}
 var FORMATTABLE = /\.(m|c)?(j|t)sx?$|\.json$/;
 var FORMAT_BATCH = 25;
 var VitestAdapter = class extends BaseAdapter {
@@ -9127,19 +8787,28 @@ var VitestAdapter = class extends BaseAdapter {
     return true;
   }
   /**
-   * Record what this module's tests do TODAY, at the last moment it is still true.
+   * Say, once, that this migration is about to become unprovable if nobody recorded a reference.
+   *
+   * ⚠️ It used to RECORD one here, which welded a measurement to an act that does not own it.
+   * Héla, 2026-09-25: the verification phase is isolated behind its own verb, so it extends
+   * without destroying. Two things were wrong with recording here, and they are one thing seen
+   * twice: a migration that could not be proved was still reported as done, because the
+   * measurement was a side effect; and the reference was taken the way the migration found
+   * convenient rather than the way the module runs its tests, which is how it came to record 2958
+   * passing on a module whose own target sees 2957.
    *
-   * The plan about to be applied deletes the jest config, and with it any way of asking again. A
-   * migration that cannot be compared to what came before is a migration nobody can check, which
-   * is the whole reason this role has a baseline gate at all.
+   * So this warns and writes nothing. The plan about to be applied deletes the jest config, and
+   * with it any way of asking again, which is precisely why the warning is here and not later.
    */
-  async beforeInit(ctx) {
+  beforeInit(ctx) {
     const adoption = readTestAdoption(ctx.cwd);
     if (adoption.state !== "jest") return Promise.resolve();
-    const [config] = adoption.jestConfigs;
-    if (config === void 0) return Promise.resolve();
-    this.say(`recording the jest reference before migrating...`);
-    this.say(captureReference(ctx.cwd, config).message);
+    if (adoption.jestConfigs.every((config) => hasReference(ctx.cwd, suiteOf(config)))) {
+      return Promise.resolve();
+    }
+    this.say(
+      `no reference is recorded for this module, so this migration will not be provable: the jest config this deletes is the only place the old suite could be read from. Record one first with \`sentinel --validate --test\`, then migrate. Proceeding without it.`
+    );
     return Promise.resolve();
   }
   /**
@@ -9282,7 +8951,7 @@ function fromWorkspaceRoot(moduleDir, options, paths) {
   if (root === void 0 || root === moduleDir) {
     return { cwd: moduleDir, options: [...options], paths: [...paths] };
   }
-  const absolute = (value) => isAbsolute3(value) ? value : resolve9(moduleDir, value);
+  const absolute = (value) => isAbsolute3(value) ? value : resolve8(moduleDir, value);
   const moved = [];
   let previousWasConfig = false;
   for (const option of options) {
@@ -9311,9 +8980,9 @@ function registerTest() {
 
 // src/roles/typescript/adapters/tsc/tsc.adapter.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync34, readFileSync as readFileSync34 } from "node:fs";
-import { createRequire as createRequire7 } from "node:module";
-import { join as join43 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync31 } from "node:fs";
+import { createRequire as createRequire6 } from "node:module";
+import { join as join39 } from "node:path";
 
 // src/roles/typescript/presets/nest.json
 var nest_default2 = {
@@ -9494,8 +9163,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync33 } from "node:fs";
-import { join as join42 } from "node:path";
+import { readFileSync as readFileSync30 } from "node:fs";
+import { join as join38 } from "node:path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -9588,7 +9257,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync33(join42(context.cwd, target.path), "utf8"),
+    readFileSync30(join38(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -9726,7 +9395,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync34(join43(cwd, target.path), "utf8"),
+        readFileSync31(join39(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -9739,7 +9408,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire7(join43(cwd, "noop.js")).resolve(preset);
+      createRequire6(join39(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -9835,7 +9504,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync34(join43(cwd, config), "utf8"),
+        readFileSync31(join39(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -9851,7 +9520,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync34(join43(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync30(join39(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -10000,7 +9669,7 @@ function detectFramework(packageJson) {
 }
 
 // src/core/dispatch.ts
-import { basename as basename3 } from "node:path";
+import { basename as basename2 } from "node:path";
 
 // src/shared/text.ts
 function ensureLines(current, lines) {
@@ -10056,8 +9725,8 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync35, readFileSync as readFileSync35, renameSync, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { resolve as resolve10, sep } from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync32, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { resolve as resolve9, sep } from "node:path";
 import { applyEdits as applyEdits3, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
 // src/shared/deep-merge.ts
@@ -10067,15 +9736,15 @@ function isPlainObject(value) {
 
 // src/core/apply-plan.ts
 function resolveWithinRoot(cwd, relativePath) {
-  const root = resolve10(cwd);
-  const absolutePath = resolve10(root, relativePath);
+  const root = resolve9(cwd);
+  const absolutePath = resolve9(root, relativePath);
   if (absolutePath !== root && !absolutePath.startsWith(root + sep)) {
     throw new Error(`Refusing to write outside the module root: "${relativePath}".`);
   }
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync35(absolutePath) ? readFileSync35(absolutePath, "utf8") : void 0;
+  return existsSync31(absolutePath) ? readFileSync32(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -10177,14 +9846,14 @@ function preparePlan(cwd, plan4) {
 }
 function writeFileAtomic(absolutePath, contents) {
   const tempPath = `${absolutePath}.sentinel-${process.pid}.tmp`;
-  writeFileSync4(tempPath, contents);
+  writeFileSync3(tempPath, contents);
   renameSync(tempPath, absolutePath);
 }
 function applyPlan(cwd, plan4) {
   const changed = preparePlan(cwd, plan4).filter((file) => file.before !== file.after);
   for (const file of changed) {
     if (file.deleted) {
-      rmSync5(file.absolutePath, { force: true });
+      rmSync4(file.absolutePath, { force: true });
       continue;
     }
     writeFileAtomic(file.absolutePath, file.after);
@@ -10193,8 +9862,8 @@ function applyPlan(cwd, plan4) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync36, readdirSync as readdirSync9, readFileSync as readFileSync36 } from "node:fs";
-import { join as join44 } from "node:path";
+import { existsSync as existsSync32, readdirSync as readdirSync8, readFileSync as readFileSync33 } from "node:fs";
+import { join as join40 } from "node:path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -10222,18 +9891,18 @@ function sourceImports(cwd, pattern) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync9(dir, { withFileTypes: true });
+      entries = readdirSync8(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!NOT_SCANNED.has(entry.name)) stack.push(join44(dir, entry.name));
+        if (!NOT_SCANNED.has(entry.name)) stack.push(join40(dir, entry.name));
         continue;
       }
       if (!SOURCE_FILE2.test(entry.name)) continue;
       try {
-        if (pattern.test(readFileSync36(join44(dir, entry.name), "utf8"))) return true;
+        if (pattern.test(readFileSync33(join40(dir, entry.name), "utf8"))) return true;
       } catch {
         continue;
       }
@@ -10242,11 +9911,11 @@ function sourceImports(cwd, pattern) {
   return false;
 }
 function dependencyNames(cwd) {
-  const path = join44(cwd, "package.json");
-  if (!existsSync36(path)) return [];
+  const path = join40(cwd, "package.json");
+  if (!existsSync32(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync36(path, "utf8"),
+      readFileSync33(path, "utf8"),
       path
     );
     return [
@@ -10260,7 +9929,7 @@ function dependencyNames(cwd) {
 function declaresJsx(cwd) {
   let entries;
   try {
-    entries = readdirSync9(cwd).filter(
+    entries = readdirSync8(cwd).filter(
       (name) => name.startsWith("tsconfig") && name.endsWith(".json")
     );
   } catch {
@@ -10269,7 +9938,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync36(join44(cwd, name), "utf8"),
+        readFileSync33(join40(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -10416,7 +10085,7 @@ async function dispatch(opts) {
   }
   if (adapter.beforeInit) {
     await adapter.beforeInit({
-      module: basename3(opts.cwd),
+      module: basename2(opts.cwd),
       cwd: opts.cwd,
       preset,
       ci: false,
@@ -10435,7 +10104,7 @@ async function dispatch(opts) {
     process.stderr.write(`  fixing what ${opts.target} can fix automatically...
 `);
     await adapter.afterInit({
-      module: basename3(opts.cwd),
+      module: basename2(opts.cwd),
       cwd: opts.cwd,
       preset,
       ci: false,