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

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

@@ -5394,6 +5394,9 @@ function registerLint() {
 
 // src/roles/test/adapters/vitest/vitest.adapter.ts
 import { spawnSync as spawnSync5 } from "child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync30 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join37 } from "path";
 
 // src/roles/test/presets/toolchain.json
 var toolchain_default2 = {
@@ -5470,7 +5473,7 @@ function testTarget(options) {
 }
 
 // src/roles/test/jest-migration.ts
-import { existsSync as existsSync28, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
 import { join as join35 } from "path";
 
 // src/roles/test/codemod/migrate-module.ts
@@ -7570,9 +7573,13 @@ function migrateModuleTests(cwd, setupFiles = []) {
 }
 
 // src/roles/test/nest/generate-config.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync7, readFileSync as readFileSync26, statSync as statSync7 } from "fs";
 import { join as join32, relative as relative6 } from "path";
 var NEST_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/nest";
+var REACT_TEST_PRESET_SPECIFIER = "@hublo/sentinel/test/react";
+function flavourOf(reading) {
+  return reading.testEnvironment === "jsdom" ? "react" : "nest";
+}
 var SENTINEL_TEST_SETUP = "@hublo/sentinel/test/setup/nest";
 var SENTINEL_MSW_SETUP = "@hublo/sentinel/test/setup/msw-lifecycle";
 var SENTINEL_WORKSPACE_SETUP = "@hublo/sentinel/test/setup/workspace";
@@ -7643,14 +7650,29 @@ function readModuleTraits(cwd) {
   return traits;
 }
 var withoutRootDir = (value) => value.replaceAll("<rootDir>/", "./").replaceAll("<rootDir>", ".");
-function setupBlock(reading, msw) {
+function ownsMswLifecycle(cwd, reading) {
+  const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []].filter(
+    (file) => !file.endsWith("jest.setup.after.env.js")
+  );
+  for (const raw of declared) {
+    const file = join32(cwd, raw.replaceAll("<rootDir>/", "").replaceAll("<rootDir>", "."));
+    if (!existsSync26(file)) continue;
+    try {
+      if (/\.listen\s*\(/.test(readFileSync26(file, "utf8"))) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function setupBlock(cwd, reading, msw) {
   const declared = [...reading.setupFiles ?? [], ...reading.setupFilesAfterEnv ?? []];
   const namedTheRootSetup = declared.some((file) => file.endsWith("jest.setup.after.env.js"));
   const own = declared.filter((file) => !file.endsWith("jest.setup.after.env.js")).map((file) => `'${withoutRootDir(file)}'`);
   const sentinel = [
     `'${SENTINEL_TEST_SETUP}'`,
     ...namedTheRootSetup ? [`'${SENTINEL_WORKSPACE_SETUP}'`] : [],
-    ...msw ? [`'${SENTINEL_MSW_SETUP}'`] : []
+    ...msw && !ownsMswLifecycle(cwd, reading) ? [`'${SENTINEL_MSW_SETUP}'`] : []
   ];
   return `        setupFiles: [${[...sentinel, ...own].join(", ")}],`;
 }
@@ -7712,7 +7734,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
   const up = hopsToRoot(cwd, workspaceRoot);
   const test = [
     environmentBlock(reading),
-    setupBlock(reading, traits.msw),
+    setupBlock(cwd, reading, traits.msw),
     envBlock(reading),
     timeoutBlock(reading),
     concurrencyBlock(cwd, reading, target),
@@ -7727,7 +7749,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
     `import path from 'node:path'`,
     "",
     ...needsDefaults ? [`import { configDefaults } from 'vitest/config'`, ""] : [],
-    `import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'`
+    flavourOf(reading) === "react" ? `import { defineConfig, reactTestConfig } from '${REACT_TEST_PRESET_SPECIFIER}'` : `import { defineConfig, nestTestConfig } from '${NEST_TEST_PRESET_SPECIFIER}'`
   ].join("\n");
   const overrides = [aliasBlock(reading), "      test: {", ...test, "      },"].filter(
     (line) => line !== ""
@@ -7738,7 +7760,7 @@ function generateNestTestConfig(cwd, reading, target = "test") {
     source: `${imports}
 
 export default defineConfig(
-  nestTestConfig({
+  ${flavourOf(reading) === "react" ? "reactTestConfig" : "nestTestConfig"}({
     root: import.meta.dirname,
     workspaceRoot: path.resolve(import.meta.dirname, '${up}'),${decoratorLine}
     overrides: {
@@ -7751,7 +7773,7 @@ ${overrides.join("\n")}
 }
 
 // src/roles/test/nest/read-jest-config.ts
-import { existsSync as existsSync26, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "fs";
 import { join as join33 } from "path";
 var CARRIED = [
   "testEnvironment",
@@ -7942,7 +7964,7 @@ function extendedConfig(source, cwd) {
       (name) => name.replace(/^\.\//, "")
     );
     const file = candidates.find(
-      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync26(join33(cwd, name))
+      (name) => /^jest[\w.-]*\.(ts|js)$/.test(name) && existsSync27(join33(cwd, name))
     );
     if (file === void 0) continue;
     if (!new RegExp(String.raw`\{\s*\.\.\.${binding}\b`).test(source)) continue;
@@ -7969,8 +7991,8 @@ function sideEffects(source, extended) {
   return found;
 }
 function readJestConfig(cwd, named) {
-  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync26(join33(cwd, name)));
-  if (file === void 0 || !existsSync26(join33(cwd, file))) return void 0;
+  const file = named ?? JEST_CONFIG_FILES.find((name) => existsSync27(join33(cwd, name)));
+  if (file === void 0 || !existsSync27(join33(cwd, file))) return void 0;
   let source;
   try {
     source = readFileSync27(join33(cwd, file), "utf8");
@@ -8054,7 +8076,7 @@ function readJestConfig(cwd, named) {
 }
 
 // src/roles/test/nest/run-modes.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { basename as basename2, join as join34 } from "path";
 var JEST_EXECUTOR = "@nx/jest:jest";
 var PRIMARY_CONFIG_FILE = "vitest.config.mts";
@@ -8076,7 +8098,7 @@ function runModes(cwd, fallback) {
     const jestConfig = entry.options?.jestConfig;
     if (jestConfig === void 0) continue;
     const name = configName(jestConfig);
-    if (!existsSync27(join34(cwd, name))) continue;
+    if (!existsSync28(join34(cwd, name))) continue;
     declared.push({
       target,
       jestConfig: name,
@@ -8105,7 +8127,7 @@ var SPEC_TSCONFIG = "tsconfig.spec.json";
 var VITEST_GLOBAL_TYPES = "vitest/globals";
 function specTypesOperation(cwd) {
   const path = join35(cwd, SPEC_TSCONFIG);
-  if (!existsSync28(path)) return void 0;
+  if (!existsSync29(path)) return void 0;
   let config;
   try {
     config = parseJsonc(
@@ -8363,6 +8385,311 @@ function plan3(context) {
   return { operations, notes };
 }
 
+// src/roles/test/reference.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync30, mkdtempSync, readFileSync as readFileSync29, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { join as join36 } from "path";
+
+// src/roles/test/baseline.ts
+function readSnapshot(report) {
+  const files = report?.testResults ?? [];
+  const passing = [];
+  const failing = [];
+  const unloadable = [];
+  for (const file of files) {
+    const assertions = file?.assertionResults ?? [];
+    if (file?.status === "failed" && assertions.length === 0) {
+      unloadable.push(typeof file.name === "string" ? file.name : "an unnamed file");
+    }
+    for (const assertion of assertions) {
+      const name = assertion?.fullName;
+      if (typeof name !== "string" || name === "") continue;
+      if (assertion.status === "passed") passing.push(name);
+      else if (assertion.status === "failed") failing.push(name);
+    }
+  }
+  const claimed = report?.numFailedTests;
+  return {
+    files: files.length,
+    passing: passing.sort(),
+    failing: failing.sort(),
+    unloadable: unloadable.sort(),
+    claimedFailing: typeof claimed === "number" ? claimed : failing.length
+  };
+}
+function difference(left, right) {
+  const remaining = /* @__PURE__ */ new Map();
+  for (const name of right) remaining.set(name, (remaining.get(name) ?? 0) + 1);
+  const missing = [];
+  for (const name of left) {
+    const left_ = remaining.get(name) ?? 0;
+    if (left_ === 0) {
+      missing.push(name);
+      continue;
+    }
+    remaining.set(name, left_ - 1);
+  }
+  return missing.sort();
+}
+var withoutRenderingQuotes = (name) => name.replaceAll(String.raw`\'`, "'").replaceAll(String.raw`\"`, '"').replaceAll(/['"`]\s*\+\s*['"`]/g, "").replaceAll(/(^|[\s:,[{(])(''|"")($|[\s,)\]}])/g, "$1<empty-string>$3").replaceAll(/['"`]/g, "");
+function withoutRenderingNoise(name) {
+  const spelled = withSortedKeys(
+    withoutUndefinedEntries(
+      withoutErrorRendering(
+        withoutNaN(
+          withoutTimestamps(withoutRenderingQuotes(withoutClassBodies(withoutStackFrames(name))))
+        )
+      )
+    )
+  );
+  return withoutArrayBrackets(
+    spelled.replaceAll(/\[\s+/g, "[").replaceAll(/\s+\]/g, "]").replaceAll(/\{\s+/g, "{").replaceAll(/\s+\}/g, "}").replaceAll(/(?<=[[{,\s])\+0\b/g, "0").replaceAll(/:\s+/g, ":").replaceAll(/,\s+/g, ",")
+  );
+}
+function withoutArrayBrackets(name) {
+  return name.replaceAll(
+    /\[([^[\]]*)\]/g,
+    (match, inner) => (
+      // `[Object]` and `[Array]` are the formatter saying it STOPPED, not an array literal.
+      // Stripping their brackets would erase the marker `collapsedOf` pairs on.
+      /^(?:Object|Array)$/.test(inner) ? match : inner.replaceAll(/,\s+/g, ",")
+    )
+  );
+}
+var withoutClassBodies = (name) => name.replaceAll(
+  /class\s+([A-Za-z_$][\w$]*)\s*\{\s*\}/g,
+  (_match, className) => `class ${className}`
+).replaceAll(
+  /class\s+([A-Za-z_$][\w$]*)[\s\S]*?\n\}/g,
+  (_match, className) => `class ${className}`
+);
+var withoutTimestamps = (name) => name.replaceAll(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z/g, "<instant>");
+var withoutNaN = (name) => name.replaceAll(/\bNaN\b/g, "null");
+function entriesOf(inner) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < inner.length; index += 1) {
+    const character = inner[index];
+    if (character === "[" || character === "(") depth += 1;
+    else if (character === "]" || character === ")") depth -= 1;
+    else if (character === "," && depth === 0) {
+      parts.push(inner.slice(start, index));
+      start = index + 1;
+    }
+    if (depth < 0) return void 0;
+  }
+  if (depth !== 0) return void 0;
+  parts.push(inner.slice(start));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+var sortedGroup = (match, inner) => {
+  if (!inner.includes(":")) return match;
+  const parts = entriesOf(inner);
+  if (parts === void 0) return match;
+  if (parts.length < 2 || !parts.every((part) => part.includes(":"))) return match;
+  return `{${[...parts].sort().join(",")}}`;
+};
+var HELD = "\u241F";
+var withSortedKeys = (name) => {
+  const held = [];
+  let current = name;
+  for (let depth = 0; depth < 24; depth += 1) {
+    const next = current.replaceAll(/\{([^{}]*)\}/g, (match, inner) => {
+      held.push(sortedGroup(match, inner));
+      return `${HELD}${held.length - 1}${HELD}`;
+    });
+    if (next === current) break;
+    current = next;
+  }
+  for (let depth = 0; depth < 24 && current.includes(HELD); depth += 1) {
+    current = current.replaceAll(
+      new RegExp(`${HELD}(\\d+)${HELD}`, "g"),
+      (_match, index) => held[Number(index)]
+    );
+  }
+  return current;
+};
+var withoutStackFrames = (name) => {
+  const frame = name.search(/\n\s+at\s/);
+  return frame === -1 ? name : name.slice(0, frame);
+};
+var withoutErrorRendering = (name) => name.replaceAll(/\[[A-Za-z]*(?:Error|Exception):[^\][]*\]/g, "{}");
+var withoutUndefinedEntries = (name) => name.replaceAll(/([{,])\s*[A-Za-z_$][\w$]*\s*:\s*undefined\s*(?=[,}])/g, "$1").replaceAll(/\{\s*,/g, "{").replaceAll(/,\s*\}/g, "}").replaceAll(/\{\s*\}/g, "{}");
+function collapsedOf(candidate, name) {
+  if (!/\[(?:Object|Array)\]/.test(candidate)) return false;
+  const pattern = candidate.split(/\[(?:Object|Array)\]/).map((part) => part.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${pattern}$`, "s").test(name);
+}
+function truncationOf(candidate, name) {
+  const cut = candidate.indexOf("\u2026");
+  if (cut === -1) return false;
+  const head = candidate.slice(0, cut);
+  const tail = candidate.slice(cut + 1);
+  return name.startsWith(head) && name.endsWith(tail);
+}
+function pairRenamed(missing, added) {
+  const remaining = [...added];
+  const renamed = [];
+  const unmatched = [];
+  for (const name of missing) {
+    const normalised = withoutRenderingNoise(name);
+    const at = remaining.findIndex((candidate) => withoutRenderingNoise(candidate) === normalised);
+    if (at === -1) {
+      unmatched.push(name);
+      continue;
+    }
+    renamed.push({ before: name, after: remaining[at] });
+    remaining.splice(at, 1);
+  }
+  const lost = [];
+  for (const name of unmatched) {
+    const normalised = withoutRenderingNoise(name);
+    const at = remaining.findIndex(
+      (candidate) => truncationOf(withoutRenderingNoise(candidate), normalised) || collapsedOf(normalised, withoutRenderingNoise(candidate))
+    );
+    if (at === -1) {
+      lost.push(name);
+      continue;
+    }
+    renamed.push({ before: name, after: remaining[at] });
+    remaining.splice(at, 1);
+  }
+  return { renamed, missing: lost, added: remaining };
+}
+function compareSnapshots(before, after) {
+  const beforeAll = [...before.passing, ...before.failing];
+  const afterAll = [...after.passing, ...after.failing];
+  const paired = pairRenamed(difference(beforeAll, afterAll), difference(afterAll, beforeAll));
+  const renamedBefore = new Set(paired.renamed.map((pair) => pair.before));
+  const regressed = difference(before.passing, after.passing).filter(
+    (name) => !paired.missing.includes(name) && !renamedBefore.has(name)
+  );
+  const failedBefore = new Set(before.failing);
+  const recovered = after.passing.filter((name) => failedBefore.has(name));
+  return {
+    identical: paired.missing.length === 0 && paired.added.length === 0 && regressed.length === 0,
+    missing: paired.missing,
+    added: paired.added,
+    regressed,
+    renamed: paired.renamed,
+    recovered,
+    alreadyFailing: before.failing.length
+  };
+}
+function unusableAsBaseline(snapshot) {
+  if (snapshot.unloadable.length > 0) {
+    return `${snapshot.unloadable.length} file(s) in the reference run did not load, so they reported no test at all and the run is short by however many they hold: ${snapshot.unloadable.slice(0, 3).join(", ")}. A reference that quietly lost tests cannot prove anything about the run after it`;
+  }
+  if (snapshot.claimedFailing > snapshot.failing.length) {
+    return `the reference run says ${snapshot.claimedFailing} test(s) failed and names only ${snapshot.failing.length} of them, so the comparison has nothing to pair the rest against and would report them as invented by the migration`;
+  }
+  if (snapshot.passing.length === 0) {
+    return `the reference run reports no passing test at all, so a green run after would prove nothing: there is no claim to preserve`;
+  }
+  return void 0;
+}
+function describeComparison(comparison) {
+  const renamedNote = comparison.renamed.length > 0 ? ` ${comparison.renamed.length} test(s) kept their identity and changed name, because the runners render an each title's interpolated value differently (e.g. "${comparison.renamed[0]?.before.slice(-40)}" -> "${comparison.renamed[0]?.after.slice(-40)}").` : "";
+  const alreadyRedNote = comparison.alreadyFailing > 0 ? ` ${comparison.alreadyFailing} test(s) were already failing before the migration and are outside this comparison, which covers only what passed.` : "";
+  const recoveredNote = comparison.recovered.length > 0 ? ` ${comparison.recovered.length} test(s) were failing before and pass now.` : "";
+  if (comparison.identical) {
+    return `every test that ran before runs and passes now.${recoveredNote}${renamedNote}${alreadyRedNote}`;
+  }
+  const parts = [];
+  if (comparison.recovered.length > 0) {
+    parts.push(`${comparison.recovered.length} test(s) were failing before and pass now`);
+  }
+  if (comparison.missing.length > 0) {
+    parts.push(
+      `${comparison.missing.length} test(s) no longer exist: ${comparison.missing.slice(0, 3).join(", ")}`
+    );
+  }
+  if (comparison.added.length > 0) {
+    parts.push(
+      `${comparison.added.length} test(s) appeared, which a migration should not do: ${comparison.added.slice(0, 3).join(", ")}`
+    );
+  }
+  if (comparison.regressed.length > 0) {
+    parts.push(
+      `${comparison.regressed.length} test(s) passed before and do not now: ${comparison.regressed.slice(0, 3).join(", ")}`
+    );
+  }
+  return `${parts.join("; ")}${renamedNote}${alreadyRedNote}`;
+}
+
+// src/roles/test/reference.ts
+var REFERENCE_FILE = ".sentinel-test-reference.json";
+function runJest(cwd, config) {
+  const bin = resolveBin(cwd, "jest");
+  if (bin === void 0) return void 0;
+  const root = findWorkspaceRoot(cwd) ?? cwd;
+  const out = join36(mkdtempSync(join36(tmpdir(), "sentinel-reference-")), "jest.json");
+  try {
+    execFileSync(bin, ["-c", join36(cwd, config), "--json", `--outputFile=${out}`, "--silent"], {
+      cwd: root,
+      stdio: ["ignore", "ignore", "ignore"],
+      maxBuffer: 1 << 28
+    });
+  } catch {
+  }
+  if (!existsSync30(out)) return void 0;
+  try {
+    return JSON.parse(readFileSync29(out, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function captureReference(cwd, config) {
+  const report = runJest(cwd, config);
+  if (report === void 0) {
+    return {
+      captured: false,
+      message: `could not run jest to record a reference, so this migration cannot be PROVED. It is still applied: a module whose jest run is broken can move, it just cannot be compared.`
+    };
+  }
+  const snapshot = readSnapshot(report);
+  const unusable = unusableAsBaseline(snapshot);
+  if (unusable !== void 0) {
+    return {
+      captured: false,
+      message: `no reference recorded: ${unusable} The migration is applied anyway, unproved.`
+    };
+  }
+  const stored = {
+    runner: "jest",
+    config,
+    takenAt: (/* @__PURE__ */ new Date()).toISOString(),
+    snapshot
+  };
+  writeFileSync3(join36(cwd, REFERENCE_FILE), `${JSON.stringify(stored, void 0, 2)}
+`);
+  return {
+    captured: true,
+    message: `recorded ${snapshot.passing.length} passing test name(s) from ${config} as the reference. The next \`sentinel --run --test\` compares against it.`
+  };
+}
+function hasReference(cwd) {
+  return existsSync30(join36(cwd, REFERENCE_FILE));
+}
+function compareAgainstReference(cwd, report) {
+  const path = join36(cwd, REFERENCE_FILE);
+  let stored;
+  try {
+    stored = JSON.parse(readFileSync29(path, "utf8"));
+  } catch {
+    rmSync3(path, { force: true });
+    return { ok: true, message: `the recorded reference could not be read, so nothing was proved.` };
+  }
+  const comparison = compareSnapshots(stored.snapshot, readSnapshot(report));
+  rmSync3(path, { force: true });
+  return {
+    ok: comparison.identical,
+    message: `${describeComparison(comparison)} (reference: ${stored.config}, ${stored.takenAt})`
+  };
+}
+
 // src/roles/test/adapters/vitest/vitest.adapter.ts
 function resolveVitest(cwd) {
   const fromSentinel = binFromOwnInstall("vitest", "vitest");
@@ -8376,6 +8703,22 @@ var VitestAdapter = class extends BaseAdapter {
   appliesTo(_preset) {
     return true;
   }
+  /**
+   * Record what this module's tests do TODAY, at the last moment it is still true.
+   *
+   * The plan about to be applied deletes the jest config, and with it any way of asking again. A
+   * migration that cannot be compared to what came before is a migration nobody can check, which
+   * is the whole reason this role has a baseline gate at all.
+   */
+  async beforeInit(ctx) {
+    const adoption = readTestAdoption(ctx.cwd);
+    if (adoption.state !== "jest") return Promise.resolve();
+    const [config] = adoption.jestConfigs;
+    if (config === void 0) return Promise.resolve();
+    this.say(`recording the jest reference before migrating...`);
+    this.say(captureReference(ctx.cwd, config).message);
+    return Promise.resolve();
+  }
   plan(context) {
     return plan3(context);
   }
@@ -8422,13 +8765,31 @@ var VitestAdapter = class extends BaseAdapter {
     }
     const { options, paths } = splitToolArgs(ctx.cwd, ctx.toolArgs, { valueFlags: [] });
     const watching = options.includes("--watch") || options.includes("-w");
-    const argv = watching ? [...options, ...paths] : ["run", ...options, ...paths];
+    const proving = !watching && hasReference(ctx.cwd);
+    const reportFile = proving ? join37(mkdtempSync2(join37(tmpdir2(), "sentinel-run-")), "vitest.json") : void 0;
+    const reporters = reportFile === void 0 ? [] : ["--reporter=default", "--reporter=json", `--outputFile=${reportFile}`];
+    const argv = watching ? [...options, ...paths] : ["run", ...reporters, ...options, ...paths];
     const result = spawnSync5(bin, argv, { cwd: ctx.cwd, stdio: "inherit" });
     if (result.error) {
       this.say(`could not run vitest (${result.error.message})`);
       return Promise.resolve({ ok: false, code: 1 });
     }
     const code = result.status ?? 1;
+    if (reportFile !== void 0) {
+      let report;
+      try {
+        report = JSON.parse(readFileSync30(reportFile, "utf8"));
+      } catch {
+        report = void 0;
+      }
+      if (report === void 0) {
+        this.say(`vitest wrote no report, so this run proved nothing against the reference.`);
+      } else {
+        const outcome = compareAgainstReference(ctx.cwd, report);
+        this.say(outcome.message);
+        if (!outcome.ok) return Promise.resolve({ ok: false, code: code === 0 ? 1 : code });
+      }
+    }
     return Promise.resolve({ ok: code === 0, code });
   }
   say(message) {
@@ -8445,9 +8806,9 @@ function registerTest() {
 
 // src/roles/typescript/adapters/tsc/tsc.adapter.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync32 } from "fs";
 import { createRequire as createRequire6 } from "module";
-import { join as join37 } from "path";
+import { join as join39 } from "path";
 
 // src/roles/typescript/presets/nest.json
 var nest_default2 = {
@@ -8628,8 +8989,8 @@ function readTsconfigAdoption(cwd) {
 }
 
 // src/roles/typescript/adapters/tsc/plan.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join36 } from "path";
+import { readFileSync as readFileSync31 } from "fs";
+import { join as join38 } from "path";
 
 // src/roles/typescript/typecheck-script.ts
 var SENTINEL_TYPECHECK_COMMAND = "sentinel --run --typescript";
@@ -8722,7 +9083,7 @@ function planAdoption(context) {
     };
   }
   const existing = parseJsonc(
-    readFileSync29(join36(context.cwd, target.path), "utf8"),
+    readFileSync31(join38(context.cwd, target.path), "utf8"),
     target.path
   );
   const extendsChain = composeExtends(existing.extends, preset);
@@ -8860,7 +9221,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     let chain;
     try {
       const parsed = parseJsonc(
-        readFileSync30(join37(cwd, target.path), "utf8"),
+        readFileSync32(join39(cwd, target.path), "utf8"),
         target.path
       );
       chain = parsed.extends;
@@ -8873,7 +9234,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
     );
     if (preset === void 0) return void 0;
     try {
-      createRequire6(join37(cwd, "noop.js")).resolve(preset);
+      createRequire6(join39(cwd, "noop.js")).resolve(preset);
       return void 0;
     } catch {
       return preset;
@@ -8969,7 +9330,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
   referencedProjects(cwd, config) {
     try {
       const parsed = parseJsonc(
-        readFileSync30(join37(cwd, config), "utf8"),
+        readFileSync32(join39(cwd, config), "utf8"),
         config
       );
       const referenced = (parsed.references ?? []).map((reference) => reference.path).filter((path) => typeof path === "string" && path.length > 0);
@@ -8985,7 +9346,7 @@ var TscAdapter = class _TscAdapter extends BaseAdapter {
    * check.
    */
   typecheckTarget(cwd) {
-    if (existsSync29(join37(cwd, "tsconfig.json"))) return "tsconfig.json";
+    if (existsSync31(join39(cwd, "tsconfig.json"))) return "tsconfig.json";
     const target = resolveTsconfigTarget(cwd);
     return target.reason === "none" ? null : target.path;
   }
@@ -9190,7 +9551,7 @@ function replaceLines(current, replacements) {
 }
 
 // src/core/apply-plan.ts
-import { existsSync as existsSync30, readFileSync as readFileSync31, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync33, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve5, sep } from "path";
 import { applyEdits as applyEdits3, findNodeAtLocation, modify, parseTree } from "jsonc-parser";
 
@@ -9209,7 +9570,7 @@ function resolveWithinRoot(cwd, relativePath) {
   return absolutePath;
 }
 function readIfExists(absolutePath) {
-  return existsSync30(absolutePath) ? readFileSync31(absolutePath, "utf8") : void 0;
+  return existsSync32(absolutePath) ? readFileSync33(absolutePath, "utf8") : void 0;
 }
 function* leaves(value, prefix = []) {
   for (const [key, keyValue] of Object.entries(value)) {
@@ -9311,14 +9672,14 @@ function preparePlan(cwd, plan4) {
 }
 function writeFileAtomic(absolutePath, contents) {
   const tempPath = `${absolutePath}.sentinel-${process.pid}.tmp`;
-  writeFileSync3(tempPath, contents);
+  writeFileSync4(tempPath, contents);
   renameSync(tempPath, absolutePath);
 }
 function applyPlan(cwd, plan4) {
   const changed = preparePlan(cwd, plan4).filter((file) => file.before !== file.after);
   for (const file of changed) {
     if (file.deleted) {
-      rmSync3(file.absolutePath, { force: true });
+      rmSync4(file.absolutePath, { force: true });
       continue;
     }
     writeFileAtomic(file.absolutePath, file.after);
@@ -9327,8 +9688,8 @@ function applyPlan(cwd, plan4) {
 }
 
 // src/core/config/preset-evidence.ts
-import { existsSync as existsSync31, readdirSync as readdirSync8, readFileSync as readFileSync32 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync8, readFileSync as readFileSync34 } from "fs";
+import { join as join40 } from "path";
 var PATH_SIGNALS = [
   {
     preset: "nest",
@@ -9362,12 +9723,12 @@ function sourceImports(cwd, pattern) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (!NOT_SCANNED.has(entry.name)) stack.push(join38(dir, entry.name));
+        if (!NOT_SCANNED.has(entry.name)) stack.push(join40(dir, entry.name));
         continue;
       }
       if (!SOURCE_FILE2.test(entry.name)) continue;
       try {
-        if (pattern.test(readFileSync32(join38(dir, entry.name), "utf8"))) return true;
+        if (pattern.test(readFileSync34(join40(dir, entry.name), "utf8"))) return true;
       } catch {
         continue;
       }
@@ -9376,11 +9737,11 @@ function sourceImports(cwd, pattern) {
   return false;
 }
 function dependencyNames(cwd) {
-  const path = join38(cwd, "package.json");
-  if (!existsSync31(path)) return [];
+  const path = join40(cwd, "package.json");
+  if (!existsSync33(path)) return [];
   try {
     const manifest = parseJsonc(
-      readFileSync32(path, "utf8"),
+      readFileSync34(path, "utf8"),
       path
     );
     return [
@@ -9403,7 +9764,7 @@ function declaresJsx(cwd) {
   for (const name of entries) {
     try {
       const config = parseJsonc(
-        readFileSync32(join38(cwd, name), "utf8"),
+        readFileSync34(join40(cwd, name), "utf8"),
         name
       );
       if (config.compilerOptions?.jsx !== void 0) return true;
@@ -9548,6 +9909,15 @@ async function dispatch(opts) {
   if (opts.dryRun) {
     return previewPlan(opts, plan4);
   }
+  if (adapter.beforeInit) {
+    await adapter.beforeInit({
+      module: basename3(opts.cwd),
+      cwd: opts.cwd,
+      preset,
+      ci: false,
+      fix: false
+    });
+  }
   for (const change of applyPlan(opts.cwd, plan4)) {
     process.stderr.write(`  ${change.deleted ? "removed" : "wrote"} ${change.path}
 `);
@@ -9591,4 +9961,4 @@ export {
   detectFramework,
   dispatch
 };
-//# sourceMappingURL=chunk-4UIZJ3TR.js.map
+//# sourceMappingURL=chunk-MUQWAZQN.js.map