@hublo/sentinel 1.4.0-alpha.3 → 1.4.0-alpha.30

package/dist/chunk-GCZKG4B2.js

@@ -0,0 +1,4743 @@
+import {
+  WORKSPACE_ROOT_MARKER,
+  findWorkspaceRoot,
+  moduleName,
+  readNxProjectName,
+  readOwnPackage,
+  readProjectPackageJson
+} from "./chunk-NW6UHNYX.js";
+
+// src/core/base-adapter.ts
+var BaseAdapter = class {
+  inspect(_ctx) {
+    throw new Error(`${this.runner}: --inspect not implemented yet`);
+  }
+  report(_ctx) {
+    throw new Error(`${this.runner}: --report not implemented yet`);
+  }
+  status(_ctx) {
+    throw new Error(`${this.runner}: --status not implemented yet`);
+  }
+};
+
+// src/roles/test/read-adoption.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "node:fs";
+import { join as join2, relative } from "node:path";
+
+// src/core/config/manifest.ts
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+function moduleScripts(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    return pkg.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+function manifestTargets(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    return pkg.nx?.targets ?? {};
+  } catch {
+    return {};
+  }
+}
+function moduleName2(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(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 (existsSync(join(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/roles/test/presets/toolchain.json
+var toolchain_default = {
+  $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_default.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 } } : {}
+    }
+  };
+}
+
+// src/roles/test/read-adoption.ts
+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) => existsSync2(join2(cwd, name)));
+}
+function jestConfigFiles(cwd) {
+  return JEST_CONFIG_FILES.filter((name) => existsSync2(join2(cwd, name)));
+}
+function rootJestConfigFiles(cwd) {
+  const root = findWorkspaceRoot(cwd);
+  if (root === void 0 || root === cwd) return [];
+  return JEST_CONFIG_FILES.filter((name) => existsSync2(join2(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 = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!NOT_WALKED.has(entry.name)) stack.push(join2(dir, entry.name));
+      } else if (TEST_FILE.test(entry.name)) {
+        found.push(relative(cwd, join2(dir, entry.name)).replaceAll("\\", "/"));
+        if (stopAtFirst) return found;
+      }
+    }
+  }
+  return found;
+}
+function readTestConfigSource(cwd, fileName) {
+  try {
+    return readFileSync2(join2(cwd, fileName), "utf8");
+  } catch {
+    return "";
+  }
+}
+function importsPreset(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 = importsPreset(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/module-env.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+var CASCADE = [".env", ".env.test"];
+var MODULE_CASCADE = [".env", ".env.local", ".env.test"];
+function parse(path) {
+  const found = {};
+  let contents;
+  try {
+    contents = readFileSync3(path, "utf8");
+  } catch {
+    return found;
+  }
+  for (const line of contents.split("\n")) {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+    if (match === null) continue;
+    const [, name, raw] = match;
+    if (name === void 0 || raw === void 0) continue;
+    const trimmed = raw.trim();
+    const unquoted = trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'") ? trimmed.slice(1, -1) : trimmed.split(" #")[0]?.trimEnd();
+    found[name] = unquoted ?? "";
+  }
+  return found;
+}
+function moduleEnvironment(cwd) {
+  const root = findWorkspaceRoot(cwd);
+  const loaded = [];
+  const added = {};
+  const files = [
+    ...root === void 0 ? [] : CASCADE.map((name) => [join3(root, name), name]),
+    ...MODULE_CASCADE.map((name) => [join3(cwd, name), `<module>/${name}`])
+  ];
+  for (const [path, label] of files) {
+    if (!existsSync3(path)) continue;
+    loaded.push(label);
+    Object.assign(added, parse(path));
+  }
+  const env = { ...added, ...process.env };
+  return { env, loaded };
+}
+
+// src/roles/test/reference.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync5, mkdirSync, mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join5, resolve } from "node:path";
+
+// src/shared/resolve-bin.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, dirname, join as join4 } from "node:path";
+var require2 = createRequire(import.meta.url);
+function resolveBin(fromDir, name) {
+  let dir = fromDir;
+  for (; ; ) {
+    const candidate = join4(dir, "node_modules", ".bin", name);
+    if (existsSync4(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 relative6 = typeof bin === "string" ? bin : bin?.[binName];
+    if (!relative6) return void 0;
+    const executable = join4(dirname(manifest), relative6);
+    return existsSync4(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/test/baseline.ts
+function readSnapshot(report) {
+  const files = report?.testResults ?? [];
+  const passing = [];
+  const failing = [];
+  const unloadable = [];
+  const skipped = [];
+  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);
+      else skipped.push(name);
+    }
+  }
+  const claimed = report?.numFailedTests;
+  return {
+    files: files.length,
+    passing: passing.sort(),
+    failing: failing.sort(),
+    unloadable: unloadable.sort(),
+    skipped: skipped.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));
+  const skippedAfter = new Set(after.skipped ?? []);
+  const missingBecauseSkipped = paired.missing.filter((name) => skippedAfter.has(name));
+  return {
+    missingBecauseSkipped,
+    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) {
+    const because = comparison.missingBecauseSkipped.length === 0 ? "" : ` ${comparison.missingBecauseSkipped.length} of them are reported by the new run and run by nobody, which is what a \`beforeAll\` that throws does: jest counted the same test as FAILED, Vitest counts it as skipped, so the name leaves both lists. Look at that file's suite setup, not at the test.`;
+    parts.push(
+      `${comparison.missing.length} test(s) no longer exist: ${comparison.missing.slice(0, 3).join(", ")}.${because}`
+    );
+  }
+  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, suite) {
+  const key = createHash("sha256").update(`${resolve(cwd)}\0${suite}`).digest("hex").slice(0, 16);
+  return join5(tmpdir(), "sentinel-test-reference", `${key}.json`);
+}
+function suiteOf(config) {
+  const base = config.replace(/^(jest|vitest)\./, "").replace(/\.[cm]?[jt]s$/, "");
+  const name = base.replace(/[.-]?config$/, "");
+  return name === "" ? "main" : name;
+}
+function runJest(cwd, config) {
+  const bin = resolveBin(cwd, "jest");
+  if (bin === void 0) return void 0;
+  const root = findWorkspaceRoot(cwd) ?? cwd;
+  const out = join5(mkdtempSync(join5(tmpdir(), "sentinel-reference-")), "jest.json");
+  try {
+    execFileSync(bin, ["-c", join5(cwd, config), "--json", `--outputFile=${out}`, "--silent"], {
+      cwd: root,
+      /*
+       * ⚠️ The module's environment, not the shell's, and this is what made the reference lie.
+       * Measured on `institution`: the task runner loads the repo's dotenv files before starting
+       * the task, a typed command does not, and the difference was 314 env names against 49. The
+       * reference recorded 2958 passing where the module's own target sees 2957. See
+       * `module-env.ts`.
+       */
+      env: moduleEnvironment(cwd).env,
+      stdio: ["ignore", "ignore", "ignore"],
+      maxBuffer: 1 << 28
+    });
+  } catch {
+  }
+  if (!existsSync5(out)) return void 0;
+  try {
+    return JSON.parse(readFileSync4(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, suiteOf(config));
+  mkdirSync(join5(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(stored, void 0, 2)}
+`);
+  return {
+    captured: true,
+    message: `recorded ${snapshot.passing.length} passing test name(s) from ${config} as the reference. Migrate, then \`sentinel --validate --test\` again to compare against it.`
+  };
+}
+function hasReference(cwd, suite) {
+  return existsSync5(referencePath(cwd, suite));
+}
+function compareAgainstReference(cwd, suite, report) {
+  const path = referencePath(cwd, suite);
+  let stored;
+  try {
+    stored = JSON.parse(readFileSync4(path, "utf8"));
+  } catch {
+    rmSync(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) rmSync(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/resolve-vitest.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" };
+}
+
+// src/roles/test/adapters/vitest/vitest.adapter.ts
+import { spawnSync } from "node:child_process";
+import { isAbsolute as isAbsolute2, resolve as resolve7 } from "node:path";
+
+// src/core/config/tool-args.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { isAbsolute, resolve as resolve2 } from "node:path";
+function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
+  const takesValue = new Set(valueFlags);
+  const options = [];
+  const paths = [];
+  let previousTakesValue = false;
+  for (const arg of toolArgs) {
+    const looksLikeOption = arg.startsWith("-");
+    const target = isAbsolute(arg) ? arg : resolve2(cwd, arg);
+    if (!previousTakesValue && !looksLikeOption && existsSync6(target)) paths.push(arg);
+    else options.push(arg);
+    previousTakesValue = !arg.includes("=") && takesValue.has(arg);
+  }
+  return { options, paths };
+}
+
+// src/core/config/nx-target.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join6 } from "node:path";
+function nxTargetMetadataOperations(options) {
+  const { targets } = options;
+  if (Object.keys(targets).length === 0) return [];
+  return [{ kind: "merge-json", path: "package.json", value: { nx: { targets } } }];
+}
+function nxTargetOperations(options) {
+  const { cwd, targets } = options;
+  const names = Object.keys(targets);
+  if (names.length === 0) return [];
+  const operations = [];
+  if (existsSync7(join6(cwd, "project.json"))) {
+    operations.push({
+      kind: "remove-json-keys",
+      path: "project.json",
+      keys: names.map((name) => ["targets", name])
+    });
+  }
+  operations.push(...nxTargetMetadataOperations(options));
+  return operations;
+}
+
+// src/core/config/project-json.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { join as join7 } from "node:path";
+function projectTargets(cwd) {
+  const path = join7(cwd, "project.json");
+  if (!existsSync8(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync5(path, "utf8")).targets;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/config/rewrite-imports.ts
+import { parseSync } from "oxc-parser";
+var movedSpecifiers = (toolchain) => new Set(toolchain.owned.map((entry) => entry.specifier));
+var defaultExportNames = (toolchain) => Object.fromEntries(
+  toolchain.owned.filter((entry) => entry.default !== void 0).map((entry) => [entry.specifier, entry.default])
+);
+function renderImport(bindings, presetSpecifier, semi) {
+  const render = (list) => list.map((b) => b.exported === b.local ? b.exported : `${b.exported} as ${b.local}`).sort((left, right) => left.localeCompare(right)).join(", ");
+  const end = semi ? ";" : "";
+  const values = bindings.filter((b) => !b.typeOnly);
+  const types = bindings.filter((b) => b.typeOnly);
+  const lines = [];
+  if (values.length > 0) lines.push(`import { ${render(values)} } from '${presetSpecifier}'${end}`);
+  if (types.length > 0) {
+    lines.push(`import type { ${render(types)} } from '${presetSpecifier}'${end}`);
+  }
+  return lines.join("\n");
+}
+function rewriteToolchainImports(toolchain, source, fileName) {
+  const moved = movedSpecifiers(toolchain);
+  const defaults = defaultExportNames(toolchain);
+  const { program, errors } = parseSync(fileName, source, { sourceType: "module" });
+  if (errors.length > 0) {
+    return {
+      kind: "blocked",
+      why: `${fileName} does not parse: ${errors[0]?.message ?? "unknown"}`
+    };
+  }
+  const imports = program.body.filter(
+    (node) => node.type === "ImportDeclaration"
+  );
+  if (imports.some((node) => node.source.value === toolchain.presetSpecifier)) {
+    return { kind: "unchanged", why: "this config already imports its toolchain from sentinel" };
+  }
+  const moving = imports.filter((node) => moved.has(node.source.value));
+  if (moving.length === 0) {
+    return {
+      kind: "unchanged",
+      why: "this config imports none of the packages sentinel owns, so there is nothing to move"
+    };
+  }
+  const bindings = [];
+  for (const node of moving) {
+    const from = node.source.value;
+    const specifiers = node.specifiers ?? [];
+    if (specifiers.length === 0) {
+      return { kind: "blocked", why: `\`import '${from}'\` has no bindings to move` };
+    }
+    for (const spec of specifiers) {
+      const typeOnly = node.importKind === "type" || spec.importKind === "type";
+      if (spec.type === "ImportDefaultSpecifier") {
+        const exported = defaults[from];
+        if (!exported) {
+          return {
+            kind: "blocked",
+            why: `no sentinel export for the default import of \`${from}\``
+          };
+        }
+        bindings.push({ exported, local: spec.local.name, typeOnly });
+        continue;
+      }
+      if (spec.type === "ImportSpecifier") {
+        bindings.push({
+          exported: spec.imported?.name ?? spec.imported?.value ?? spec.local.name,
+          local: spec.local.name,
+          typeOnly
+        });
+        continue;
+      }
+      return {
+        kind: "blocked",
+        why: `\`import * as ${spec.local.name} from '${from}'\` cannot be mapped onto sentinel's named exports`
+      };
+    }
+  }
+  const spans = moving.map((node) => ({ start: node.start, end: node.end })).sort((left, right) => left.start - right.start);
+  const first = spans[0];
+  const rest = spans.slice(1);
+  let out = source;
+  for (const span of rest.slice().reverse()) {
+    const after = out.slice(span.end).match(/^\r?\n/)?.[0].length ?? 0;
+    out = out.slice(0, span.start) + out.slice(span.end + after);
+  }
+  const semi = source.slice(first.start, first.end).trimEnd().endsWith(";");
+  out = out.slice(0, first.start) + renderImport(bindings, toolchain.presetSpecifier, semi) + out.slice(first.end);
+  return {
+    kind: "rewritten",
+    source: out,
+    moved: [...new Set(moving.map((node) => node.source.value))].sort()
+  };
+}
+
+// src/roles/test/jest-migration.ts
+import { existsSync as existsSync18, readFileSync as readFileSync17, readdirSync as readdirSync6 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
+import { dirname as dirname10, join as join22, relative as relative5 } from "node:path";
+
+// src/shared/jsonc.ts
+import { parse as parse2, printParseErrorCode } from "jsonc-parser";
+function parseJsonc(text, source = "config") {
+  const errors = [];
+  const value = parse2(text, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    const details = errors.map((error) => printParseErrorCode(error.error)).join(", ");
+    throw new Error(`${source}: malformed JSONC (${details}).`);
+  }
+  return value;
+}
+
+// src/roles/test/codemod/migrate-module.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
+import { join as join15 } from "node:path";
+import { parseSync as parseSync7 } from "oxc-parser";
+
+// src/roles/test/msw-lifecycle.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+import { join as join8 } 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 = join8(cwd, raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", "."));
+    if (!existsSync9(file)) continue;
+    try {
+      if (/\.listen\s*\(/.test(readFileSync6(file, "utf8"))) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+
+// src/roles/test/support-file-name.ts
+var JEST_PREFIX = "jest.";
+var VITEST_PREFIX = "vitest.";
+function vitestSupportName(relative6) {
+  const cut = relative6.lastIndexOf("/");
+  const directory = cut === -1 ? "" : relative6.slice(0, cut + 1);
+  const base = relative6.slice(cut + 1);
+  if (!base.startsWith(JEST_PREFIX)) return relative6;
+  return `${directory}${VITEST_PREFIX}${base.slice(JEST_PREFIX.length)}`;
+}
+
+// src/roles/test/codemod/migrate-file.ts
+import { dirname as dirname6 } from "node:path";
+import { parseSync as parseSync6 } from "oxc-parser";
+
+// src/shared/ast.ts
+var SKIP = /* @__PURE__ */ Symbol("skip-subtree");
+function walk(node, visit) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const entry of node) walk(entry, visit);
+    return;
+  }
+  const current = node;
+  if (typeof current.type === "string" && visit(current) === SKIP) return;
+  for (const value of Object.values(current)) {
+    if (value !== null && typeof value === "object") walk(value, visit);
+  }
+}
+
+// src/roles/test/codemod/assertion-return-value.ts
+var MEMBER_TYPES = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function rootedAtExpect(node) {
+  let current = node;
+  for (let depth = 0; current !== void 0 && depth < 12; depth += 1) {
+    if (current.type === "CallExpression") {
+      const callee = current.callee;
+      if (callee?.type === "Identifier") return callee.name === "expect";
+      current = callee;
+      continue;
+    }
+    if (MEMBER_TYPES.has(current.type)) {
+      current = current.object;
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+function capture(node) {
+  if (node.type !== "VariableDeclaration") return void 0;
+  const declarations = node.declarations ?? [];
+  if (declarations.length !== 1) return void 0;
+  const only = declarations[0];
+  const id = only.id;
+  const init = only.init;
+  if (id?.type !== "Identifier" || init?.type !== "AwaitExpression") return void 0;
+  if (!rootedAtExpect(init.argument)) return void 0;
+  return { name: id.name, init };
+}
+function undefinedAssertionOf(node, name) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES.has(callee.type)) return false;
+  const property = callee.property;
+  if (property?.type !== "Identifier" || property.name !== "toBeUndefined") return false;
+  const object = callee.object;
+  if (object?.type !== "CallExpression") return false;
+  if (object.callee?.type !== "Identifier") return false;
+  if (object.callee.name !== "expect") return false;
+  const [argument] = object.arguments ?? [];
+  return argument?.type === "Identifier" && argument.name === name;
+}
+function rewriteAssertionReturnValue(source, program) {
+  const captures = [];
+  walk(program, (node) => {
+    const found = capture(node);
+    if (found === void 0) return;
+    captures.push({
+      name: found.name,
+      declarationStart: node.start,
+      initStart: found.init.start
+    });
+  });
+  const notReferences = [];
+  walk(program, (node) => {
+    if (node.type === "Property" || node.type === "ObjectProperty" || node.type === "PropertyDefinition") {
+      if (node.computed === true) return;
+      const key = node.key;
+      if (key !== void 0)
+        notReferences.push({ start: key.start, end: key.end });
+      return;
+    }
+    if (MEMBER_TYPES.has(node.type) && node.computed !== true) {
+      const property = node.property;
+      if (property !== void 0) {
+        notReferences.push({ start: property.start, end: property.end });
+      }
+    }
+  });
+  const functions = [];
+  walk(program, (node) => {
+    if (/Function|ArrowFunctionExpression/.test(node.type)) functions.push(node);
+  });
+  const scopeOf = (position) => {
+    const containing = functions.filter((fn) => position >= fn.start && position <= fn.end).sort(
+      (a, b) => a.end - a.start - (b.end - b.start)
+    );
+    const nearest = containing[0];
+    return nearest === void 0 ? { start: 0, end: source.length } : { start: nearest.start, end: nearest.end };
+  };
+  const edits = [];
+  const refusals = [];
+  for (const found of captures) {
+    const readings = [];
+    let readElsewhere = false;
+    const scope = scopeOf(found.declarationStart);
+    walk(program, (node) => {
+      const start = node.start;
+      if (start < scope.start || node.end > scope.end) return;
+      if (undefinedAssertionOf(node, found.name)) {
+        readings.push(node);
+        return;
+      }
+      if (node.type !== "Identifier" || node.name !== found.name) return;
+      if (notReferences.some((span) => start >= span.start && node.end <= span.end)) {
+        return;
+      }
+      const inside = readings.some(
+        (reading) => start >= reading.start && node.end <= reading.end
+      );
+      const isBinding = start < found.initStart;
+      if (!inside && !isBinding) readElsewhere = true;
+    });
+    if (readings.length === 0 || readElsewhere) {
+      if (readings.length > 0) refusals.push(found.name);
+      continue;
+    }
+    edits.push({ start: found.declarationStart, end: found.initStart, text: "" });
+    for (const reading of readings) {
+      const from = reading.start;
+      let to = reading.end;
+      while (to < source.length && /[ \t;]/.test(source[to])) to += 1;
+      let head = from;
+      while (head > 0 && /[ \t]/.test(source[head - 1])) head -= 1;
+      if (head > 0 && source[head - 1] === "\n") head -= 1;
+      edits.push({ start: head, end: to, text: "" });
+    }
+  }
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: captures.length - refusals.length, refusals };
+}
+
+// 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_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 ?? [];
+  return argument?.type === "ArrowFunctionExpression" ? argument : void 0;
+}
+function assertedMockedClass(source, node) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  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));
+}
+function readsThis(node) {
+  let found = false;
+  walk(node, (inner) => {
+    if (inner.type === "ThisExpression") found = true;
+  });
+  return found;
+}
+function rewriteConstructibleMocks(source, program, factories) {
+  const edits = [];
+  const refusals = [];
+  let rewritten = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const subtrees = [...factories];
+  walk(program, (node) => {
+    if (assertedMockedClass(source, node)) subtrees.push(node);
+  });
+  for (const subtree of subtrees) {
+    walk(subtree, (node) => {
+      const arrow = mockImplementationArrow(node);
+      if (arrow === void 0 || seen.has(arrow)) return;
+      seen.add(arrow);
+      if (readsThis(arrow)) {
+        refusals.push({
+          binding: "mockImplementation",
+          reason: `a mock implementation reads \`this\`, so it cannot become a function expression, and an arrow cannot be constructed by Vitest. This one needs a human.`
+        });
+        return;
+      }
+      const params = arrow.params ?? [];
+      const paramsText = params.length === 0 ? "" : source.slice(params[0]?.start, params[params.length - 1]?.end);
+      const body = arrow.body;
+      const bodyText = source.slice(body.start, body.end);
+      const text = body.type === "BlockStatement" ? `function (${paramsText}) ${bodyText}` : `function (${paramsText}) {
+  return ${bodyText}
+}`;
+      edits.push({ start: arrow.start, end: arrow.end, text });
+      rewritten += 1;
+    });
+  }
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return { source: result, rewritten, refusals };
+}
+
+// src/roles/test/codemod/deep-imports.ts
+var DEEP_ENTRIES = {
+  "jest-mock-extended/lib/Mock": { root: "jest-mock-extended", defaultExport: "mock" }
+};
+function normaliseDeepImports(source) {
+  let result = source;
+  let rewritten = 0;
+  for (const [deep, { root, defaultExport }] of Object.entries(DEEP_ENTRIES)) {
+    const quoted = deep.replaceAll("/", "\\/");
+    const defaultImport = new RegExp(`import\\s+(\\w+)\\s+from\\s+(['"])${quoted}\\2`, "g");
+    result = result.replace(defaultImport, (_whole, binding, quote) => {
+      rewritten += 1;
+      const named = binding === defaultExport ? defaultExport : `${defaultExport} as ${binding}`;
+      return `import { ${named} } from ${quote}${root}${quote}`;
+    });
+    const anyImport = new RegExp(`(from\\s+)(['"])${quoted}\\2`, "g");
+    result = result.replace(anyImport, (_whole, from, quote) => {
+      rewritten += 1;
+      return `${from}${quote}${root}${quote}`;
+    });
+  }
+  return { source: result, rewritten };
+}
+
+// src/roles/test/codemod/each-table-rows.ts
+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_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_TYPES4.has(object.type)) {
+    object = object.object;
+  }
+  if (object?.type !== "Identifier" || !RUNNERS.has(object.name)) return void 0;
+  const [table] = node.arguments ?? [];
+  return table?.type === "ArrayExpression" ? table : void 0;
+}
+function rewriteEachTableRows(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    const table = eachTable(node);
+    if (table === void 0) return;
+    const rows = table.elements ?? [];
+    if (rows.length === 0 || rows.some((row) => row === null)) return;
+    const arrays = rows.filter((row) => row.type === "ArrayExpression").length;
+    if (arrays === 0 || arrays === rows.length) return;
+    const wrapped = rows.map((row) => source.slice(row.start, row.end)).map((text) => `[${text}]`).join(", ");
+    edits.push({ start: table.start, end: table.end, text: `[${wrapped}]` });
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
+// src/roles/test/codemod/each-title.ts
+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_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 ?? [];
+  if (title === void 0) return void 0;
+  return title.type === "StringLiteral" || title.type === "Literal" || title.type === "TemplateLiteral" ? title : void 0;
+}
+function rewriteSpecifiers(text) {
+  let result = "";
+  let rewritten = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] !== "%") {
+      result += text[index];
+      continue;
+    }
+    const next = text[index + 1];
+    if (next === "%") {
+      result += "%%";
+      index += 1;
+      continue;
+    }
+    if (next === "p") {
+      result += "%j";
+      rewritten += 1;
+      index += 1;
+      continue;
+    }
+    result += "%";
+  }
+  return { text: result, rewritten };
+}
+function rewriteEachTitles(source, program) {
+  const edits = [];
+  let rewritten = 0;
+  walk(program, (node) => {
+    const title = eachTitle(node);
+    if (title === void 0) return;
+    const start = title.start;
+    const end = title.end;
+    const replacement = rewriteSpecifiers(source.slice(start, end));
+    if (replacement.rewritten === 0) return;
+    edits.push({ start, end, text: replacement.text });
+    rewritten += replacement.rewritten;
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return { source: result, rewritten };
+}
+
+// src/roles/test/codemod/empty-mock-implementation.ts
+var METHODS = /* @__PURE__ */ new Set(["mockImplementation", "mockImplementationOnce"]);
+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_TYPES6.has(callee.type)) return;
+    const property = callee.property;
+    if (property?.type !== "Identifier" || !METHODS.has(property.name)) return;
+    insertAt.push(node.end - 1);
+  });
+  let result = source;
+  for (const position of [...insertAt].sort((left, right) => right - left)) {
+    result = `${result.slice(0, position)}() => undefined${result.slice(position)}`;
+  }
+  return { source: result, rewritten: insertAt.length };
+}
+
+// src/roles/test/codemod/fake-timer-options.ts
+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_TYPES7.has(callee.type)) return void 0;
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier") return void 0;
+  if (object.name !== "jest" && object.name !== "vi") return void 0;
+  if (property?.type !== "Identifier" || !TIMER_CALLS.has(property.name)) return void 0;
+  const [options] = node.arguments ?? [];
+  return options?.type === "ObjectExpression" ? options : void 0;
+}
+var FAKEABLE = [
+  "setTimeout",
+  "clearTimeout",
+  "setImmediate",
+  "clearImmediate",
+  "setInterval",
+  "clearInterval",
+  "Date",
+  "hrtime",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "requestIdleCallback",
+  "cancelIdleCallback",
+  "performance"
+];
+function withSeparator(source, options, property) {
+  const properties = options.properties ?? [];
+  const index = properties.indexOf(property);
+  const start = property.start;
+  const end = property.end;
+  if (index < properties.length - 1) {
+    const next = properties[index + 1]?.start;
+    const between2 = next === void 0 ? "" : source.slice(end, next);
+    const comma2 = between2.indexOf(",");
+    if (comma2 >= 0) return { start, end: end + comma2 + 1 };
+    return { start, end };
+  }
+  const previous = properties[index - 1]?.end;
+  if (previous === void 0) return { start, end };
+  const between = source.slice(previous, start);
+  const comma = between.lastIndexOf(",");
+  return comma >= 0 ? { start: previous + comma, end } : { start, end };
+}
+function stringLiterals(node) {
+  if (node.type !== "ArrayExpression") return void 0;
+  const values = [];
+  for (const element of node.elements ?? []) {
+    if (element?.type !== "Literal" || typeof element.value !== "string") return void 0;
+    values.push(element.value);
+  }
+  return values;
+}
+function rewriteFakeTimerOptions(source, program) {
+  const edits = [];
+  const translated = [];
+  const refusals = [];
+  const warnings = [];
+  walk(program, (node) => {
+    const options = timerOptions(node);
+    if (options === void 0) return;
+    for (const property of options.properties ?? []) {
+      const key = property.key;
+      if (key?.type !== "Identifier") continue;
+      const value = property.value;
+      if (value === void 0) continue;
+      const span = { start: property.start, end: property.end };
+      if (key.name === "advanceTimers") {
+        if (value.type === "Literal" && value.value === true) {
+          edits.push({ ...span, text: "shouldAdvanceTime: true" });
+          translated.push("advanceTimers -> shouldAdvanceTime");
+          continue;
+        }
+        if (value.type === "Literal" && typeof value.value === "number") {
+          edits.push({
+            ...span,
+            text: `shouldAdvanceTime: true, advanceTimeDelta: ${value.value}`
+          });
+          translated.push("advanceTimers -> shouldAdvanceTime + advanceTimeDelta");
+          continue;
+        }
+        refusals.push({
+          binding: "advanceTimers",
+          reason: "`useFakeTimers({ advanceTimers })` translates to sinon's `shouldAdvanceTime`, but only when the value can be read here: this one is neither `true` nor a number, and inventing a delta would be inventing behaviour."
+        });
+        continue;
+      }
+      if (key.name === "legacyFakeTimers") {
+        const asked = value.type === "Literal" && value.value === true;
+        edits.push({ ...withSeparator(source, options, property), text: "" });
+        if (asked) {
+          warnings.push(
+            "`useFakeTimers({ legacyFakeTimers: true })` was REMOVED, not translated: it selects jest's pre-27 timer implementation, and Vitest installs sinon's clock with no equivalent. The call now uses the modern clock, which is what jest itself defaults to. Re-read any test that depended on the old one."
+          );
+        }
+        continue;
+      }
+      if (key.name === "doNotFake") {
+        const excluded = stringLiterals(value);
+        if (excluded === void 0) {
+          refusals.push({
+            binding: "doNotFake",
+            reason: "`useFakeTimers({ doNotFake })` becomes sinon's `toFake`, which is its COMPLEMENT, so the list has to be readable here. This one is not a list of string literals."
+          });
+          continue;
+        }
+        const kept = FAKEABLE.filter((name) => !excluded.includes(name));
+        edits.push({
+          ...span,
+          text: `toFake: [${kept.map((name) => `'${name}'`).join(", ")}]`
+        });
+        translated.push("doNotFake -> toFake");
+      }
+    }
+  });
+  if (edits.length === 0) return { source, translated, refusals, warnings };
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return { source: result, translated, refusals, warnings };
+}
+
+// src/roles/test/codemod/scope.ts
+function readIdentifiers(node, runsLater) {
+  const names = [];
+  walk(node, (current) => {
+    if (current !== node && runsLater?.(current) === true) return SKIP;
+    if (current.type === "Property" || current.type === "ObjectProperty") {
+      if (current.shorthand === true) {
+        names.push(...readIdentifiers(current.value, runsLater));
+        return SKIP;
+      }
+      if (current.computed === true) return;
+      const key = current.key;
+      if (key?.type !== "Identifier") return;
+      names.push(...readIdentifiers(current.value, runsLater));
+      return SKIP;
+    }
+    if (current.type === "MemberExpression" || current.type === "StaticMemberExpression") {
+      if (current.computed === true) return;
+      names.push(...readIdentifiers(current.object, runsLater));
+      return SKIP;
+    }
+    if (current.type === "Identifier") {
+      names.push(current.name);
+      return SKIP;
+    }
+    return void 0;
+  });
+  return names;
+}
+function patternNames(pattern) {
+  const names = [];
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return;
+    const current = node;
+    switch (current.type) {
+      case "Identifier":
+        names.push(current.name);
+        return;
+      case "ObjectPattern":
+        for (const property of current.properties ?? []) {
+          visit(property.type === "RestElement" ? property.argument : property.value);
+        }
+        return;
+      case "ArrayPattern":
+        for (const element of current.elements ?? []) visit(element);
+        return;
+      case "AssignmentPattern":
+        visit(current.left);
+        return;
+      case "RestElement":
+        visit(current.argument);
+        return;
+      default:
+        return;
+    }
+  };
+  visit(pattern);
+  return names;
+}
+function moduleBindings(program) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const statement2 of program.body ?? []) {
+    if (statement2.type !== "VariableDeclaration") continue;
+    for (const declarator of statement2.declarations ?? []) {
+      const init = declarator.init ?? void 0;
+      for (const name of patternNames(declarator.id)) bindings.set(name, init);
+    }
+  }
+  return bindings;
+}
+function importedNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement2 of program.body ?? []) {
+    if (statement2.type !== "ImportDeclaration") continue;
+    for (const specifier of statement2.specifiers ?? []) {
+      const local = specifier.local;
+      if (local?.type === "Identifier") names.add(local.name);
+    }
+  }
+  return names;
+}
+function declaredInside(factory) {
+  const names = /* @__PURE__ */ new Set();
+  walk(factory, (node) => {
+    if (node.type === "VariableDeclarator" || node.type === "FunctionDeclaration") {
+      for (const name of patternNames(node.id)) names.add(name);
+    }
+    if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+      for (const parameter of node.params ?? []) {
+        for (const name of patternNames(parameter)) names.add(name);
+      }
+    }
+  });
+  return names;
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration"
+]);
+function capturedBindings(factory, bindings) {
+  const own = declaredInside(factory);
+  const invoked = /* @__PURE__ */ new Set();
+  walk(factory, (node) => {
+    if (node.type !== "CallExpression") return;
+    let callee = node.callee;
+    while (callee?.type === "ParenthesizedExpression") callee = callee.expression;
+    if (callee !== void 0 && FUNCTION_TYPES.has(callee.type)) invoked.add(callee);
+  });
+  const runsLater = (candidate) => FUNCTION_TYPES.has(candidate.type) && !invoked.has(candidate);
+  const captured = /* @__PURE__ */ new Set();
+  for (const name of readIdentifiers(factory, runsLater)) {
+    if (bindings.has(name) && !own.has(name)) captured.add(name);
+  }
+  return [...captured];
+}
+function hoistable(name, bindings, imported, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(name)) return true;
+  seen.add(name);
+  const init = bindings.get(name);
+  if (init === void 0) return false;
+  for (const read3 of readIdentifiers(init)) {
+    if (imported.has(read3)) return false;
+    if (bindings.has(read3) && !hoistable(read3, bindings, imported, seen)) return false;
+  }
+  return true;
+}
+
+// src/roles/test/codemod/hoist.ts
+function simpleDeclarations(program) {
+  const found = /* @__PURE__ */ new Map();
+  for (const statement2 of program.body ?? []) {
+    if (statement2.type !== "VariableDeclaration") continue;
+    const declarations = statement2.declarations ?? [];
+    if (declarations.length !== 1) continue;
+    const declarator = declarations[0];
+    const id = declarator.id;
+    const init = declarator.init;
+    if (id?.type !== "Identifier" || init === void 0 || init === null) continue;
+    found.set(id.name, { statement: statement2, init, kind: statement2.kind ?? "const" });
+  }
+  return found;
+}
+function interdependent(names, bindings) {
+  for (const name of names) {
+    for (const read3 of readIdentifiers(bindings.get(name))) {
+      if (read3 !== name && names.includes(read3)) return `${name} reads ${read3}`;
+    }
+  }
+  return void 0;
+}
+function statementSpan(source, statement2) {
+  let end = statement2.end;
+  if (source[end] === "\r") end++;
+  if (source[end] === "\n") end++;
+  return { start: statement2.start, end };
+}
+function hoistCapturedBindings(source, program, factories, bindings, imported) {
+  const captured = [...new Set(factories.flatMap((factory) => capturedBindings(factory, bindings)))];
+  if (captured.length === 0) return { source, hoisted: [], refusals: [] };
+  const refusals = [];
+  for (const name of captured) {
+    if (hoistable(name, bindings, imported)) continue;
+    refusals.push({
+      binding: name,
+      reason: bindings.get(name) === void 0 ? `\`${name}\` cannot move into vi.hoisted: it is declared without an initializer, so there is nothing for vi.hoisted to carry` : `\`${name}\` cannot move into vi.hoisted: its initializer reads something imported, so it cannot live above the import graph`
+    });
+  }
+  const declarations = simpleDeclarations(program);
+  for (const name of captured) {
+    if (!declarations.has(name) && !refusals.some((refusal) => refusal.binding === name)) {
+      refusals.push({
+        binding: name,
+        reason: `it is not declared as a plain \`${name} = ...\` at module scope`
+      });
+    }
+  }
+  const cycle = interdependent(captured, bindings);
+  if (cycle !== void 0) {
+    refusals.push({
+      binding: captured.join(", "),
+      reason: `${cycle}, and an object literal cannot refer to its own keys`
+    });
+  }
+  if (refusals.length > 0) return { source, hoisted: [], refusals };
+  const ordered = captured.map((name) => ({
+    name,
+    ...declarations.get(name)
+  })).sort((left, right) => left.statement.start - right.statement.start);
+  const first = ordered[0];
+  const semi = source.slice(first.statement.start, first.statement.end).trimEnd().endsWith(";");
+  const end = semi ? ";" : "";
+  const initOf = ({ init }) => source.slice(init.start, init.end);
+  const constants = ordered.filter(({ kind }) => kind === "const");
+  const objectLine = constants.length === 0 ? void 0 : `const { ${constants.map(({ name }) => name).join(", ")} } = vi.hoisted(() => ({ ${constants.map((entry) => `${entry.name}: ${initOf(entry)}`).join(", ")} }))${end}
+`;
+  const lines = [];
+  let objectEmitted = false;
+  for (const entry of ordered) {
+    if (entry.kind === "const") {
+      if (!objectEmitted && objectLine !== void 0) {
+        lines.push(objectLine);
+        objectEmitted = true;
+      }
+      continue;
+    }
+    lines.push(`${entry.kind} ${entry.name} = vi.hoisted(() => ${initOf(entry)})${end}
+`);
+  }
+  const hoistedLine = lines.join("");
+  const edits = ordered.map(({ statement: statement2 }, index) => {
+    const span = statementSpan(source, statement2);
+    return { ...span, text: index === 0 ? hoistedLine : "" };
+  });
+  let rewritten = source;
+  for (const edit of edits.sort((left, right) => right.start - left.start)) {
+    rewritten = rewritten.slice(0, edit.start) + edit.text + rewritten.slice(edit.end);
+  }
+  return { source: rewritten, hoisted: ordered.map(({ name }) => name), refusals: [] };
+}
+
+// src/roles/test/codemod/hook-return-value.ts
+var HOOKS = /* @__PURE__ */ new Set(["beforeEach", "afterEach", "beforeAll", "afterAll"]);
+var MEMBER_TYPES8 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function hookCallback(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier" || !HOOKS.has(callee.name)) return void 0;
+  const [callback] = node.arguments ?? [];
+  return callback?.type === "ArrowFunctionExpression" ? callback : void 0;
+}
+function configuresAMock(body) {
+  if (body.type !== "CallExpression") return false;
+  const callee = body.callee;
+  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);
+}
+function rewriteHookReturnValue(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    const callback = hookCallback(node);
+    if (callback === void 0 || callback.async === true) return;
+    const body = callback.body;
+    if (body === void 0 || body.type === "BlockStatement") return;
+    if (!configuresAMock(body)) return;
+    const start = body.start;
+    const end = body.end;
+    edits.push({ start, end, text: `{
+    ${source.slice(start, end)}
+  }` });
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
+// src/roles/test/codemod/inject-type-import.ts
+import { parseSync as parseSync3 } from "oxc-parser";
+
+// src/roles/test/codemod/rename.ts
+import { parseSync as parseSync2 } from "oxc-parser";
+var VITEST_TYPE_SOURCE = "vitest";
+var RUNTIME_RENAMES = /* @__PURE__ */ new Set([
+  // Mocks
+  "clearAllMocks",
+  "doMock",
+  "fn",
+  "mock",
+  "mocked",
+  "resetAllMocks",
+  "resetModules",
+  "restoreAllMocks",
+  "spyOn",
+  "unmock",
+  /*
+   * Timers, as a family rather than as the two the corpus happens to use today. Running this over
+   * the repo reported `jest.runAllTimers` as unknown, which was a hole in the table rather than a
+   * finding about the code. Each name here was then checked against a running Vitest, so adding the
+   * siblings is not speculation: a file gaining one tomorrow gets the same answer as one using it
+   * today, instead of a report about a member that was always going to be a rename.
+   */
+  "advanceTimersByTime",
+  "advanceTimersByTimeAsync",
+  "advanceTimersToNextTimer",
+  "clearAllTimers",
+  "getRealSystemTime",
+  "getTimerCount",
+  "runAllTimers",
+  "runAllTimersAsync",
+  "runOnlyPendingTimers",
+  "setSystemTime",
+  "useFakeTimers",
+  "useRealTimers"
+]);
+var TYPE_RENAMES = {
+  Mock: "Mock",
+  MockedClass: "MockedClass",
+  MockedFunction: "MockedFunction",
+  MockedObject: "MockedObject",
+  Mocked: "Mocked",
+  SpiedFunction: "MockInstance",
+  SpyInstance: "MockInstance"
+};
+var NAMED_RULE = {
+  requireActual: `await vi.importActual(...), which makes the surrounding factory async`,
+  requireMock: `await vi.importMock(...), which makes the surrounding factory async`,
+  setTimeout: `vi.setConfig({ testTimeout: ... }), which is configuration rather than a call`
+};
+var OWNED_BY_A_LATER_PASS = /* @__PURE__ */ new Set(["isolateModules", "isolateModulesAsync"]);
+function lineOf(source, offset) {
+  let line = 1;
+  for (let index = 0; index < offset && index < source.length; index++) {
+    if (source[index] === "\n") line++;
+  }
+  return line;
+}
+function valueEdit(node, source, outcome) {
+  const object = node.object;
+  const property = node.property;
+  if (object?.type !== "Identifier" || object.name !== "jest") return void 0;
+  if (property?.type !== "Identifier") return void 0;
+  const member = property.name;
+  if (RUNTIME_RENAMES.has(member)) {
+    outcome.rewritten++;
+    return { start: object.start, end: object.end, text: "vi" };
+  }
+  if (OWNED_BY_A_LATER_PASS.has(member)) return void 0;
+  outcome.unhandled.push({
+    member: `jest.${member}`,
+    line: lineOf(source, object.start),
+    ...NAMED_RULE[member] === void 0 ? {} : { rule: NAMED_RULE[member] }
+  });
+  return void 0;
+}
+function typeEdit(node, source, outcome, needed) {
+  const left = node.left;
+  const right = node.right;
+  if (left?.type !== "Identifier" || left.name !== "jest") return void 0;
+  if (right?.type !== "Identifier") return void 0;
+  const member = right.name;
+  const replacement = TYPE_RENAMES[member];
+  if (replacement === void 0) {
+    outcome.unhandled.push({ member: `jest.${member}`, line: lineOf(source, node.start) });
+    return void 0;
+  }
+  needed.add(replacement);
+  outcome.rewritten++;
+  return { start: node.start, end: node.end, text: replacement };
+}
+function renameJestToVitest(fileName, source) {
+  const outcome = { source, typeImports: [], rewritten: 0, unhandled: [] };
+  const { program, errors } = parseSync2(fileName, source, { sourceType: "module" });
+  if (errors.length > 0) return outcome;
+  const edits = [];
+  const needed = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    if (node.type === "MemberExpression" || node.type === "StaticMemberExpression") {
+      const edit = valueEdit(node, source, outcome);
+      if (edit !== void 0) edits.push(edit);
+      return;
+    }
+    if (node.type === "TSQualifiedName") {
+      const edit = typeEdit(node, source, outcome, needed);
+      if (edit !== void 0) edits.push(edit);
+    }
+  });
+  outcome.typeImports = [...needed].sort();
+  let rewritten = source;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    rewritten = rewritten.slice(0, edit.start) + edit.text + rewritten.slice(edit.end);
+  }
+  outcome.source = rewritten;
+  return outcome;
+}
+
+// src/roles/test/codemod/inject-type-import.ts
+function renderTypeImport(names, semi) {
+  return `import type { ${names.join(", ")} } from '${VITEST_TYPE_SOURCE}'${semi ? ";" : ""}`;
+}
+function importDeclarations(program) {
+  return (program.body ?? []).filter((node) => node.type === "ImportDeclaration");
+}
+function usesSemicolons(source, imports) {
+  const first = imports[0];
+  if (first === void 0) return false;
+  return source.slice(first.start, first.end).trimEnd().endsWith(";");
+}
+function existingVitestImport(imports) {
+  return imports.find(
+    (node) => node.source?.value === VITEST_TYPE_SOURCE
+  );
+}
+function alreadyImported(declaration) {
+  return (declaration.specifiers ?? []).filter((specifier) => specifier.type === "ImportSpecifier").map((specifier) => specifier.imported?.name).filter((name) => name !== void 0);
+}
+function injectTypeImport(fileName, source, typeNames) {
+  if (typeNames.length === 0) return source;
+  const { program, errors } = parseSync3(fileName, source, { sourceType: "module" });
+  if (errors.length > 0) return source;
+  const imports = importDeclarations(program);
+  const semi = usesSemicolons(source, imports);
+  const existing = existingVitestImport(imports);
+  if (existing !== void 0) {
+    const merged = [.../* @__PURE__ */ new Set([...alreadyImported(existing), ...typeNames])].sort();
+    if (merged.length === alreadyImported(existing).length) return source;
+    return source.slice(0, existing.start) + renderTypeImport(merged, semi) + source.slice(existing.end);
+  }
+  const line = renderTypeImport([...new Set(typeNames)].sort(), semi);
+  const first = imports[0];
+  if (first === void 0) return `${line}
+
+${source}`;
+  return source.slice(0, first.start) + line + "\n" + source.slice(first.start);
+}
+
+// src/roles/test/codemod/named-rules.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname2, join as join9 } from "node:path";
+function isCommonJsPackage(fromFile, specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return false;
+  let resolved;
+  try {
+    resolved = createRequire2(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 = dirname2(resolved);
+  for (let depth = 0; depth < 12; depth += 1) {
+    const manifest = join9(dir, "package.json");
+    if (existsSync10(manifest)) {
+      try {
+        return JSON.parse(readFileSync7(manifest, "utf8")).type !== "module";
+      } catch {
+        return false;
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+var MEMBER_TYPES9 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var ASYNC_REPLACEMENTS = {
+  requireActual: "importActual",
+  requireMock: "importMock"
+};
+function mockedSpecifiers(program) {
+  const found = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee === void 0 || !MEMBER_TYPES9.has(callee.type)) return;
+    const object = callee.object;
+    const property = callee.property;
+    if (object?.type !== "Identifier") return;
+    if (object.name !== "jest" && object.name !== "vi") return;
+    if (property?.type !== "Identifier" || property.name !== "mock") return;
+    const [specifier] = node.arguments ?? [];
+    if (specifier?.type === "StringLiteral" || specifier?.type === "Literal") {
+      found.add(String(specifier.value));
+    }
+  });
+  return found;
+}
+var FUNCTIONS = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
+function walkWithEnclosingFunction(node, enclosing, visit) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const entry of node) walkWithEnclosingFunction(entry, enclosing, visit);
+    return;
+  }
+  const current = node;
+  const next = FUNCTIONS.has(current.type) ? current : enclosing;
+  if (typeof current.type === "string") visit(current, enclosing);
+  for (const value of Object.values(current)) {
+    if (value !== null && typeof value === "object") walkWithEnclosingFunction(value, next, visit);
+  }
+}
+function bareRequire(node) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier" || callee.name !== "require") return false;
+  const args = node.arguments ?? [];
+  return args.length === 1 && args[0] !== void 0;
+}
+function mockFactoryReturn(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  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;
+  if (!["jest", "vi", "vitest"].includes(object.name)) return void 0;
+  if (property?.name !== "mock") return void 0;
+  const factory = (node.arguments ?? [])[1];
+  if (factory?.type !== "ArrowFunctionExpression" && factory?.type !== "FunctionExpression") {
+    return void 0;
+  }
+  let body = factory.body;
+  while (body?.type === "ParenthesizedExpression") body = body.expression;
+  if (body === void 0) return void 0;
+  if (body.type !== "BlockStatement") return body;
+  const statements = body.body ?? [];
+  if (statements.length !== 1) return void 0;
+  const only = statements[0];
+  if (only?.type !== "ReturnStatement") return void 0;
+  let argument = only.argument;
+  while (argument?.type === "ParenthesizedExpression") {
+    argument = argument.expression;
+  }
+  return argument;
+}
+function ownedCall(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression" && callee?.type !== "StaticMemberExpression") {
+    return void 0;
+  }
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier" || object.name !== "jest") return void 0;
+  return property?.type === "Identifier" ? property.name : void 0;
+}
+function argumentText(source, call) {
+  const args = call.arguments ?? [];
+  if (args.length === 0) return "";
+  const first = args[0];
+  const last = args[args.length - 1];
+  return source.slice(first.start, last.end);
+}
+function applyEdits(source, edits) {
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return result;
+}
+function applyNamedRules(source, program, fileName = "") {
+  const edits = [];
+  const applied = /* @__PURE__ */ new Set();
+  const asyncify = /* @__PURE__ */ new Set();
+  const mocked = mockedSpecifiers(program);
+  const wholeStatement = /* @__PURE__ */ new Map();
+  walk(program, (node) => {
+    if (node.type !== "ExpressionStatement") return;
+    const expression = node.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);
+    if (returned !== void 0) handedToTheRunnerAsAModule.add(returned);
+  });
+  const readsANameOffIt = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    if (node.type === "VariableDeclarator") {
+      const id = node.id;
+      const init = node.init ?? void 0;
+      if (id !== void 0 && id.type !== "Identifier" && init !== void 0) {
+        readsANameOffIt.add(init);
+      }
+      return;
+    }
+    if (!MEMBER_TYPES9.has(node.type)) return;
+    const object = node.object;
+    if (object !== void 0) readsANameOffIt.add(object);
+  });
+  walkWithEnclosingFunction(program, void 0, (node, enclosing) => {
+    const member = ownedCall(node);
+    if (member === void 0 && !bareRequire(node)) return;
+    if (member === "requireMock") {
+      const [specifier] = node.arguments ?? [];
+      const literal = specifier?.type === "StringLiteral" || specifier?.type === "Literal" ? String(specifier.value) : void 0;
+      if (literal !== void 0 && mocked.has(literal)) {
+        edits.push({
+          start: node.start,
+          end: node.end,
+          text: placed(node, `await import(${argumentText(source, node)})`)
+        });
+        applied.add("jest.requireMock");
+        if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
+        return;
+      }
+    }
+    const asyncReplacement = member === void 0 ? void 0 : ASYNC_REPLACEMENTS[member];
+    if (asyncReplacement !== void 0) {
+      edits.push({
+        start: node.start,
+        end: node.end,
+        text: placed(node, `await vi.${asyncReplacement}(${argumentText(source, node)})`)
+      });
+      applied.add(`jest.${member}`);
+      if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
+      return;
+    }
+    if (bareRequire(node)) {
+      const [specifier] = node.arguments ?? [];
+      const literal = specifier?.type === "StringLiteral" || specifier?.type === "Literal" ? String(specifier.value) : void 0;
+      const interop = literal !== void 0 && !readsANameOffIt.has(node) && !handedToTheRunnerAsAModule.has(node) && !wholeStatement.has(node) && isCommonJsPackage(fileName, literal) ? ".default" : "";
+      edits.push({
+        start: node.start,
+        end: node.end,
+        text: placed(node, `await import(${argumentText(source, node)})`, interop)
+      });
+      applied.add("require");
+      if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
+      return;
+    }
+    if (member === "mock" && enclosing !== void 0) {
+      const callee = node.callee;
+      edits.push({
+        start: callee.start,
+        end: callee.end,
+        text: "vi.doMock"
+      });
+      applied.add("jest.mock inside a function");
+      return;
+    }
+    if (member === "setTimeout") {
+      edits.push({
+        start: node.start,
+        end: node.end,
+        text: `vi.setConfig({ testTimeout: ${argumentText(source, node)} })`
+      });
+      applied.add("jest.setTimeout");
+    }
+  });
+  for (const fn of asyncify) {
+    edits.push({ start: fn.start, end: fn.start, text: "async " });
+  }
+  return { source: applyEdits(source, edits), applied: [...applied].sort() };
+}
+
+// src/roles/test/codemod/isolate-modules.ts
+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_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;
+  if (property?.type !== "Identifier" || !ISOLATORS.has(property.name)) return void 0;
+  const [callback] = node.arguments ?? [];
+  return callback !== void 0 && FUNCTIONS2.has(callback.type) ? { call: node, callback } : void 0;
+}
+function unusableIsolatingCall(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  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;
+  if (property?.type !== "Identifier" || !ISOLATORS.has(property.name)) return void 0;
+  const [callback] = node.arguments ?? [];
+  return callback === void 0 || FUNCTIONS2.has(callback.type) ? void 0 : `jest.${property.name}`;
+}
+function indentationAt(source, offset) {
+  const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+  return /^[ \t]*/.exec(source.slice(lineStart, offset))?.[0] ?? "";
+}
+function rewriteIsolateModules(source, program) {
+  const edits = [];
+  const refusals = [];
+  const asyncify = /* @__PURE__ */ new Set();
+  let rewritten = 0;
+  walkWithEnclosingFunction(program, void 0, (node, enclosing) => {
+    const unusable = unusableIsolatingCall(node);
+    if (unusable !== void 0) {
+      refusals.push({
+        binding: unusable,
+        reason: `${unusable} is called with something other than a function, so the callback cannot be invoked against a reset registry. This one needs a human.`
+      });
+      return;
+    }
+    const found = isolatingCall(node);
+    if (found === void 0) return;
+    const callbackText = source.slice(found.callback.start, found.callback.end);
+    const callback = found.callback.async === true ? callbackText : `async ${callbackText}`;
+    const indent = indentationAt(source, found.call.start);
+    edits.push({
+      start: found.call.start,
+      end: found.call.end,
+      text: `vi.resetModules()
+${indent}await (${callback})()`
+    });
+    rewritten += 1;
+    if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
+  });
+  for (const fn of asyncify) {
+    edits.push({ start: fn.start, end: fn.start, text: "async " });
+  }
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return { source: result, rewritten, refusals };
+}
+
+// src/roles/test/codemod/mock-as-value.ts
+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_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");
+}
+function mockBinding(node) {
+  if (node.type !== "VariableDeclaration") return void 0;
+  const declarations = node.declarations ?? [];
+  if (declarations.length !== 1) return void 0;
+  const [declarator] = declarations;
+  const id = declarator?.id;
+  const init = declarator?.init;
+  if (id?.type !== "Identifier" || !isViMockCall(init)) return void 0;
+  return { name: id.name, call: init };
+}
+function rewriteMockAsValue(source, program) {
+  const bindings = /* @__PURE__ */ new Map();
+  walk(program, (node) => {
+    const found = mockBinding(node);
+    if (found !== void 0) bindings.set(found.name, { declaration: node, call: found.call });
+  });
+  if (bindings.size === 0) return { source, rewritten: 0, refusals: [] };
+  const memberUses = /* @__PURE__ */ new Map();
+  const otherUses = /* @__PURE__ */ new Map();
+  walk(program, (node) => {
+    if (MEMBER_TYPES11.has(node.type)) {
+      const object = node.object;
+      if (object?.type === "Identifier" && bindings.has(object.name)) {
+        const list = memberUses.get(object.name) ?? [];
+        list.push(object);
+        memberUses.set(object.name, list);
+        return;
+      }
+    }
+    if (node.type !== "Identifier" || !bindings.has(node.name)) return;
+    const declared = bindings.get(node.name);
+    const insideDeclaration = node.start >= declared?.declaration.start && node.end <= declared?.declaration.end;
+    if (insideDeclaration) return;
+    const seen = memberUses.get(node.name) ?? [];
+    if (seen.some((use) => use.start === node.start)) return;
+    otherUses.set(node.name, (otherUses.get(node.name) ?? 0) + 1);
+  });
+  const edits = [];
+  const refusals = [];
+  let rewritten = 0;
+  for (const [name, { declaration, call }] of bindings) {
+    if ((otherUses.get(name) ?? 0) > 0) {
+      refusals.push({
+        binding: name,
+        reason: `\`${name}\` is \`jest.mock()\`'s return value used as a value elsewhere, not only as \`${name}.member(...)\`. vi.mock() returns nothing, so this needs a human.`
+      });
+      continue;
+    }
+    edits.push({
+      start: declaration.start,
+      end: declaration.end,
+      text: source.slice(call.start, call.end)
+    });
+    for (const use of memberUses.get(name) ?? []) {
+      edits.push({ start: use.start, end: use.end, text: "vi" });
+    }
+    rewritten += 1;
+  }
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return { source: result, rewritten, refusals };
+}
+
+// src/roles/test/codemod/mock-factory-default.ts
+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_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;
+  if (object?.type !== "Identifier" || !["vi", "vitest"].includes(object.name)) {
+    return void 0;
+  }
+  const [specifier, factory] = node.arguments ?? [];
+  if (specifier?.type !== "Literal" || typeof specifier.value !== "string") return void 0;
+  if (factory === void 0) return void 0;
+  return { specifier: specifier.value, factory };
+}
+function returnedExpression(factory) {
+  const object = returnedObject(factory);
+  if (object !== void 0) return { node: object, isObject: true };
+  if (factory.type !== "ArrowFunctionExpression") return void 0;
+  let body = factory.body;
+  while (body?.type === "ParenthesizedExpression") body = body.expression;
+  if (body === void 0) return void 0;
+  if (body.type !== "BlockStatement") return { node: body, isObject: false, concise: true };
+  const statements = body.body ?? [];
+  if (statements.length !== 1) return void 0;
+  const only = statements[0];
+  if (only?.type !== "ReturnStatement") return void 0;
+  const argument = only.argument;
+  return argument === void 0 ? void 0 : { node: argument, isObject: false };
+}
+function returnedObject(factory) {
+  if (factory.type !== "ArrowFunctionExpression") return void 0;
+  let body = factory.body;
+  while (body?.type === "ParenthesizedExpression") body = body.expression;
+  if (body?.type === "ObjectExpression") return body;
+  const statements = body?.body ?? [];
+  if (statements.length !== 1) return void 0;
+  const only = statements[0];
+  if (only?.type === "ExpressionStatement" && only.expression?.type === "ObjectExpression") {
+    return only.expression;
+  }
+  if (only?.type === "ReturnStatement" && only.argument?.type === "ObjectExpression") {
+    return only.argument;
+  }
+  return void 0;
+}
+function isModuleNamespace(node) {
+  let current = node;
+  while (current?.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  if (current?.type === "AwaitExpression") {
+    let argument = current.argument;
+    while (argument?.type === "ParenthesizedExpression") {
+      argument = argument.expression;
+    }
+    current = argument;
+  }
+  return current?.type === "ImportExpression";
+}
+function namesDefault(object) {
+  return (object.properties ?? []).some((property) => {
+    const key = property.key;
+    if (key?.type === "Identifier") return key.name === "default";
+    if (key?.type === "Literal") return key.value === "default";
+    return false;
+  });
+}
+function rewriteMockFactoryDefault(source, program, defaultImported) {
+  const edits = [];
+  walk(program, (node) => {
+    const call = mockCall(node);
+    if (call === void 0) return;
+    const returned = returnedExpression(call.factory);
+    if (returned === void 0) return;
+    if (returned.isObject && namesDefault(returned.node)) return;
+    if (returned.isObject && !defaultImported.has(call.specifier)) return;
+    if (!returned.isObject && isModuleNamespace(returned.node)) return;
+    if (!returned.isObject) {
+      const expression = source.slice(returned.node.start, returned.node.end);
+      edits.push({
+        start: returned.node.start,
+        end: returned.node.end,
+        // Parenthesised when it is the arrow's own body, or it is read as a block, not an object.
+        literal: returned.concise === true ? `({ default: ${expression} })` : `{ default: ${expression} }`,
+        specifier: call.specifier,
+        wrap: false
+      });
+      return;
+    }
+    const object = returned.node;
+    const literal = source.slice(object.start, object.end);
+    if (literal.includes(BINDING)) return;
+    const body = call.factory.body;
+    edits.push({
+      start: body.start,
+      end: body.end,
+      literal,
+      specifier: call.specifier,
+      wrap: true
+    });
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    const text = edit.wrap ? `{ const ${BINDING} = ${edit.literal}; return { ...${BINDING}, default: ${BINDING} } }` : edit.literal;
+    result = `${result.slice(0, edit.start)}${text}${result.slice(edit.end)}`;
+  }
+  return {
+    source: result,
+    rewritten: edits.length,
+    specifiers: [...new Set(edits.map((edit) => edit.specifier))]
+  };
+}
+
+// src/roles/test/codemod/mock-promise-resolve.ts
+var MOCK_FACTORY = /* @__PURE__ */ new Set(["fn", "spyOn"]);
+function isMockFactory2(source, node) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression") return false;
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier" || property?.type !== "Identifier") return false;
+  const runner = source.slice(object.start, object.end);
+  const method = source.slice(property.start, property.end);
+  return (runner === "jest" || runner === "vi") && MOCK_FACTORY.has(method);
+}
+function resolvedValue(source, executor) {
+  if (executor.type !== "ArrowFunctionExpression" && executor.type !== "FunctionExpression") {
+    return void 0;
+  }
+  const params = executor.params;
+  if (params?.length !== 1) return void 0;
+  const parameter = params[0];
+  if (parameter.type !== "Identifier") return void 0;
+  const resolveName = source.slice(parameter.start, parameter.end);
+  const body = executor.body;
+  if (body === void 0) return void 0;
+  let call;
+  if (body.type === "BlockStatement") {
+    const statements = body.body;
+    if (statements?.length !== 1) return void 0;
+    const only = statements[0];
+    if (only.type !== "ExpressionStatement") return void 0;
+    call = only.expression;
+  } else {
+    call = body;
+  }
+  if (call?.type !== "CallExpression") return void 0;
+  const callee = call.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  if (source.slice(callee.start, callee.end) !== resolveName) return void 0;
+  const args = call.arguments;
+  if (args?.length !== 1) return void 0;
+  return args[0];
+}
+function rewriteMockPromiseResolve(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    if (!isMockFactory2(source, node)) return;
+    for (const argument of node.arguments ?? []) {
+      walk(argument, (inner) => {
+        if (inner.type !== "NewExpression") return;
+        const callee = inner.callee;
+        if (callee?.type !== "Identifier") return;
+        if (source.slice(callee.start, callee.end) !== "Promise") return;
+        if ((inner.typeArguments ?? inner.typeParameters) !== void 0) return;
+        const executors = inner.arguments ?? [];
+        if (executors.length !== 1) return;
+        const value = resolvedValue(source, executors[0]);
+        if (value === void 0) return;
+        edits.push({
+          start: inner.start,
+          end: inner.end,
+          text: `Promise.resolve(${source.slice(value.start, value.end)})`
+        });
+      });
+    }
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
+// src/roles/test/codemod/mocked-module-binding.ts
+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_TYPES13.has(callee.type)) return void 0;
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier") return void 0;
+  if (object.name !== "vi" && object.name !== "jest") return void 0;
+  if (property?.type !== "Identifier" || property.name !== "mock") return void 0;
+  const [first] = node.arguments ?? [];
+  if (first?.type !== "Literal") return void 0;
+  return source.slice(first.start, first.end).slice(1, -1);
+}
+function awaitedImport(source, node) {
+  if (node?.type !== "AwaitExpression") return void 0;
+  const call = node.argument;
+  if (call?.type !== "ImportExpression") return void 0;
+  const specifier = call.source ?? call.arguments?.[0];
+  if (specifier?.type !== "Literal") return void 0;
+  return source.slice(specifier.start, specifier.end).slice(1, -1);
+}
+function annotateMockedBindings(source, program) {
+  const mocked = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    const specifier = mockedSpecifier(source, node);
+    if (specifier !== void 0) mocked.add(specifier);
+  });
+  if (mocked.size === 0) return { source, rewritten: 0, typeImports: [] };
+  const edits = [];
+  for (const statement2 of program.body ?? []) {
+    if (statement2.type !== "VariableDeclaration") continue;
+    const declarations = statement2.declarations ?? [];
+    if (declarations.length !== 1) continue;
+    const [only] = declarations;
+    if (only === void 0) continue;
+    if (only.id?.type !== "Identifier") continue;
+    const init = only.init;
+    const specifier = awaitedImport(source, init);
+    if (specifier === void 0 || !mocked.has(specifier)) continue;
+    const start = init?.start;
+    const end = init?.end;
+    const expression = source.slice(start, end);
+    if (source.slice(end, end + 4).trimStart().startsWith("as"))
+      continue;
+    edits.push({
+      start,
+      end,
+      text: `(${expression}) as unknown as Record<string, Mock>`
+    });
+  }
+  if (edits.length === 0) return { source, rewritten: 0, typeImports: [] };
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length, typeImports: ["Mock"] };
+}
+
+// src/roles/test/codemod/propagate-await.ts
+import { parseSync as parseSync4 } from "oxc-parser";
+var FUNCTIONS3 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
+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();
+  walk(program, (node) => {
+    if (node.type === "FunctionDeclaration" && node.async === true) {
+      const id2 = node.id;
+      if (id2?.type === "Identifier") names.add(id2.name);
+      return;
+    }
+    if (node.type !== "VariableDeclarator") return;
+    const init = node.init ?? void 0;
+    const id = node.id;
+    if (init === void 0 || !FUNCTIONS3.has(init.type) || init.async !== true) return;
+    if (id?.type === "Identifier") names.add(id.name);
+  });
+  return names;
+}
+function returningFunctionNames(program, changed) {
+  const names = /* @__PURE__ */ new Set();
+  const returnsChanged = (fn) => {
+    const body = fn.body;
+    if (body === void 0) return false;
+    if (callTo(body, changed) !== void 0) return true;
+    let found = false;
+    walk(body, (node) => {
+      if (node.type !== "ReturnStatement") return;
+      const argument = node.argument;
+      if (argument !== void 0 && callTo(argument, changed) !== void 0) found = true;
+    });
+    return found;
+  };
+  walk(program, (node) => {
+    if (node.type === "FunctionDeclaration" && returnsChanged(node)) {
+      const id2 = node.id;
+      if (id2?.type === "Identifier") names.add(id2.name);
+      return;
+    }
+    if (node.type !== "VariableDeclarator") return;
+    const init = node.init ?? void 0;
+    const id = node.id;
+    if (init === void 0 || !FUNCTIONS3.has(init.type)) return;
+    if (id?.type === "Identifier" && returnsChanged(init)) names.add(id.name);
+  });
+  return names;
+}
+function callTo(node, names) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  const name = callee.name;
+  return names.has(name) ? name : void 0;
+}
+function walkWithContext(node, enclosing, parent, visit) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) walkWithContext(item, enclosing, parent, visit);
+    return;
+  }
+  const current = node;
+  const isFunction = typeof current.type === "string" && FUNCTIONS3.has(current.type);
+  if (typeof current.type === "string") visit(current, enclosing, parent);
+  const nextEnclosing = isFunction ? current : enclosing;
+  const nextParent = typeof current.type === "string" ? current : parent;
+  for (const value of Object.values(current)) {
+    if (value !== null && typeof value === "object") {
+      walkWithContext(value, nextEnclosing, nextParent, visit);
+    }
+  }
+}
+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_TYPES14.has(parent.type) && parent.object === call) {
+    const property = parent.property;
+    return property?.type === "Identifier" && ALREADY_A_PROMISE.has(property.name);
+  }
+  return false;
+}
+function applyEdits2(source, edits) {
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return result;
+}
+function propagateAwait(fileName, source, original, elsewhere = /* @__PURE__ */ new Set()) {
+  const wasAsync = asyncFunctionNames(original);
+  let current = source;
+  let rewritten = 0;
+  for (let round = 0; round < 12; round += 1) {
+    let parsed;
+    try {
+      parsed = parseSync4(fileName, current);
+    } catch {
+      return { source: current, rewritten };
+    }
+    const program = parsed.program;
+    const changed = new Set(elsewhere);
+    for (const name of asyncFunctionNames(program)) {
+      if (!wasAsync.has(name)) changed.add(name);
+    }
+    if (changed.size === 0) return { source: current, rewritten };
+    for (const name of returningFunctionNames(program, changed)) changed.add(name);
+    const edits = [];
+    const asyncify = /* @__PURE__ */ new Set();
+    walkWithContext(program, void 0, void 0, (node, enclosing, parent) => {
+      if (callTo(node, changed) === void 0) return;
+      if (alreadyHandled(node, parent)) return;
+      edits.push({ start: node.start, end: node.start, text: "await " });
+      if (enclosing !== void 0 && enclosing.async !== true) asyncify.add(enclosing);
+    });
+    if (edits.length === 0) return { source: current, rewritten };
+    for (const fn of asyncify) {
+      edits.push({ start: fn.start, end: fn.start, text: "async " });
+    }
+    rewritten += edits.length - asyncify.size;
+    current = applyEdits2(current, edits);
+  }
+  return { source: current, rewritten };
+}
+
+// src/roles/test/codemod/reexport-barrel-mock.ts
+import { readFileSync as readFileSync8, readdirSync as readdirSync2, statSync } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { dirname as dirname3, join as join10 } 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) {
+  const found = [];
+  walk(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee === void 0 || !MEMBER_TYPES15.has(callee.type)) return;
+    const object = callee.object;
+    const property = callee.property;
+    if (object?.type !== "Identifier") return;
+    if (object.name !== "vi" && object.name !== "jest") return;
+    if (property?.name !== "mock") return;
+    const first = (node.arguments ?? [])[0];
+    if (first?.type !== "Literal" || typeof first.value !== "string") return;
+    found.push({
+      specifier: first.value,
+      start: node.start,
+      end: node.end,
+      literalStart: first.start,
+      literalEnd: first.end
+    });
+  });
+  return found;
+}
+function packageRoot(fromFile, name) {
+  try {
+    return dirname3(createRequire3(fromFile).resolve(`${name}/package.json`));
+  } catch {
+    return void 0;
+  }
+}
+function resolveFrom(fromFile, specifier) {
+  try {
+    return createRequire3(fromFile).resolve(specifier);
+  } catch {
+    return void 0;
+  }
+}
+function barrelsFor(fromFile, name, target) {
+  const root = packageRoot(fromFile, name);
+  if (root === void 0) return [];
+  let entries;
+  try {
+    entries = readdirSync2(root);
+  } catch {
+    return [];
+  }
+  const aliases = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".js")) continue;
+    const path = join10(root, entry);
+    let body;
+    try {
+      if (!statSync(path).isFile()) continue;
+      body = readFileSync8(path, "utf8");
+    } catch {
+      continue;
+    }
+    const match = PURE_REEXPORT.exec(body.trim());
+    if (match === null) continue;
+    if (resolveFrom(path, match[2]) !== target) continue;
+    aliases.push(`${name}/${entry.slice(0, -".js".length)}`);
+  }
+  return aliases.sort();
+}
+function rewriteReexportBarrelMocks(fromFile, source, program) {
+  const calls = mockCalls(program);
+  if (calls.length === 0) return { source, added: [] };
+  const alreadyMocked = new Set(calls.map((call) => call.specifier));
+  const added = [];
+  const insertions = [];
+  for (const call of calls) {
+    const parts = PACKAGE_SUBPATH.exec(call.specifier);
+    if (parts === null) continue;
+    const target = resolveFrom(fromFile, call.specifier);
+    if (target === void 0) continue;
+    for (const alias of barrelsFor(fromFile, parts[1], target)) {
+      if (alreadyMocked.has(alias)) continue;
+      alreadyMocked.add(alias);
+      added.push(alias);
+      const text = source.slice(call.start, call.literalStart) + `'${alias}'` + source.slice(call.literalEnd, call.end);
+      insertions.push({ at: call.end, text: `
+${text}` });
+    }
+  }
+  if (insertions.length === 0) return { source, added: [] };
+  let rewritten = source;
+  for (const insertion of insertions.sort((a, b) => b.at - a.at)) {
+    rewritten = rewritten.slice(0, insertion.at) + insertion.text + rewritten.slice(insertion.at);
+  }
+  return { source: rewritten, added };
+}
+
+// src/roles/test/codemod/repoint-msw.ts
+import { parseSync as parseSync5 } from "oxc-parser";
+var SENTINEL_MSW_SERVER = "@hublo/sentinel/test/msw";
+var SENTINEL_MSW_API = "@hublo/sentinel/test/tools/msw";
+var MSW_PACKAGE = /^msw$/;
+var MSW_SERVER_MODULE = /(^|\/)msw\/server$/;
+function importsServer(declaration) {
+  return (declaration.specifiers ?? []).some((specifier) => {
+    const imported = specifier.imported;
+    const local = specifier.local;
+    return imported?.name === "server" || imported === void 0 && local?.name === "server";
+  });
+}
+function repointMswServer(fileName, source) {
+  const { program, errors } = parseSync5(fileName, source, { sourceType: "module" });
+  if (errors.length > 0) return { source, repointed: false };
+  const edits = [];
+  walk(program, (node) => {
+    if (node.type !== "ImportDeclaration") return;
+    const specifier = node.source;
+    if (specifier?.value === void 0) return;
+    const isServer = MSW_SERVER_MODULE.test(specifier.value) && importsServer(node);
+    const isPackage2 = MSW_PACKAGE.test(specifier.value);
+    if (!isServer && !isPackage2) return;
+    edits.push({
+      start: specifier.start,
+      end: specifier.end,
+      to: isServer ? SENTINEL_MSW_SERVER : SENTINEL_MSW_API
+    });
+  });
+  if (edits.length === 0) return { source, repointed: false };
+  let rewritten = source;
+  for (const edit of edits.sort((left, right) => right.start - left.start)) {
+    const quote = source[edit.start] === '"' ? '"' : "'";
+    rewritten = rewritten.slice(0, edit.start) + `${quote}${edit.to}${quote}` + rewritten.slice(edit.end);
+  }
+  return { source: rewritten, repointed: true };
+}
+
+// src/roles/test/codemod/setup-static-imports.ts
+import { dirname as dirname5, resolve as resolve5 } from "node:path";
+
+// src/core/context.ts
+import { existsSync as existsSync11 } from "node:fs";
+import { dirname as dirname4, join as join12, resolve as resolve3 } from "node:path";
+
+// src/core/discover-modules.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync9, rmSync as rmSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join11 } from "node:path";
+function runNx(cwd, args) {
+  const nx = resolveBin(cwd, "nx") ?? "nx";
+  try {
+    return execFileSync2(nx, args, {
+      cwd,
+      encoding: "utf8",
+      env: { ...process.env, NX_DAEMON: "false" }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `sentinel: could not run nx (${message}). Is nx installed in this workspace, and are you at its root?`,
+      { cause: error }
+    );
+  }
+}
+function readGraph(cwd) {
+  const dir = mkdtempSync2(join11(tmpdir2(), "sentinel-nx-"));
+  const file = join11(dir, "graph.json");
+  try {
+    runNx(cwd, ["graph", "--file", file]);
+    const parsed = JSON.parse(readFileSync9(file, "utf8"));
+    const nodes = parsed.graph?.nodes;
+    if (!nodes || typeof nodes !== "object") {
+      throw new Error(
+        "sentinel: unexpected nx graph output (no graph.nodes); the installed nx version may be incompatible."
+      );
+    }
+    return Object.entries(nodes).map(([name, node]) => ({
+      name,
+      root: join11(cwd, node.data.root)
+    }));
+  } finally {
+    rmSync2(dir, { recursive: true, force: true });
+  }
+}
+function discoverModules(cwd, options = {}) {
+  const modules = readGraph(cwd);
+  if (!options.affected) return modules;
+  const affected = new Set(
+    JSON.parse(runNx(cwd, ["show", "projects", "--affected", "--json"]))
+  );
+  return modules.filter((module) => affected.has(module.name));
+}
+
+// src/core/context.ts
+var MODULE_MARKERS = ["package.json", "project.json"];
+function isModuleDir(cwd) {
+  return MODULE_MARKERS.some((marker) => existsSync11(join12(cwd, marker)));
+}
+function findModuleRoot(startDir, workspaceRoot) {
+  let dir = resolve3(startDir);
+  for (; ; ) {
+    if (workspaceRoot !== void 0 && dir === resolve3(workspaceRoot)) return void 0;
+    if (isModuleDir(dir)) return dir;
+    const parent = dirname4(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function resolveContext(cwd, opts) {
+  const atRoot = existsSync11(join12(cwd, WORKSPACE_ROOT_MARKER));
+  if (!atRoot && isModuleDir(cwd)) {
+    if (opts.module) {
+      throw new Error(
+        "You are in a module directory: drop --module (the context is the current module)."
+      );
+    }
+    if (opts.ci) {
+      throw new Error("--ci selects the affected set from the workspace root; run it there.");
+    }
+    const name = moduleName(cwd);
+    return { modules: [{ name, root: cwd }], scope: "cwd-module" };
+  }
+  if (atRoot) {
+    if (opts.module) {
+      const found = discoverModules(cwd).find((module) => module.name === opts.module);
+      if (!found) throw new Error(`module "${opts.module}" not found in the workspace.`);
+      return { modules: [found], scope: "named-module" };
+    }
+    if (opts.ci) return { modules: discoverModules(cwd, { affected: true }), scope: "affected" };
+    return { modules: discoverModules(cwd), scope: "all" };
+  }
+  throw new Error(
+    `Run sentinel from a module directory or the workspace root (found neither ${MODULE_MARKERS.join("/")} nor ${WORKSPACE_ROOT_MARKER} here).`
+  );
+}
+
+// src/roles/test/codemod/workspace-specifier.ts
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { join as join13, relative as relative2, resolve as resolve4 } from "node:path";
+var EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", "/index.ts", "/index.js"];
+function pathEntries(workspaceRoot) {
+  const file = join13(workspaceRoot, "tsconfig.base.json");
+  if (!existsSync12(file)) return [];
+  let paths;
+  try {
+    paths = parseJsonc(
+      readFileSync10(file, "utf8"),
+      "tsconfig.base.json"
+    )?.compilerOptions?.paths;
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const [key, targets] of Object.entries(paths ?? {})) {
+    const target = targets[0];
+    if (target === void 0) continue;
+    const wildcard = key.endsWith("/*") && target.endsWith("/*");
+    entries.push({
+      key: wildcard ? key.slice(0, -2) : key,
+      target: resolve4(workspaceRoot, wildcard ? target.slice(0, -2) : target),
+      wildcard
+    });
+  }
+  return entries.sort((left, right) => right.target.length - left.target.length);
+}
+function workspaceSpecifier(workspaceRoot, file) {
+  const absolute = resolve4(file);
+  for (const entry of pathEntries(workspaceRoot)) {
+    if (!entry.wildcard) {
+      if (EXTENSIONS.some((extension) => `${entry.target}${extension}` === absolute)) {
+        return entry.key;
+      }
+      continue;
+    }
+    const rest = relative2(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}`;
+  }
+  return void 0;
+}
+
+// src/roles/test/codemod/setup-static-imports.ts
+function requireCall(source, node) {
+  if (node?.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier" || callee.name !== "require") return void 0;
+  const args = node.arguments ?? [];
+  const [only] = args;
+  if (args.length !== 1 || only?.type !== "Literal") return void 0;
+  const raw = source.slice(only.start, only.end);
+  return raw.slice(1, -1);
+}
+function importable(written, fileName, workspaceRoot) {
+  if (!written.startsWith(".")) return written;
+  const fileDir = dirname5(fileName);
+  const moduleRoot = findModuleRoot(fileDir, workspaceRoot) ?? fileDir;
+  const target = resolve5(fileDir, written);
+  if (target.startsWith(`${moduleRoot}/`)) return written;
+  if (workspaceRoot === void 0) return void 0;
+  return workspaceSpecifier(workspaceRoot, target);
+}
+function statement(fileName, source, node, specifier, written) {
+  if (node.type === "ExpressionStatement") return `import '${specifier}'`;
+  const declarations = node.declarations ?? [];
+  const [only] = declarations;
+  if (declarations.length !== 1 || only === void 0) return void 0;
+  const id = only.id;
+  if (id?.type === "Identifier") {
+    const name = source.slice(id.start, id.end);
+    return isCommonJsPackage(fileName, written) ? `import ${name} from '${specifier}'` : `import * as ${name} from '${specifier}'`;
+  }
+  if (id?.type === "ObjectPattern" && isPlainShorthand(id)) {
+    const names = source.slice(id.start, id.end);
+    return `import ${names} from '${specifier}'`;
+  }
+  return void 0;
+}
+function isPlainShorthand(pattern) {
+  const properties = pattern.properties ?? [];
+  if (properties.length === 0) return false;
+  return properties.every(
+    (property) => property.type === "Property" && property.shorthand === true && property.computed !== true && property.value?.type === "Identifier"
+  );
+}
+function rewriteSetupStaticImports(fileName, source, program, workspaceRoot) {
+  const body = program.body ?? [];
+  const edits = [];
+  const refusals = [];
+  for (const node of body) {
+    if (node.type === "ImportDeclaration") continue;
+    const expression = node.type === "ExpressionStatement" ? node.expression : node.type === "VariableDeclaration" ? node.declarations?.[0]?.init : void 0;
+    const written = requireCall(source, expression);
+    if (written === void 0) break;
+    const specifier = importable(written, fileName, workspaceRoot);
+    if (specifier === void 0) {
+      refusals.push(written);
+      break;
+    }
+    const text = statement(fileName, source, node, specifier, written);
+    if (text === void 0) break;
+    edits.push({ start: node.start, end: node.end, text });
+  }
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length, refusals };
+}
+
+// src/roles/test/codemod/spy-instance-type.ts
+var SPY_TYPES = /* @__PURE__ */ new Set(["SpyInstance"]);
+var QUALIFIED_ONLY = /* @__PURE__ */ new Set(["Mock"]);
+var VITEST_NAME = { SpyInstance: "MockInstance", Mock: "Mock" };
+function typeNameOf(source, node) {
+  const name = node.typeName;
+  if (name === void 0) return void 0;
+  return source.slice(name.start, name.end);
+}
+function rewriteSpyInstanceType(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    if (node.type !== "TSTypeReference") return;
+    const written = typeNameOf(source, node);
+    if (written === void 0) return;
+    const qualified = written.startsWith("jest.");
+    const bare = qualified ? written.slice("jest.".length) : written;
+    if (!SPY_TYPES.has(bare) && !(qualified && QUALIFIED_ONLY.has(bare))) return;
+    const args = (node.typeArguments ?? node.typeParameters)?.params;
+    if (args === void 0 || args.length === 0) return;
+    const text = (argument) => source.slice(argument.start, argument.end);
+    const returns = text(args[0]);
+    const parameters = args.length > 1 ? `...args: ${text(args[1])}` : "...args: never[]";
+    const target = VITEST_NAME[bare];
+    edits.push({
+      start: node.start,
+      end: node.end,
+      text: `${target}<(${parameters}) => ${returns}>`,
+      imports: target
+    });
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return {
+    source: result,
+    rewritten: edits.length,
+    // Only the names actually written, so a file does not import a type it never uses.
+    typeImports: [...new Set(edits.map((edit) => edit.imports))]
+  };
+}
+
+// src/roles/test/codemod/migrate-file.ts
+function mockFactories(program) {
+  const factories = [];
+  walk(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee?.type !== "MemberExpression" && callee?.type !== "StaticMemberExpression") return;
+    const object = callee.object;
+    const property = callee.property;
+    if (object?.type !== "Identifier") return;
+    if (object.name !== "jest" && object.name !== "vi") return;
+    if (property?.name !== "mock") return;
+    const args = node.arguments ?? [];
+    if (args.length > 1) factories.push(args[1]);
+  });
+  return factories;
+}
+function parse3(fileName, source) {
+  const { program, errors } = parseSync6(fileName, source, { sourceType: "module" });
+  return errors.length > 0 ? void 0 : program;
+}
+function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new Set(), asyncHelpers = /* @__PURE__ */ new Set(), modulesOwnMsw = false) {
+  const untouched = {
+    source,
+    changed: false,
+    renamed: 0,
+    hoisted: [],
+    unhandled: [],
+    warnings: [],
+    refusals: [],
+    rulesApplied: [],
+    mswRepointed: false
+  };
+  const unparsable = (step) => ({
+    ...untouched,
+    refusals: [
+      {
+        binding: step,
+        reason: `this file no longer parses after the \`${step}\` step, so nothing was written for it. That is a defect in sentinel, not in the file: please report it with the file name.`
+      }
+    ]
+  });
+  const beforeStatic = parse3(fileName, source);
+  if (beforeStatic === void 0) return unparsable("reading the file");
+  const statics = rewriteSetupStaticImports(
+    fileName,
+    source,
+    beforeStatic,
+    findWorkspaceRoot(dirname6(fileName))
+  );
+  source = statics.source;
+  const original = statics.rewritten === 0 ? beforeStatic : parse3(fileName, source);
+  if (original === void 0) return unparsable("hoisting the setup requires");
+  const titles = rewriteEachTitles(source, original);
+  const tables = rewriteEachTableRows(titles.source, original);
+  const afterTables = parse3(fileName, tables.source);
+  if (afterTables === void 0) return unparsable("each table rows");
+  const spyTypes = rewriteSpyInstanceType(tables.source, afterTables);
+  const afterSpyTypes = parse3(fileName, spyTypes.source);
+  if (afterSpyTypes === void 0) return unparsable("SpyInstance types");
+  const ruled = applyNamedRules(spyTypes.source, afterSpyTypes, fileName);
+  const renamed = renameJestToVitest(fileName, ruled.source);
+  const afterRename = parse3(fileName, renamed.source);
+  if (afterRename === void 0) return unparsable("jest to vi rename");
+  const fakeTimers = rewriteFakeTimerOptions(renamed.source, afterRename);
+  const afterFakeTimers = parse3(fileName, fakeTimers.source);
+  if (afterFakeTimers === void 0) return unparsable("fake timer options");
+  const mocks = rewriteMockAsValue(fakeTimers.source, afterFakeTimers);
+  const afterMocks = parse3(fileName, mocks.source);
+  if (afterMocks === void 0) return unparsable("mock as a value");
+  const constructible = rewriteConstructibleMocks(
+    mocks.source,
+    afterMocks,
+    mockFactories(afterMocks)
+  );
+  const afterConstructible = parse3(fileName, constructible.source);
+  if (afterConstructible === void 0) return unparsable("constructible mocks");
+  const factoryDefault = rewriteMockFactoryDefault(
+    constructible.source,
+    afterConstructible,
+    defaultImported
+  );
+  const beforeReturnValue = parse3(fileName, factoryDefault.source);
+  if (beforeReturnValue === void 0) return unparsable("mock factory default");
+  const returnValue = rewriteAssertionReturnValue(factoryDefault.source, beforeReturnValue);
+  const afterReturnValue = parse3(fileName, returnValue.source);
+  if (afterReturnValue === void 0) return unparsable("assertion return value");
+  const isolated = rewriteIsolateModules(returnValue.source, afterReturnValue);
+  const afterIsolate = parse3(fileName, isolated.source);
+  if (afterIsolate === void 0) return unparsable("isolate modules");
+  const emptyImplementations = rewriteEmptyMockImplementation(isolated.source, afterIsolate);
+  const afterEmpty = parse3(fileName, emptyImplementations.source);
+  if (afterEmpty === void 0) return unparsable("empty mock implementation");
+  const hooks = rewriteHookReturnValue(emptyImplementations.source, afterEmpty);
+  const afterHooks = parse3(fileName, hooks.source);
+  if (afterHooks === void 0) return unparsable("hook return value");
+  const promises = rewriteMockPromiseResolve(hooks.source, afterHooks);
+  const awaited = propagateAwait(fileName, promises.source, original, asyncHelpers);
+  const program = parse3(fileName, awaited.source);
+  if (program === void 0) return unparsable("hook body");
+  const hoist = hoistCapturedBindings(
+    awaited.source,
+    program,
+    mockFactories(program),
+    moduleBindings(program),
+    importedNames(program)
+  );
+  const afterHoist = parse3(fileName, hoist.source);
+  if (afterHoist === void 0) return unparsable("hoisting captured bindings");
+  const mockedBindings = annotateMockedBindings(hoist.source, afterHoist);
+  const afterBindings = parse3(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
+  ]);
+  const deep = normaliseDeepImports(withImport);
+  const repointed = modulesOwnMsw ? { source: deep.source, repointed: false } : repointMswServer(fileName, deep.source);
+  const finalProgram = parse3(fileName, repointed.source);
+  if (finalProgram === void 0) return unparsable("msw server import");
+  const barrels = rewriteReexportBarrelMocks(fileName, repointed.source, finalProgram);
+  return {
+    source: barrels.source,
+    changed: barrels.source !== source,
+    renamed: renamed.rewritten,
+    hoisted: hoist.hoisted,
+    unhandled: renamed.unhandled,
+    rulesApplied: [
+      ...ruled.applied,
+      ...titles.rewritten > 0 ? ["each title %p"] : [],
+      ...mocks.rewritten > 0 ? ["vi.mock as a value"] : [],
+      ...deep.rewritten > 0 ? ["deep import normalised"] : [],
+      ...constructible.rewritten > 0 ? ["constructible mock implementation"] : [],
+      ...isolated.rewritten > 0 ? ["jest.isolateModules"] : [],
+      ...emptyImplementations.rewritten > 0 ? ["empty mockImplementation"] : [],
+      ...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
+    ].sort(),
+    refusals: [
+      /*
+       * A leading require that leaves its module and that no `paths` entry covers. Reported rather
+       * than written in a shape we know nx refuses, which is Héla's bound: we refuse only where the
+       * constraint is beyond us, and inventing a workspace alias is. Measured on this repo: 3 such
+       * requires across 136 setup files, all 3 covered, so this list stays empty here.
+       */
+      ...statics.refusals.map((specifier) => ({
+        binding: specifier,
+        reason: `\`require('${specifier}')\` reaches another project, and \`tsconfig.base.json\` declares no path for it. A static import of a relative path is refused by nx, and \`await import()\` would make it a dynamic dependency, which forbids every static import of that project across this module. Add a \`paths\` entry for it, or move the file inside this project.`
+      })),
+      ...fakeTimers.refusals,
+      ...hoist.refusals,
+      ...mocks.refusals.map((refusal) => ({ binding: refusal.binding, reason: refusal.reason })),
+      ...constructible.refusals,
+      ...isolated.refusals
+    ],
+    warnings: fakeTimers.warnings,
+    mswRepointed: repointed.repointed
+  };
+}
+
+// src/roles/test/codemod/test-support-files.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11, readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
+import { dirname as dirname7, join as join14, relative as relative3, resolve as resolve6 } from "node:path";
+var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".vite"]);
+var TEST_FILE2 = /\.(spec|test)\.[cm]?[jt]sx?$/;
+var SOURCE_FILE = /\.[cm]?[jt]sx?$/;
+var EXTENSIONS2 = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"];
+function relativeSpecifiers(source) {
+  const found = [];
+  const patterns = [
+    /\bfrom\s+['"](\.[^'"]*)['"]/g,
+    /\bimport\s+['"](\.[^'"]*)['"]/g,
+    /\bimport\s*\(\s*['"](\.[^'"]*)['"]\s*\)/g,
+    /\brequire\s*\(\s*['"](\.[^'"]*)['"]\s*\)/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of source.matchAll(pattern)) found.push(match[1]);
+  }
+  return found;
+}
+function resolveSpecifier(fromFile, specifier) {
+  const base = resolve6(dirname7(fromFile), specifier);
+  if (existsSync13(base) && statSync2(base).isFile()) return base;
+  for (const extension of EXTENSIONS2) {
+    if (existsSync13(`${base}${extension}`)) return `${base}${extension}`;
+  }
+  for (const extension of EXTENSIONS2) {
+    const index = join14(base, `index${extension}`);
+    if (existsSync13(index)) return index;
+  }
+  return void 0;
+}
+function moduleSources(cwd) {
+  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 (!SKIPPED.has(entry.name)) stack.push(join14(dir, entry.name));
+      } else if (SOURCE_FILE.test(entry.name)) {
+        found.push(join14(dir, entry.name));
+      }
+    }
+  }
+  return found;
+}
+function read(path) {
+  try {
+    return readFileSync11(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function setupFilesInside(cwd, named) {
+  const kept = [];
+  for (const raw of named) {
+    const withoutToken = raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", ".");
+    const full = resolve6(cwd, withoutToken);
+    const inside = relative3(cwd, full);
+    if (inside.startsWith("..") || inside === "") continue;
+    if (!existsSync13(full)) continue;
+    kept.push(inside.replaceAll("\\", "/"));
+  }
+  return kept;
+}
+function listTestSupportFiles(cwd, setupFiles = []) {
+  const sources = moduleSources(cwd);
+  const contents = /* @__PURE__ */ new Map();
+  for (const file of sources) {
+    const source = read(file);
+    if (source !== void 0) contents.set(file, source);
+  }
+  const importedBy = /* @__PURE__ */ new Map();
+  for (const [file, source] of contents) {
+    for (const specifier of relativeSpecifiers(source)) {
+      const target = resolveSpecifier(file, specifier);
+      if (target === void 0 || !contents.has(target)) continue;
+      importedBy.set(target, [...importedBy.get(target) ?? [], file]);
+    }
+  }
+  const testOnly = /* @__PURE__ */ new Set();
+  const queue = sources.filter((file) => TEST_FILE2.test(file));
+  const isTestOnly = (file) => (importedBy.get(file) ?? []).every(
+    (importer) => TEST_FILE2.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 (!isTestOnly(target)) continue;
+      testOnly.add(target);
+      queue.push(target);
+    }
+  }
+  const reachable = [...testOnly].filter((file) => /\brequire\s*\(/.test(contents.get(file) ?? "")).map((file) => relative3(cwd, file).replaceAll("\\", "/"));
+  return [.../* @__PURE__ */ new Set([...reachable, ...setupFilesInside(cwd, setupFiles)])].sort();
+}
+
+// src/roles/test/codemod/migrate-module.ts
+function parse4(source) {
+  const { program, errors } = parseSync7("file.ts", source, { sourceType: "module" });
+  return errors.length > 0 ? void 0 : program;
+}
+function read2(path) {
+  try {
+    return readFileSync12(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var SKIPPED2 = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".vite"]);
+function defaultImportedSpecifiers(cwd) {
+  const found = /* @__PURE__ */ new Set();
+  const pattern = /^\s*import\s+[A-Za-z_$][\w$]*\s*(?:,\s*\{[^}]*\}\s*)?from\s+['"]([^'"]+)['"]/gm;
+  const walk2 = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync4(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIPPED2.has(entry)) continue;
+      const path = join15(dir, entry);
+      let directory;
+      try {
+        directory = statSync3(path).isDirectory();
+      } catch {
+        continue;
+      }
+      if (directory) {
+        walk2(path);
+        continue;
+      }
+      if (!/\.tsx?$/.test(entry)) continue;
+      const source = read2(path);
+      if (source === void 0) continue;
+      for (const match of source.matchAll(pattern)) found.add(match[1]);
+    }
+  };
+  walk2(cwd);
+  return found;
+}
+function migrateModuleTests(cwd, setupFiles = []) {
+  const modulesOwnMsw = ownsMswLifecycle(cwd, setupFiles);
+  const operations = [];
+  const blockers = [];
+  const collected = [];
+  let files = 0;
+  let renamed = 0;
+  let hoisted = 0;
+  const defaultImported = defaultImportedSpecifiers(cwd);
+  const asyncHelpers = /* @__PURE__ */ new Set();
+  for (const relative6 of listTestSupportFiles(cwd, setupFiles)) {
+    const source = read2(join15(cwd, relative6));
+    if (source === void 0) {
+      blockers.push({ file: relative6, reason: "this file could not be read" });
+      continue;
+    }
+    const migrated = migrateTestFile(
+      join15(cwd, relative6),
+      source,
+      defaultImported,
+      /* @__PURE__ */ new Set(),
+      modulesOwnMsw
+    );
+    const renamedTo = vitestSupportName(relative6);
+    if (!migrated.changed && renamedTo === relative6) continue;
+    if (renamedTo !== relative6) operations.push({ kind: "delete", path: relative6 });
+    const before = parse4(source);
+    const after = parse4(migrated.source);
+    if (before !== void 0 && after !== void 0) {
+      const wasAsync = asyncFunctionNames(before);
+      for (const name of asyncFunctionNames(after)) {
+        if (!wasAsync.has(name)) asyncHelpers.add(name);
+      }
+    }
+    files++;
+    renamed += migrated.renamed;
+    operations.push({ kind: "write", path: renamedTo, contents: migrated.source });
+  }
+  for (const relative6 of listTestFiles(cwd)) {
+    const source = read2(join15(cwd, relative6));
+    if (source === void 0) {
+      blockers.push({ file: relative6, reason: "this file could not be read" });
+      continue;
+    }
+    const migrated = migrateTestFile(
+      join15(cwd, relative6),
+      source,
+      defaultImported,
+      asyncHelpers,
+      modulesOwnMsw
+    );
+    for (const member of migrated.unhandled) {
+      blockers.push({
+        file: `${relative6}:${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: relative6, reason: refusal.reason });
+    }
+    if (!migrated.changed) continue;
+    files++;
+    renamed += migrated.renamed;
+    if (migrated.hoisted.length > 0) hoisted++;
+    operations.push({ kind: "write", path: relative6, 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 readdirSync5, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
+import { join as join16, relative as relative4 } from "node:path";
+var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/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 SENTINEL_A11Y_SETUP = "@hublo/sentinel/test/setup/a11y";
+var SENTINEL_W3C_SETUP = "@hublo/sentinel/test/setup/w3c";
+function hopsToRoot(cwd, workspaceRoot) {
+  const up = relative4(cwd, workspaceRoot).replaceAll("\\", "/");
+  return up === "" ? "." : up;
+}
+function inlineBlock(packages) {
+  if (packages.length === 0) return "";
+  const list = packages.map((name) => `'${name}'`).join(", ");
+  return `        server: { deps: { inline: [${list}] } },`;
+}
+function coverageBlock(reading) {
+  return reading.coverageDirectory === void 0 ? "" : `        coverage: { reportsDirectory: '${reading.coverageDirectory}' },`;
+}
+function environmentBlock(reading) {
+  return reading.testEnvironment === void 0 ? "" : `        environment: '${reading.testEnvironment}',`;
+}
+var SKIPPED3 = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".vite"]);
+var BARE_AUTOMOCK = /(?:vi|vitest|jest)\.mock\(\s*['"]([^'".][^'"]*)['"]\s*\)/g;
+var MENTIONS_MSW = /from\s+['"](msw(\/[^'"]*)?|@hublo\/test\/msw\/server|@hublo\/sentinel\/test\/msw)['"]/;
+var DECORATED_ABSTRACT_MEMBER = /@[A-Za-z_$][\w$]*\s*(?:\([^)]*\))?\s*(?:\r?\n\s*(?:@[A-Za-z_$][\w$]*\s*(?:\([^)]*\))?\s*)*)*\r?\n\s*(?:public |protected |private |readonly )*abstract\s+[A-Za-z_$][\w$]*\s*[?!]?\s*[:(]/;
+function readModuleTraits(cwd) {
+  const traits = {
+    msw: false,
+    decoratedAbstractMember: false,
+    automockedPackages: []
+  };
+  const automocked = /* @__PURE__ */ new Set();
+  const walk2 = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync5(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIPPED3.has(entry)) continue;
+      const path = join16(dir, entry);
+      let directory;
+      try {
+        directory = statSync4(path).isDirectory();
+      } catch {
+        continue;
+      }
+      if (directory) {
+        walk2(path);
+        continue;
+      }
+      if (!/\.tsx?$/.test(entry)) continue;
+      let source;
+      try {
+        source = readFileSync13(path, "utf8");
+      } catch {
+        continue;
+      }
+      if (!traits.msw && MENTIONS_MSW.test(source)) traits.msw = true;
+      if (!traits.decoratedAbstractMember && DECORATED_ABSTRACT_MEMBER.test(source)) {
+        traits.decoratedAbstractMember = true;
+      }
+      BARE_AUTOMOCK.lastIndex = 0;
+      for (const match of source.matchAll(BARE_AUTOMOCK)) automocked.add(match[1]);
+    }
+  };
+  walk2(cwd);
+  traits.automockedPackages = [...automocked].sort();
+  return traits;
+}
+var withoutRootDir = (value) => value.replaceAll("<rootDir>/", "./").replaceAll("<rootDir>", ".");
+function ownsMswLifecycle2(cwd, reading) {
+  return ownsMswLifecycle(cwd, [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []]);
+}
+function setupBlock(cwd, reading, msw) {
+  const dom = flavourOf(reading) === "react";
+  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) => `'${vitestSupportName(withoutRootDir(file))}'`);
+  const sentinel = [
+    `'${SENTINEL_TEST_SETUP}'`,
+    ...dom ? [`'${SENTINEL_A11Y_SETUP}'`, `'${SENTINEL_W3C_SETUP}'`] : [],
+    ...namedTheRootSetup ? [`'${SENTINEL_WORKSPACE_SETUP}'`] : [],
+    ...msw && namedTheRootSetup && !ownsMswLifecycle2(cwd, reading) ? [`'${SENTINEL_MSW_SETUP}'`] : []
+  ];
+  return `        setupFiles: [${[...sentinel, ...own].join(", ")}],`;
+}
+function envBlock(reading) {
+  if (reading.env === void 0 || reading.env.length === 0) return "";
+  const entries = reading.env.map((entry) => `          ${entry.name}: ${entry.value},`);
+  return ["        env: {", ...entries, "        },"].join("\n");
+}
+function concurrencyBlock(cwd, reading, target) {
+  const declared = reading.maxWorkers;
+  if (declared !== void 0) {
+    return declared === "1" ? `        fileParallelism: false,` : `        maxWorkers: ${declared},`;
+  }
+  const nxTarget = projectTargets(cwd)?.[target];
+  for (const level of [nxTarget?.options, nxTarget?.configurations?.ci]) {
+    if (level === void 0) continue;
+    if (level.runInBand === true) return `        fileParallelism: false,`;
+    if (typeof level.maxWorkers === "number") {
+      return level.maxWorkers === 1 ? `        fileParallelism: false,` : `        maxWorkers: ${level.maxWorkers},`;
+    }
+  }
+  return "";
+}
+function timeoutBlock(reading) {
+  return reading.testTimeout === void 0 ? "" : `        testTimeout: ${reading.testTimeout},`;
+}
+function globalSetupBlock(reading) {
+  if (reading.globalSetup === void 0) return "";
+  const files = reading.globalSetup.map((file) => `'${vitestSupportName(withoutRootDir(file))}'`).join(", ");
+  return `        globalSetup: [${files}],`;
+}
+function includeBlock(reading) {
+  if (reading.testMatch === void 0) return "";
+  const globs = reading.testMatch.map((glob) => `'${withoutRootDir(glob)}'`).join(", ");
+  return `        include: [${globs}],`;
+}
+function excludeBlock(reading) {
+  if (reading.excludeGlobs === void 0 || reading.excludeGlobs.length === 0) return "";
+  const globs = reading.excludeGlobs.map((glob) => `'${glob}'`).join(", ");
+  return `        exclude: [...configDefaults.exclude, ${globs}],`;
+}
+function isPackage(replacement) {
+  return !replacement.startsWith(".") && !replacement.startsWith("/") && !replacement.toLowerCase().includes("<rootdir>");
+}
+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 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");
+}
+function generateNestTestConfig(cwd, reading, target = "test") {
+  if (reading.refusals.length > 0) return { refusals: reading.refusals };
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  if (workspaceRoot === void 0) {
+    return { refusals: ["the workspace root could not be found from this module"] };
+  }
+  const traits = readModuleTraits(cwd);
+  const up = hopsToRoot(cwd, workspaceRoot);
+  const test = [
+    environmentBlock(reading),
+    setupBlock(cwd, reading, traits.msw),
+    envBlock(reading),
+    timeoutBlock(reading),
+    concurrencyBlock(cwd, reading, target),
+    globalSetupBlock(reading),
+    includeBlock(reading),
+    excludeBlock(reading),
+    inlineBlock(traits.automockedPackages),
+    coverageBlock(reading)
+  ].filter((line) => line !== "");
+  const needsDefaults = test.some((line) => line.includes("configDefaults"));
+  const imports = [
+    `import path from 'node:path'`,
+    "",
+    ...needsDefaults ? [`import { configDefaults } from 'vitest/config'`, ""] : [],
+    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 !== ""
+  );
+  const decoratorLine = traits.decoratedAbstractMember ? "\n    lowerDecoratorsWithTypeScript: true," : "";
+  return {
+    refusals: [],
+    source: `${imports}
+
+export default defineConfig(
+  ${flavourOf(reading) === "react" ? "reactTestConfig" : "nestTestConfig"}({
+    root: import.meta.dirname,
+    workspaceRoot: path.resolve(import.meta.dirname, '${up}'),${decoratorLine}
+    overrides: {
+${overrides.join("\n")}
+    },
+  }),
+)
+`
+  };
+}
+
+// src/roles/test/nest/read-jest-config.ts
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "node:fs";
+import { join as join17 } from "node:path";
+var CARRIED = [
+  "testEnvironment",
+  "coverageDirectory",
+  "setupFilesAfterEnv",
+  "setupFiles",
+  "testTimeout",
+  "maxWorkers",
+  "globalSetup",
+  "testMatch",
+  "collectCoverageFrom",
+  "testPathIgnorePatterns",
+  "moduleNameMapper"
+];
+var DISCARDED = [
+  "preset",
+  "displayName",
+  "moduleFileExtensions",
+  "transform",
+  "extensionsToTreatAsEsm"
+];
+var STRING = String.raw`['"\`]([^'"\`]*)['"\`]`;
+function readString(body, key) {
+  const value = new RegExp(String.raw`\b${key}\s*:\s*${STRING}`).exec(body)?.[1];
+  return value?.includes("${") === true ? void 0 : value;
+}
+function readNumber(body, key) {
+  return new RegExp(String.raw`\b${key}\s*:\s*(\d+)`).exec(body)?.[1];
+}
+function objectBody(source, key) {
+  const at = new RegExp(String.raw`\b${key}\s*:\s*\{`).exec(source);
+  if (at === null) return void 0;
+  const from = at.index + at[0].length - 1;
+  let depth = 0;
+  for (let i = from; i < source.length; i += 1) {
+    if (source[i] === "{") depth += 1;
+    else if (source[i] === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(from + 1, i);
+    }
+  }
+  return void 0;
+}
+function objectBodyAfter(source, offset) {
+  const open = source.indexOf("{", offset);
+  if (open === -1) return void 0;
+  let depth = 0;
+  for (let i = open; i < source.length; i += 1) {
+    if (source[i] === "{") depth += 1;
+    else if (source[i] === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(open + 1, i);
+    }
+  }
+  return void 0;
+}
+function readEnvironment(source) {
+  const entries = [];
+  const at = /process\.env\s*=\s*Object\.assign\(\s*process\.env\s*,/.exec(source);
+  if (at !== null) {
+    const block = objectBody(source.slice(at.index), "assign") ?? objectBodyAfter(source, at.index);
+    for (const raw of (block ?? "").split(/,(?![^[\]{}]*[\]}])/)) {
+      const entry = /^\s*(?:\/\/[^\n]*\n\s*)?([A-Za-z_][\w]*)\s*:\s*([\s\S]+?)\s*$/.exec(raw);
+      if (entry !== null) entries.push({ name: entry[1], value: entry[2] });
+    }
+  }
+  for (const match of source.matchAll(/process\.env\.(\w+)\s*\?\?=\s*(.+?),?\s*$/gm)) {
+    entries.push({ name: match[1], value: match[2] });
+  }
+  return entries;
+}
+function readCoverageFrom(body) {
+  const globs = readStringArray(body, "collectCoverageFrom");
+  if (globs === void 0) return void 0;
+  return {
+    include: globs.filter((glob) => !glob.startsWith("!")),
+    exclude: globs.filter((glob) => glob.startsWith("!")).map((glob) => glob.slice(1))
+  };
+}
+function translateIgnorePattern(raw) {
+  const pattern = raw.replaceAll("\\\\", "\\");
+  if (pattern === "/node_modules/" || pattern === "node_modules") return {};
+  const suffix = /^\\\.([\w.\\-]+)\$$/.exec(pattern);
+  if (suffix !== null) return { glob: `**/*.${suffix[1].replaceAll("\\.", ".")}` };
+  const directory = /^\/([\w\-/]+)\/$/.exec(pattern);
+  if (directory !== null) return { glob: `**/${directory[1]}/**` };
+  return {
+    refusal: `its \`testPathIgnorePatterns\` entry \`${raw}\` is a regex shape this reader does not translate. Vitest excludes by GLOB, and a regex copied across matches nothing, so the files it names would all run`
+  };
+}
+function readModuleNameMapper(body) {
+  const block = objectBody(body, "moduleNameMapper");
+  if (block === void 0) return { aliases: [], dropped: [] };
+  const aliases = [];
+  const dropped = [];
+  for (const entry of block.matchAll(
+    new RegExp(String.raw`${STRING}\s*:\s*\n?\s*${STRING}`, "g")
+  )) {
+    const find = entry[1];
+    const replacement = entry[2];
+    const named = find.replace(/^\^/, "").replace(/\$$/, "").replaceAll("\\", "");
+    if (named !== "" && replacement.includes(`node_modules/${named}/`)) {
+      dropped.push(find);
+      continue;
+    }
+    aliases.push({ find, replacement: replacement.replace(/^<rootDir>\//, "") });
+  }
+  return { aliases, dropped };
+}
+function readStringArray(body, key) {
+  const raw = new RegExp(String.raw`\b${key}\s*:\s*\[([^\]]*)\]`).exec(body)?.[1];
+  if (raw === void 0) return void 0;
+  return [...raw.matchAll(new RegExp(STRING, "g"))].map((match) => match[1]);
+}
+function configBody(source) {
+  const start = /(?:const\s+\w+(?::\s*\w+)?\s*=|export\s+default)\s*\{/.exec(source);
+  if (start === null) return void 0;
+  let depth = 0;
+  const from = start.index + start[0].length - 1;
+  for (let i = from; i < source.length; i += 1) {
+    const char = source[i];
+    if (char === "{") depth += 1;
+    else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(from + 1, i);
+    }
+  }
+  return void 0;
+}
+function declaredKeys(body) {
+  const keys = [];
+  let depth = 0;
+  let quote;
+  let token = "";
+  for (let i = 0; i < body.length; i += 1) {
+    const char = body[i];
+    if (quote !== void 0) {
+      if (char === quote && body[i - 1] !== "\\") quote = void 0;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "/" && body[i + 1] === "/") {
+      const end = body.indexOf("\n", i);
+      i = end === -1 ? body.length : end;
+      token = "";
+      continue;
+    }
+    if (char === "/" && body[i + 1] === "*") {
+      const end = body.indexOf("*/", i + 2);
+      i = end === -1 ? body.length : end + 1;
+      token = "";
+      continue;
+    }
+    if (char === "{" || char === "[" || char === "(") {
+      depth += 1;
+      token = "";
+      continue;
+    }
+    if (char === "}" || char === "]" || char === ")") {
+      depth -= 1;
+      token = "";
+      continue;
+    }
+    if (depth === 0 && char === ":") {
+      const key = /([A-Za-z_$][\w$]*)\s*$/.exec(token)?.[1];
+      if (key !== void 0) keys.push(key);
+      token = "";
+      continue;
+    }
+    if (depth === 0 && char === ",") {
+      token = "";
+      continue;
+    }
+    token += char;
+  }
+  return keys;
+}
+function extendedConfig(source, cwd) {
+  if (cwd === void 0) return void 0;
+  for (const line of source.split("\n")) {
+    const match = /^\s*import\s+(?!type\b)(\w+)\s+from\s+['"](\.[^'"]*)['"]/.exec(line);
+    if (match === null) continue;
+    const [, binding, specifier] = match;
+    const candidates = [specifier, `${specifier}.ts`, `${specifier}.js`].map(
+      (name) => name.replace(/^\.\//, "")
+    );
+    const file = candidates.find(
+      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync14(join17(cwd, name))
+    );
+    if (file === void 0) continue;
+    if (!new RegExp(String.raw`\{\s*\.\.\.${binding}\b`).test(source)) continue;
+    return { binding, file };
+  }
+  return void 0;
+}
+function sideEffects(source, extended) {
+  const found = [];
+  for (const line of source.split("\n")) {
+    const valueImport = /^\s*import\s+(?!type\b)(.*)$/.exec(line);
+    if (valueImport === null || /from\s+['"]jest['"]/.test(line)) continue;
+    const bindings = [
+      ...(/\{([^}]*)\}/.exec(valueImport[1])?.[1] ?? "").split(","),
+      /^\s*(\w+)\s*(?:,|from)/.exec(valueImport[1])?.[1] ?? ""
+    ].map((name) => name.split(" as ").pop()?.trim() ?? "").filter((name) => name !== "");
+    if (extended !== void 0 && bindings.includes(extended.binding)) continue;
+    const used = bindings.some((name) => {
+      const uses = source.match(new RegExp(String.raw`\b${name}\b`, "g")) ?? [];
+      return uses.length > 1;
+    });
+    if (used) found.push(`it imports a value it uses (\`${line.trim()}\`)`);
+  }
+  return found;
+}
+function readJestConfig(cwd, named) {
+  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync14(join17(cwd, name)));
+  if (file === void 0 || !existsSync14(join17(cwd, file))) return void 0;
+  let source;
+  try {
+    source = readFileSync14(join17(cwd, file), "utf8");
+  } catch {
+    return { file, refusals: [`${file} could not be read`], notes: [] };
+  }
+  const extended = extendedConfig(source, cwd);
+  const refusals = sideEffects(source, extended);
+  const body = configBody(source);
+  if (body === void 0) {
+    return { file, refusals: [...refusals, "its config object could not be located"], notes: [] };
+  }
+  const known = /* @__PURE__ */ new Set([...CARRIED, ...DISCARDED]);
+  for (const key of declaredKeys(body)) {
+    if (!known.has(key)) refusals.push(`it declares \`${key}\`, which is not transposed`);
+  }
+  const notes = [];
+  const afterEnv = readStringArray(body, "setupFilesAfterEnv");
+  const before = readStringArray(body, "setupFiles");
+  if (afterEnv !== void 0 && before !== void 0) {
+    notes.push(
+      "jest runs `setupFiles` before its test framework is installed and `setupFilesAfterEnv` after it; Vitest has one `setupFiles`, so both land there in that order. A setup file that relied on the framework being ABSENT will now find it present"
+    );
+  }
+  const ignore = readStringArray(body, "testPathIgnorePatterns") ?? [];
+  const excludeGlobs = [];
+  for (const pattern of ignore) {
+    const { glob, refusal } = translateIgnorePattern(pattern);
+    if (refusal !== void 0) refusals.push(refusal);
+    else if (glob !== void 0) excludeGlobs.push(glob);
+  }
+  const mapper = readModuleNameMapper(body);
+  for (const find of mapper.dropped) {
+    notes.push(
+      `\`moduleNameMapper\` entry \`${find}\` pointed at another build of the package it matches, which is jest saying it could not load the package as it ships. Vitest can, so the mapping is dropped rather than carried`
+    );
+  }
+  for (const alias of mapper.aliases) {
+    if (/<rootdir>/i.test(alias.replacement) && !alias.replacement.includes("<rootDir>")) {
+      notes.push(
+        `\`moduleNameMapper\` entry \`${alias.find}\` writes \`${/<[Rr]oot[Dd]ir>/.exec(alias.replacement)?.[0] ?? "<RootDir>"}\`, and jest only substitutes \`<rootDir>\`. That mapping resolved to a literal directory under jest too, so it has never done anything; it is carried unchanged rather than quietly repaired`
+      );
+    }
+  }
+  const coverageFrom = readCoverageFrom(body);
+  const env = readEnvironment(source);
+  const globalSetup = readString(body, "globalSetup");
+  const testTimeout = readNumber(body, "testTimeout");
+  const maxWorkers = readNumber(body, "maxWorkers");
+  const testMatch = readStringArray(body, "testMatch");
+  const base = extended === void 0 ? void 0 : readJestConfig(cwd, extended.file);
+  const inherited = base === void 0 ? {} : { ...base, refusals: [], notes: [] };
+  for (const [jestKey, field] of [
+    ["testPathIgnorePatterns", "excludeGlobs"],
+    ["setupFilesAfterEnv", "setupFilesAfterEnv"],
+    ["setupFiles", "setupFiles"],
+    ["testMatch", "testMatch"],
+    ["collectCoverageFrom", "coverageFrom"],
+    ["moduleNameMapper", "aliases"]
+  ]) {
+    if (declaredKeys(body).includes(jestKey)) delete inherited[field];
+  }
+  return {
+    ...inherited,
+    file,
+    ...readString(body, "testEnvironment") !== void 0 ? { testEnvironment: readString(body, "testEnvironment") } : {},
+    ...readString(body, "coverageDirectory") !== void 0 ? { coverageDirectory: readString(body, "coverageDirectory") } : {},
+    ...afterEnv !== void 0 ? { setupFilesAfterEnv: afterEnv } : {},
+    ...before !== void 0 ? { setupFiles: before } : {},
+    ...testTimeout !== void 0 ? { testTimeout } : {},
+    ...maxWorkers !== void 0 ? { maxWorkers } : {},
+    ...globalSetup !== void 0 ? { globalSetup: [globalSetup] } : {},
+    ...testMatch !== void 0 ? { testMatch } : {},
+    ...coverageFrom !== void 0 ? { coverageFrom } : {},
+    ...excludeGlobs.length > 0 ? { excludeGlobs } : {},
+    ...mapper.aliases.length > 0 ? { aliases: mapper.aliases } : {},
+    ...env.length > 0 ? { env } : {},
+    refusals: [...base?.refusals ?? [], ...refusals],
+    notes: [...base?.notes ?? [], ...notes]
+  };
+}
+
+// src/roles/test/nest/run-modes.ts
+import { existsSync as existsSync15 } from "node:fs";
+import { basename as basename2, join as join18 } 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("\\", "/"));
+}
+function configFileFor(target) {
+  if (target === PRIMARY_TARGET) return PRIMARY_CONFIG_FILE;
+  const suffix = target.startsWith("test-") ? target.slice("test-".length) : target;
+  return `vitest.${suffix}.config.mts`;
+}
+function runModes(cwd, fallback) {
+  const targets = projectTargets(cwd) ?? {};
+  const declared = [];
+  for (const [target, raw] of Object.entries(targets)) {
+    const entry = raw;
+    if (entry.executor !== JEST_EXECUTOR) continue;
+    const jestConfig = entry.options?.jestConfig;
+    if (jestConfig === void 0) continue;
+    const name = configName(jestConfig);
+    if (!existsSync15(join18(cwd, name))) continue;
+    declared.push({
+      target,
+      jestConfig: name,
+      vitestConfig: configFileFor(target),
+      primary: target === PRIMARY_TARGET
+    });
+  }
+  if (declared.length === 0) {
+    const [only] = fallback;
+    return only === void 0 ? [] : [
+      {
+        target: PRIMARY_TARGET,
+        jestConfig: only,
+        vitestConfig: PRIMARY_CONFIG_FILE,
+        primary: true
+      }
+    ];
+  }
+  return declared.sort(
+    (left, right) => left.primary === right.primary ? left.target.localeCompare(right.target) : Number(right.primary) - Number(left.primary)
+  );
+}
+
+// src/roles/test/written-file-formatter.ts
+import { existsSync as existsSync17 } from "node:fs";
+import { dirname as dirname9, join as join21 } from "node:path";
+
+// src/roles/format/read-adoption.ts
+import { existsSync as existsSync16, readFileSync as readFileSync15 } from "node:fs";
+import { join as join19 } from "node:path";
+
+// src/roles/format/config-policy.ts
+var FORMAT_CONFIG_FILE = ".oxfmtrc.json";
+var FORMAT_SCRIPT_NAME = "format";
+var PROVENANCE_KEY = "$sentinel";
+var PERMITTED_LOCAL_KEYS = [
+  "useTabs",
+  "tabWidth",
+  "printWidth",
+  "semi",
+  "singleQuote",
+  "jsxSingleQuote",
+  "trailingComma",
+  "quoteProps",
+  "bracketSpacing",
+  "bracketSameLine",
+  "arrowParens",
+  "endOfLine",
+  "objectWrap",
+  "proseWrap",
+  "experimentalOperatorPosition"
+];
+var ALWAYS_LOCAL_KEYS = ["ignorePatterns", "overrides"];
+var FORMAT_DEFAULT_IGNORES = ["**/*.toml"];
+var PRETTIER_CONFIG_FILES = [
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.json5",
+  ".prettierrc.yml",
+  ".prettierrc.yaml",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.mjs",
+  "prettier.config.js",
+  "prettier.config.cjs",
+  "prettier.config.mjs"
+];
+function formatTargets() {
+  return {
+    [FORMAT_SCRIPT_NAME]: {
+      cache: true,
+      inputs: ["default", `{projectRoot}/${FORMAT_CONFIG_FILE}`]
+    },
+    [`${FORMAT_SCRIPT_NAME}:fix`]: { cache: false }
+  };
+}
+
+// src/roles/format/presets/base.json
+var base_default = {
+  printWidth: 80,
+  semi: false,
+  singleQuote: true,
+  trailingComma: "all",
+  sortPackageJson: false,
+  sortImports: false
+};
+
+// src/roles/format/presets/nest-imports.json
+var nest_imports_default = {
+  customGroups: [
+    {
+      groupName: "workspace",
+      elementNamePattern: ["@hublo/**", "@shared/**", "@front/**", "@network/**"]
+    }
+  ],
+  groups: ["builtin", "external", "workspace", ["parent", "index"], "sibling"],
+  newlinesBetween: true,
+  order: "asc",
+  ignoreCase: false
+};
+
+// src/roles/format/preset-data.ts
+var FORMAT_PRESETS = ["base", "svelte", "nest"];
+function hasFormatPreset(name) {
+  return FORMAT_PRESETS.includes(name);
+}
+function formatPresetName(declared) {
+  if (declared === "svelte") return "svelte";
+  if (declared === "nest") return "nest";
+  return "base";
+}
+function formatPresetFor(preset) {
+  const base = base_default;
+  const name = formatPresetName(preset);
+  if (name === "svelte") return { ...base, svelte: true };
+  if (name === "nest") return { ...base, sortImports: nest_imports_default };
+  return base;
+}
+
+// src/roles/format/read-adoption.ts
+var NOT_ADOPTED = (configFile, unreadable = null) => ({
+  configFile,
+  preset: null,
+  adopted: false,
+  conformant: false,
+  drift: [],
+  local: {},
+  presetVersion: null,
+  effective: {},
+  unreadable
+});
+function sameValue(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function readFormatAdoption(cwd) {
+  const path = join19(cwd, FORMAT_CONFIG_FILE);
+  if (!existsSync16(path)) return NOT_ADOPTED(null);
+  let parsed;
+  try {
+    parsed = parseJsonc(readFileSync15(path, "utf8"), FORMAT_CONFIG_FILE);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return NOT_ADOPTED(FORMAT_CONFIG_FILE, `${FORMAT_CONFIG_FILE} could not be parsed (${reason})`);
+  }
+  const provenance = parsed[PROVENANCE_KEY];
+  if (!provenance || typeof provenance.preset !== "string") return NOT_ADOPTED(FORMAT_CONFIG_FILE);
+  if (!hasFormatPreset(provenance.preset)) {
+    return NOT_ADOPTED(
+      FORMAT_CONFIG_FILE,
+      `${FORMAT_CONFIG_FILE} declares the format preset "${provenance.preset}", which sentinel does not ship (shipped: ${FORMAT_PRESETS.join(", ")}). Re-run \`sentinel --init --format\`.`
+    );
+  }
+  const declaredLocal = Array.isArray(provenance.local) ? provenance.local : [];
+  const preset = formatPresetFor(provenance.preset);
+  const drift = [];
+  const local = {};
+  for (const [key, expected] of Object.entries(preset)) {
+    if (declaredLocal.includes(key)) {
+      local[key] = parsed[key];
+      continue;
+    }
+    if (!(key in parsed) || !sameValue(parsed[key], expected)) drift.push(key);
+  }
+  for (const key of declaredLocal) {
+    if (!(key in preset)) local[key] = parsed[key];
+  }
+  for (const key of ALWAYS_LOCAL_KEYS) {
+    if (key in parsed) local[key] = parsed[key];
+  }
+  return {
+    configFile: FORMAT_CONFIG_FILE,
+    preset: provenance.preset,
+    adopted: true,
+    conformant: drift.length === 0,
+    drift,
+    local,
+    presetVersion: typeof provenance.version === "string" ? provenance.version : null,
+    effective: parsed,
+    unreadable: null
+  };
+}
+
+// src/roles/format/resolve-oxfmt.ts
+import { readFileSync as readFileSync16 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import { dirname as dirname8, join as join20 } from "node:path";
+function resolveOxfmt(cwd) {
+  return resolveBin(cwd, "oxfmt") ?? binFromOwnInstall("oxfmt", "oxfmt");
+}
+function oxfmtRejects(key, value) {
+  const schema = configSchema();
+  const property = schema?.properties?.[key];
+  if (!property) return false;
+  const definition = resolveRef(schema, property);
+  if (Array.isArray(definition.enum)) return !definition.enum.includes(value);
+  if (definition.type === "boolean") return typeof value !== "boolean";
+  if (definition.type === "integer" || definition.type === "number")
+    return typeof value !== "number";
+  return false;
+}
+function resolveRef(schema, node) {
+  const ref = node.$ref ?? node.allOf?.[0]?.$ref;
+  const name = ref?.startsWith("#/definitions/") ? ref.slice("#/definitions/".length) : void 0;
+  return (name ? schema.definitions?.[name] : void 0) ?? node;
+}
+var cachedSchema;
+function configSchema() {
+  if (cachedSchema !== void 0) return cachedSchema ?? void 0;
+  cachedSchema = readConfigSchema() ?? null;
+  return cachedSchema ?? void 0;
+}
+function readConfigSchema() {
+  try {
+    const manifest = createRequire4(import.meta.url).resolve("oxfmt/package.json");
+    const schemaPath = join20(dirname8(manifest), "configuration_schema.json");
+    return JSON.parse(readFileSync16(schemaPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/roles/test/written-file-formatter.ts
+var PRETTIER_CONFIGS = [
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.json5",
+  ".prettierrc.yaml",
+  ".prettierrc.yml",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.mjs",
+  ".prettierrc.toml",
+  "prettier.config.js",
+  "prettier.config.cjs",
+  "prettier.config.mjs"
+];
+function prettierConfigFrom(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    for (const name of PRETTIER_CONFIGS) {
+      if (existsSync17(join21(dir, name))) return join21(dir, name);
+    }
+    const parent = dirname9(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function writtenFileFormatter(cwd) {
+  if (readFormatAdoption(cwd).configFile !== null) {
+    const oxfmt = resolveOxfmt(cwd);
+    if (oxfmt !== void 0) {
+      return { bin: oxfmt, args: ["--write"], origin: "this module's own oxfmt config" };
+    }
+  }
+  const config = prettierConfigFrom(cwd);
+  const prettier = resolveBin(cwd, "prettier");
+  if (config !== void 0 && prettier !== void 0) {
+    return {
+      bin: prettier,
+      args: ["--write", "--log-level", "warn"],
+      origin: `the workspace's Prettier`
+    };
+  }
+  return void 0;
+}
+
+// src/roles/test/jest-migration.ts
+var SPEC_TSCONFIG = "tsconfig.spec.json";
+var VITEST_GLOBAL_TYPES = "vitest/globals";
+function specTypesOperation(cwd) {
+  const path = join22(cwd, SPEC_TSCONFIG);
+  if (!existsSync18(path)) return void 0;
+  let config;
+  try {
+    config = parseJsonc(
+      readFileSync17(path, "utf8"),
+      SPEC_TSCONFIG
+    );
+  } catch {
+    return void 0;
+  }
+  const types = config?.compilerOptions?.types;
+  if (!Array.isArray(types) || !types.includes("jest")) return void 0;
+  return {
+    kind: "merge-json",
+    path: SPEC_TSCONFIG,
+    value: {
+      compilerOptions: {
+        types: types.map((entry) => entry === "jest" ? VITEST_GLOBAL_TYPES : entry)
+      }
+    }
+  };
+}
+function shippedTypesPath(cwd, declaration) {
+  try {
+    const manifest = createRequire5(join22(cwd, "noop.cjs")).resolve("@hublo/sentinel/package.json");
+    const file = join22(dirname10(manifest), declaration);
+    if (existsSync18(file)) {
+      const path = relative5(cwd, file);
+      return path.startsWith(".") ? path : `./${path}`;
+    }
+  } catch {
+  }
+  return `./node_modules/@hublo/sentinel/${declaration}`;
+}
+function tsconfigFileListOperations(cwd) {
+  const operations = [];
+  let names;
+  try {
+    names = readdirSync6(cwd).filter((name) => TSCONFIG_FILE.test(name));
+  } catch {
+    return operations;
+  }
+  for (const name of names) {
+    let config;
+    try {
+      config = parseJsonc(
+        readFileSync17(join22(cwd, name), "utf8"),
+        name
+      );
+    } catch {
+      continue;
+    }
+    const include = Array.isArray(config?.include) ? rewriteFileList(config.include) : void 0;
+    const exclude = Array.isArray(config?.exclude) ? rewriteFileList(config.exclude) : void 0;
+    const files = Array.isArray(config?.files) ? rewriteFileList(config.files) : void 0;
+    const withTypes = name === SPEC_TSCONFIG ? withShippedTypes(cwd, files ?? config?.files) : void 0;
+    if (include === void 0 && exclude === void 0 && files === void 0 && withTypes === void 0)
+      continue;
+    operations.push({
+      kind: "merge-json",
+      path: name,
+      value: {
+        ...include === void 0 ? {} : { include },
+        ...exclude === void 0 ? {} : { exclude },
+        ...withTypes === void 0 ? files === void 0 ? {} : { files } : { files: withTypes }
+      }
+    });
+  }
+  return operations;
+}
+function rewriteFileList(entries) {
+  const rewritten = entries.filter((entry) => typeof entry !== "string" || !JEST_CONFIG_ENTRY.test(entry)).map((entry) => typeof entry === "string" ? vitestSupportName(entry) : entry);
+  const unchanged = rewritten.length === entries.length && rewritten.every((entry, index) => entry === entries[index]);
+  return unchanged ? void 0 : rewritten;
+}
+function withShippedTypes(cwd, files) {
+  const entries = Array.isArray(files) ? files : [];
+  const missing = SHIPPED_TYPES.filter(
+    (declaration) => !entries.some((entry) => entry.endsWith(declaration))
+  );
+  if (missing.length === 0) return void 0;
+  return [...entries, ...missing.map((declaration) => shippedTypesPath(cwd, declaration))];
+}
+var SHIPPED_TYPES = ["types/mock-extended.d.ts", "types/jest-global.d.ts"];
+var JEST_CONFIG_ENTRY = /(^|\/)jest\.[\w.-]*config\.[cm]?[jt]s$/;
+var TSCONFIG_FILE = /^tsconfig[\w.-]*\.json$/;
+function siblingScriptRewrites(cwd) {
+  const rewrites = {};
+  for (const [name, command] of Object.entries(moduleScripts(cwd))) {
+    if (name === TEST_SCRIPT_NAME || typeof command !== "string") continue;
+    const rewritten = rewriteVitestScript(command);
+    if (rewritten !== command) rewrites[name] = rewritten;
+  }
+  return rewrites;
+}
+function blocked(reason) {
+  return { operations: [], blocked: reason };
+}
+function planJestMigration(context, adoption) {
+  const modes = runModes(context.cwd, adoption.jestConfigs);
+  if (modes.length === 0) {
+    return blocked(`no jest config could be found for this module, so nothing was written.`);
+  }
+  const prepared = [];
+  for (const mode of modes) {
+    const reading = readJestConfig(context.cwd, mode.jestConfig);
+    if (reading === void 0) {
+      return blocked(`${mode.jestConfig} could not be read, so nothing was written.`);
+    }
+    const generated = generateNestTestConfig(context.cwd, reading, mode.target);
+    if (generated.source === void 0) {
+      return blocked(
+        `${mode.jestConfig} (the \`${mode.target}\` target) does not transpose as it stands: ${generated.refusals.join("; ")}. Nothing was written; this needs a look before the migration runs.`
+      );
+    }
+    prepared.push({ mode, reading, source: generated.source });
+  }
+  const migration = migrateModuleTests(
+    context.cwd,
+    prepared.flatMap(({ reading }) => [
+      ...reading.setupFiles ?? [],
+      ...reading.setupFilesAfterEnv ?? [],
+      ...reading.globalSetup ?? []
+    ])
+  );
+  if (migration.blockers.length > 0) {
+    const listed = migration.blockers.map((blocker) => `
+    ${blocker.file}: ${blocker.reason}`).join("");
+    return blocked(
+      `${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 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(
+    prepared.map(({ mode }) => [
+      mode.target,
+      mode.primary ? SENTINEL_TEST_COMMAND : `${SENTINEL_TEST_COMMAND} --config ${mode.vitestConfig}`
+    ])
+  );
+  const operations = [
+    ...prepared.map(({ mode, source }) => ({
+      kind: "write",
+      path: mode.vitestConfig,
+      contents: source
+    })),
+    ...migration.operations,
+    ...specTypes === void 0 ? [] : [specTypes],
+    ...tsconfigFileListOperations(context.cwd),
+    manifestOperation(context.cwd, { ...scripts, ...siblings }),
+    ...prepared.flatMap(
+      ({ mode }) => nxTargetOperations({
+        cwd: context.cwd,
+        targets: testTarget({
+          name: mode.target,
+          configFiles: [mode.vitestConfig],
+          outputs: existingFor(mode.target)?.outputs ?? [],
+          dependsOn: existingFor(mode.target)?.dependsOn ?? [],
+          configurations: existingFor(mode.target)?.configurations ?? {}
+        })
+      })
+    ),
+    ...[.../* @__PURE__ */ new Set([...adoption.jestConfigs, ...prepared.map(({ mode }) => mode.jestConfig)])].map(
+      (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` : ""}.`,
+    `${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.`)
+  ];
+  for (const warning of migration.warnings) notes.push(`\u26A0\uFE0F ${warning}`);
+  notes.push(
+    `the config files this wrote are named \`vitest.*\` where they were \`jest.*\`. An ignore written by NAME no longer covers them: if your lint or format config ignores \`jest.*\`, add the \`vitest.*\` equivalent, or accept that these files are now checked.`
+  );
+  if (specTypes !== void 0) {
+    notes.push(
+      `${SPEC_TSCONFIG} now declares \`${VITEST_GLOBAL_TYPES}\` instead of \`jest\`. Without it the module keeps depending on @types/jest and \`jest.Mock\` still resolves, so the migration would look finished while the dependency it cuts is still declared.`
+    );
+  }
+  const formatter = writtenFileFormatter(context.cwd);
+  if (formatter !== void 0) {
+    notes.push(
+      `the files this rewrote were run through ${formatter.origin} afterwards. Two things needed it: the Vitest type imports land 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 config would pick. Neither is a defect, and both would have failed your format check. What no formatter does is ORDER imports, so if your lint enforces \`import/order\`, run its fixer too.`
+    );
+  } else {
+    notes.push(
+      `no style is declared here, by this module or its workspace, so what was written keeps the shape it was written in, and the Vitest type imports sit beside the existing ones rather than where your \`import/order\` wants them. That rule is classified by a prefix list this package cannot read, so it is left to the tool that owns it: run your module's own lint fixer (\`nx run <module>:lint --fix\` here) and its formatter before committing.`
+    );
+  }
+  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.`
+  );
+  if (Object.keys(siblings).length > 0) {
+    notes.push(`rewrote ${Object.keys(siblings).join(", ")} to run through sentinel.`);
+  }
+  return { operations, notes };
+}
+
+// src/roles/test/plan.ts
+function ownedTestDependencies(cwd, declared) {
+  return declared.filter((entry) => SENTINEL_OWNED_TEST_PACKAGES.includes(entry.name)).flatMap((entry) => [
+    ["dependencies", entry.name],
+    ["devDependencies", entry.name]
+  ]).filter(([section]) => section !== void 0);
+}
+var DEFERRED = {
+  svelte: `the svelte modules here carry no svelte test at all, so adopting them would prove nothing about svelte, and their owners have a framework migration under way that moves these versions anyway`
+};
+function plan(context) {
+  const deferred = DEFERRED[context.preset];
+  if (deferred !== void 0) {
+    return {
+      operations: [],
+      skipped: `the test role defers ${context.preset} for now. It defers because ${deferred}.`
+    };
+  }
+  const configFile = testConfigFile(context.cwd);
+  const adoption = readTestAdoption(context.cwd);
+  if (adoption.state === "no-tests") {
+    const operations2 = adoption.jestConfigs.map((name) => ({
+      kind: "delete",
+      path: name
+    }));
+    const owned2 = ownedTestDependencies(context.cwd, adoption.ownDeclarations);
+    if (owned2.length > 0) {
+      operations2.push({ kind: "remove-json-keys", path: "package.json", keys: owned2 });
+    }
+    const hasTarget = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME] !== void 0;
+    if (hasTarget) {
+      operations2.push({
+        kind: "remove-json-keys",
+        path: "project.json",
+        keys: [["targets", TEST_SCRIPT_NAME]]
+      });
+    }
+    if (operations2.length === 0) {
+      return {
+        operations: [],
+        skipped: `this module has no test and no jest leftovers, so there is nothing to do here.`
+      };
+    }
+    return {
+      operations: operations2,
+      notes: [
+        // Names what is actually removed, never a shape this module does not have: half of these
+        // modules carry a config with no target behind it, and claiming otherwise would describe
+        // an operation the plan never performs.
+        `this module has no test file, so this is a cleanup rather than an adoption: ${[...adoption.jestConfigs, ...hasTarget ? ["the jest target it feeds"] : []].join(" and ")} removed, so nothing here breaks the day jest leaves the workspace. No test config is written in exchange, because there is nothing to configure.`
+      ]
+    };
+  }
+  if (configFile === void 0) {
+    if (adoption.state === "jest") return planJestMigration(context, adoption);
+    return {
+      operations: [],
+      skipped: `this module has no test config and no test files, so there is nothing to point at sentinel. What it needs is its jest leftovers removed, which is a cleanup rather than an adoption.`
+    };
+  }
+  const operations = [];
+  const notes = [];
+  const rewrite = rewriteToolchainImports(
+    testToolchain(context.preset),
+    readTestConfigSource(context.cwd, configFile),
+    configFile
+  );
+  if (rewrite.kind === "blocked") {
+    return {
+      operations: [],
+      skipped: `${configFile} could not be pointed at sentinel, so nothing was written: ${rewrite.why}. Nothing here is broken; this needs a look before the role applies.`
+    };
+  }
+  if (rewrite.kind === "rewritten") {
+    operations.push({ kind: "write", path: configFile, contents: rewrite.source });
+    notes.push(
+      `${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] ?? manifestTargets(context.cwd)[TEST_SCRIPT_NAME];
+  const outputs = existing?.outputs ?? [];
+  const dependsOn = existing?.dependsOn ?? [];
+  const configurations = existing?.configurations ?? {};
+  if (dependsOn.length > 0) {
+    notes.push(`carried \`dependsOn\` from the replaced target: ${dependsOn.join(", ")}.`);
+  }
+  if (Object.keys(configurations).length > 0) {
+    notes.push(
+      `carried the \`${Object.keys(configurations).join("`, `")}\` configuration(s): CI invokes \`--configuration=ci\`, and a target that no longer offers it fails the caller, not the module.`
+    );
+  }
+  if (outputs.length === 0) {
+    notes.push(
+      `this target declares no \`outputs\`, so it is left UNCACHED. Caching a run that restores nothing is the defect where nx reports a hit and the coverage directory is empty; if this module writes coverage, declare where and the target can cache.`
+    );
+  }
+  const siblingScripts = {};
+  for (const [name, command] of Object.entries(moduleScripts(context.cwd))) {
+    if (name === TEST_SCRIPT_NAME || typeof command !== "string") continue;
+    const rewritten = rewriteVitestScript(command);
+    if (rewritten !== command) siblingScripts[name] = rewritten;
+  }
+  if (Object.keys(siblingScripts).length > 0) {
+    notes.push(
+      `rewrote ${Object.keys(siblingScripts).join(", ")} to run through sentinel: they called vitest directly, and the dependency they relied on is removed below. A watch script keeps watching, through \`-- --watch\`.`
+    );
+  }
+  operations.push(
+    manifestOperation(context.cwd, {
+      [TEST_SCRIPT_NAME]: SENTINEL_TEST_COMMAND,
+      ...siblingScripts
+    })
+  );
+  operations.push(
+    ...nxTargetOperations({
+      cwd: context.cwd,
+      targets: testTarget({ configFiles: [configFile], outputs, dependsOn, configurations })
+    })
+  );
+  const owned = ownedTestDependencies(context.cwd, adoption.ownDeclarations);
+  if (owned.length > 0) {
+    operations.push({ kind: "remove-json-keys", path: "package.json", keys: owned });
+    notes.push(
+      `removed ${[...new Set(owned.map(([, name]) => name))].join(", ")} from this module: sentinel owns the runner now, and two copies of Vitest in one run give the plugins a different Vite than the one running them.`
+    );
+  }
+  if (adoption.jestConfigs.length > 0) {
+    notes.push(
+      `${adoption.jestConfigs.join(", ")} is still here beside the Vitest config. It is not this step's to delete, since something may still run it, but the workspace cannot drop jest while it exists.`
+    );
+  }
+  return { operations, notes };
+}
+
+// src/roles/test/adapters/vitest/vitest.adapter.ts
+var FORMATTABLE = /\.(m|c)?(j|t)sx?$|\.json$/;
+var FORMAT_BATCH = 25;
+var VitestAdapter = class extends BaseAdapter {
+  target = "test";
+  runner = "vitest";
+  appliesTo(_preset) {
+    return 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.
+   *
+   * 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.
+   */
+  beforeInit(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    if (adoption.state !== "jest") return Promise.resolve();
+    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();
+  }
+  /**
+   * Hand what was just written to the module's OWN formatter.
+   *
+   * ⚠️ Not a style sentinel imposes: the module adopted `.oxfmtrc.json`, and this runs that
+   * config over the files this role created. Without it, `--init --test` leaves a module whose
+   * own `--run --format` fails on a file the module never wrote.
+   *
+   * Measured on `apps/nest/microservices/agency`, in this repository's CI:
+   *
+   *     agency:format   12 files, including vitest.config.mts and
+   *                     vitest.integration.config.mts, both generated here
+   *
+   * The generator cannot avoid it by wrapping at a fixed width, because the width is the
+   * MODULE's decision: `printWidth` lives in its own config, and 12 modules already set their
+   * own. Guessing it is how a tool starts owning a setting it does not own.
+   *
+   * The same delegation the build role asks a human to do by hand, done.
+   *
+   * ## ⚠️ Two boundaries, both learned by crossing them
+   *
+   * ### Only a module that has a formatter CONFIG
+   *
+   * The question is not "can a formatter be found". It always can: sentinel depends on oxfmt and
+   * ships the binary, so `resolveOxfmt` falls back to its own install and never returns undefined
+   * once sentinel is installed. Asking it that way meant a module with no oxfmt config was
+   * formatted with oxfmt's DEFAULTS, which is a style nobody here chose.
+   *
+   * So the CONFIG is read. A module that wrote its own `.oxfmtrc.json` without adopting the role
+   * has still stated a style, and running it is delegation; running oxfmt with no config is us
+   * choosing one.
+   *
+   * Measured on `apps/nest/microservices/institution`, which has not adopted format and whose lint
+   * forbids semicolons: `institution:lint` went from green to failing, thousands of `semi`, on a
+   * module whose 2958 tests pass. So the adoption is read, not the binary.
+   *
+   * ### Only the files this just WROTE
+   *
+   * `--write .` is a whole-directory pass, and that is not a tidy-up. Same measurement: 1813 files
+   * changed, 47333 insertions, 55506 deletions, in a module whose migration touched 268. A
+   * migration diff is read by a person.
+   *
+   * A module that has not adopted format keeps what was written exactly as written, and is told so.
+   * The codemod rewrites tokens in place, so those files keep the shape they already had.
+   */
+  async afterInit(ctx) {
+    const written = (ctx.written ?? []).filter((file) => FORMATTABLE.test(file));
+    if (written.length === 0) return Promise.resolve();
+    const formatter = writtenFileFormatter(ctx.cwd);
+    if (formatter === void 0) {
+      this.say(
+        `no style is declared here, by this module or its workspace, so the ${written.length} file(s) this wrote keep the shape they were written in. Run your own formatter over them before committing.`
+      );
+      return Promise.resolve();
+    }
+    let failed = 0;
+    for (let at = 0; at < written.length; at += FORMAT_BATCH) {
+      const batch = written.slice(at, at + FORMAT_BATCH);
+      const pass = spawnSync(formatter.bin, [...formatter.args, ...batch], {
+        cwd: ctx.cwd,
+        encoding: "utf8"
+      });
+      if (pass.status !== 0) failed += batch.length;
+    }
+    this.say(
+      failed === 0 ? `formatted the ${written.length} file(s) this wrote with ${formatter.origin}, so a format check passes on files it did not write itself.` : (
+        // Adoption SUCCEEDED; only the tidy-up did not. Failing here would revert a migration
+        // over a formatting pass, which is the wrong trade.
+        `${formatter.origin} could not run over ${failed} of the ${written.length} file(s) this wrote. Adoption itself is applied; run your formatter before committing.`
+      )
+    );
+    return Promise.resolve();
+  }
+  plan(context) {
+    return plan(context);
+  }
+  async status(ctx) {
+    return Promise.resolve(readTestAdoption(ctx.cwd));
+  }
+  async inspect(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    return Promise.resolve({
+      state: adoption.state,
+      runner: adoption.runner,
+      configFile: adoption.configFile,
+      jestConfigs: adoption.jestConfigs,
+      adopted: adoption.adopted,
+      conformant: adoption.conformant,
+      drift: adoption.drift,
+      unreadable: adoption.unreadable
+    });
+  }
+  /**
+   * Run the module's tests.
+   *
+   * A module that has not adopted is reported and PASSES, the stance every role takes: `--run`
+   * with no named target sweeps the workspace, so failing here would exit non-zero on the 107
+   * modules still on jest, which says nothing anyone can act on.
+   */
+  async run(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    if (!adoption.adopted) {
+      this.say(
+        adoption.state === "jest" ? `this module tests with jest (${adoption.jestConfigs.join(", ")}); run \`sentinel --init --test\` to migrate it.` : adoption.state === "no-tests" ? `this module has no tests.` : `no sentinel preset in this module's Vitest config; run \`sentinel --init --test\` to adopt.`
+      );
+      return Promise.resolve({ ok: true, code: 0 });
+    }
+    const { bin, origin } = resolveVitest(ctx.cwd);
+    if (bin === void 0) {
+      this.say(`could not find the vitest binary. Run \`pnpm install\` in the module.`);
+      return Promise.resolve({ ok: false, code: 1 });
+    }
+    if (origin === "module") {
+      this.say(
+        `using the MODULE's vitest, not sentinel's. An adopted config gets its plugins from sentinel, and two copies fail in ways that never mention a version. Remove vitest from this module's package.json.`
+      );
+    }
+    const { options: typedOptions, paths: typedPaths } = splitToolArgs(ctx.cwd, ctx.toolArgs, {
+      valueFlags: ["--config", "-c"]
+    });
+    const { cwd: runFrom, options, paths } = fromWorkspaceRoot(ctx.cwd, typedOptions, typedPaths);
+    const watching = options.includes("--watch") || options.includes("-w");
+    const argv = watching ? [...options, ...paths] : ["run", ...options, ...paths];
+    const result = spawnSync(bin, argv, { cwd: runFrom, 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;
+    return Promise.resolve({ ok: code === 0, code });
+  }
+  say(message) {
+    process.stderr.write(`sentinel test(vitest): ${message}
+`);
+  }
+};
+function fromWorkspaceRoot(moduleDir, options, paths) {
+  const root = findWorkspaceRoot(moduleDir);
+  if (root === void 0 || root === moduleDir) {
+    return { cwd: moduleDir, options: [...options], paths: [...paths] };
+  }
+  const absolute = (value) => isAbsolute2(value) ? value : resolve7(moduleDir, value);
+  const moved = [];
+  let previousWasConfig = false;
+  for (const option of options) {
+    if (previousWasConfig) {
+      moved.push(absolute(option));
+      previousWasConfig = false;
+      continue;
+    }
+    if (option.startsWith("--config=")) moved.push(`--config=${absolute(option.slice(9))}`);
+    else moved.push(option);
+    previousWasConfig = option === "--config" || option === "-c";
+  }
+  return {
+    cwd: root,
+    // `--root` LAST, so a caller cannot be silently overridden by our own flag.
+    options: [...moved, "--root", moduleDir],
+    paths: paths.map((path) => absolute(path))
+  };
+}
+
+export {
+  moduleScripts,
+  selfCommand,
+  adoptedPackageName,
+  manifestOperation,
+  projectTargets,
+  BaseAdapter,
+  splitToolArgs,
+  resolveBin,
+  binFromOwnInstall,
+  binSearchPath,
+  parseJsonc,
+  nxTargetOperations,
+  FORMAT_CONFIG_FILE,
+  FORMAT_SCRIPT_NAME,
+  PROVENANCE_KEY,
+  PERMITTED_LOCAL_KEYS,
+  ALWAYS_LOCAL_KEYS,
+  FORMAT_DEFAULT_IGNORES,
+  PRETTIER_CONFIG_FILES,
+  formatTargets,
+  formatPresetName,
+  formatPresetFor,
+  readFormatAdoption,
+  rewriteToolchainImports,
+  resolveOxfmt,
+  oxfmtRejects,
+  walk,
+  readTestAdoption,
+  resolveContext,
+  moduleEnvironment,
+  suiteOf,
+  captureReference,
+  hasReference,
+  compareAgainstReference,
+  resolveVitest,
+  VitestAdapter,
+  fromWorkspaceRoot
+};