@hublo/sentinel 1.2.0-alpha.33 → 1.2.0-alpha.35

package/dist/{chunk-DJAN2UTQ.js → chunk-GQID2U34.js}

@@ -596,9 +596,9 @@ 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);
+    const relative7 = typeof bin === "string" ? bin : bin?.[binName];
+    if (!relative7) return void 0;
+    const executable = join6(dirname2(manifest), relative7);
     return existsSync7(executable) ? executable : void 0;
   } catch {
     return void 0;
@@ -1005,9 +1005,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 parse3 = (value) => value.replace(/^[\^~>=<\s]+/, "").split("-")[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = parse3(declared);
+  const right = parse3(needed);
   for (let at = 0; at < Math.max(left.length, right.length); at++) {
     const a = left[at] ?? 0;
     const b = right[at] ?? 0;
@@ -4692,6 +4692,23 @@ import { join as join27 } from "path";
 import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
 import { join as join25 } 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(/^\.\//, "");
@@ -4737,16 +4754,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;
@@ -5654,9 +5661,17 @@ function testTarget(options) {
   };
 }
 
+// src/roles/test/jest-migration.ts
+import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
+import { join as join32 } from "path";
+
+// src/roles/test/codemod/migrate-module.ts
+import { readFileSync as readFileSync24 } from "fs";
+import { join as join30 } from "path";
+
 // src/roles/test/read-adoption.ts
 import { existsSync as existsSync25, readFileSync as readFileSync23, readdirSync as readdirSync3 } from "fs";
-import { join as join29 } from "path";
+import { join as join29, relative as relative5 } from "path";
 var JEST_CONFIG_FILES = [
   "jest.config.ts",
   "jest.config.js",
@@ -5678,6 +5693,13 @@ function rootJestConfigFiles(cwd) {
 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();
@@ -5691,11 +5713,12 @@ function hasTestFiles(cwd) {
       if (entry.isDirectory()) {
         if (!NOT_WALKED.has(entry.name)) stack.push(join29(dir, entry.name));
       } else if (TEST_FILE.test(entry.name)) {
-        return true;
+        found.push(relative5(cwd, join29(dir, entry.name)).replaceAll("\\", "/"));
+        if (stopAtFirst) return found;
       }
     }
   }
-  return false;
+  return found;
 }
 function readTestConfigSource(cwd, fileName) {
   try {
@@ -5766,6 +5789,769 @@ function readTestAdoption(cwd) {
   };
 }
 
+// src/roles/test/codemod/migrate-file.ts
+import { parseSync as parseSync5 } from "oxc-parser";
+
+// src/roles/test/codemod/scope.ts
+function readIdentifiers(node) {
+  const names = [];
+  walk(node, (current) => {
+    if (current.type === "Property" || current.type === "ObjectProperty") {
+      if (current.shorthand === true) {
+        names.push(...readIdentifiers(current.value));
+        return SKIP;
+      }
+      if (current.computed === true) return;
+      const key = current.key;
+      if (key?.type !== "Identifier") return;
+      names.push(...readIdentifiers(current.value));
+      return SKIP;
+    }
+    if (current.type === "MemberExpression" || current.type === "StaticMemberExpression") {
+      if (current.computed === true) return;
+      names.push(...readIdentifiers(current.object));
+      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;
+}
+function capturedBindings(factory, bindings) {
+  const own = declaredInside(factory);
+  const captured = /* @__PURE__ */ new Set();
+  for (const name of readIdentifiers(factory)) {
+    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 read2 of readIdentifiers(init)) {
+    if (imported.has(read2)) return false;
+    if (bindings.has(read2) && !hoistable(read2, 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 });
+  }
+  return found;
+}
+function interdependent(names, bindings) {
+  for (const name of names) {
+    for (const read2 of readIdentifiers(bindings.get(name))) {
+      if (read2 !== name && names.includes(read2)) return `${name} reads ${read2}`;
+    }
+  }
+  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 ? `it is declared without an initializer, so there is nothing for vi.hoisted to carry` : `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 \`const ${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 entries = ordered.map(({ name, init }) => `${name}: ${source.slice(init.start, init.end)}`).join(", ");
+  const first = ordered[0];
+  const semi = source.slice(first.statement.start, first.statement.end).trimEnd().endsWith(";");
+  const hoistedLine = `const { ${ordered.map(({ name }) => name).join(", ")} } = vi.hoisted(() => ({ ${entries} }))${semi ? ";" : ""}
+`;
+  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/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 = {
+  isolateModules: `vi.resetModules() followed by a dynamic import, since vi.resetModules() with a require() returns the CACHED module`,
+  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`
+};
+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" };
+  }
+  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
+var ASYNC_REPLACEMENTS = {
+  requireActual: "importActual",
+  requireMock: "importMock"
+};
+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 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) {
+  const edits = [];
+  const applied = /* @__PURE__ */ new Set();
+  const asyncify = /* @__PURE__ */ new Set();
+  walkWithEnclosingFunction(program, void 0, (node, enclosing) => {
+    const member = ownedCall(node);
+    if (member === void 0) return;
+    const asyncReplacement = 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 (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/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 } = parseSync5(fileName, source, { sourceType: "module" });
+  return errors.length > 0 ? void 0 : program;
+}
+function migrateTestFile(fileName, source) {
+  const untouched = {
+    source,
+    changed: false,
+    renamed: 0,
+    hoisted: [],
+    unhandled: [],
+    refusals: [],
+    rulesApplied: []
+  };
+  const original = parse2(fileName, source);
+  if (original === void 0) return untouched;
+  const ruled = applyNamedRules(source, original);
+  const renamed = renameJestToVitest(fileName, ruled.source);
+  const program = parse2(fileName, renamed.source);
+  if (program === void 0) return untouched;
+  const hoist = hoistCapturedBindings(
+    renamed.source,
+    program,
+    mockFactories(program),
+    moduleBindings(program),
+    importedNames(program)
+  );
+  const withImport = injectTypeImport(fileName, hoist.source, renamed.typeImports);
+  return {
+    source: withImport,
+    changed: withImport !== source,
+    renamed: renamed.rewritten,
+    hoisted: hoist.hoisted,
+    unhandled: renamed.unhandled,
+    refusals: hoist.refusals,
+    rulesApplied: ruled.applied
+  };
+}
+
+// src/roles/test/codemod/migrate-module.ts
+function read(path) {
+  try {
+    return readFileSync24(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function migrateModuleTests(cwd) {
+  const operations = [];
+  const blockers = [];
+  let files = 0;
+  let renamed = 0;
+  let hoisted = 0;
+  for (const relative7 of listTestFiles(cwd)) {
+    const source = read(join30(cwd, relative7));
+    if (source === void 0) {
+      blockers.push({ file: relative7, reason: "this file could not be read" });
+      continue;
+    }
+    const migrated = migrateTestFile(join30(cwd, relative7), source);
+    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.binding}\` cannot move into vi.hoisted: ${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 { relative as relative6 } from "path";
+var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/nest";
+var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/nest";
+var NEST_TEST_CONFIG_FILE = "vitest.config.mts";
+function hopsToRoot(cwd, workspaceRoot) {
+  const up = relative6(cwd, workspaceRoot).replaceAll("\\", "/");
+  return up === "" ? "." : up;
+}
+function coverageBlock(reading) {
+  return reading.coverageDirectory === void 0 ? "" : `        coverage: { reportsDirectory: '${reading.coverageDirectory}' },`;
+}
+function environmentBlock(reading) {
+  return reading.testEnvironment === void 0 ? "" : `        environment: '${reading.testEnvironment}',`;
+}
+function generateNestTestConfig(cwd, reading) {
+  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 up = hopsToRoot(cwd, workspaceRoot);
+  const test = [
+    environmentBlock(reading),
+    `        setupFiles: ['${SENTINEL_TEST_SETUP}'],`,
+    coverageBlock(reading)
+  ].filter((line) => line !== "");
+  return {
+    refusals: [],
+    source: `import path from 'node:path'
+
+import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'
+
+export default defineConfig(
+  nestTestConfig({
+    root: import.meta.dirname,
+    workspaceRoot: path.resolve(import.meta.dirname, '${up}'),
+    overrides: {
+      test: {
+${test.join("\n")}
+      },
+    },
+  }),
+)
+`
+  };
+}
+
+// src/roles/test/nest/read-jest-config.ts
+import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
+import { join as join31 } from "path";
+var CARRIED = ["testEnvironment", "coverageDirectory", "setupFilesAfterEnv"];
+var DISCARDED = ["preset", "displayName", "moduleFileExtensions"];
+var STRING = String.raw`['"]([^'"]*)['"]`;
+function readString(body, key) {
+  return new RegExp(String.raw`\b${key}\s*:\s*${STRING}`).exec(body)?.[1];
+}
+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;
+  for (const line of body.split("\n")) {
+    if (depth === 0) {
+      const key = /^\s*([A-Za-z_$][\w$]*)\s*:/.exec(line);
+      if (key !== null) keys.push(key[1]);
+    }
+    for (const char of line) {
+      if (char === "{" || char === "[") depth += 1;
+      else if (char === "}" || char === "]") depth -= 1;
+    }
+  }
+  return keys;
+}
+function sideEffects(source) {
+  const found = [];
+  if (/^\s*process\.env\s*[.=]/m.test(source)) {
+    found.push("it sets `process.env`, which the generated config would not carry");
+  }
+  const valueImport = /^\s*import\s+(?!type\b)[^\n]*$/m.exec(source);
+  if (valueImport !== null && !/from\s+['"]jest['"]/.test(valueImport[0])) {
+    found.push(`it imports a value (\`${valueImport[0].trim()}\`)`);
+  }
+  return found;
+}
+function readJestConfig(cwd) {
+  const file = JEST_CONFIG_FILES.find((name) => existsSync26(join31(cwd, name)));
+  if (file === void 0) return void 0;
+  let source;
+  try {
+    source = readFileSync25(join31(cwd, file), "utf8");
+  } catch {
+    return { file, refusals: [`${file} could not be read`] };
+  }
+  const refusals = sideEffects(source);
+  const body = configBody(source);
+  if (body === void 0) {
+    return { file, refusals: [...refusals, "its config object could not be located"] };
+  }
+  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 setup = readStringArray(source, "setupFilesAfterEnv");
+  return {
+    file,
+    ...readString(source, "testEnvironment") !== void 0 ? { testEnvironment: readString(source, "testEnvironment") } : {},
+    ...readString(source, "coverageDirectory") !== void 0 ? { coverageDirectory: readString(source, "coverageDirectory") } : {},
+    ...setup !== void 0 ? { setupFilesAfterEnv: setup } : {},
+    refusals
+  };
+}
+
+// src/roles/test/jest-migration.ts
+var SPEC_TSCONFIG = "tsconfig.spec.json";
+var VITEST_GLOBAL_TYPES = "vitest/globals";
+function specTypesOperation(cwd) {
+  const path = join32(cwd, SPEC_TSCONFIG);
+  if (!existsSync27(path)) return void 0;
+  let config;
+  try {
+    config = parseJsonc(
+      readFileSync26(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) {
+  if (adoption.jestConfigs.length > 1) {
+    const [primary, ...rest] = adoption.jestConfigs;
+    return blocked(
+      `this module has a second run mode (${rest.join(", ")}) beside ${primary}, with its own target. One config file cannot stand for both, and how run modes are expressed under Vitest is an open question here, so this module is not migrated yet.`
+    );
+  }
+  const reading = readJestConfig(context.cwd);
+  if (reading === void 0) {
+    return blocked(`${adoption.jestConfigs.join(", ")} could not be read, so nothing was written.`);
+  }
+  const generated = generateNestTestConfig(context.cwd, reading);
+  if (generated.source === void 0) {
+    return blocked(
+      `this module's jest config does not transpose as it stands: ${generated.refusals.join("; ")}. Nothing was written; this needs a look before the migration runs.`
+    );
+  }
+  const migration = migrateModuleTests(context.cwd);
+  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 existing = projectTargets(context.cwd)?.[TEST_SCRIPT_NAME];
+  const siblings = siblingScriptRewrites(context.cwd);
+  const specTypes = specTypesOperation(context.cwd);
+  const operations = [
+    { kind: "write", path: NEST_TEST_CONFIG_FILE, contents: generated.source },
+    ...migration.operations,
+    ...specTypes === void 0 ? [] : [specTypes],
+    manifestOperation(context.cwd, { [TEST_SCRIPT_NAME]: SENTINEL_TEST_COMMAND, ...siblings }),
+    ...nxTargetOperations({
+      cwd: context.cwd,
+      targets: testTarget({
+        configFiles: [NEST_TEST_CONFIG_FILE],
+        outputs: existing?.outputs ?? [],
+        dependsOn: existing?.dependsOn ?? [],
+        configurations: existing?.configurations ?? {}
+      })
+    }),
+    ...adoption.jestConfigs.map((name) => ({ kind: "delete", path: name }))
+  ];
+  if (existing !== void 0) {
+    operations.push({
+      kind: "remove-json-keys",
+      path: "project.json",
+      keys: [["targets", TEST_SCRIPT_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.`
+  );
+  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) => [
@@ -5773,13 +6559,57 @@ function ownedTestDependencies(cwd, declared) {
     ["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: adoption.state === "jest" ? `this module tests with jest (${adoption.jestConfigs.join(", ")}). Migrating it moves its test FILES as well as its config, which is the next step of this role and not this one.` : `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.`
+      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 = [];
@@ -5938,9 +6768,9 @@ function registerTest() {
 
 // src/roles/typescript/adapters/tsc/tsc.adapter.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import { join as join31 } from "path";
+import { join as join34 } from "path";
 
 // src/roles/typescript/presets/nest.json
 var nest_default2 = {
@@ -6121,8 +6951,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync24 } from "fs";
-import { join as join30 } from "path";
+import { readFileSync as readFileSync27 } from "fs";
+import { join as join33 } from "path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -6215,7 +7045,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync24(join30(context.cwd, target.path), "utf8"),
+    readFileSync27(join33(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -6353,7 +7183,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync25(join31(cwd, target.path), "utf8"),
+        readFileSync28(join34(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -6366,7 +7196,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire4(join31(cwd, "noop.js")).resolve(preset);
+      createRequire4(join34(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -6462,7 +7292,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync25(join31(cwd, config), "utf8"),
+        readFileSync28(join34(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -6478,7 +7308,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync26(join31(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync28(join34(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -6683,9 +7513,9 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync27, readFileSync as readFileSync26, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync29, 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 { applyEdits as applyEdits2, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
 // src/shared/deep-merge.ts
 function isPlainObject(value) {
@@ -6702,7 +7532,7 @@ function resolveWithinRoot(cwd, relativePath) {
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync27(absolutePath) ? readFileSync26(absolutePath, "utf8") : void 0;
+  return existsSync29(absolutePath) ? readFileSync29(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -6717,7 +7547,7 @@ function mergeJsonc(current, value) {
     const edits = modify(text, path, leaf, {
       formattingOptions: { insertSpaces: true, tabSize: 2 }
     });
-    text = applyEdits(text, edits);
+    text = applyEdits2(text, edits);
   }
   return text.endsWith("\n") ? text : text + "\n";
 }
@@ -6729,7 +7559,7 @@ function removeJsoncKeys(current, keys) {
     const edits = modify(text, path, void 0, {
       formattingOptions: { insertSpaces: true, tabSize: 2 }
     });
-    text = applyEdits(text, edits);
+    text = applyEdits2(text, edits);
   }
   return text.endsWith("\n") ? text : text + "\n";
 }
@@ -6820,8 +7650,8 @@ function applyPlan(cwd, plan4) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync28, readdirSync as readdirSync4, readFileSync as readFileSync27 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync4, readFileSync as readFileSync30 } from "fs";
+import { join as join35 } from "path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -6834,12 +7664,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_FILE = /\.[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 = readdirSync4(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!NOT_SCANNED.has(entry.name)) stack.push(join35(dir, entry.name));
+        continue;
+      }
+      if (!SOURCE_FILE.test(entry.name)) continue;
+      try {
+        if (pattern.test(readFileSync30(join35(dir, entry.name), "utf8"))) return true;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return false;
+}
 function dependencyNames(cwd) {
-  const path = join32(cwd, "package.json");
-  if (!existsSync28(path)) return [];
+  const path = join35(cwd, "package.json");
+  if (!existsSync30(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync27(path, "utf8"),
+      readFileSync30(path, "utf8"),
       path
     );
     return [
@@ -6862,7 +7722,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync27(join32(cwd, name), "utf8"),
+        readFileSync30(join35(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -6887,6 +7747,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 presetContradiction(declared, cwd) {
@@ -6957,6 +7821,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) {
@@ -7042,4 +7912,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-DJAN2UTQ.js.map
+//# sourceMappingURL=chunk-GQID2U34.js.map