@hublo/sentinel 1.4.0-alpha.2 → 1.4.0-alpha.4

package/dist/{chunk-4UIZJ3TR.js → chunk-ASBZQAXV.js}

@@ -220,6 +220,14 @@ function moduleScripts(cwd) {
     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"));
@@ -5394,6 +5402,9 @@ function registerLint() {
 
 // src/roles/test/adapters/vitest/vitest.adapter.ts
 import { spawnSync as spawnSync5 } from "child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync30 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join37 } from "path";
 
 // src/roles/test/presets/toolchain.json
 var toolchain_default2 = {
@@ -5470,7 +5481,7 @@ function testTarget(options) {
 }
 
 // src/roles/test/jest-migration.ts
-import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
 import { join as join35 } from "path";
 
 // src/roles/test/codemod/migrate-module.ts
@@ -6581,12 +6592,47 @@ function applyNamedRules(source, program, fileName = "") {
   const applied = /* @__PURE__ */ new Set();
   const asyncify = /* @__PURE__ */ new Set();
   const mocked = mockedSpecifiers(program);
-  const wholeStatement = /* @__PURE__ */ new Set();
+  const wholeStatement = /* @__PURE__ */ new Map();
   walk(program, (node) => {
     if (node.type !== "ExpressionStatement") return;
     const expression = node.expression;
-    if (expression !== void 0) wholeStatement.add(expression);
+    if (expression !== void 0) wholeStatement.set(expression, node);
+  });
+  const standsAlone = /* @__PURE__ */ new Set();
+  const alone = (node) => {
+    if (node !== void 0) standsAlone.add(node);
+  };
+  walk(program, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        return alone(node.init);
+      case "AssignmentExpression":
+        return alone(node.right);
+      case "ReturnStatement":
+      case "ExportDefaultDeclaration":
+        return alone(node.argument ?? node.declaration);
+      case "ArrowFunctionExpression":
+        return node.expression === true ? alone(node.body) : void 0;
+      case "ConditionalExpression":
+        alone(node.consequent);
+        return alone(node.alternate);
+      case "ArrayExpression":
+        return (node.elements ?? []).forEach((e) => alone(e ?? void 0));
+      case "Property":
+      case "ObjectProperty":
+        return node.shorthand === true ? void 0 : alone(node.value);
+      case "CallExpression":
+      case "NewExpression":
+        return (node.arguments ?? []).forEach((a) => alone(a));
+      default:
+        return;
+    }
   });
+  const placed = (node, expression, trailing = "") => {
+    if (trailing !== "") return `(${expression})${trailing}`;
+    if (wholeStatement.has(node)) return expression;
+    return standsAlone.has(node) ? expression : `(${expression})`;
+  };
   const handedToTheRunnerAsAModule = /* @__PURE__ */ new Set();
   walk(program, (node) => {
     const returned = mockFactoryReturn(node);
@@ -6616,7 +6662,7 @@ function applyNamedRules(source, program, fileName = "") {
         edits.push({
           start: node.start,
           end: node.end,
-          text: `(await import(${argumentText(source, node)}))`
+          text: placed(node, `await import(${argumentText(source, node)})`)
         });
         applied.add("jest.requireMock");
         if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
@@ -6628,7 +6674,7 @@ function applyNamedRules(source, program, fileName = "") {
       edits.push({
         start: node.start,
         end: node.end,
-        text: `(await vi.${asyncReplacement}(${argumentText(source, node)}))`
+        text: placed(node, `await vi.${asyncReplacement}(${argumentText(source, node)})`)
       });
       applied.add(`jest.${member}`);
       if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
@@ -6641,7 +6687,7 @@ function applyNamedRules(source, program, fileName = "") {
       edits.push({
         start: node.start,
         end: node.end,
-        text: wholeStatement.has(node) ? `await import(${argumentText(source, node)});` : `(await import(${argumentText(source, node)}))${interop}`
+        text: placed(node, `await import(${argumentText(source, node)})`, interop)
       });
       applied.add("require");
       if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
@@ -7161,11 +7207,6 @@ ${text}` });
 import { parseSync as parseSync6 } from "oxc-parser";
 var SENTINEL_MSW_SERVER = "@hublo/sentinel/test/msw";
 var MSW_SERVER_MODULE = /(^|\/)msw\/server$/;
-var MSW_PACKAGE = /^msw$/;
-function importsMswPackage(declaration) {
-  const source = declaration.source?.value;
-  return source !== void 0 && MSW_PACKAGE.test(source);
-}
 function importsServer(declaration) {
   return (declaration.specifiers ?? []).some((specifier) => {
     const imported = specifier.imported;
@@ -7181,8 +7222,7 @@ function repointMswServer(fileName, source) {
     if (node.type !== "ImportDeclaration") return;
     const specifier = node.source;
     if (specifier?.value === void 0) return;
-    const isServerModule = MSW_SERVER_MODULE.test(specifier.value) && importsServer(node);
-    if (!isServerModule && !importsMswPackage(node)) return;
+    if (!MSW_SERVER_MODULE.test(specifier.value) || !importsServer(node)) return;
     edits.push({ start: specifier.start, end: specifier.end });
   });
   if (edits.length === 0) return { source, repointed: false };
@@ -7570,13 +7610,16 @@ function migrateModuleTests(cwd, setupFiles = []) {
 }
 
 // src/roles/test/nest/generate-config.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "fs";
 import { join as join32, relative as relative6 } from "path";
 var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/nest";
-var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/nest";
+var REACT_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/react";
+function flavourOf(reading) {
+  return reading.testEnvironment === "jsdom" ? "react" : "nest";
+}
+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";
-var NEST_TEST_CONFIG_FILE = "vitest.config.mts";
 function hopsToRoot(cwd, workspaceRoot) {
   const up = relative6(cwd, workspaceRoot).replaceAll("\\", "/");
   return up === "" ? "." : up;
@@ -7643,14 +7686,29 @@ function readModuleTraits(cwd) {
   return traits;
 }
 var withoutRootDir = (value) => value.replaceAll("<rootDir>/", "./").replaceAll("<rootDir>", ".");
-function setupBlock(reading, msw) {
+function ownsMswLifecycle(cwd, reading) {
+  const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []].filter(
+    (file) => !file.endsWith("jest.setup.after.env.js")
+  );
+  for (const raw of declared) {
+    const file = join32(cwd, raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", "."));
+    if (!existsSync26(file)) continue;
+    try {
+      if (/\.listen\s*\(/.test(readFileSync26(file, "utf8"))) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function setupBlock(cwd, reading, msw) {
   const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []];
   const namedTheRootSetup = declared.some((file) => file.endsWith("jest.setup.after.env.js"));
   const own = declared.filter((file) => !file.endsWith("jest.setup.after.env.js")).map((file) => `'${withoutRootDir(file)}'`);
   const sentinel = [
     `'${SENTINEL_TEST_SETUP}'`,
     ...namedTheRootSetup ? [`'${SENTINEL_WORKSPACE_SETUP}'`] : [],
-    ...msw ? [`'${SENTINEL_MSW_SETUP}'`] : []
+    ...msw && !ownsMswLifecycle(cwd, reading) ? [`'${SENTINEL_MSW_SETUP}'`] : []
   ];
   return `        setupFiles: [${[...sentinel, ...own].join(", ")}],`;
 }
@@ -7697,7 +7755,8 @@ function aliasBlock(reading) {
   if (reading.aliases === void 0 || reading.aliases.length === 0) return "";
   const entries = reading.aliases.map((alias) => {
     const pattern = alias.find.replaceAll(String.raw`\\`, "\\").replaceAll("/", String.raw`\/`);
-    const target = isPackage(alias.replacement) ? `'${alias.replacement}'` : `path.resolve(import.meta.dirname, '${withoutRootDir(alias.replacement)}')`;
+    const deadToken = /<rootdir>/i.test(alias.replacement) && !alias.replacement.includes("<rootDir>");
+    const target = isPackage(alias.replacement) ? `'${alias.replacement}'` : deadToken ? `'${alias.replacement}'` : `path.resolve(import.meta.dirname, '${withoutRootDir(alias.replacement)}')`;
     return `          { find: /${pattern}/, replacement: ${target} },`;
   });
   return ["      resolve: {", "        alias: [", ...entries, "        ],", "      },"].join("\n");
@@ -7712,7 +7771,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
   const up = hopsToRoot(cwd, workspaceRoot);
   const test = [
     environmentBlock(reading),
-    setupBlock(reading, traits.msw),
+    setupBlock(cwd, reading, traits.msw),
     envBlock(reading),
     timeoutBlock(reading),
     concurrencyBlock(cwd, reading, target),
@@ -7727,7 +7786,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
     `import path from 'node:path'`,
     "",
     ...needsDefaults ? [`import { configDefaults } from 'vitest/config'`, ""] : [],
-    `import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'`
+    flavourOf(reading) === "react" ? `import { defineConfig, reactTestConfig } from '${REACT_TEST_PRESET_SPECIFIER}'` : `import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'`
   ].join("\n");
   const overrides = [aliasBlock(reading), "      test: {", ...test, "      },"].filter(
     (line) => line !== ""
@@ -7738,7 +7797,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
     source: `${imports}
 
 export default defineConfig(
-  nestTestConfig({
+  ${flavourOf(reading) === "react" ? "reactTestConfig" : "nestTestConfig"}({
     root: import.meta.dirname,
     workspaceRoot: path.resolve(import.meta.dirname, '${up}'),${decoratorLine}
     overrides: {
@@ -7751,7 +7810,7 @@ ${overrides.join("\n")}
 }
 
 // src/roles/test/nest/read-jest-config.ts
-import { existsSync as existsSync26, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "fs";
 import { join as join33 } from "path";
 var CARRIED = [
   "testEnvironment",
@@ -7942,7 +8001,7 @@ function extendedConfig(source, cwd) {
       (name) => name.replace(/^\.\//, "")
     );
     const file = candidates.find(
-      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync26(join33(cwd, name))
+      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync27(join33(cwd, name))
     );
     if (file === void 0) continue;
     if (!new RegExp(String.raw`\{\s*\.\.\.${binding}\b`).test(source)) continue;
@@ -7969,8 +8028,8 @@ function sideEffects(source, extended) {
   return found;
 }
 function readJestConfig(cwd, named) {
-  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync26(join33(cwd, name)));
-  if (file === void 0 || !existsSync26(join33(cwd, file))) return void 0;
+  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync27(join33(cwd, name)));
+  if (file === void 0 || !existsSync27(join33(cwd, file))) return void 0;
   let source;
   try {
     source = readFileSync27(join33(cwd, file), "utf8");
@@ -8054,7 +8113,7 @@ function readJestConfig(cwd, named) {
 }
 
 // src/roles/test/nest/run-modes.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { basename as basename2, join as join34 } from "path";
 var JEST_EXECUTOR = "@nx/jest:jest";
 var PRIMARY_CONFIG_FILE = "vitest.config.mts";
@@ -8076,7 +8135,7 @@ function runModes(cwd, fallback) {
     const jestConfig = entry.options?.jestConfig;
     if (jestConfig === void 0) continue;
     const name = configName(jestConfig);
-    if (!existsSync27(join34(cwd, name))) continue;
+    if (!existsSync28(join34(cwd, name))) continue;
     declared.push({
       target,
       jestConfig: name,
@@ -8105,7 +8164,7 @@ var SPEC_TSCONFIG = "tsconfig.spec.json";
 var VITEST_GLOBAL_TYPES = "vitest/globals";
 function specTypesOperation(cwd) {
   const path = join35(cwd, SPEC_TSCONFIG);
-  if (!existsSync28(path)) return void 0;
+  if (!existsSync29(path)) return void 0;
   let config;
   try {
     config = parseJsonc(
@@ -8173,8 +8232,9 @@ function planJestMigration(context, adoption) {
       `${migration.blockers.length} thing(s) in this module's test files need a human before it can move. Nothing was written, because a config without its files is a suite calling jest.* under Vitest.${listed}`
     );
   }
-  const targets = projectTargets(context.cwd) ?? {};
-  const existingFor = (name) => targets[name];
+  const fromProject = projectTargets(context.cwd) ?? {};
+  const fromManifest = manifestTargets(context.cwd);
+  const existingFor = (name) => fromProject[name] ?? fromManifest[name];
   const siblings = siblingScriptRewrites(context.cwd);
   const specTypes = specTypesOperation(context.cwd);
   const scripts = Object.fromEntries(
@@ -8208,9 +8268,10 @@ function planJestMigration(context, adoption) {
       (name) => ({ kind: "delete", path: name })
     )
   ];
+  const escaping = (prepared[0]?.reading.aliases ?? []).map((alias) => alias.replacement).filter((replacement) => replacement.includes(".."));
   const notes = [
     `${migration.files} test file(s) migrated from jest to Vitest, ${migration.renamed} site(s) rewritten${migration.hoisted > 0 ? `, ${migration.hoisted} of them moving a mock factory's captures into vi.hoisted` : ""}.`,
-    `${NEST_TEST_CONFIG_FILE} written from what ${adoption.jestConfigs.join(", ")} declared, and that config deleted. Every specifier in the new one is a package name: nothing in it reaches outside this module.`
+    `${prepared.map(({ mode }) => mode.vitestConfig).join(", ")} written from what ${prepared.map(({ mode }) => mode.jestConfig).join(", ")} declared, and that config deleted.` + (escaping.length === 0 ? ` Every specifier in the new one is a package name: nothing in it reaches outside this module.` : ` \u26A0\uFE0F ${escaping.length} alias(es) carried from that config reach OUTSIDE this module: ${escaping.slice(0, 3).join(", ")}. They came from its \`moduleNameMapper\` and are kept as they were, but a module that reaches out cannot be moved on its own.`)
   ];
   if (specTypes !== void 0) {
     notes.push(
@@ -8218,7 +8279,7 @@ function planJestMigration(context, adoption) {
     );
   }
   notes.push(
-    `run this module's own lint --fix (or its formatter) after installing: the Vitest type imports are written beside the existing ones, and ordering belongs to the tool that enforces it.`
+    `run this module's own formatter (or lint --fix) on what this wrote, after installing. Two things need it: the Vitest type imports are written beside the existing ones, and a rewritten call is often SHORTER than the one it replaced, so the line breaks around it are no longer the ones your formatter would pick. Neither is a defect, and both fail a format check. Layout is a repository setting, so sentinel leaves it to the tool that owns it.`
   );
   notes.push(
     `then run this module's TYPECHECK, not only its tests. The migration rewrites types as well as calls, and a wrong type is invisible to a green suite: measured on a real module, \`--run --test\` passed while \`--run --typescript\` reported ten errors it had not had before.`
@@ -8308,7 +8369,7 @@ function plan3(context) {
       `${configFile} now imports ${rewrite.moved.join(", ")} from sentinel. Only the import lines changed: every alias, setup file, timeout and coverage path is untouched, so this suite runs what it ran before.`
     );
   }
-  const existing = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME];
+  const existing = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME] ?? manifestTargets(context.cwd)[TEST_SCRIPT_NAME];
   const outputs = existing?.outputs ?? [];
   const dependsOn = existing?.dependsOn ?? [];
   const configurations = existing?.configurations ?? {};
@@ -8363,6 +8424,329 @@ function plan3(context) {
   return { operations, notes };
 }
 
+// src/roles/test/reference.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import { existsSync as existsSync30, mkdirSync, mkdtempSync, readFileSync as readFileSync29, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join36, resolve as resolve5 } from "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 difference(left, right) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const name of right) remaining.set(name, (remaining.get(name) ?? 0) + 1);
+  const missing = [];
+  for (const name of left) {
+    const left_ = remaining.get(name) ?? 0;
+    if (left_ === 0) {
+      missing.push(name);
+      continue;
+    }
+    remaining.set(name, left_ - 1);
+  }
+  return missing.sort();
+}
+var withoutRenderingQuotes = (name) => name.replaceAll(String.raw`\'`, "'").replaceAll(String.raw`\"`, '"').replaceAll(/['"`]\s*\+\s*['"`]/g, "").replaceAll(/(^|[\s:,[{(])(''|"")($|[\s,)\]}])/g, "$1<empty-string>$3").replaceAll(/['"`]/g, "");
+function withoutRenderingNoise(name) {
+  const spelled = withSortedKeys(
+    withoutUndefinedEntries(
+      withoutErrorRendering(
+        withoutNaN(
+          withoutTimestamps(withoutRenderingQuotes(withoutClassBodies(withoutStackFrames(name))))
+        )
+      )
+    )
+  );
+  return withoutArrayBrackets(
+    spelled.replaceAll(/\[\s+/g, "[").replaceAll(/\s+\]/g, "]").replaceAll(/\{\s+/g, "{").replaceAll(/\s+\}/g, "}").replaceAll(/(?<=[[{,\s])\+0\b/g, "0").replaceAll(/:\s+/g, ":").replaceAll(/,\s+/g, ",")
+  );
+}
+function withoutArrayBrackets(name) {
+  return name.replaceAll(
+    /\[([^[\]]*)\]/g,
+    (match, inner) => (
+      // `[Object]` and `[Array]` are the formatter saying it STOPPED, not an array literal.
+      // Stripping their brackets would erase the marker `collapsedOf` pairs on.
+      /^(?:Object|Array)$/.test(inner) ? match : inner.replaceAll(/,\s+/g, ",")
+    )
+  );
+}
+var withoutClassBodies = (name) => name.replaceAll(
+  /class\s+([A-Za-z_$][\w$]*)\s*\{\s*\}/g,
+  (_match, className) => `class ${className}`
+).replaceAll(
+  /class\s+([A-Za-z_$][\w$]*)[\s\S]*?\n\}/g,
+  (_match, className) => `class ${className}`
+);
+var withoutTimestamps = (name) => name.replaceAll(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, "<instant>");
+var withoutNaN = (name) => name.replaceAll(/\bNaN\b/g, "null");
+function entriesOf(inner) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < inner.length; index += 1) {
+    const character = inner[index];
+    if (character === "[" || character === "(") depth += 1;
+    else if (character === "]" || character === ")") depth -= 1;
+    else if (character === "," && depth === 0) {
+      parts.push(inner.slice(start, index));
+      start = index + 1;
+    }
+    if (depth < 0) return void 0;
+  }
+  if (depth !== 0) return void 0;
+  parts.push(inner.slice(start));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+var sortedGroup = (match, inner) => {
+  if (!inner.includes(":")) return match;
+  const parts = entriesOf(inner);
+  if (parts === void 0) return match;
+  if (parts.length < 2 || !parts.every((part) => part.includes(":"))) return match;
+  return `{${[...parts].sort().join(",")}}`;
+};
+var HELD = "\u241F";
+var withSortedKeys = (name) => {
+  const held = [];
+  let current = name;
+  for (let depth = 0; depth < 24; depth += 1) {
+    const next = current.replaceAll(/\{([^{}]*)\}/g, (match, inner) => {
+      held.push(sortedGroup(match, inner));
+      return `${HELD}${held.length - 1}${HELD}`;
+    });
+    if (next === current) break;
+    current = next;
+  }
+  for (let depth = 0; depth < 24 && current.includes(HELD); depth += 1) {
+    current = current.replaceAll(
+      new RegExp(`${HELD}(\\d+)${HELD}`, "g"),
+      (_match, index) => held[Number(index)]
+    );
+  }
+  return current;
+};
+var withoutStackFrames = (name) => {
+  const frame = name.search(/\n\s+at\s/);
+  return frame === -1 ? name : name.slice(0, frame);
+};
+var withoutErrorRendering = (name) => name.replaceAll(/\[[A-Za-z]*(?:Error|Exception):[^\][]*\]/g, "{}");
+var withoutUndefinedEntries = (name) => name.replaceAll(/([{,])\s*[A-Za-z_$][\w$]*\s*:\s*undefined\s*(?=[,}])/g, "$1").replaceAll(/\{\s*,/g, "{").replaceAll(/,\s*\}/g, "}").replaceAll(/\{\s*\}/g, "{}");
+function collapsedOf(candidate, name) {
+  if (!/\[(?:Object|Array)\]/.test(candidate)) return false;
+  const pattern = candidate.split(/\[(?:Object|Array)\]/).map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${pattern}$`, "s").test(name);
+}
+function truncationOf(candidate, name) {
+  const cut = candidate.indexOf("\u2026");
+  if (cut === -1) return false;
+  const head = candidate.slice(0, cut);
+  const tail = candidate.slice(cut + 1);
+  return name.startsWith(head) && name.endsWith(tail);
+}
+function pairRenamed(missing, added) {
+  const remaining = [...added];
+  const renamed = [];
+  const unmatched = [];
+  for (const name of missing) {
+    const normalised = withoutRenderingNoise(name);
+    const at = remaining.findIndex((candidate) => withoutRenderingNoise(candidate) === normalised);
+    if (at === -1) {
+      unmatched.push(name);
+      continue;
+    }
+    renamed.push({ before: name, after: remaining[at] });
+    remaining.splice(at, 1);
+  }
+  const lost = [];
+  for (const name of unmatched) {
+    const normalised = withoutRenderingNoise(name);
+    const at = remaining.findIndex(
+      (candidate) => truncationOf(withoutRenderingNoise(candidate), normalised) || collapsedOf(normalised, withoutRenderingNoise(candidate))
+    );
+    if (at === -1) {
+      lost.push(name);
+      continue;
+    }
+    renamed.push({ before: name, after: remaining[at] });
+    remaining.splice(at, 1);
+  }
+  return { renamed, missing: lost, added: remaining };
+}
+function compareSnapshots(before, after) {
+  const beforeAll = [...before.passing, ...before.failing];
+  const afterAll = [...after.passing, ...after.failing];
+  const paired = pairRenamed(difference(beforeAll, afterAll), difference(afterAll, beforeAll));
+  const renamedBefore = new Set(paired.renamed.map((pair) => pair.before));
+  const regressed = difference(before.passing, after.passing).filter(
+    (name) => !paired.missing.includes(name) && !renamedBefore.has(name)
+  );
+  const failedBefore = new Set(before.failing);
+  const recovered = after.passing.filter((name) => failedBefore.has(name));
+  return {
+    identical: paired.missing.length === 0 && paired.added.length === 0 && regressed.length === 0,
+    missing: paired.missing,
+    added: paired.added,
+    regressed,
+    renamed: paired.renamed,
+    recovered,
+    alreadyFailing: before.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;
+}
+function renamedExample(before, after) {
+  let shared = 0;
+  while (shared < before.length && shared < after.length && before[shared] === after[shared]) {
+    shared += 1;
+  }
+  const boundary = before.lastIndexOf(" ", shared);
+  const from = boundary > 0 ? boundary + 1 : 0;
+  const ellipsis = from > 0 ? "\u2026" : "";
+  return `"${ellipsis}${before.slice(from)}" -> "${ellipsis}${after.slice(from)}"`;
+}
+function describeComparison(comparison) {
+  const firstRename = comparison.renamed[0];
+  const renamedNote = firstRename === void 0 ? "" : ` ${comparison.renamed.length} test(s) kept their identity and changed name, because the runners render an each title's interpolated value differently (e.g. ${renamedExample(firstRename.before, firstRename.after)}).`;
+  const alreadyRedNote = comparison.alreadyFailing > 0 ? ` ${comparison.alreadyFailing} test(s) were already failing before the migration and are outside this comparison, which covers only what passed.` : "";
+  const recoveredNote = comparison.recovered.length > 0 ? ` ${comparison.recovered.length} test(s) were failing before and pass now.` : "";
+  if (comparison.identical) {
+    return `every test that ran before runs and passes now.${recoveredNote}${renamedNote}${alreadyRedNote}`;
+  }
+  const parts = [];
+  if (comparison.recovered.length > 0) {
+    parts.push(`${comparison.recovered.length} test(s) were failing before and pass now`);
+  }
+  if (comparison.missing.length > 0) {
+    parts.push(
+      `${comparison.missing.length} test(s) no longer exist: ${comparison.missing.slice(0, 3).join(", ")}`
+    );
+  }
+  if (comparison.added.length > 0) {
+    parts.push(
+      `${comparison.added.length} test(s) appeared, which a migration should not do: ${comparison.added.slice(0, 3).join(", ")}`
+    );
+  }
+  if (comparison.regressed.length > 0) {
+    parts.push(
+      `${comparison.regressed.length} test(s) passed before and do not now: ${comparison.regressed.slice(0, 3).join(", ")}`
+    );
+  }
+  return `${parts.join("; ")}.${renamedNote}${alreadyRedNote}`;
+}
+
+// src/roles/test/reference.ts
+function referencePath(cwd) {
+  const key = createHash("sha256").update(resolve5(cwd)).digest("hex").slice(0, 16);
+  return join36(tmpdir(), "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 = join36(mkdtempSync(join36(tmpdir(), "sentinel-reference-")), "jest.json");
+  try {
+    execFileSync(bin, ["-c", join36(cwd, config), "--json", `--outputFile=${out}`, "--silent"], {
+      cwd: root,
+      stdio: ["ignore", "ignore", "ignore"],
+      maxBuffer: 1 << 28
+    });
+  } catch {
+  }
+  if (!existsSync30(out)) return void 0;
+  try {
+    return JSON.parse(readFileSync29(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(join36(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.`
+  };
+}
+function hasReference(cwd) {
+  return existsSync30(referencePath(cwd));
+}
+function compareAgainstReference(cwd, report) {
+  const path = referencePath(cwd);
+  let stored;
+  try {
+    stored = JSON.parse(readFileSync29(path, "utf8"));
+  } catch {
+    rmSync3(path, { force: true });
+    return { ok: true, message: `the recorded reference could not be read, so nothing was proved.` };
+  }
+  const comparison = compareSnapshots(stored.snapshot, readSnapshot(report));
+  if (comparison.identical) rmSync3(path, { force: true });
+  const kept = comparison.identical ? "" : ` The reference is KEPT until a run passes it, so this does not go green by running again. Fix the suite and re-run, or delete ${path} to abandon the proof on purpose.`;
+  return {
+    ok: comparison.identical,
+    message: `${describeComparison(comparison)} (reference: ${stored.config}, ${stored.takenAt})${kept}`
+  };
+}
+
 // src/roles/test/adapters/vitest/vitest.adapter.ts
 function resolveVitest(cwd) {
   const fromSentinel = binFromOwnInstall("vitest", "vitest");
@@ -8376,6 +8760,22 @@ var VitestAdapter = class extends BaseAdapter {
   appliesTo(_preset) {
     return true;
   }
+  /**
+   * Record what this module's tests do TODAY, at the last moment it is still true.
+   *
+   * 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.
+   */
+  async 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);
+    return Promise.resolve();
+  }
   plan(context) {
     return plan3(context);
   }
@@ -8422,13 +8822,31 @@ var VitestAdapter = class extends BaseAdapter {
     }
     const { options, paths } = splitToolArgs(ctx.cwd, ctx.toolArgs, { valueFlags: [] });
     const watching = options.includes("--watch") || options.includes("-w");
-    const argv = watching ? [...options, ...paths] : ["run", ...options, ...paths];
+    const proving = !watching && hasReference(ctx.cwd);
+    const reportFile = proving ? join37(mkdtempSync2(join37(tmpdir2(), "sentinel-run-")), "vitest.json") : void 0;
+    const reporters = reportFile === void 0 ? [] : ["--reporter=default", "--reporter=json", `--outputFile=${reportFile}`];
+    const argv = watching ? [...options, ...paths] : ["run", ...reporters, ...options, ...paths];
     const result = spawnSync5(bin, argv, { cwd: ctx.cwd, stdio: "inherit" });
     if (result.error) {
       this.say(`could not run vitest (${result.error.message})`);
       return Promise.resolve({ ok: false, code: 1 });
     }
     const code = result.status ?? 1;
+    if (reportFile !== void 0) {
+      let report;
+      try {
+        report = JSON.parse(readFileSync30(reportFile, "utf8"));
+      } catch {
+        report = void 0;
+      }
+      if (report === void 0) {
+        this.say(`vitest wrote no report, so this run proved nothing against the reference.`);
+      } else {
+        const outcome = compareAgainstReference(ctx.cwd, report);
+        this.say(outcome.message);
+        if (!outcome.ok) return Promise.resolve({ ok: false, code: code === 0 ? 1 : code });
+      }
+    }
     return Promise.resolve({ ok: code === 0, code });
   }
   say(message) {
@@ -8445,9 +8863,9 @@ function registerTest() {
 
 // src/roles/typescript/adapters/tsc/tsc.adapter.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync32 } from "fs";
 import { createRequire as createRequire6 } from "module";
-import { join as join37 } from "path";
+import { join as join39 } from "path";
 
 // src/roles/typescript/presets/nest.json
 var nest_default2 = {
@@ -8628,8 +9046,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join36 } from "path";
+import { readFileSync as readFileSync31 } from "fs";
+import { join as join38 } from "path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -8722,7 +9140,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync29(join36(context.cwd, target.path), "utf8"),
+    readFileSync31(join38(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -8860,7 +9278,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync30(join37(cwd, target.path), "utf8"),
+        readFileSync32(join39(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -8873,7 +9291,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire6(join37(cwd, "noop.js")).resolve(preset);
+      createRequire6(join39(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -8969,7 +9387,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync30(join37(cwd, config), "utf8"),
+        readFileSync32(join39(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -8985,7 +9403,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync29(join37(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync31(join39(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -9190,8 +9608,8 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync30, readFileSync as readFileSync31, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve5, sep } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync33, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve6, sep } from "path";
 import { applyEdits as applyEdits3, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
 // src/shared/deep-merge.ts
@@ -9201,15 +9619,15 @@ function isPlainObject(value) {
 
 // src/core/apply-plan.ts
 function resolveWithinRoot(cwd, relativePath) {
-  const root = resolve5(cwd);
-  const absolutePath = resolve5(root, relativePath);
+  const root = resolve6(cwd);
+  const absolutePath = resolve6(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 existsSync30(absolutePath) ? readFileSync31(absolutePath, "utf8") : void 0;
+  return existsSync32(absolutePath) ? readFileSync33(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -9311,14 +9729,14 @@ function preparePlan(cwd, plan4) {
 }
 function writeFileAtomic(absolutePath, contents) {
   const tempPath = `${absolutePath}.sentinel-${process.pid}.tmp`;
-  writeFileSync3(tempPath, contents);
+  writeFileSync4(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) {
-      rmSync3(file.absolutePath, { force: true });
+      rmSync4(file.absolutePath, { force: true });
       continue;
     }
     writeFileAtomic(file.absolutePath, file.after);
@@ -9327,8 +9745,8 @@ function applyPlan(cwd, plan4) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync31, readdirSync as readdirSync8, readFileSync as readFileSync32 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync8, readFileSync as readFileSync34 } from "fs";
+import { join as join40 } from "path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -9362,12 +9780,12 @@ function sourceImports(cwd, pattern) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!NOT_SCANNED.has(entry.name)) stack.push(join38(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(readFileSync32(join38(dir, entry.name), "utf8"))) return true;
+        if (pattern.test(readFileSync34(join40(dir, entry.name), "utf8"))) return true;
       } catch {
         continue;
       }
@@ -9376,11 +9794,11 @@ function sourceImports(cwd, pattern) {
   return false;
 }
 function dependencyNames(cwd) {
-  const path = join38(cwd, "package.json");
-  if (!existsSync31(path)) return [];
+  const path = join40(cwd, "package.json");
+  if (!existsSync33(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync32(path, "utf8"),
+      readFileSync34(path, "utf8"),
       path
     );
     return [
@@ -9403,7 +9821,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync32(join38(cwd, name), "utf8"),
+        readFileSync34(join40(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -9548,6 +9966,15 @@ async function dispatch(opts) {
   if (opts.dryRun) {
     return previewPlan(opts, plan4);
   }
+  if (adapter.beforeInit) {
+    await adapter.beforeInit({
+      module: basename3(opts.cwd),
+      cwd: opts.cwd,
+      preset,
+      ci: false,
+      fix: false
+    });
+  }
   for (const change of applyPlan(opts.cwd, plan4)) {
     process.stderr.write(`  ${change.deleted ? "removed" : "wrote"} ${change.path}
 `);
@@ -9591,4 +10018,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-4UIZJ3TR.js.map
+//# sourceMappingURL=chunk-ASBZQAXV.js.map