@hublo/sentinel 1.3.0 → 1.4.0-alpha.2

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

@@ -1,3 +1,12 @@
+import {
+  DEFAULT_MAX_DIAGNOSTICS,
+  findWorkspaceRoot,
+  moduleName,
+  readNxProjectName,
+  readOwnPackage,
+  readProjectPackageJson
+} from "./chunk-WLFE5RUU.js";
+
 // src/core/registry.ts
 var adapters = [];
 var PresetUnsupportedError = class extends Error {
@@ -67,58 +76,6 @@ function resolve(target, preset, runner) {
   return matching[0];
 }
 
-// src/shared/package-json.ts
-import { existsSync, readFileSync } from "fs";
-import { basename, dirname, join } from "path";
-import { fileURLToPath } from "url";
-function readOwnPackage() {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  for (; ; ) {
-    const pkgPath = join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        if (typeof pkg.version === "string") {
-          const bin = typeof pkg.bin === "string" ? pkg.bin : Object.values(pkg.bin ?? {})[0];
-          return { name: pkg.name ?? "@hublo/sentinel", version: pkg.version, bin };
-        }
-      } catch {
-      }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) return { name: "@hublo/sentinel", version: "0.0.0" };
-    dir = parent;
-  }
-}
-function readOwnVersion() {
-  return readOwnPackage().version;
-}
-function readProjectPackageJson(dir) {
-  const path = join(dir, "package.json");
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    process.stderr.write(`sentinel: could not parse ${path}; ignoring for detection.
-`);
-    return {};
-  }
-}
-function readNxProjectName(dir) {
-  const path = join(dir, "project.json");
-  if (!existsSync(path)) return void 0;
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
-    return typeof parsed.name === "string" ? parsed.name : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function moduleName(dir) {
-  const declared = readProjectPackageJson(dir).name;
-  return readNxProjectName(dir) ?? (declared === void 0 ? basename(dir) : declared);
-}
-
 // src/core/base-adapter.ts
 var BaseAdapter = class {
   inspect(_ctx) {
@@ -166,15 +123,15 @@ function palette(stream) {
 }
 
 // src/roles/build/nest/nx-target.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2, relative } from "path";
+import { existsSync, readFileSync } from "fs";
+import { join, relative } from "path";
 var DEPRECATED_NX_BUILDER = "@nx/webpack:webpack";
 var TRANSLATABLE_WEBPACK_CONFIG = "tools/webpack-configs/update.webpack.config.js";
 var readProjectJson = (cwd) => {
-  const path = join2(cwd, "project.json");
-  if (!existsSync2(path)) return void 0;
+  const path = join(cwd, "project.json");
+  if (!existsSync(path)) return void 0;
   try {
-    return JSON.parse(readFileSync2(path, "utf8"));
+    return JSON.parse(readFileSync(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -217,7 +174,7 @@ function liveFileReplacements(cwd, target) {
   const live = [];
   for (const configuration of Object.values(configurations)) {
     for (const replacement of configuration.fileReplacements ?? []) {
-      const exists = existsSync2(join2(workspaceRoot, replacement.replace)) || existsSync2(join2(workspaceRoot, replacement.with));
+      const exists = existsSync(join(workspaceRoot, replacement.replace)) || existsSync(join(workspaceRoot, replacement.with));
       if (exists) live.push(replacement.replace);
     }
   }
@@ -238,8 +195,8 @@ function workspaceRootHops(cwd, target) {
 }
 
 // src/roles/build/read-adoption.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 
 // src/core/config/module-type.ts
 function esmReadiness(fileName, packageType) {
@@ -253,11 +210,11 @@ function esmReadiness(fileName, packageType) {
 }
 
 // src/core/config/manifest.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { basename as basename2, join as join3 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { basename, join as join2 } from "path";
 function moduleScripts(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync3(join3(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
     return pkg.scripts ?? {};
   } catch {
     return {};
@@ -265,7 +222,7 @@ function moduleScripts(cwd) {
 }
 function moduleName2(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync3(join3(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
     return pkg.name;
   } catch {
     return void 0;
@@ -280,7 +237,7 @@ function selfCommand(cwd, flags) {
   return `node ${own.bin.replace(/^\.\//, "")} ${flags}`;
 }
 function adoptedPackageName(cwd) {
-  return readProjectPackageJson(cwd).name ?? readNxProjectName(cwd) ?? basename2(cwd);
+  return readProjectPackageJson(cwd).name ?? readNxProjectName(cwd) ?? basename(cwd);
 }
 function manifestOperation(cwd, scripts) {
   const own = readOwnPackage();
@@ -288,7 +245,7 @@ function manifestOperation(cwd, scripts) {
     scripts,
     devDependencies: { [own.name]: isSelfAdoption(cwd) ? "link:." : own.version }
   };
-  if (existsSync3(join3(cwd, "package.json"))) {
+  if (existsSync2(join2(cwd, "package.json"))) {
     return { kind: "merge-json", path: "package.json", value };
   }
   return {
@@ -298,6 +255,19 @@ function manifestOperation(cwd, scripts) {
   };
 }
 
+// src/core/config/project-json.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+function projectTargets(cwd) {
+  const path = join3(cwd, "project.json");
+  if (!existsSync3(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync3(path, "utf8")).targets;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/roles/build/presets/requirements.json
 var requirements_default = {
   svelte: {
@@ -413,19 +383,6 @@ var SENTINEL_OWNED_BUILD_PACKAGES = OWNED_PACKAGES.map(
   (entry) => entry.package
 );
 
-// src/roles/build/project-json.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
-function projectTargets(cwd) {
-  const path = join4(cwd, "project.json");
-  if (!existsSync4(path)) return void 0;
-  try {
-    return JSON.parse(readFileSync4(path, "utf8")).targets;
-  } catch {
-    return void 0;
-  }
-}
-
 // src/roles/build/adoption-drift.ts
 function buildAdoptionDrift(cwd) {
   const drift = [];
@@ -488,7 +445,7 @@ var NOT_ADOPTED = (configFile, unreadable = null) => ({
   unreadable
 });
 function buildConfigFile(cwd) {
-  return BUILD_CONFIG_FILES.find((name) => existsSync5(join5(cwd, name)));
+  return BUILD_CONFIG_FILES.find((name) => existsSync4(join4(cwd, name)));
 }
 function importsSpecifier(source, specifier) {
   const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -514,7 +471,7 @@ function readBuildConfigSource(cwd) {
   const configFile = buildConfigFile(cwd);
   if (!configFile) return void 0;
   try {
-    return readFileSync5(join5(cwd, configFile), "utf8");
+    return readFileSync4(join4(cwd, configFile), "utf8");
   } catch {
     return void 0;
   }
@@ -524,7 +481,7 @@ function readBuildAdoption(cwd) {
   if (!configFile) return NOT_ADOPTED(null);
   let source;
   try {
-    source = readFileSync5(join5(cwd, configFile), "utf8");
+    source = readFileSync4(join4(cwd, configFile), "utf8");
   } catch (error) {
     return NOT_ADOPTED(configFile, error instanceof Error ? error.message : String(error));
   }
@@ -560,7 +517,7 @@ function readBuildAdoption(cwd) {
 import { spawnSync } from "child_process";
 
 // src/core/config/tool-args.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { isAbsolute, resolve as resolve2 } from "path";
 function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
   const takesValue = new Set(valueFlags);
@@ -570,7 +527,7 @@ function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
   for (const arg of toolArgs) {
     const looksLikeOption = arg.startsWith("-");
     const target = isAbsolute(arg) ? arg : resolve2(cwd, arg);
-    if (!previousTakesValue && !looksLikeOption && existsSync6(target)) paths.push(arg);
+    if (!previousTakesValue && !looksLikeOption && existsSync5(target)) paths.push(arg);
     else options.push(arg);
     previousTakesValue = !arg.includes("=") && takesValue.has(arg);
   }
@@ -578,16 +535,16 @@ function splitToolArgs(cwd, toolArgs = [], { valueFlags = [] } = {}) {
 }
 
 // src/shared/resolve-bin.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { createRequire } from "module";
-import { delimiter, dirname as dirname2, join as join6 } from "path";
+import { delimiter, dirname, join as join5 } from "path";
 var require2 = createRequire(import.meta.url);
 function resolveBin(fromDir, name) {
   let dir = fromDir;
   for (; ; ) {
-    const candidate = join6(dir, "node_modules", ".bin", name);
-    if (existsSync7(candidate)) return candidate;
-    const parent = dirname2(dir);
+    const candidate = join5(dir, "node_modules", ".bin", name);
+    if (existsSync6(candidate)) return candidate;
+    const parent = dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -596,10 +553,10 @@ function binFromOwnInstall(packageName, binName) {
   try {
     const manifest = require2.resolve(`${packageName}/package.json`);
     const bin = require2(manifest).bin;
-    const relative5 = typeof bin === "string" ? bin : bin?.[binName];
-    if (!relative5) return void 0;
-    const executable = join6(dirname2(manifest), relative5);
-    return existsSync7(executable) ? executable : void 0;
+    const relative7 = typeof bin === "string" ? bin : bin?.[binName];
+    if (!relative7) return void 0;
+    const executable = join5(dirname(manifest), relative7);
+    return existsSync6(executable) ? executable : void 0;
   } catch {
     return void 0;
   }
@@ -611,12 +568,12 @@ function binSearchPath(cwd) {
 }
 
 // src/roles/build/plan.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
 
 // src/core/config/existing-command.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 
 // src/shared/jsonc.ts
 import { parse, printParseErrorCode } from "jsonc-parser";
@@ -635,7 +592,7 @@ function nxTargetCommand(cwd, target) {
   let project;
   try {
     project = parseJsonc(
-      readFileSync6(join7(cwd, "project.json"), "utf8"),
+      readFileSync5(join6(cwd, "project.json"), "utf8"),
       "project.json"
     );
   } catch {
@@ -666,8 +623,8 @@ function existingCommand(cwd, target) {
 }
 
 // src/core/config/nx-target.ts
-import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
 function nxTargetMetadataOperations(options) {
   const { targets } = options;
   if (Object.keys(targets).length === 0) return [];
@@ -678,7 +635,7 @@ function nxTargetOperations(options) {
   const names = Object.keys(targets);
   if (names.length === 0) return [];
   const operations = [];
-  if (existsSync8(join8(cwd, "project.json"))) {
+  if (existsSync7(join7(cwd, "project.json"))) {
     operations.push({
       kind: "remove-json-keys",
       path: "project.json",
@@ -732,8 +689,8 @@ function keepsOtherCommands(script, sentinelCommand) {
 }
 
 // src/roles/format/read-adoption.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
 
 // src/roles/format/config-policy.ts
 var FORMAT_CONFIG_FILE = ".oxfmtrc.json";
@@ -839,11 +796,11 @@ function sameValue(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
 }
 function readFormatAdoption(cwd) {
-  const path = join9(cwd, FORMAT_CONFIG_FILE);
-  if (!existsSync9(path)) return NOT_ADOPTED2(null);
+  const path = join8(cwd, FORMAT_CONFIG_FILE);
+  if (!existsSync8(path)) return NOT_ADOPTED2(null);
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync7(path, "utf8"), FORMAT_CONFIG_FILE);
+    parsed = parseJsonc(readFileSync6(path, "utf8"), FORMAT_CONFIG_FILE);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return NOT_ADOPTED2(FORMAT_CONFIG_FILE, `${FORMAT_CONFIG_FILE} could not be parsed (${reason})`);
@@ -944,8 +901,8 @@ function devTargetOperations(cwd, devScript) {
 }
 
 // src/roles/build/nest/adopt.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join9 } from "path";
 var NEST_CONFIG_FILE = "vite.config.mts";
 function asSource(value, depth) {
   const pad = "  ".repeat(depth);
@@ -994,9 +951,9 @@ function nestBuildOutputs(target) {
 }
 var OUT_DIR_IN_CONFIG = /^\s*outDir:\s*'([^']+)'/m;
 function nestOutputsFromConfig(cwd) {
-  const configPath = join10(cwd, NEST_CONFIG_FILE);
-  if (!existsSync10(configPath)) return void 0;
-  const outDir = OUT_DIR_IN_CONFIG.exec(readFileSync8(configPath, "utf8"))?.[1];
+  const configPath = join9(cwd, NEST_CONFIG_FILE);
+  if (!existsSync9(configPath)) return void 0;
+  const outDir = OUT_DIR_IN_CONFIG.exec(readFileSync7(configPath, "utf8"))?.[1];
   return outDir === void 0 ? void 0 : [`{workspaceRoot}/${outDir}`];
 }
 function nestAdoptionOperations(cwd, target) {
@@ -1005,9 +962,9 @@ function nestAdoptionOperations(cwd, target) {
 
 // src/roles/build/requirements.ts
 function atLeast(declared, needed) {
-  const parse2 = (value) => value.replace(/^[\^~>=<\s]+/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const left = parse2(declared);
-  const right = parse2(needed);
+  const parse4 = (value) => value.replace(/^[\^~>=<\s]+/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = parse4(declared);
+  const right = parse4(needed);
   for (let at = 0; at < Math.max(left.length, right.length); at++) {
     const a = left[at] ?? 0;
     const b = right[at] ?? 0;
@@ -1037,14 +994,15 @@ var movedSpecifiers = (toolchain) => new Set(toolchain.owned.map((entry) => entr
 var defaultExportNames = (toolchain) => Object.fromEntries(
   toolchain.owned.filter((entry) => entry.default !== void 0).map((entry) => [entry.specifier, entry.default])
 );
-function renderImport(bindings, presetSpecifier) {
+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}'`);
+  if (values.length > 0) lines.push(`import { ${render(values)} } from '${presetSpecifier}'${end}`);
   if (types.length > 0) {
-    lines.push(`import type { ${render(types)} } from '${presetSpecifier}'`);
+    lines.push(`import type { ${render(types)} } from '${presetSpecifier}'${end}`);
   }
   return lines.join("\n");
 }
@@ -1113,7 +1071,8 @@ function rewriteToolchainImports(toolchain, source, fileName) {
     const after = out.slice(span.end).match(/^\r?\n/)?.[0].length ?? 0;
     out = out.slice(0, span.start) + out.slice(span.end + after);
   }
-  out = out.slice(0, first.start) + renderImport(bindings, toolchain.presetSpecifier) + out.slice(first.end);
+  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,
@@ -1299,9 +1258,9 @@ function planNestService(context, webpackTarget) {
   };
 }
 function readConfigSource(cwd, configFile) {
-  if (!existsSync11(join11(cwd, configFile))) return "";
+  if (!existsSync10(join10(cwd, configFile))) return "";
   try {
-    return readFileSync9(join11(cwd, configFile), "utf8");
+    return readFileSync8(join10(cwd, configFile), "utf8");
   } catch {
     return "";
   }
@@ -1486,224 +1445,23 @@ var ViteDevAdapter = class extends ViteRoleAdapter {
 };
 
 // src/roles/build/declared-outputs.ts
-import { existsSync as existsSync13, rmSync, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join13 } from "path";
-
-// src/core/workspace-prep.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync } from "fs";
-import { dirname as dirname3, join as join12, relative as relative2 } from "path";
-
-// src/core/settings.ts
-var WORKSPACE_ROOT_MARKER = "nx.json";
-var DEFAULT_MAX_DIAGNOSTICS = 100;
-
-// src/core/workspace-prep.ts
-var OVERRIDE_KEY = "i18next>typescript";
-var NATIVE_TS_ALIAS = "@typescript/native";
-var WORKSPACE_YAML = "pnpm-workspace.yaml";
-var RELEASE_AGE_KEY = "minimumReleaseAgeExclude";
-var LIST_ITEM = /^(\s*)-\s+(.*?)\s*$/;
-var MAP_ENTRY = /^(\s+)(.*?):\s+(.*?)\s*$/;
-function findWorkspaceRoot(startDir) {
-  let dir = startDir;
-  for (; ; ) {
-    if (existsSync12(join12(dir, WORKSPACE_ROOT_MARKER))) return dir;
-    const parent = dirname3(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
-  }
-}
-function declaredNativeTs(pkg) {
-  const spec = pkg.dependencies?.[NATIVE_TS_ALIAS] ?? pkg.devDependencies?.[NATIVE_TS_ALIAS];
-  if (!spec) return void 0;
-  const version = spec.slice(spec.lastIndexOf("@") + 1).replace(/^[\^~>=<\s]+/, "");
-  return version || void 0;
-}
-function ensureI18nextSingleton(root, dryRun) {
-  const pkgPath = join12(root, "package.json");
-  if (!existsSync12(pkgPath)) return void 0;
-  const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
-  const want = declaredNativeTs(pkg);
-  if (!want) return void 0;
-  const yamlPath = join12(root, WORKSPACE_YAML);
-  if (!existsSync12(yamlPath)) return void 0;
-  const lines = readFileSync10(yamlPath, "utf8").split("\n");
-  const entry = findOverrideEntry(lines);
-  if (entry.valueIdx !== void 0 && entry.value === want) return void 0;
-  if (dryRun) return `would pin ${OVERRIDE_KEY} to ${want} in ${WORKSPACE_YAML} (i18next singleton)`;
-  applyOverride(lines, entry, want);
-  writeFileSync(yamlPath, lines.join("\n"));
-  return `pinned ${OVERRIDE_KEY} to ${want} in ${WORKSPACE_YAML} (i18next singleton)`;
-}
-function findOverrideEntry(lines) {
-  const blockIdx = lines.findIndex((line) => line.replace(/\s+$/, "") === "overrides:");
-  if (blockIdx === -1) return { indent: "  " };
-  let lastEntryIdx = blockIdx;
-  let indent = "  ";
-  for (let i = blockIdx + 1; i < lines.length; i++) {
-    const match = lines[i]?.match(MAP_ENTRY);
-    if (!match) break;
-    indent = match[1] ?? indent;
-    lastEntryIdx = i;
-    if ((match[2] ?? "").replace(/^['"]|['"]$/g, "") === OVERRIDE_KEY) {
-      return {
-        valueIdx: i,
-        value: (match[3] ?? "").replace(/^['"]|['"]$/g, ""),
-        blockIdx,
-        lastEntryIdx,
-        indent
-      };
-    }
-  }
-  return { blockIdx, lastEntryIdx, indent };
-}
-function applyOverride(lines, entry, want) {
-  const line = `${entry.indent}'${OVERRIDE_KEY}': ${want}`;
-  if (entry.valueIdx !== void 0) {
-    lines[entry.valueIdx] = line;
-    return;
-  }
-  if (entry.lastEntryIdx !== void 0) {
-    lines.splice(entry.lastEntryIdx + 1, 0, line);
-    return;
-  }
-  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
-  lines.push("overrides:", line, "");
-}
-function ensureReleaseAgeAllowList(root, dryRun) {
-  const yamlPath = join12(root, WORKSPACE_YAML);
-  if (!existsSync12(yamlPath)) return void 0;
-  const own = readOwnPackage().name;
-  const lines = readFileSync10(yamlPath, "utf8").split("\n");
-  const keyIdx = lines.findIndex((line) => line.replace(/\s+$/, "") === `${RELEASE_AGE_KEY}:`);
-  if (keyIdx === -1) return void 0;
-  let lastItemIdx = keyIdx;
-  let indent = "  ";
-  for (let i = keyIdx + 1; i < lines.length; i++) {
-    const match = lines[i]?.match(LIST_ITEM);
-    if (!match) break;
-    indent = match[1] ?? indent;
-    lastItemIdx = i;
-    if ((match[2] ?? "").replace(/^['"]|['"]$/g, "") === own) return void 0;
-  }
-  if (dryRun) return `would allow-list ${own} under ${RELEASE_AGE_KEY}`;
-  lines.splice(lastItemIdx + 1, 0, `${indent}- '${own}'`);
-  writeFileSync(yamlPath, lines.join("\n"));
-  return `allow-listed ${own} under ${RELEASE_AGE_KEY} in ${WORKSPACE_YAML}`;
-}
-var PRETTIER_IGNORE = ".prettierignore";
-var EXCLUSION_HEADER = "# @hublo/sentinel: modules formatted by oxfmt, not by the root Prettier";
-var ROOT_PRETTIER_CONFIGS = [
-  ".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 ensureFormatterExclusion(root, moduleDir, dryRun) {
-  const rel = relative2(root, moduleDir).replaceAll("\\", "/");
-  if (rel === "" || rel.startsWith("..")) return void 0;
-  const ignorePath = join12(root, PRETTIER_IGNORE);
-  const hasPrettier = existsSync12(ignorePath) || ROOT_PRETTIER_CONFIGS.some((name) => existsSync12(join12(root, name)));
-  if (!hasPrettier) return void 0;
-  const pattern = `/${rel}/`;
-  const existing = existsSync12(ignorePath) ? readFileSync10(ignorePath, "utf8") : "";
-  const lines = existing.split("\n");
-  if (lines.some((line) => line.trim().replace(/\/$/, "") === pattern.replace(/\/$/, ""))) {
-    return void 0;
-  }
-  if (dryRun) return `would exclude ${rel} from the root Prettier (${PRETTIER_IGNORE})`;
-  const headerIdx = lines.findIndex((line) => line.trim() === EXCLUSION_HEADER);
-  if (headerIdx === -1) {
-    const prefix = existing.trim() === "" ? "" : `${existing.replace(/\n*$/, "")}
-
-`;
-    writeFileSync(ignorePath, `${prefix}${EXCLUSION_HEADER}
-${pattern}
-`);
-  } else {
-    let end = headerIdx + 1;
-    while (end < lines.length && lines[end]?.trim().startsWith("/")) end += 1;
-    const managed = [...lines.slice(headerIdx + 1, end), pattern].sort();
-    writeFileSync(
-      ignorePath,
-      [...lines.slice(0, headerIdx + 1), ...managed, ...lines.slice(end)].join("\n")
-    );
-  }
-  return `excluded ${rel} from the root Prettier (${PRETTIER_IGNORE}): it formats itself now`;
-}
-function ensureWorkspacePrep(opts) {
-  const dryRun = Boolean(opts.dryRun);
-  return [
-    ensureI18nextSingleton(opts.root, dryRun),
-    ensureReleaseAgeAllowList(opts.root, dryRun),
-    opts.formattedModule === void 0 ? void 0 : ensureFormatterExclusion(opts.root, opts.formattedModule, dryRun)
-  ].filter((message) => message !== void 0);
-}
-function inspectWorkspacePrep(root) {
-  const entries = [];
-  let pkg = {};
-  const pkgPath = join12(root, "package.json");
-  if (existsSync12(pkgPath)) {
-    try {
-      pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
-    } catch {
-      pkg = {};
-    }
-  }
-  const yamlPath = join12(root, WORKSPACE_YAML);
-  const yaml = existsSync12(yamlPath) ? readFileSync10(yamlPath, "utf8") : void 0;
-  const pinned = yaml === void 0 ? void 0 : findOverrideEntry(yaml.split("\n")).value;
-  if (pinned !== void 0) {
-    const stillForks = declaredNativeTs(pkg);
-    entries.push({
-      rule: `${WORKSPACE_YAML} \u2192 overrides.${OVERRIDE_KEY}`,
-      reason: stillForks === void 0 ? `pinned to ${pinned}, but the root no longer declares ${NATIVE_TS_ALIAS}, so nothing forks any more. This override is now dead config and can be removed.` : `pinned to ${pinned}, matching the second TypeScript the root declares (${NATIVE_TS_ALIAS}). It re-resolves i18next for EVERY module that depends on it, not only adopted ones. It retires with the second TypeScript.`
-    });
-  }
-  const legacy = pkg.pnpm?.overrides?.[OVERRIDE_KEY];
-  if (legacy !== void 0) {
-    entries.push({
-      rule: `package.json \u2192 pnpm.overrides.${OVERRIDE_KEY}`,
-      reason: `pinned to ${legacy}, but pnpm 11 no longer reads the \`pnpm\` field of package.json and says nothing about it, so this override is not applied. Move it to ${WORKSPACE_YAML} under \`overrides:\`, which pnpm 10 and 11 both read.`
-    });
-  }
-  const own = readOwnPackage().name;
-  if (yaml !== void 0) {
-    const listed = new RegExp(`^\\s*-\\s*['"]?${own.replace("/", "\\/")}['"]?\\s*$`, "m").test(yaml);
-    if (listed) {
-      const gated = new RegExp(`^\\s*minimumReleaseAge\\s*:`, "m").test(yaml);
-      entries.push({
-        rule: `${WORKSPACE_YAML} \u2192 ${RELEASE_AGE_KEY}: ${own}`,
-        reason: gated ? `${own} is exempt from this workspace's release-age gate, so a freshly published version installs instead of being held. That is a standing exemption from a supply-chain control: the exposure is one bump wide, since the version is pinned and the lockfile carries its integrity, so a re-publish of the same version does not pass. Retire it once a bump can simply wait out the window.` : `${own} is allow-listed, but this workspace no longer sets minimumReleaseAge, so there is no gate to be exempt from. This entry is now dead config and can be removed.`
-      });
-    }
-  }
-  return entries;
-}
-
-// src/roles/build/declared-outputs.ts
+import { existsSync as existsSync11, rmSync, statSync, writeFileSync } from "fs";
+import { join as join11 } from "path";
 function declaredBuildTarget(cwd) {
   return readProjectPackageJson(cwd).nx?.targets?.[BUILD_SCRIPT_NAME];
 }
 function resolveOutputToken(token, cwd) {
-  if (token.startsWith("{projectRoot}/")) return join13(cwd, token.slice("{projectRoot}/".length));
+  if (token.startsWith("{projectRoot}/")) return join11(cwd, token.slice("{projectRoot}/".length));
   if (token.startsWith("{workspaceRoot}/")) {
     const root = findWorkspaceRoot(cwd);
-    return root === void 0 ? void 0 : join13(root, token.slice("{workspaceRoot}/".length));
+    return root === void 0 ? void 0 : join11(root, token.slice("{workspaceRoot}/".length));
   }
-  return join13(cwd, token);
+  return join11(cwd, token);
 }
 function buildStamp(cwd) {
-  const marker = join13(cwd, `.sentinel-build-stamp-${process.pid}`);
+  const marker = join11(cwd, `.sentinel-build-stamp-${process.pid}`);
   try {
-    writeFileSync2(marker, "");
+    writeFileSync(marker, "");
     const stamp = statSync(marker).mtimeMs;
     rmSync(marker, { force: true });
     return stamp;
@@ -1712,7 +1470,7 @@ function buildStamp(cwd) {
   }
 }
 function writtenSince(path, startedAt) {
-  if (!existsSync13(path)) return false;
+  if (!existsSync11(path)) return false;
   try {
     return statSync(path).mtimeMs >= startedAt;
   } catch {
@@ -1861,12 +1619,12 @@ function registerBuild() {
 
 // src/roles/format/adapters/oxfmt/oxfmt.adapter.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 
 // src/core/config/has-source.ts
 import { readdirSync } from "fs";
-import { extname, join as join14, relative as relative3 } from "path";
+import { extname, join as join12, relative as relative2 } from "path";
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1917,7 +1675,7 @@ function hasSourceFiles(cwd, extensions) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!SKIP_DIRECTORIES.has(entry.name)) queue.push(join14(dir, entry.name));
+        if (!SKIP_DIRECTORIES.has(entry.name)) queue.push(join12(dir, entry.name));
         continue;
       }
       if (wanted.has(extname(entry.name))) return true;
@@ -1938,12 +1696,12 @@ function listSourceFiles(cwd, extensions) {
       continue;
     }
     for (const entry of entries) {
-      const full = join14(dir, entry.name);
+      const full = join12(dir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRECTORIES.has(entry.name)) queue.push(full);
         continue;
       }
-      if (wanted.has(extname(entry.name))) found.push(relative3(cwd, full));
+      if (wanted.has(extname(entry.name))) found.push(relative2(cwd, full));
     }
   }
   return found;
@@ -1984,8 +1742,8 @@ function writesWhenRewritten(name, command) {
 var CHECK_SCRIPT_NAMES = /* @__PURE__ */ new Set(["lint", "format", "check", "test", "typecheck", "verify"]);
 
 // src/roles/format/inherited-ignores.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { join as join13 } from "path";
 var ROOT_IGNORE_FILE = ".prettierignore";
 function isPattern(line) {
   const trimmed = line.trim();
@@ -2001,11 +1759,11 @@ function toModulePattern(pattern) {
 }
 function inheritedIgnorePatterns(workspaceRoot) {
   if (!workspaceRoot) return [];
-  const path = join15(workspaceRoot, ROOT_IGNORE_FILE);
-  if (!existsSync14(path)) return [];
+  const path = join13(workspaceRoot, ROOT_IGNORE_FILE);
+  if (!existsSync12(path)) return [];
   let contents;
   try {
-    contents = readFileSync11(path, "utf8");
+    contents = readFileSync9(path, "utf8");
   } catch {
     return [];
   }
@@ -2050,13 +1808,13 @@ function needsSvelteCompiler(output) {
 }
 
 // src/roles/format/prettier-config.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
 
 // src/roles/format/resolve-oxfmt.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname4, join as join16 } from "path";
+import { dirname as dirname2, join as join14 } from "path";
 function resolveOxfmt(cwd) {
   return resolveBin(cwd, "oxfmt") ?? binFromOwnInstall("oxfmt", "oxfmt");
 }
@@ -2085,8 +1843,8 @@ function configSchema() {
 function readConfigSchema() {
   try {
     const manifest = createRequire2(import.meta.url).resolve("oxfmt/package.json");
-    const schemaPath = join16(dirname4(manifest), "configuration_schema.json");
-    return JSON.parse(readFileSync12(schemaPath, "utf8"));
+    const schemaPath = join14(dirname2(manifest), "configuration_schema.json");
+    return JSON.parse(readFileSync10(schemaPath, "utf8"));
   } catch {
     return void 0;
   }
@@ -2117,14 +1875,14 @@ function toOxfmtOverrides(value) {
   return { overrides, unresolved };
 }
 function readPrettierSettings(cwd) {
-  const file = PRETTIER_CONFIG_FILES.find((name) => existsSync15(join17(cwd, name)));
+  const file = PRETTIER_CONFIG_FILES.find((name) => existsSync13(join15(cwd, name)));
   if (!file) return { options: {}, unresolved: [] };
   if (/\.(js|cjs|mjs)$/.test(file)) {
     return { options: {}, file, unresolved: [`${file} is JavaScript, so it was not executed`] };
   }
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync13(join17(cwd, file), "utf8"), file);
+    parsed = parseJsonc(readFileSync11(join15(cwd, file), "utf8"), file);
   } catch {
     return { options: {}, file, unresolved: [`${file} could not be parsed`] };
   }
@@ -2235,7 +1993,7 @@ var OxfmtAdapter = class extends BaseAdapter {
       manifestOperation(context.cwd, this.formatScripts(context.cwd))
     ];
     const prettierConfigs = PRETTIER_CONFIG_FILES.filter(
-      (name) => existsSync16(join18(context.cwd, name))
+      (name) => existsSync14(join16(context.cwd, name))
     );
     for (const name of prettierConfigs) operations.push({ kind: "delete", path: name });
     const removableDeps = this.modulePrettierDependencies(context.cwd);
@@ -2475,7 +2233,7 @@ var OxfmtAdapter = class extends BaseAdapter {
   modulePrettierDependencies(cwd) {
     const isPrettierPackage = (name) => name === "prettier" || name.startsWith("prettier-plugin-") || name.startsWith("@prettier/");
     try {
-      const manifest = JSON.parse(readFileSync14(join18(cwd, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync12(join16(cwd, "package.json"), "utf8"));
       return Object.keys(manifest.devDependencies ?? {}).filter(isPrettierPackage).map((name) => ["devDependencies", name]);
     } catch {
       return [];
@@ -2557,8 +2315,8 @@ function registerFormat() {
 
 // src/roles/lint/adapters/oxlint/oxlint.adapter.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync22, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync20, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join26 } from "path";
 
 // src/core/config/deferred-rules.ts
 function deferredRuleNames(rules) {
@@ -2567,7 +2325,7 @@ function deferredRuleNames(rules) {
 
 // src/core/fix-report.ts
 import { statSync as statSync2 } from "fs";
-import { join as join19 } from "path";
+import { join as join17 } from "path";
 var CONFIG_REFUSED = /failed to parse .*config|invalid config file/i;
 function readFailure(output) {
   const lines = output.split("\n").map((line2) => line2.trim());
@@ -2587,7 +2345,7 @@ function fingerprint(path) {
 function snapshotFiles(cwd, extensions) {
   const snapshot = /* @__PURE__ */ new Map();
   for (const file of listSourceFiles(cwd, extensions)) {
-    const mark = fingerprint(join19(cwd, file));
+    const mark = fingerprint(join17(cwd, file));
     if (mark !== void 0) snapshot.set(file, mark);
   }
   return snapshot;
@@ -2595,7 +2353,7 @@ function snapshotFiles(cwd, extensions) {
 function changedSince(cwd, before, extensions) {
   const changed = [];
   for (const file of listSourceFiles(cwd, extensions)) {
-    const now = fingerprint(join19(cwd, file));
+    const now = fingerprint(join17(cwd, file));
     if (now === void 0) continue;
     if (before.get(file) !== now) changed.push(file);
   }
@@ -2614,8 +2372,8 @@ function describeFixOutcome(outcome, toolLabel) {
 }
 
 // src/roles/lint/module-baseline.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
+import { join as join18 } from "path";
 var LINT_BASELINE_FILE = ".oxlintrc.baseline.json";
 var LINT_MEASURE_FILE = ".oxlintrc.measure.json";
 var LINT_BASELINE_SPECIFIER = `./${LINT_BASELINE_FILE}`;
@@ -2659,11 +2417,11 @@ function describeHolds(holds) {
   return `held ${holds.length} rule(s) at \`warn\` for this module, covering ${total} violation(s) that were already there: ${listed}${rest}. They are written to ${LINT_BASELINE_FILE}, they still report, and they return to \`error\` once fixed and re-initialized`;
 }
 function heldRules(cwd) {
-  const path = join20(cwd, LINT_BASELINE_FILE);
-  if (!existsSync17(path)) return [];
+  const path = join18(cwd, LINT_BASELINE_FILE);
+  if (!existsSync15(path)) return [];
   try {
     const parsed = parseJsonc(
-      readFileSync15(path, "utf8"),
+      readFileSync13(path, "utf8"),
       LINT_BASELINE_FILE
     );
     return Object.keys(parsed.rules ?? {});
@@ -4489,14 +4247,14 @@ function downgradedRulesFor(preset) {
 }
 
 // src/roles/lint/extra-layers.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { isAbsolute as isAbsolute2, join as join21, resolve as resolve3 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { isAbsolute as isAbsolute2, join as join19, resolve as resolve3 } from "path";
 function ruleCount(cwd, specifier) {
   const path = isAbsolute2(specifier) ? specifier : resolve3(cwd, specifier);
-  if (!existsSync18(path)) return void 0;
+  if (!existsSync16(path)) return void 0;
   try {
     const parsed = parseJsonc(
-      readFileSync16(path, "utf8"),
+      readFileSync14(path, "utf8"),
       specifier
     );
     return Object.keys(parsed.rules ?? {}).length;
@@ -4516,7 +4274,7 @@ function extraLayers(cwd, extendsList) {
 function committedExtendsList(cwd, configFile) {
   try {
     const parsed = parseJsonc(
-      readFileSync16(join21(cwd, configFile), "utf8"),
+      readFileSync14(join19(cwd, configFile), "utf8"),
       configFile
     );
     return Array.isArray(parsed.extends) ? parsed.extends.filter((entry) => typeof entry === "string") : [];
@@ -4575,8 +4333,8 @@ function errorCountsByConfigRule(stdout) {
 }
 
 // src/core/config/read-adoption.ts
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
+import { join as join21 } from "path";
 
 // src/core/config/owned-keys.ts
 function presetOwnedKeys(config, permitted, presetSets) {
@@ -4591,12 +4349,12 @@ function localOnlyKeys(config, permitted, presetSets) {
 }
 
 // src/core/config/resolve-config-target.ts
-import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { join as join20 } from "path";
 function readExtends(absolutePath) {
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync17(absolutePath, "utf8"), absolutePath);
+    parsed = parseJsonc(readFileSync15(absolutePath, "utf8"), absolutePath);
   } catch {
     return [];
   }
@@ -4610,8 +4368,8 @@ function resolveConfigTarget(moduleDir, { candidates, markers, fallback }) {
   let existing;
   let existingExtendsSomething = false;
   for (const candidate of candidates) {
-    const absolutePath = join22(moduleDir, candidate);
-    if (!existsSync19(absolutePath)) continue;
+    const absolutePath = join20(moduleDir, candidate);
+    if (!existsSync17(absolutePath)) continue;
     const chain = readExtends(absolutePath);
     if (existing === void 0) {
       existing = candidate;
@@ -4644,12 +4402,12 @@ var NOT_ADOPTED3 = (configFile, unreadable = null) => ({
 });
 function readAdoption(cwd, options) {
   const target = resolveConfigTarget(cwd, options);
-  if (target.reason === "none" || !existsSync20(join23(cwd, target.path))) {
+  if (target.reason === "none" || !existsSync18(join21(cwd, target.path))) {
     return NOT_ADOPTED3(target.reason === "none" ? null : target.path);
   }
   let parsed;
   try {
-    parsed = parseJsonc(readFileSync18(join23(cwd, target.path), "utf8"), target.path);
+    parsed = parseJsonc(readFileSync16(join21(cwd, target.path), "utf8"), target.path);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     return NOT_ADOPTED3(target.path, `${target.path} could not be parsed (${reason})`);
@@ -4683,10 +4441,10 @@ function readLintAdoption(cwd) {
 }
 
 // src/roles/lint/resolve-oxlint.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { delimiter as delimiter2, dirname as dirname5, join as join24 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { delimiter as delimiter2, dirname as dirname3, join as join22 } from "path";
+import { fileURLToPath } from "url";
 var PACKAGE_OF = {
   oxlint: "oxlint",
   tsgolint: "oxlint-tsgolint"
@@ -4701,7 +4459,7 @@ function canRunTypeAware(cwd) {
 function oxlintPath(cwd, env) {
   const shim = tsgolintShim(cwd);
   if (!shim) return env.PATH;
-  return [dirname5(shim), env.PATH].filter(Boolean).join(delimiter2);
+  return [dirname3(shim), env.PATH].filter(Boolean).join(delimiter2);
 }
 function tsgolintShim(cwd) {
   const fromModule = resolveBin(cwd, "tsgolint");
@@ -4709,32 +4467,49 @@ function tsgolintShim(cwd) {
   const candidates = [];
   for (const owner of ["oxlint-tsgolint", "oxlint"]) {
     try {
-      const packageDir = dirname5(require3.resolve(`${owner}/package.json`));
-      candidates.push(join24(packageDir, "node_modules", ".bin", "tsgolint"));
-      candidates.push(join24(packageDir, "..", ".bin", "tsgolint"));
+      const packageDir = dirname3(require3.resolve(`${owner}/package.json`));
+      candidates.push(join22(packageDir, "node_modules", ".bin", "tsgolint"));
+      candidates.push(join22(packageDir, "..", ".bin", "tsgolint"));
     } catch {
     }
   }
   try {
-    const ownRoot = dirname5(require3.resolve("@hublo/sentinel/package.json"));
-    candidates.push(join24(ownRoot, "node_modules", ".bin", "tsgolint"));
+    const ownRoot = dirname3(require3.resolve("@hublo/sentinel/package.json"));
+    candidates.push(join22(ownRoot, "node_modules", ".bin", "tsgolint"));
   } catch {
-    candidates.push(resolveBin(dirname5(fileURLToPath2(import.meta.url)), "tsgolint") ?? "");
+    candidates.push(resolveBin(dirname3(fileURLToPath(import.meta.url)), "tsgolint") ?? "");
   }
-  return candidates.find((candidate) => candidate !== "" && existsSync21(candidate));
+  return candidates.find((candidate) => candidate !== "" && existsSync19(candidate));
 }
 function oxlintSearchPath(cwd) {
   return binSearchPath(cwd);
 }
 
 // src/roles/lint/adapters/oxlint/plan.ts
-import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
+import { join as join25 } from "path";
 
 // src/roles/lint/eslint-ignores.ts
-import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { join as join23 } from "path";
 import { parseSync as parseSync2 } 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/lint/eslint-ignores.ts
 var OPAQUE_SOURCE = /\b(includeIgnoreFile)\s*\([^)]*\)/g;
 function toOxlintPattern(pattern) {
   return pattern.replace(/^\.\//, "");
@@ -4745,11 +4520,11 @@ function readRootEslintIgnores(root) {
   return { patterns: patterns.filter((pattern) => pattern.startsWith("**/")), unresolved };
 }
 function readEslintIgnores(cwd) {
-  const config = ESLINT_CONFIG_FILES.map((name) => join25(cwd, name)).find((path) => existsSync22(path));
+  const config = ESLINT_CONFIG_FILES.map((name) => join23(cwd, name)).find((path) => existsSync20(path));
   if (!config) return { patterns: [], unresolved: [] };
   let source;
   try {
-    source = readFileSync19(config, "utf8");
+    source = readFileSync17(config, "utf8");
   } catch {
     return { patterns: [], unresolved: [] };
   }
@@ -4780,16 +4555,6 @@ function readEslintIgnores(cwd) {
   });
   return { patterns: [...patterns], unresolved: [...unresolved] };
 }
-function walk(node, visit) {
-  if (!node || typeof node !== "object") return;
-  const current = node;
-  if (typeof current.type === "string") visit(current);
-  for (const key of Object.keys(current)) {
-    const value = current[key];
-    if (Array.isArray(value)) for (const entry of value) walk(entry, visit);
-    else if (value && typeof value === "object") walk(value, visit);
-  }
-}
 function calleeName(node) {
   const callee = node.callee;
   return callee?.type === "Identifier" ? callee.name : void 0;
@@ -4850,8 +4615,8 @@ function lintPresetFor(preset) {
 }
 
 // src/roles/lint/rename-suppressions.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync20, statSync as statSync3 } from "fs";
-import { join as join26, relative as relative4 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync3 } from "fs";
+import { join as join24, relative as relative3 } from "path";
 var SOURCE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -4898,7 +4663,7 @@ function* sourceFiles(dir) {
     return;
   }
   for (const entry of entries) {
-    const full = join26(dir, entry);
+    const full = join24(dir, entry);
     let isDirectory;
     try {
       isDirectory = statSync3(full).isDirectory();
@@ -4918,7 +4683,7 @@ function findSuppressionRenames(cwd, renames) {
   for (const file of sourceFiles(cwd)) {
     let content;
     try {
-      content = readFileSync20(file, "utf8");
+      content = readFileSync18(file, "utf8");
     } catch {
       continue;
     }
@@ -4942,7 +4707,7 @@ function findSuppressionRenames(cwd, renames) {
       }
       if (hits.length === 0) return;
       found.push({
-        file: relative4(cwd, file),
+        file: relative3(cwd, file),
         line: index + 1,
         from: line,
         to: line.replace(rules, renamed.join(", ")),
@@ -5046,7 +4811,7 @@ function plan2(context) {
       keys: removableDeps
     });
   }
-  const eslintConfigs = ESLINT_CONFIG_FILES.filter((name) => existsSync23(join27(context.cwd, name)));
+  const eslintConfigs = ESLINT_CONFIG_FILES.filter((name) => existsSync21(join25(context.cwd, name)));
   for (const name of eslintConfigs) operations.push({ kind: "delete", path: name });
   operations.push(
     ...nxTargetOperations({
@@ -5144,7 +4909,7 @@ function lintScripts(cwd) {
 function committedExtends(cwd) {
   try {
     const parsed = parseJsonc(
-      readFileSync21(join27(cwd, LINT_CONFIG_FILE), "utf8"),
+      readFileSync19(join25(cwd, LINT_CONFIG_FILE), "utf8"),
       LINT_CONFIG_FILE
     );
     return Array.isArray(parsed.extends) ? parsed.extends.filter((entry) => typeof entry === "string") : [];
@@ -5155,7 +4920,7 @@ function committedExtends(cwd) {
 function committedIgnorePatterns(cwd) {
   try {
     const parsed = parseJsonc(
-      readFileSync21(join27(cwd, LINT_CONFIG_FILE), "utf8"),
+      readFileSync19(join25(cwd, LINT_CONFIG_FILE), "utf8"),
       LINT_CONFIG_FILE
     );
     return Array.isArray(parsed.ignorePatterns) ? parsed.ignorePatterns.filter((entry) => typeof entry === "string") : [];
@@ -5167,7 +4932,7 @@ function moduleEslintDependencies(cwd) {
   const isEslintPackage = (name) => name === "eslint" || name === "@types/eslint" || name === "typescript-eslint" || name.startsWith("@typescript-eslint/") || name.startsWith("eslint-plugin-") || name.startsWith("eslint-config-") || name.startsWith("@eslint/");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync21(join27(cwd, "package.json"), "utf8"));
+    manifest = JSON.parse(readFileSync19(join25(cwd, "package.json"), "utf8"));
   } catch {
     return [];
   }
@@ -5301,23 +5066,23 @@ ${result.stderr ?? ""}`);
    * build the developer can see, rather than a silent half-adoption they cannot.
    */
   writeModuleBaseline(ctx, oxlint, env) {
-    const configPath = join28(ctx.cwd, LINT_CONFIG_FILE);
-    const baselinePath = join28(ctx.cwd, LINT_BASELINE_FILE);
-    if (!existsSync24(configPath)) return;
+    const configPath = join26(ctx.cwd, LINT_CONFIG_FILE);
+    const baselinePath = join26(ctx.cwd, LINT_BASELINE_FILE);
+    if (!existsSync22(configPath)) return;
     let config;
     try {
       config = parseJsonc(
-        readFileSync22(configPath, "utf8"),
+        readFileSync20(configPath, "utf8"),
         LINT_CONFIG_FILE
       );
     } catch {
       return;
     }
     const current = Array.isArray(config.extends) ? config.extends : [];
-    const measurePath = join28(ctx.cwd, LINT_MEASURE_FILE);
+    const measurePath = join26(ctx.cwd, LINT_MEASURE_FILE);
     let measured;
     try {
-      writeFileSync3(
+      writeFileSync2(
         measurePath,
         `${JSON.stringify({ ...config, extends: extendsWithBaseline(current, false) }, null, 2)}
 `
@@ -5349,7 +5114,7 @@ ${result.stderr ?? ""}`);
     const holds = holdsFrom(errorCountsByConfigRule(measured.stdout ?? ""));
     const next = extendsWithBaseline(current, holds.length > 0);
     if (holds.length > 0) {
-      writeFileSync3(baselinePath, renderBaseline(holds, readOwnPackage().version));
+      writeFileSync2(baselinePath, renderBaseline(holds, readOwnPackage().version));
       process.stderr.write(`  ${palette(process.stderr).warn(describeHolds(holds))}
 `);
     } else {
@@ -5357,12 +5122,12 @@ ${result.stderr ?? ""}`);
     }
     if (next.length !== current.length || next.some((entry, at) => entry !== current[at])) {
       config.extends = next;
-      writeFileSync3(configPath, `${JSON.stringify(config, null, 2)}
+      writeFileSync2(configPath, `${JSON.stringify(config, null, 2)}
 `);
     }
   }
   async run(ctx) {
-    if (!existsSync24(join28(ctx.cwd, LINT_CONFIG_FILE))) {
+    if (!existsSync22(join26(ctx.cwd, LINT_CONFIG_FILE))) {
       process.stderr.write(
         `sentinel lint(oxlint): no ${LINT_CONFIG_FILE} in this module; run \`sentinel --init --lint\` to adopt.
 `
@@ -5510,7 +5275,7 @@ ${result.stderr ?? ""}`);
     let stub;
     try {
       stub = parseJsonc(
-        readFileSync22(join28(cwd, LINT_CONFIG_FILE), "utf8"),
+        readFileSync20(join26(cwd, LINT_CONFIG_FILE), "utf8"),
         LINT_CONFIG_FILE
       );
     } catch {
@@ -5520,7 +5285,7 @@ ${result.stderr ?? ""}`);
     for (const entry of stub.extends ?? []) {
       try {
         const preset = parseJsonc(
-          readFileSync22(join28(cwd, entry), "utf8"),
+          readFileSync20(join26(cwd, entry), "utf8"),
           entry
         );
         for (const rule of Object.keys(preset.rules ?? {})) names.add(rule);
@@ -5590,14 +5355,14 @@ ${result.stderr ?? ""}`);
     let parsed;
     try {
       parsed = parseJsonc(
-        readFileSync22(join28(cwd, LINT_CONFIG_FILE), "utf8"),
+        readFileSync20(join26(cwd, LINT_CONFIG_FILE), "utf8"),
         LINT_CONFIG_FILE
       );
     } catch {
       return void 0;
     }
     const targets = Array.isArray(parsed.extends) ? parsed.extends.filter((entry) => typeof entry === "string") : typeof parsed.extends === "string" ? [parsed.extends] : [];
-    return targets.find((target) => !existsSync24(join28(cwd, target)));
+    return targets.find((target) => !existsSync22(join26(cwd, target)));
   }
   /** Announce what is not enforced, so reduced coverage is never silent. */
   announceDisabled(preset) {
@@ -5627,89 +5392,3140 @@ function registerLint() {
   setDefaultRunner("lint", "oxlint");
 }
 
-// src/roles/typescript/adapters/tsc/tsc.adapter.ts
+// src/roles/test/adapters/vitest/vitest.adapter.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
-import { createRequire as createRequire4 } from "module";
-import { join as join30 } from "path";
 
-// src/roles/typescript/presets/nest.json
-var nest_default2 = {
-  compilerOptions: {
-    module: "esnext",
-    moduleResolution: "bundler",
-    types: ["node"],
-    experimentalDecorators: true,
-    emitDecoratorMetadata: true,
-    declaration: true,
-    sourceMap: true
-  },
-  notes: {
-    module: "the backends are webpack-bundled and tsc only typechecks, so the module format is the bundler's concern; `bundler` resolution is what the repo already uses, and the only Node-friendly option TS7 still accepts since it removed classic `node`",
-    target: "deliberately NOT set, here or in lib: those are environment the repo base owns. Overriding target flips useDefineForClassFields (TS2612) and narrowing lib drops DOM (GLfloat); both REPLACE the base rather than merge"
-  }
+// src/roles/test/presets/toolchain.json
+var toolchain_default2 = {
+  $comment: "The test toolchain sentinel owns. Same shape and same rule as the build one: a single table drives what `--init` removes from a module's package.json, which import specifiers move, and the name each default import is re-exported under, so the three cannot disagree.",
+  owned: [
+    {
+      package: "vitest",
+      specifier: "vitest/config",
+      named: ["defineConfig", "mergeConfig"],
+      types: ["ConfigEnv", "TestUserConfig", "ViteUserConfig"],
+      why: "the runner itself, declared at the workspace ROOT today, which is what stops a module being testable on its own. Note the package is `vitest` and the specifier is `vitest/config`: the same split as nitro on the build side, and the reason one table holds both."
+    },
+    {
+      package: "vite",
+      specifier: "vite",
+      named: ["loadEnv"],
+      why: "`loadEnv` has no equivalent in `vitest/config`, and two of the six configs import it from vite to build their test env. Re-exported here rather than claimed: the BUILD role owns the `vite` package, and two roles owning one package is how a version conflict gets written down twice."
+    }
+  ]
 };
 
-// src/roles/typescript/presets/node.json
-var node_default2 = {
-  compilerOptions: {
-    module: "esnext",
-    moduleResolution: "bundler",
-    types: ["node"],
-    declaration: true
-  },
-  notes: {
-    module: "esnext/bundler like the react and nest presets, matching a monorepo whose libs are bundler-resolved in practice. NOT NodeNext: that would force its stricter ESM rules onto libs the repo resolves through a bundler"
-  }
-};
+// src/roles/test/preset-data.ts
+var OWNED_TEST_PACKAGES = toolchain_default2.owned;
 
-// src/roles/typescript/presets/react.json
-var react_default2 = {
-  compilerOptions: {
-    target: "ES2023",
-    lib: ["ES2023", "DOM", "DOM.Iterable"],
-    module: "ESNext",
-    moduleResolution: "bundler",
-    jsx: "react-jsx",
-    useDefineForClassFields: true,
-    isolatedModules: true,
-    moduleDetection: "force",
-    noEmit: true,
-    noUncheckedSideEffectImports: true
-  },
-  notes: {
-    noEmit: "vite owns the build; tsc only typechecks here"
-  }
+// src/roles/test/config-policy.ts
+var TEST_PRESET_SPECIFIERS = {
+  react: "@hublo/sentinel/test/react",
+  nest: "@hublo/sentinel/test/nest"
 };
-
-// src/roles/typescript/presets/shared.json
-var shared_default2 = {
-  $schema: "https://json.schemastore.org/tsconfig",
-  compilerOptions: {
-    strict: true,
-    noFallthroughCasesInSwitch: true,
-    forceConsistentCasingInFileNames: true,
-    esModuleInterop: true,
-    skipLibCheck: true
-  },
-  deferred: {
-    noImplicitAny: {
-      phase: 2,
-      reason: "the implicit-any migration (TS70xx)"
-    },
-    noUnusedLocals: {
-      phase: 2,
-      reason: "unused-local cleanup (TS6133)"
-    },
-    noUnusedParameters: {
-      phase: 2,
-      reason: "unused-parameter cleanup (TS6133)"
+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/typescript/preset-data.ts
-var SHARED = shared_default2;
+// src/roles/test/jest-migration.ts
+import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
+import { join as join35 } from "path";
+
+// src/roles/test/codemod/migrate-module.ts
+import { readdirSync as readdirSync6, readFileSync as readFileSync25, statSync as statSync6 } from "fs";
+import { join as join31 } from "path";
+import { parseSync as parseSync8 } from "oxc-parser";
+
+// src/roles/test/read-adoption.ts
+import { existsSync as existsSync23, readFileSync as readFileSync21, readdirSync as readdirSync3 } from "fs";
+import { join as join27, relative as relative4 } from "path";
+var JEST_CONFIG_FILES = [
+  "jest.config.ts",
+  "jest.config.js",
+  "jest.prisma.config.ts",
+  "jest.functional.config.ts",
+  "jest.integration-config.ts"
+];
+function testConfigFile(cwd) {
+  return TEST_CONFIG_FILES.find((name) => existsSync23(join27(cwd, name)));
+}
+function jestConfigFiles(cwd) {
+  return JEST_CONFIG_FILES.filter((name) => existsSync23(join27(cwd, name)));
+}
+function rootJestConfigFiles(cwd) {
+  const root = findWorkspaceRoot(cwd);
+  if (root === void 0 || root === cwd) return [];
+  return JEST_CONFIG_FILES.filter((name) => existsSync23(join27(root, name)));
+}
+var TEST_FILE = /[.-](spec|test)\.[cm]?[jt]sx?$/;
+var NOT_WALKED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".nx", ".turbo"]);
+function hasTestFiles(cwd) {
+  return walkTestFiles(cwd, true).length > 0;
+}
+function listTestFiles(cwd) {
+  return walkTestFiles(cwd, false).sort();
+}
+function walkTestFiles(cwd, stopAtFirst) {
+  const found = [];
+  const stack = [cwd];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!NOT_WALKED.has(entry.name)) stack.push(join27(dir, entry.name));
+      } else if (TEST_FILE.test(entry.name)) {
+        found.push(relative4(cwd, join27(dir, entry.name)).replaceAll("\\", "/"));
+        if (stopAtFirst) return found;
+      }
+    }
+  }
+  return found;
+}
+function readTestConfigSource(cwd, fileName) {
+  try {
+    return readFileSync21(join27(cwd, fileName), "utf8");
+  } catch {
+    return "";
+  }
+}
+function importsPreset2(source) {
+  return ALL_TEST_PRESET_SPECIFIERS.some((specifier) => {
+    const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(String.raw`(?:from|import)\s*\(?\s*['"]${escaped}['"]`).test(source);
+  });
+}
+function readTestAdoption(cwd) {
+  const manifest = readProjectPackageJson(cwd);
+  const jestConfigs = jestConfigFiles(cwd);
+  const configFile = testConfigFile(cwd);
+  const declared = { ...manifest.dependencies, ...manifest.devDependencies };
+  const ownDeclarations = ["vitest", "jest", "@nx/jest", "jest-mock-extended", "@swc/jest"].filter((name) => declared[name] !== void 0).map((name) => ({ name, version: declared[name] }));
+  if (configFile === void 0) {
+    const hasTests = hasTestFiles(cwd);
+    const inheritsRootConfig = hasTests && jestConfigs.length === 0 && rootJestConfigFiles(cwd).length > 0;
+    return {
+      configFile: null,
+      preset: null,
+      adopted: false,
+      conformant: false,
+      drift: [],
+      unreadable: null,
+      state: hasTests ? "jest" : "no-tests",
+      runner: hasTests ? "jest" : "none",
+      jestConfigs,
+      inheritsRootConfig,
+      ownDeclarations
+    };
+  }
+  const source = readTestConfigSource(cwd, configFile);
+  if (source === "") {
+    return {
+      configFile,
+      preset: null,
+      adopted: false,
+      conformant: false,
+      drift: [],
+      unreadable: `${configFile} could not be read`,
+      state: "vitest-own-toolchain",
+      runner: "vitest",
+      jestConfigs,
+      inheritsRootConfig: false,
+      // it has a config of its own, readable or not
+      ownDeclarations
+    };
+  }
+  const adopted = importsPreset2(source);
+  const script = moduleScripts(cwd)["test"];
+  return {
+    configFile,
+    preset: adopted ? "react" : null,
+    adopted,
+    conformant: adopted && script !== void 0 && jestConfigs.length === 0,
+    drift: [],
+    unreadable: null,
+    state: adopted ? "adopted" : "vitest-own-toolchain",
+    runner: "vitest",
+    jestConfigs,
+    inheritsRootConfig: false,
+    // local always wins: this module is out of the root's reach
+    ownDeclarations
+  };
+}
+
+// src/roles/test/codemod/migrate-file.ts
+import { parseSync as parseSync7 } from "oxc-parser";
+
+// 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 && /[\s;]/.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/constructible-mocks.ts
+var MEMBER_TYPES2 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function mockImplementationArrow(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES2.has(callee.type)) return void 0;
+  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_TYPES2.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_TYPES3 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var RUNNERS = /* @__PURE__ */ new Set(["it", "test", "describe"]);
+function eachTable(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES3.has(callee.type)) return void 0;
+  const property = callee.property;
+  if (property?.type !== "Identifier" || property.name !== "each") return void 0;
+  let object = callee.object;
+  while (object !== void 0 && MEMBER_TYPES3.has(object.type)) {
+    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_TYPES4 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function eachTitle(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const inner = node.callee;
+  if (inner?.type !== "CallExpression") return void 0;
+  const member = inner.callee;
+  if (member === void 0 || !MEMBER_TYPES4.has(member.type)) return void 0;
+  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_TYPES5 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function rewriteEmptyMockImplementation(source, program) {
+  const insertAt = [];
+  walk(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    if ((node.arguments ?? []).length > 0) return;
+    const callee = node.callee;
+    if (callee === void 0 || !MEMBER_TYPES5.has(callee.type)) return;
+    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_TYPES6 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var TIMER_CALLS = /* @__PURE__ */ new Set(["useFakeTimers"]);
+function timerOptions(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES6.has(callee.type)) return void 0;
+  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 stringLiterals2(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 = [];
+  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 === "doNotFake") {
+        const excluded = stringLiterals2(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 };
+  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 };
+}
+
+// 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 statement of program.body ?? []) {
+    if (statement.type !== "VariableDeclaration") continue;
+    for (const declarator of statement.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 statement of program.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    for (const specifier of statement.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 statement of program.body ?? []) {
+    if (statement.type !== "VariableDeclaration") continue;
+    const declarations = statement.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, init, kind: statement.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, statement) {
+  let end = statement.end;
+  if (source[end] === "\r") end++;
+  if (source[end] === "\n") end++;
+  return { start: statement.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 }, index) => {
+    const span = statementSpan(source, statement);
+    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_TYPES7 = /* @__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_TYPES7.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 parseSync4 } from "oxc-parser";
+
+// src/roles/test/codemod/rename.ts
+import { parseSync as parseSync3 } 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 } = parseSync3(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 } = parseSync4(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([...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 existsSync24, readFileSync as readFileSync22 } from "fs";
+import { createRequire as createRequire4 } from "module";
+import { dirname as dirname4, join as join28 } from "path";
+function isCommonJsPackage(fromFile, specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return false;
+  let resolved;
+  try {
+    resolved = createRequire4(fromFile).resolve(specifier);
+  } catch {
+    return false;
+  }
+  if (!resolved.includes(`${"/"}node_modules${"/"}`)) return false;
+  if (resolved.endsWith(".mjs")) return false;
+  if (resolved.endsWith(".cjs")) return true;
+  let dir = dirname4(resolved);
+  for (let depth = 0; depth < 12; depth += 1) {
+    const manifest = join28(dir, "package.json");
+    if (existsSync24(manifest)) {
+      try {
+        return JSON.parse(readFileSync22(manifest, "utf8")).type !== "module";
+      } catch {
+        return false;
+      }
+    }
+    const parent = dirname4(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+var MEMBER_TYPES8 = /* @__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_TYPES8.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_TYPES8.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 Set();
+  walk(program, (node) => {
+    if (node.type !== "ExpressionStatement") return;
+    const expression = node.expression;
+    if (expression !== void 0) wholeStatement.add(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_TYPES8.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: `(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: `(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: wholeStatement.has(node) ? `await import(${argumentText(source, 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_TYPES9 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var ISOLATORS = /* @__PURE__ */ new Set(["isolateModules", "isolateModulesAsync"]);
+var FUNCTIONS2 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+function isolatingCall(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES9.has(callee.type)) return void 0;
+  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_TYPES9.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_TYPES10 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+function isViMockCall(node) {
+  if (node?.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES10.has(callee.type)) return false;
+  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_TYPES10.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_TYPES11 = /* @__PURE__ */ new Set(["MemberExpression", "StaticMemberExpression"]);
+var BINDING = "sentinelMockedModule";
+function mockCall(node) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee === void 0 || !MEMBER_TYPES11.has(callee.type)) return void 0;
+  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/propagate-await.ts
+import { parseSync as parseSync5 } from "oxc-parser";
+var FUNCTIONS3 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
+var MEMBER_TYPES12 = /* @__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_TYPES12.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 = parseSync5(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 readFileSync23, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { createRequire as createRequire5 } from "module";
+import { dirname as dirname5, join as join29 } from "path";
+var MEMBER_TYPES13 = /* @__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_TYPES13.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 dirname5(createRequire5(fromFile).resolve(`${name}/package.json`));
+  } catch {
+    return void 0;
+  }
+}
+function resolveFrom(fromFile, specifier) {
+  try {
+    return createRequire5(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 = readdirSync4(root);
+  } catch {
+    return [];
+  }
+  const aliases = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".js")) continue;
+    const path = join29(root, entry);
+    let body;
+    try {
+      if (!statSync4(path).isFile()) continue;
+      body = readFileSync23(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 parseSync6 } from "oxc-parser";
+var SENTINEL_MSW_SERVER = "@hublo/sentinel/test/msw";
+var MSW_SERVER_MODULE = /(^|\/)msw\/server$/;
+var MSW_PACKAGE = /^msw$/;
+function importsMswPackage(declaration) {
+  const source = declaration.source?.value;
+  return source !== void 0 && MSW_PACKAGE.test(source);
+}
+function importsServer(declaration) {
+  return (declaration.specifiers ?? []).some((specifier) => {
+    const imported = specifier.imported;
+    const local = specifier.local;
+    return imported?.name === "server" || imported === void 0 && local?.name === "server";
+  });
+}
+function repointMswServer(fileName, source) {
+  const { program, errors } = parseSync6(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 isServerModule = MSW_SERVER_MODULE.test(specifier.value) && importsServer(node);
+    if (!isServerModule && !importsMswPackage(node)) return;
+    edits.push({ start: specifier.start, end: specifier.end });
+  });
+  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}${SENTINEL_MSW_SERVER}${quote}` + rewritten.slice(edit.end);
+  }
+  return { source: rewritten, repointed: true };
+}
+
+// src/roles/test/codemod/spy-instance-type.ts
+var SPY_TYPES = /* @__PURE__ */ new Set(["SpyInstance"]);
+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 bare = written.startsWith("jest.") ? written.slice("jest.".length) : written;
+    if (!SPY_TYPES.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: any[]";
+    edits.push({
+      start: node.start,
+      end: node.end,
+      text: `MockInstance<(${parameters}) => ${returns}>`
+    });
+  });
+  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: edits.length > 0 ? ["MockInstance"] : []
+  };
+}
+
+// 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 parse2(fileName, source) {
+  const { program, errors } = parseSync7(fileName, source, { sourceType: "module" });
+  return errors.length > 0 ? void 0 : program;
+}
+function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new Set(), asyncHelpers = /* @__PURE__ */ new Set()) {
+  const untouched = {
+    source,
+    changed: false,
+    renamed: 0,
+    hoisted: [],
+    unhandled: [],
+    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 original = parse2(fileName, source);
+  if (original === void 0) return unparsable("reading the file");
+  const titles = rewriteEachTitles(source, original);
+  const tables = rewriteEachTableRows(titles.source, original);
+  const afterTables = parse2(fileName, tables.source);
+  if (afterTables === void 0) return unparsable("each table rows");
+  const spyTypes = rewriteSpyInstanceType(tables.source, afterTables);
+  const afterSpyTypes = parse2(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 = parse2(fileName, renamed.source);
+  if (afterRename === void 0) return unparsable("jest to vi rename");
+  const fakeTimers = rewriteFakeTimerOptions(renamed.source, afterRename);
+  const afterFakeTimers = parse2(fileName, fakeTimers.source);
+  if (afterFakeTimers === void 0) return unparsable("fake timer options");
+  const mocks = rewriteMockAsValue(fakeTimers.source, afterFakeTimers);
+  const afterMocks = parse2(fileName, mocks.source);
+  if (afterMocks === void 0) return unparsable("mock as a value");
+  const constructible = rewriteConstructibleMocks(
+    mocks.source,
+    afterMocks,
+    mockFactories(afterMocks)
+  );
+  const afterConstructible = parse2(fileName, constructible.source);
+  if (afterConstructible === void 0) return unparsable("constructible mocks");
+  const factoryDefault = rewriteMockFactoryDefault(
+    constructible.source,
+    afterConstructible,
+    defaultImported
+  );
+  const beforeReturnValue = parse2(fileName, factoryDefault.source);
+  if (beforeReturnValue === void 0) return unparsable("mock factory default");
+  const returnValue = rewriteAssertionReturnValue(factoryDefault.source, beforeReturnValue);
+  const afterReturnValue = parse2(fileName, returnValue.source);
+  if (afterReturnValue === void 0) return unparsable("assertion return value");
+  const isolated = rewriteIsolateModules(returnValue.source, afterReturnValue);
+  const afterIsolate = parse2(fileName, isolated.source);
+  if (afterIsolate === void 0) return unparsable("isolate modules");
+  const emptyImplementations = rewriteEmptyMockImplementation(isolated.source, afterIsolate);
+  const afterEmpty = parse2(fileName, emptyImplementations.source);
+  if (afterEmpty === void 0) return unparsable("empty mock implementation");
+  const hooks = rewriteHookReturnValue(emptyImplementations.source, afterEmpty);
+  const awaited = propagateAwait(fileName, hooks.source, original, asyncHelpers);
+  const program = parse2(fileName, awaited.source);
+  if (program === void 0) return unparsable("hook body");
+  const hoist = hoistCapturedBindings(
+    awaited.source,
+    program,
+    mockFactories(program),
+    moduleBindings(program),
+    importedNames(program)
+  );
+  const withImport = injectTypeImport(fileName, hoist.source, [
+    ...renamed.typeImports,
+    ...spyTypes.typeImports
+  ]);
+  const deep = normaliseDeepImports(withImport);
+  const repointed = repointMswServer(fileName, deep.source);
+  const finalProgram = parse2(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"] : [],
+      ...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: [
+      ...fakeTimers.refusals,
+      ...hoist.refusals,
+      ...mocks.refusals.map((refusal) => ({ binding: refusal.binding, reason: refusal.reason })),
+      ...constructible.refusals,
+      ...isolated.refusals
+    ],
+    mswRepointed: repointed.repointed
+  };
+}
+
+// src/roles/test/codemod/test-support-files.ts
+import { existsSync as existsSync25, readFileSync as readFileSync24, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { dirname as dirname6, join as join30, relative as relative5, resolve as resolve4 } from "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 EXTENSIONS = [".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 = resolve4(dirname6(fromFile), specifier);
+  if (existsSync25(base) && statSync5(base).isFile()) return base;
+  for (const extension of EXTENSIONS) {
+    if (existsSync25(`${base}${extension}`)) return `${base}${extension}`;
+  }
+  for (const extension of EXTENSIONS) {
+    const index = join30(base, `index${extension}`);
+    if (existsSync25(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 = readdirSync5(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!SKIPPED.has(entry.name)) stack.push(join30(dir, entry.name));
+      } else if (SOURCE_FILE.test(entry.name)) {
+        found.push(join30(dir, entry.name));
+      }
+    }
+  }
+  return found;
+}
+function read(path) {
+  try {
+    return readFileSync24(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 = resolve4(cwd, withoutToken);
+    const inside = relative5(cwd, full);
+    if (inside.startsWith("..") || inside === "") continue;
+    if (!existsSync25(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) => relative5(cwd, file).replaceAll("\\", "/"));
+  return [.../* @__PURE__ */ new Set([...reachable, ...setupFilesInside(cwd, setupFiles)])].sort();
+}
+
+// src/roles/test/codemod/migrate-module.ts
+function parse3(source) {
+  const { program, errors } = parseSync8("file.ts", source, { sourceType: "module" });
+  return errors.length > 0 ? void 0 : program;
+}
+function read2(path) {
+  try {
+    return readFileSync25(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 = readdirSync6(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIPPED2.has(entry)) continue;
+      const path = join31(dir, entry);
+      let directory;
+      try {
+        directory = statSync6(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 operations = [];
+  const blockers = [];
+  let files = 0;
+  let renamed = 0;
+  let hoisted = 0;
+  const defaultImported = defaultImportedSpecifiers(cwd);
+  const asyncHelpers = /* @__PURE__ */ new Set();
+  for (const relative7 of listTestSupportFiles(cwd, setupFiles)) {
+    const source = read2(join31(cwd, relative7));
+    if (source === void 0) {
+      blockers.push({ file: relative7, reason: "this file could not be read" });
+      continue;
+    }
+    const migrated = migrateTestFile(join31(cwd, relative7), source, defaultImported);
+    if (!migrated.changed) continue;
+    const before = parse3(source);
+    const after = parse3(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: relative7, contents: migrated.source });
+  }
+  for (const relative7 of listTestFiles(cwd)) {
+    const source = read2(join31(cwd, relative7));
+    if (source === void 0) {
+      blockers.push({ file: relative7, reason: "this file could not be read" });
+      continue;
+    }
+    const migrated = migrateTestFile(join31(cwd, relative7), source, defaultImported, asyncHelpers);
+    for (const member of migrated.unhandled) {
+      blockers.push({
+        file: `${relative7}:${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}`
+      });
+    }
+    for (const refusal of migrated.refusals) {
+      blockers.push({ file: relative7, reason: refusal.reason });
+    }
+    if (!migrated.changed) continue;
+    files++;
+    renamed += migrated.renamed;
+    if (migrated.hoisted.length > 0) hoisted++;
+    operations.push({ kind: "write", path: relative7, contents: migrated.source });
+  }
+  return blockers.length > 0 ? { operations: [], files, renamed, hoisted, blockers } : { operations, files, renamed, hoisted, blockers: [] };
+}
+
+// src/roles/test/nest/generate-config.ts
+import { readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "fs";
+import { join as join32, relative as relative6 } from "path";
+var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/nest";
+var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/nest";
+var SENTINEL_MSW_SETUP = "@hublo/sentinel/test/setup/msw-lifecycle";
+var SENTINEL_WORKSPACE_SETUP = "@hublo/sentinel/test/setup/workspace";
+var NEST_TEST_CONFIG_FILE = "vitest.config.mts";
+function hopsToRoot(cwd, workspaceRoot) {
+  const up = relative6(cwd, workspaceRoot).replaceAll("\\", "/");
+  return up === "" ? "." : up;
+}
+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 = readdirSync7(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIPPED3.has(entry)) continue;
+      const path = join32(dir, entry);
+      let directory;
+      try {
+        directory = statSync7(path).isDirectory();
+      } catch {
+        continue;
+      }
+      if (directory) {
+        walk2(path);
+        continue;
+      }
+      if (!/\.tsx?$/.test(entry)) continue;
+      let source;
+      try {
+        source = readFileSync26(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 setupBlock(reading, msw) {
+  const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []];
+  const namedTheRootSetup = declared.some((file) => file.endsWith("jest.setup.after.env.js"));
+  const own = declared.filter((file) => !file.endsWith("jest.setup.after.env.js")).map((file) => `'${withoutRootDir(file)}'`);
+  const sentinel = [
+    `'${SENTINEL_TEST_SETUP}'`,
+    ...namedTheRootSetup ? [`'${SENTINEL_WORKSPACE_SETUP}'`] : [],
+    ...msw ? [`'${SENTINEL_MSW_SETUP}'`] : []
+  ];
+  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 ci = projectTargets(cwd)?.[target]?.configurations?.ci;
+  if (ci === void 0) return "";
+  if (ci.runInBand === true) return `        fileParallelism: false,`;
+  if (typeof ci.maxWorkers === "number") {
+    return ci.maxWorkers === 1 ? `        fileParallelism: false,` : `        maxWorkers: ${ci.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) => `'${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 target = isPackage(alias.replacement) ? `'${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(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'`, ""] : [],
+    `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(
+  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 existsSync26, readFileSync as readFileSync27 } from "fs";
+import { join as join33 } from "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) && existsSync26(join33(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) => existsSync26(join33(cwd, name)));
+  if (file === void 0 || !existsSync26(join33(cwd, file))) return void 0;
+  let source;
+  try {
+    source = readFileSync27(join33(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 existsSync27 } from "fs";
+import { basename as basename2, join as join34 } from "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 (!existsSync27(join34(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/jest-migration.ts
+var SPEC_TSCONFIG = "tsconfig.spec.json";
+var VITEST_GLOBAL_TYPES = "vitest/globals";
+function specTypesOperation(cwd) {
+  const path = join35(cwd, SPEC_TSCONFIG);
+  if (!existsSync28(path)) return void 0;
+  let config;
+  try {
+    config = parseJsonc(
+      readFileSync28(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 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 targets = projectTargets(context.cwd) ?? {};
+  const existingFor = (name) => targets[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],
+    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 notes = [
+    `${migration.files} test file(s) migrated from jest to Vitest, ${migration.renamed} site(s) rewritten${migration.hoisted > 0 ? `, ${migration.hoisted} of them moving a mock factory's captures into vi.hoisted` : ""}.`,
+    `${NEST_TEST_CONFIG_FILE} written from what ${adoption.jestConfigs.join(", ")} declared, and that config deleted. Every specifier in the new one is a package name: nothing in it reaches outside this module.`
+  ];
+  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.`
+    );
+  }
+  notes.push(
+    `run this module's own lint --fix (or its formatter) after installing: the Vitest type imports are written beside the existing ones, and ordering belongs to the tool that enforces it.`
+  );
+  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 plan3(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];
+  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
+function resolveVitest(cwd) {
+  const fromSentinel = binFromOwnInstall("vitest", "vitest");
+  if (fromSentinel !== void 0) return { bin: fromSentinel, origin: "sentinel" };
+  const fromModule = resolveBin(cwd, "vitest");
+  return fromModule !== void 0 ? { bin: fromModule, origin: "module" } : { bin: void 0, origin: "module" };
+}
+var VitestAdapter = class extends BaseAdapter {
+  target = "test";
+  runner = "vitest";
+  appliesTo(_preset) {
+    return true;
+  }
+  plan(context) {
+    return plan3(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, paths } = splitToolArgs(ctx.cwd, ctx.toolArgs, { valueFlags: [] });
+    const watching = options.includes("--watch") || options.includes("-w");
+    const argv = watching ? [...options, ...paths] : ["run", ...options, ...paths];
+    const result = spawnSync5(bin, argv, { cwd: ctx.cwd, stdio: "inherit" });
+    if (result.error) {
+      this.say(`could not run vitest (${result.error.message})`);
+      return Promise.resolve({ ok: false, code: 1 });
+    }
+    const code = result.status ?? 1;
+    return Promise.resolve({ ok: code === 0, code });
+  }
+  say(message) {
+    process.stderr.write(`sentinel test(vitest): ${message}
+`);
+  }
+};
+
+// src/roles/test/register.ts
+function registerTest() {
+  register(new VitestAdapter());
+  setDefaultRunner("test", "vitest");
+}
+
+// src/roles/typescript/adapters/tsc/tsc.adapter.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
+import { createRequire as createRequire6 } from "module";
+import { join as join37 } from "path";
+
+// src/roles/typescript/presets/nest.json
+var nest_default2 = {
+  compilerOptions: {
+    module: "esnext",
+    moduleResolution: "bundler",
+    types: ["node"],
+    experimentalDecorators: true,
+    emitDecoratorMetadata: true,
+    declaration: true,
+    sourceMap: true
+  },
+  notes: {
+    module: "the backends are webpack-bundled and tsc only typechecks, so the module format is the bundler's concern; `bundler` resolution is what the repo already uses, and the only Node-friendly option TS7 still accepts since it removed classic `node`",
+    target: "deliberately NOT set, here or in lib: those are environment the repo base owns. Overriding target flips useDefineForClassFields (TS2612) and narrowing lib drops DOM (GLfloat); both REPLACE the base rather than merge"
+  }
+};
+
+// src/roles/typescript/presets/node.json
+var node_default2 = {
+  compilerOptions: {
+    module: "esnext",
+    moduleResolution: "bundler",
+    types: ["node"],
+    declaration: true
+  },
+  notes: {
+    module: "esnext/bundler like the react and nest presets, matching a monorepo whose libs are bundler-resolved in practice. NOT NodeNext: that would force its stricter ESM rules onto libs the repo resolves through a bundler"
+  }
+};
+
+// src/roles/typescript/presets/react.json
+var react_default2 = {
+  compilerOptions: {
+    target: "ES2023",
+    lib: ["ES2023", "DOM", "DOM.Iterable"],
+    module: "ESNext",
+    moduleResolution: "bundler",
+    jsx: "react-jsx",
+    useDefineForClassFields: true,
+    isolatedModules: true,
+    moduleDetection: "force",
+    noEmit: true,
+    noUncheckedSideEffectImports: true
+  },
+  notes: {
+    noEmit: "vite owns the build; tsc only typechecks here"
+  }
+};
+
+// src/roles/typescript/presets/shared.json
+var shared_default2 = {
+  $schema: "https://json.schemastore.org/tsconfig",
+  compilerOptions: {
+    strict: true,
+    noFallthroughCasesInSwitch: true,
+    forceConsistentCasingInFileNames: true,
+    esModuleInterop: true,
+    skipLibCheck: true
+  },
+  deferred: {
+    noImplicitAny: {
+      phase: 2,
+      reason: "the implicit-any migration (TS70xx)"
+    },
+    noUnusedLocals: {
+      phase: 2,
+      reason: "unused-local cleanup (TS6133)"
+    },
+    noUnusedParameters: {
+      phase: 2,
+      reason: "unused-parameter cleanup (TS6133)"
+    }
+  }
+};
+
+// src/roles/typescript/preset-data.ts
+var SHARED = shared_default2;
 var LAYERS = {
   nest: nest_default2,
   node: node_default2,
@@ -5812,8 +8628,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync29 } from "fs";
+import { join as join36 } from "path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -5906,7 +8722,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync23(join29(context.cwd, target.path), "utf8"),
+    readFileSync29(join36(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -6044,7 +8860,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync24(join30(cwd, target.path), "utf8"),
+        readFileSync30(join37(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -6057,7 +8873,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire4(join30(cwd, "noop.js")).resolve(preset);
+      createRequire6(join37(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -6098,7 +8914,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
       return { ok: false, code: 1 };
     }
     if (options.length > 0) return this.runWithOptions(ctx, tsc, config);
-    const result = spawnSync5(tsc, ["-b", config], { cwd: ctx.cwd, stdio: "inherit" });
+    const result = spawnSync6(tsc, ["-b", config], { cwd: ctx.cwd, stdio: "inherit" });
     if (result.error) {
       process.stderr.write(
         `sentinel typescript(tsc): could not run tsc (${result.error.message}); is TypeScript installed in the module?
@@ -6133,7 +8949,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let worst = 0;
     for (const project of this.referencedProjects(ctx.cwd, config)) {
       const args = ["-p", project, "--noEmit", "--composite", "false", ...ctx.toolArgs ?? []];
-      const result = spawnSync5(tsc, args, { cwd: ctx.cwd, stdio: "inherit" });
+      const result = spawnSync6(tsc, args, { cwd: ctx.cwd, stdio: "inherit" });
       if (result.error) {
         process.stderr.write(
           `sentinel typescript(tsc): could not run tsc (${result.error.message}); is TypeScript installed in the module?
@@ -6153,7 +8969,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync24(join30(cwd, config), "utf8"),
+        readFileSync30(join37(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -6169,7 +8985,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync25(join30(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync29(join37(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -6222,7 +9038,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
       return { ok: true, code: 0, metrics: _TscAdapter.NOTHING_TO_REPORT };
     }
     const tsc = resolveBin(ctx.cwd, "tsc") ?? "tsc";
-    const result = spawnSync5(tsc, ["-b", config], { cwd: ctx.cwd, encoding: "utf8" });
+    const result = spawnSync6(tsc, ["-b", config], { cwd: ctx.cwd, encoding: "utf8" });
     if (result.error) {
       process.stderr.write(
         `sentinel typescript(tsc): could not run tsc (${result.error.message}); is TypeScript installed in the module?
@@ -6265,7 +9081,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * errors in the output mean the rule must be on.
    */
   noImplicitAnyEnabled(cwd, tsc, config, mainOutput) {
-    const shown = spawnSync5(tsc, ["-p", config, "--showConfig"], { cwd, encoding: "utf8" });
+    const shown = spawnSync6(tsc, ["-p", config, "--showConfig"], { cwd, encoding: "utf8" });
     if (shown.status === 0 && shown.stdout) {
       try {
         const co = parseJsonc(
@@ -6292,6 +9108,7 @@ function registerAdapters() {
   registerLint();
   registerFormat();
   registerBuild();
+  registerTest();
 }
 
 // src/core/detect-framework.ts
@@ -6373,9 +9190,9 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync26, readFileSync as readFileSync25, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve4, sep } from "path";
-import { applyEdits, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
+import { existsSync as existsSync30, readFileSync as readFileSync31, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve5, sep } from "path";
+import { applyEdits as applyEdits3, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
 // src/shared/deep-merge.ts
 function isPlainObject(value) {
@@ -6384,15 +9201,15 @@ function isPlainObject(value) {
 
 // src/core/apply-plan.ts
 function resolveWithinRoot(cwd, relativePath) {
-  const root = resolve4(cwd);
-  const absolutePath = resolve4(root, relativePath);
+  const root = resolve5(cwd);
+  const absolutePath = resolve5(root, relativePath);
   if (absolutePath !== root && !absolutePath.startsWith(root + sep)) {
     throw new Error(`Refusing to write outside the module root: "${relativePath}".`);
   }
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync26(absolutePath) ? readFileSync25(absolutePath, "utf8") : void 0;
+  return existsSync30(absolutePath) ? readFileSync31(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -6407,7 +9224,7 @@ function mergeJsonc(current, value) {
     const edits = modify(text, path, leaf, {
       formattingOptions: { insertSpaces: true, tabSize: 2 }
     });
-    text = applyEdits(text, edits);
+    text = applyEdits3(text, edits);
   }
   return text.endsWith("\n") ? text : text + "\n";
 }
@@ -6419,7 +9236,7 @@ function removeJsoncKeys(current, keys) {
     const edits = modify(text, path, void 0, {
       formattingOptions: { insertSpaces: true, tabSize: 2 }
     });
-    text = applyEdits(text, edits);
+    text = applyEdits3(text, edits);
   }
   return text.endsWith("\n") ? text : text + "\n";
 }
@@ -6473,9 +9290,9 @@ function applyOperationTo(current, operation) {
     }
   }
 }
-function preparePlan(cwd, plan3) {
+function preparePlan(cwd, plan4) {
   const prepared = /* @__PURE__ */ new Map();
-  for (const operation of plan3.operations) {
+  for (const operation of plan4.operations) {
     const absolutePath = resolveWithinRoot(cwd, operation.path);
     const existing = prepared.get(operation.path);
     const before = existing?.before ?? readIfExists(absolutePath) ?? "";
@@ -6494,11 +9311,11 @@ function preparePlan(cwd, plan3) {
 }
 function writeFileAtomic(absolutePath, contents) {
   const tempPath = `${absolutePath}.sentinel-${process.pid}.tmp`;
-  writeFileSync4(tempPath, contents);
+  writeFileSync3(tempPath, contents);
   renameSync(tempPath, absolutePath);
 }
-function applyPlan(cwd, plan3) {
-  const changed = preparePlan(cwd, plan3).filter((file) => file.before !== file.after);
+function applyPlan(cwd, plan4) {
+  const changed = preparePlan(cwd, plan4).filter((file) => file.before !== file.after);
   for (const file of changed) {
     if (file.deleted) {
       rmSync3(file.absolutePath, { force: true });
@@ -6510,8 +9327,8 @@ function applyPlan(cwd, plan3) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync27, readdirSync as readdirSync3, readFileSync as readFileSync26 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync31, readdirSync as readdirSync8, readFileSync as readFileSync32 } from "fs";
+import { join as join38 } from "path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -6528,12 +9345,42 @@ var DEPENDENCY_SIGNALS = [
   { preset: "svelte", pattern: /^svelte$|^@sveltejs\// },
   { preset: "nest", pattern: /^@nestjs\// }
 ];
+var IMPORT_SIGNALS = [
+  { preset: "nest", pattern: /@nestjs\//, evidence: 'its code imports "@nestjs/"' }
+];
+var SOURCE_FILE2 = /\.[cm]?[jt]sx?$/;
+var NOT_SCANNED = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage", ".git", ".nx", ".turbo", "build"]);
+function sourceImports(cwd, pattern) {
+  const stack = [cwd];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync8(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!NOT_SCANNED.has(entry.name)) stack.push(join38(dir, entry.name));
+        continue;
+      }
+      if (!SOURCE_FILE2.test(entry.name)) continue;
+      try {
+        if (pattern.test(readFileSync32(join38(dir, entry.name), "utf8"))) return true;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return false;
+}
 function dependencyNames(cwd) {
-  const path = join31(cwd, "package.json");
-  if (!existsSync27(path)) return [];
+  const path = join38(cwd, "package.json");
+  if (!existsSync31(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync26(path, "utf8"),
+      readFileSync32(path, "utf8"),
       path
     );
     return [
@@ -6547,7 +9394,7 @@ function dependencyNames(cwd) {
 function declaresJsx(cwd) {
   let entries;
   try {
-    entries = readdirSync3(cwd).filter(
+    entries = readdirSync8(cwd).filter(
       (name) => name.startsWith("tsconfig") && name.endsWith(".json")
     );
   } catch {
@@ -6556,7 +9403,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync26(join31(cwd, name), "utf8"),
+        readFileSync32(join38(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -6581,6 +9428,10 @@ function presetSignals(cwd) {
       signals.push({ preset, evidence });
     }
   }
+  for (const { preset, pattern, evidence } of IMPORT_SIGNALS) {
+    if (signals.some((signal) => signal.preset === preset)) continue;
+    if (sourceImports(cwd, pattern)) signals.push({ preset, evidence });
+  }
   return signals;
 }
 function correctingSignal(detected, cwd) {
@@ -6611,14 +9462,14 @@ function resolveFlavour(opts) {
   }
   return detection.preset;
 }
-function previewPlan(opts, plan3) {
-  const changed = preparePlan(opts.cwd, plan3).filter((file) => file.before !== file.after);
+function previewPlan(opts, plan4) {
+  const changed = preparePlan(opts.cwd, plan4).filter((file) => file.before !== file.after);
   if (opts.json) {
     process.stdout.write(
       JSON.stringify(
         {
           dryRun: true,
-          notes: plan3.notes ?? [],
+          notes: plan4.notes ?? [],
           files: changed.map(({ path, before, after, deleted }) => ({
             path,
             action: deleted ? "delete" : before.length === 0 ? "create" : "update",
@@ -6633,7 +9484,7 @@ function previewPlan(opts, plan3) {
     return 0;
   }
   process.stderr.write("  dry run: no files written\n");
-  for (const note of plan3.notes ?? []) process.stderr.write(`  ${note}
+  for (const note of plan4.notes ?? []) process.stderr.write(`  ${note}
 `);
   if (changed.length === 0) {
     process.stderr.write("  nothing to change\n");
@@ -6655,6 +9506,12 @@ async function dispatch(opts) {
   }
   const detected = resolveFlavour(opts);
   const resolutionPreset = opts.preset ?? declaredPresetFor(opts.target, opts.cwd) ?? detected;
+  if (resolutionPreset === "tools") {
+    const message = `tools modules are not adopted one at a time: they sometimes hold configuration shared with the workspace root, so they move WITH the root, as one reviewed change owned by the tooling team rather than by the module's team.`;
+    process.stderr.write(`  ${palette(process.stderr).dim(`${opts.target}: ${message}`)}
+`);
+    return 0;
+  }
   const adapter = resolve(opts.target, resolutionPreset, opts.runner);
   const preset = opts.preset ?? adapter.declaredPreset?.(opts.cwd) ?? detected;
   if (opts.preset !== void 0) {
@@ -6677,25 +9534,25 @@ async function dispatch(opts) {
     }
   }
   const context = { cwd: opts.cwd, preset: effective };
-  const plan3 = await adapter.plan(context);
-  if (plan3.blocked) {
-    process.stderr.write(`sentinel (${opts.target}): ${plan3.blocked}
+  const plan4 = await adapter.plan(context);
+  if (plan4.blocked) {
+    process.stderr.write(`sentinel (${opts.target}): ${plan4.blocked}
 `);
     return 1;
   }
-  if (plan3.skipped) {
-    process.stderr.write(`  ${palette(process.stderr).dim(`${opts.target}: ${plan3.skipped}`)}
+  if (plan4.skipped) {
+    process.stderr.write(`  ${palette(process.stderr).dim(`${opts.target}: ${plan4.skipped}`)}
 `);
     return 0;
   }
   if (opts.dryRun) {
-    return previewPlan(opts, plan3);
+    return previewPlan(opts, plan4);
   }
-  for (const change of applyPlan(opts.cwd, plan3)) {
+  for (const change of applyPlan(opts.cwd, plan4)) {
     process.stderr.write(`  ${change.deleted ? "removed" : "wrote"} ${change.path}
 `);
   }
-  for (const note of plan3.notes ?? []) process.stderr.write(`  ${note}
+  for (const note of plan4.notes ?? []) process.stderr.write(`  ${note}
 `);
   if (adapter.afterInit) {
     process.stderr.write(`  fixing what ${opts.target} can fix automatically...
@@ -6719,16 +9576,9 @@ export {
   declaredPresetFor,
   availableTargets,
   resolve,
-  readOwnVersion,
-  readProjectPackageJson,
-  moduleName,
   buildConfigFile,
   BaseAdapter,
   resolveBin,
-  WORKSPACE_ROOT_MARKER,
-  findWorkspaceRoot,
-  ensureWorkspacePrep,
-  inspectWorkspacePrep,
   VERBS,
   TARGETS,
   LONG_RUNNING_TARGETS,
@@ -6741,4 +9591,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-676GBPMS.js.map
+//# sourceMappingURL=chunk-4UIZJ3TR.js.map