@geonosis/ratchet 2.1.0 → 2.2.0

package/dist/{chunk-H4PLCM5J.js → chunk-IQ6TXLWC.js}

@@ -1,6 +1,6 @@
 // src/core/envelope.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 var ENVELOPES_DIR = ".geonosis/envelopes";
 var envelopePath = (root, tool) => join(root, ENVELOPES_DIR, `${tool}.json`);
@@ -12,6 +12,14 @@ var UnbalancedEnvelope = class extends Error {
 };
 var isCount = (value) => Number.isSafeInteger(value) && value >= 0;
 var unbalancedMessage = (envelope, next) => `${envelope.tool}: considered ${envelope.considered} but accounts for ${envelope.read + envelope.refused.length + envelope.excused.length} \u2014 ${envelope.read} read + ${envelope.refused.length} refused + ${envelope.excused.length} excused. A run that has lost count of its own inputs cannot say what it measured, so no verdict was rendered and no envelope was written. Next: ${next}`;
+var FORBIDDEN_ROOT = "GEONOSIS_ENVELOPES_FORBIDDEN_ROOT";
+var refuseForbiddenRoot = (root) => {
+  const forbidden = process.env[FORBIDDEN_ROOT];
+  if (forbidden === void 0 || resolve(forbidden) !== resolve(root)) return;
+  throw new UnbalancedEnvelope(
+    `${root} is off limits to envelope writers in this process (${FORBIDDEN_ROOT}) \u2014 a run that writes one into a shared root races every other run reading it, and leaves a file the next one takes for real. Point this at a scratch root of its own: tooling/scratch-dir.ts.`
+  );
+};
 var writeEnvelope = ({
   envelope,
   next,
@@ -35,6 +43,7 @@ var writeEnvelope = ({
   if (envelope.considered !== envelope.read + envelope.refused.length + envelope.excused.length) {
     throw new UnbalancedEnvelope(unbalancedMessage(envelope, next));
   }
+  refuseForbiddenRoot(root);
   const at = envelopePath(root, envelope.tool);
   mkdirSync(dirname(at), { recursive: true });
   writeFileSync(at, `${JSON.stringify(envelope, void 0, 2)}
@@ -153,11 +162,11 @@ var acquireExclusive = async ({
 
 // src/core/config.ts
 import { existsSync, readFileSync as readFileSync3 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 var CONFIG_FILE = "geonosis.ratchet.json";
 var keyOf = (entry) => entry.key ?? entry.counter;
 var loadConfig = (cwd) => {
-  const path = resolve(cwd, CONFIG_FILE);
+  const path = resolve2(cwd, CONFIG_FILE);
   if (!existsSync(path)) {
     throw new Error(`no ${CONFIG_FILE} in ${cwd} \u2014 the ratchet has nothing to count`);
   }
@@ -189,7 +198,7 @@ var loadConfig = (cwd) => {
 };
 var resolveBaseline = (cwd) => {
   try {
-    const parsed = JSON.parse(readFileSync3(resolve(cwd, CONFIG_FILE), "utf8"));
+    const parsed = JSON.parse(readFileSync3(resolve2(cwd, CONFIG_FILE), "utf8"));
     return typeof parsed.baseline === "string" ? parsed.baseline : "gate-baseline.json";
   } catch {
     return "gate-baseline.json";
@@ -237,11 +246,11 @@ ${output.trim()}`
 // src/core/prove.ts
 import { existsSync as existsSync2, mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { delimiter, dirname as dirname4, join as join3, resolve as resolve3 } from "path";
+import { delimiter, dirname as dirname4, join as join3, resolve as resolve4 } from "path";
 
 // src/core/exclusive.ts
 import { spawn } from "child_process";
-import { dirname as dirname3, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 var MARK = /^exclusive-hold (start|end) (\d+)$/gm;
 var KEY = "exclusive";
 var spanOf = (output) => {
@@ -256,7 +265,7 @@ var hold = (cli, holdMs, lockPath) => new Promise((done) => {
     process.execPath,
     [cli, "--exclusive", "--exclusive-timeout", "60", "--hold", String(holdMs)],
     {
-      cwd: dirname3(resolve2(cli)),
+      cwd: dirname3(resolve3(cli)),
       env: { ...process.env, GEONOSIS_HEAVY_LOCK: lockPath },
       stdio: ["ignore", "pipe", "pipe"]
     }
@@ -306,7 +315,7 @@ ${runs.map((one) => `exit ${String(one.code)}: ${one.output.trim().slice(-300)}`
 // src/core/prove.ts
 var toolPath = (cwd) => {
   const dirs = [];
-  let dir = resolve3(cwd);
+  let dir = resolve4(cwd);
   for (; ; ) {
     const bin = join3(dir, "node_modules", ".bin");
     if (existsSync2(bin)) dirs.push(bin);
@@ -433,7 +442,7 @@ var runProve = async ({
 
 // src/core/ratchet.ts
 import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var EVIDENCE_LINES = 10;
 var recorded = (counter, params, run) => {
   let output = "";
@@ -480,7 +489,7 @@ var runRatchet = async ({
   tier
 }) => {
   const config = loadConfig(cwd);
-  const baselinePath = resolve4(cwd, config.baseline);
+  const baselinePath = resolve5(cwd, config.baseline);
   if (!existsSync3(baselinePath)) {
     throw new Error(`no ${config.baseline} in ${cwd} \u2014 nothing to ratchet against`);
   }
@@ -649,7 +658,7 @@ var bundleBytes = {
 
 // src/counters/ci.ts
 import { readdirSync, readFileSync as readFileSync5 } from "fs";
-import { join as join5, resolve as resolve5 } from "path";
+import { join as join5, resolve as resolve6 } from "path";
 var DISABLED = /\bif:[ \t]*false\b/;
 var WORKFLOW = /\.ya?ml$/;
 var disabledCiJobs = {
@@ -664,7 +673,7 @@ var disabledCiJobs = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("disabledCiJobs", params, "dir", ".github/workflows");
-    const dir = resolve5(cwd, relative);
+    const dir = resolve6(cwd, relative);
     let files;
     try {
       files = readdirSync(dir, { withFileTypes: true }).filter((entry) => WORKFLOW.test(entry.name)).map((entry) => join5(dir, entry.name));
@@ -722,12 +731,40 @@ var excusesIn = (params) => {
     typeof declared === "object" && declared !== null && !Array.isArray(declared) ? Object.keys(declared) : []
   );
 };
+var HEADING_LINE = /^([A-Z][A-Za-z ]+?) \((\d+)\)\s*$/;
+var UNRESOLVED = "Unresolved imports";
+var KNIP_DEFAULT = "npx knip --reporter compact";
+var knipEvidence = ({
+  output,
+  params
+}) => {
+  const command = typeof params["command"] === "string" ? params["command"] : KNIP_DEFAULT;
+  const said = [];
+  let heading;
+  for (const line of output.split("\n")) {
+    const found = HEADING_LINE.exec(line);
+    if (found !== null) {
+      heading = found[1];
+      said.push(line.trim());
+      continue;
+    }
+    if (heading === void 0 || line.trim() === "") continue;
+    said.push(`  ${line.trim()}`);
+    if (heading === UNRESOLVED) {
+      said.push(
+        `  resolved by \`${command}\` on ${process.version} \u2014 an unresolved import is a fact about the resolver, and this class read one number on CI and another on a laptop over one tree`
+      );
+    }
+  }
+  return said;
+};
 var knipIssues = {
+  evidence: knipEvidence,
   id: "knipIssues",
   probe: { ...captured("Unused files (1)\nsrc/gone.ts\n"), expect: 1 },
   readingParams: ["headings"],
   run: async ({ params, run }) => {
-    const command = stringParam("knipIssues", params, "command", "npx knip --reporter compact");
+    const command = stringParam("knipIssues", params, "command", KNIP_DEFAULT);
     const printed = headingsIn(run(command).output);
     const counted = stringsParam(params, "headings", [...printed.keys()]);
     const excused = excusesIn(params);
@@ -755,7 +792,7 @@ var boundaryIssues = {
 
 // src/counters/format.ts
 import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 var unformattedFiles = {
   id: "unformattedFiles",
   probe: {
@@ -770,13 +807,13 @@ var unformattedFiles = {
       "command",
       "npx oxfmt --config .oxfmtrc.json --list-different ."
     );
-    return run(command).output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && existsSync4(resolve6(cwd, line))).length;
+    return run(command).output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && existsSync4(resolve7(cwd, line))).length;
   }
 };
 
 // src/counters/gate-report.ts
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 var DEFAULT_REPORT = ".geonosis/gate-report.json";
 var fastTierMs = {
   id: "fastTierMs",
@@ -799,8 +836,8 @@ var fastTierMs = {
     const wanted = stringParam("fastTierMs", params, "tier", "fast");
     const own = `.geonosis/gate-report.${wanted}.json`;
     const asked = stringParam("fastTierMs", params, "report", "");
-    const relative = asked !== "" ? asked : existsSync5(resolve7(cwd, own)) ? own : DEFAULT_REPORT;
-    const path = resolve7(cwd, relative);
+    const relative = asked !== "" ? asked : existsSync5(resolve8(cwd, own)) ? own : DEFAULT_REPORT;
+    const path = resolve8(cwd, relative);
     if (!existsSync5(path)) {
       throw new CounterError(
         "fastTierMs",
@@ -832,7 +869,7 @@ var fastTierMs = {
 
 // src/counters/law.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var lawLineCount = {
   id: "lawLineCount",
   probe: {
@@ -842,7 +879,7 @@ var lawLineCount = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("lawLineCount", params, "path", "CLAUDE.md");
-    const path = resolve8(cwd, relative);
+    const path = resolve9(cwd, relative);
     if (!existsSync6(path)) throw new CounterError("lawLineCount", `no law file at ${relative}`);
     return readFileSync7(path, "utf8").replace(/\n$/, "").split("\n").length;
   }
@@ -850,7 +887,7 @@ var lawLineCount = {
 
 // src/counters/oxlint.ts
 import { existsSync as existsSync7, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 var DEFAULT_COMMAND = "npx oxlint --format=unix --config .oxlintrc.json .";
 var PROBE_COMMAND = "oxlint --format=unix --config .oxlintrc.json .";
 var oxlintProbe = (severity, rule, source) => ({
@@ -1013,18 +1050,18 @@ var oxlintRule = {
     const config = typeof params.config === "string" ? params.config : "";
     const expect = expectedFormat("oxlintRule", params);
     if (config === "") return countRule(run(command), rule, expect);
-    const source = resolve9(cwd, config);
+    const source = resolve10(cwd, config);
     if (!existsSync7(source)) throw new CounterError("oxlintRule", `no config at ${config}`);
     const strictName = `.oxlintrc.ratchet-${key}.json`;
     const strict = readFileSync8(source, "utf8").replace(
       new RegExp(`("[^"]*${escapeForRegex(rule)}"\\s*:\\s*\\[?\\s*)"(warn|off)"`),
       '$1"error"'
     );
-    writeFileSync6(resolve9(cwd, strictName), strict);
+    writeFileSync6(resolve10(cwd, strictName), strict);
     try {
       return countRule(run(command.replace("{config}", strictName)), rule, expect);
     } finally {
-      rmSync3(resolve9(cwd, strictName), { force: true });
+      rmSync3(resolve10(cwd, strictName), { force: true });
     }
   }
 };
@@ -1032,7 +1069,7 @@ var oxlintRule = {
 // src/counters/probes.ts
 import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
 import { createRequire } from "module";
-import { join as join6, resolve as resolve10 } from "path";
+import { join as join6, resolve as resolve11 } from "path";
 import { pathToFileURL } from "url";
 var ID = "probelessRules";
 var OFF = /* @__PURE__ */ new Set([0, "0", "allow", "off", false]);
@@ -1110,7 +1147,7 @@ var probelessRules = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam(ID, params, "config", ".oxlintrc.json");
-    const path = resolve10(cwd, relative);
+    const path = resolve11(cwd, relative);
     if (!existsSync8(path)) throw new CounterError(ID, `no oxlint config at ${relative}`);
     let config;
     try {
@@ -1152,7 +1189,7 @@ import { join as join8 } from "path";
 
 // src/counters/workspace.ts
 import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
-import { join as join7, resolve as resolve11 } from "path";
+import { join as join7, resolve as resolve12 } from "path";
 var SKIP = /^(node_modules|\.)/;
 var childDirs = (dir) => {
   try {
@@ -1207,7 +1244,7 @@ var nameOf = (dir) => {
   }
 };
 var workspaceDirs = (cwd) => {
-  const root = resolve11(cwd);
+  const root = resolve12(cwd);
   const pnpm = join7(root, "pnpm-workspace.yaml");
   const manifest = join7(root, "package.json");
   const patterns = existsSync9(pnpm) ? pnpmPatterns(pnpm) : existsSync9(manifest) ? npmPatterns(manifest) : [];
@@ -1283,6 +1320,56 @@ var packagesWithoutTypecheck = {
   }
 };
 
+// src/counters/seams.ts
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
+import { join as join9, resolve as resolve13 } from "path";
+var CONFIG = "geonosis.json";
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".turbo", "coverage", "dist", "node_modules"]);
+var asPattern = (glob) => new RegExp(
+  `^${glob.split("/").map(
+    (part) => part === "**" ? ".*" : part.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("*", "[^/]*")
+  ).join("/").replaceAll(".*/", "(?:.*/)?")}$`
+);
+var filesUnder = (root, at = root) => readdirSync4(at, { withFileTypes: true }).flatMap((entry) => {
+  if (SKIP_DIRS.has(entry.name)) return [];
+  const full = join9(at, entry.name);
+  if (entry.isDirectory()) return filesUnder(root, full);
+  return entry.isFile() ? [full.slice(root.length + 1)] : [];
+});
+var seamGlobsIn = (root) => {
+  const at = join9(root, CONFIG);
+  if (!existsSync10(at)) return [];
+  try {
+    const seams = JSON.parse(readFileSync11(at, "utf8")).adoption?.seams;
+    return Array.isArray(seams) ? seams.filter((one) => typeof one === "string") : [];
+  } catch {
+    return [];
+  }
+};
+var linesIn = (path) => {
+  const body = readFileSync11(path, "utf8");
+  return body === "" ? 0 : body.replace(/\n$/, "").split("\n").length;
+};
+var adoptionSeamLines = {
+  id: "adoptionSeamLines",
+  probe: {
+    expect: 3,
+    input: (dir) => {
+      plant(dir, CONFIG, `${JSON.stringify({ adoption: { seams: ["src/**/*.ts"] } })}
+`);
+      plant(dir, "src/adapter.ts", "one\ntwo\nthree\n");
+      plant(dir, "src/not-a-seam.md", "four\nfive\n");
+    },
+    params: {}
+  },
+  run: async ({ cwd }) => {
+    const root = resolve13(cwd);
+    const globs = seamGlobsIn(root).map(asPattern);
+    if (globs.length === 0) return 0;
+    return filesUnder(root).filter((one) => globs.some((pattern) => pattern.test(one))).reduce((total2, one) => total2 + linesIn(join9(root, one)), 0);
+  }
+};
+
 // src/counters/sum-of-counts.ts
 var sumOfCounts = {
   id: "sumOfCounts",
@@ -1305,15 +1392,15 @@ var sumOfCounts = {
 };
 
 // src/counters/suppressions.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
-import { join as join9, resolve as resolve12 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
+import { join as join10, resolve as resolve14 } from "path";
 var CODE_FILE = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|vue|svelte|astro)$/;
 var SKIP3 = /^(?:node_modules|dist|coverage|\.[^.]|__fixtures__)/;
 var SUPPRESSION = /(?:eslint|oxlint|biome)-(?:disable|ignore)(?:-next-line|-line)?|@ts-expect-error|@ts-ignore/g;
 var countIn = (dir, depth = 12) => {
   let entries;
   try {
-    entries = readdirSync4(dir, { withFileTypes: true });
+    entries = readdirSync5(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -1321,12 +1408,12 @@ var countIn = (dir, depth = 12) => {
   for (const entry of entries) {
     if (SKIP3.test(entry.name)) continue;
     if (entry.isDirectory()) {
-      if (depth > 0) found += countIn(join9(dir, entry.name), depth - 1);
+      if (depth > 0) found += countIn(join10(dir, entry.name), depth - 1);
       continue;
     }
     if (!CODE_FILE.test(entry.name)) continue;
     try {
-      found += readFileSync11(join9(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
+      found += readFileSync12(join10(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
     } catch {
     }
   }
@@ -1340,14 +1427,107 @@ var suppressionCount = {
   },
   run: async ({ cwd, params }) => {
     const roots = stringsParam(params, "roots", ["."]);
-    return roots.reduce((sum, root) => sum + countIn(resolve12(cwd, root)), 0);
+    return roots.reduce((sum, root) => sum + countIn(resolve14(cwd, root)), 0);
+  }
+};
+
+// src/counters/surface.ts
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { join as join11, resolve as resolve15 } from "path";
+var DECLARED = /^export\s+(?:declare\s+)?(?:abstract\s+)?(?:const|function|class|type|interface|enum|let|var)\s+([$\w]+)/;
+var BRACED = /^export\s+(?:type\s+)?\{([^}]*)\}(?:\s+from\s+(['"])(.+?)\2)?/;
+var nameOf2 = (spec) => {
+  const named = spec.trim().replace(/^type\s+/, "");
+  if (named === "") return void 0;
+  const parts = named.split(/\s+as\s+/);
+  return (parts.at(-1) ?? "").trim() || void 0;
+};
+var exportedSurfaceIn = (source) => {
+  const found = /* @__PURE__ */ new Map();
+  for (const line of source.split("\n")) {
+    const declared = DECLARED.exec(line);
+    if (declared !== null) {
+      found.set(declared[1] ?? "", line.trim());
+      continue;
+    }
+    const braced = BRACED.exec(line);
+    if (braced === null) continue;
+    const from = braced[3];
+    for (const spec of (braced[1] ?? "").split(",")) {
+      const name = nameOf2(spec);
+      if (name === void 0) continue;
+      found.set(
+        name,
+        from === void 0 ? `export { ${name} }` : `export { ${name} } from '${from}'`
+      );
+    }
+  }
+  return found;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var declarationEntriesOf = (dir) => {
+  const at = join11(dir, "package.json");
+  if (!existsSync11(at)) {
+    throw new CounterError("floorSurface", `no package.json in ${dir} \u2014 that is not a package`);
+  }
+  const manifest = JSON.parse(readFileSync13(at, "utf8"));
+  const found = [];
+  const walk = (value) => {
+    if (typeof value === "string" && value.endsWith(".d.ts")) found.push(value);
+    if (isRecord(value)) for (const one of Object.values(value)) walk(one);
+  };
+  walk({ exports: manifest["exports"], types: manifest["types"] });
+  return [...new Set(found)];
+};
+var floorSurface = {
+  evidence: ({ params }) => [`the doors declared by ${String(params["dir"] ?? "this package")}`],
+  id: "floorSurface",
+  probe: {
+    expect: 3,
+    input: (dir) => {
+      plant(
+        dir,
+        "floor/package.json",
+        `${JSON.stringify({ exports: { ".": { types: "./dist/index.d.ts" } }, name: "floor" })}
+`
+      );
+      plant(
+        dir,
+        "floor/dist/index.d.ts",
+        "export declare const open: () => void;\nexport type Handle = { id: string };\nexport { c as close } from './chunk.js';\ndeclare const hidden: number;\n"
+      );
+    },
+    params: { dir: "floor" }
+  },
+  run: async ({ cwd, params }) => {
+    const relative = stringParam("floorSurface", params, "dir");
+    const dir = resolve15(cwd, relative);
+    const entries = declarationEntriesOf(dir);
+    if (entries.length === 0) {
+      throw new CounterError(
+        "floorSurface",
+        `${relative} promises no .d.ts in its exports map \u2014 a package whose surface cannot be read is not a package this can hold`
+      );
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const at = resolve15(dir, entry);
+      if (!existsSync11(at)) {
+        throw new CounterError(
+          "floorSurface",
+          `${relative} promises ${entry} and it is not there \u2014 build before measuring, or the surface reads as empty`
+        );
+      }
+      for (const name of exportedSurfaceIn(readFileSync13(at, "utf8")).keys()) names.add(name);
+    }
+    return names.size;
   }
 };
 
 // src/counters/tests.ts
-import { existsSync as existsSync10, mkdtempSync as mkdtempSync2, readFileSync as readFileSync12, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync12, mkdtempSync as mkdtempSync2, readFileSync as readFileSync14, rmSync as rmSync4 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join10, resolve as resolve13 } from "path";
+import { join as join12, resolve as resolve16 } from "path";
 var COUNTER = "testFailures";
 var VITEST_LINE = /^\s*Tests {2,}(.+?)\s*$/;
 var VITEST_TOTAL = /\(\d+\)$/;
@@ -1379,7 +1559,7 @@ ${output.trim().slice(-500)}`
   );
 };
 var fromReport = (path) => {
-  if (!existsSync10(path)) {
+  if (!existsSync12(path)) {
     throw new CounterError(
       COUNTER,
       `the runner wrote no report at ${path} \u2014 a crash before the reporter is not a pass`
@@ -1387,7 +1567,7 @@ var fromReport = (path) => {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync12(path, "utf8"));
+    report = JSON.parse(readFileSync14(path, "utf8"));
   } catch (error) {
     throw new CounterError(
       COUNTER,
@@ -1411,14 +1591,14 @@ var fromReport = (path) => {
 };
 var reportPathFor = (cwd, params, command) => {
   const named = params.reportPath;
-  if (typeof named === "string" && named !== "") return { own: false, path: resolve13(cwd, named) };
+  if (typeof named === "string" && named !== "") return { own: false, path: resolve16(cwd, named) };
   if (!command.includes(PLACEHOLDER)) {
     throw new CounterError(
       COUNTER,
       `report: "${VITEST_JSON}" needs somewhere to put the report \u2014 write ${PLACEHOLDER} into the command (--outputFile=${PLACEHOLDER}) or give the entry a "reportPath"`
     );
   }
-  return { own: true, path: join10(mkdtempSync2(join10(tmpdir2(), "geonosis-report-")), "report.json") };
+  return { own: true, path: join12(mkdtempSync2(join12(tmpdir2(), "geonosis-report-")), "report.json") };
 };
 var testFailures = {
   id: COUNTER,
@@ -1467,21 +1647,21 @@ var testFailures = {
       run(command.replaceAll(PLACEHOLDER, path));
       return fromReport(path);
     } finally {
-      if (own) rmSync4(join10(path, ".."), { force: true, recursive: true });
+      if (own) rmSync4(join12(path, ".."), { force: true, recursive: true });
     }
   }
 };
 
 // src/counters/todos.ts
-import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync13 } from "fs";
-import { join as join11, resolve as resolve14 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
+import { join as join13, resolve as resolve17 } from "path";
 var CODE_FILE2 = /\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|vue|svelte|astro)$/;
 var SKIP4 = /^(?:node_modules|dist|coverage|\.[^.]|__fixtures__)/;
 var PLAN_FILE = /^(\d{3,})-[a-z\d][a-z\d.-]*\.md$/;
 var plansIn = (dir) => {
-  if (!existsSync11(dir)) return /* @__PURE__ */ new Set();
+  if (!existsSync13(dir)) return /* @__PURE__ */ new Set();
   const found = /* @__PURE__ */ new Set();
-  for (const name of readdirSync5(dir)) {
+  for (const name of readdirSync6(dir)) {
     const number = PLAN_FILE.exec(name)?.[1];
     if (number !== void 0) found.add(String(Number(number)));
   }
@@ -1490,7 +1670,7 @@ var plansIn = (dir) => {
 var countIn2 = (dir, marker, plans, depth = 12) => {
   let entries;
   try {
-    entries = readdirSync5(dir, { withFileTypes: true });
+    entries = readdirSync6(dir, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -1498,13 +1678,13 @@ var countIn2 = (dir, marker, plans, depth = 12) => {
   for (const entry of entries) {
     if (SKIP4.test(entry.name)) continue;
     if (entry.isDirectory()) {
-      if (depth > 0) found += countIn2(join11(dir, entry.name), marker, plans, depth - 1);
+      if (depth > 0) found += countIn2(join13(dir, entry.name), marker, plans, depth - 1);
       continue;
     }
     if (!CODE_FILE2.test(entry.name)) continue;
     let text = "";
     try {
-      text = readFileSync13(join11(dir, entry.name), "utf8");
+      text = readFileSync15(join13(dir, entry.name), "utf8");
     } catch {
       continue;
     }
@@ -1528,22 +1708,22 @@ var orphanTodos = {
   readingParams: ["markers"],
   run: async ({ cwd, params }) => {
     const markers = stringsParam(params, "markers", ["TODO", "FIXME"]);
-    const plans = plansIn(resolve14(cwd, stringParam("orphanTodos", params, "plans", "plans")));
+    const plans = plansIn(resolve17(cwd, stringParam("orphanTodos", params, "plans", "plans")));
     const marker = new RegExp(
       `\\b(?:${markers.map(escapeForRegex).join("|")})\\b(?:\\((\\d+)\\))?`,
       "g"
     );
     const roots = stringsParam(params, "roots", ["."]);
-    return roots.reduce((sum, root) => sum + countIn2(resolve14(cwd, root), marker, plans), 0);
+    return roots.reduce((sum, root) => sum + countIn2(resolve17(cwd, root), marker, plans), 0);
   }
 };
 
 // src/counters/typecheck.ts
-var UNRESOLVED = /error TS(?:2305|2307): ([^\n]*)/g;
+var UNRESOLVED2 = /error TS(?:2305|2307): ([^\n]*)/g;
 var SPECIFIER = /'([^']+)'/g;
 var specifiersIn = (message) => [...message.matchAll(SPECIFIER)].map(([, quoted]) => (quoted ?? "").replaceAll('"', ""));
 var unbuiltIn = (cwd, output) => {
-  const messages = [...output.matchAll(UNRESOLVED)].map(([, message]) => message ?? "");
+  const messages = [...output.matchAll(UNRESOLVED2)].map(([, message]) => message ?? "");
   if (messages.length === 0) return [];
   const packages = workspacePackageNames(cwd);
   const named = messages.flatMap((message) => specifiersIn(message)).flatMap(
@@ -1573,8 +1753,8 @@ var typecheckErrors = {
 };
 
 // src/counters/walk.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
+import { resolve as resolve18 } from "path";
 var DEFAULT_REPORT2 = ".geonosis/walk-report.json";
 var CLASSES = /* @__PURE__ */ new Set([
   "buy-box-above-fold",
@@ -1618,8 +1798,8 @@ var walkFindings = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("walkFindings", params, "report", DEFAULT_REPORT2);
-    const path = resolve15(cwd, relative);
-    if (!existsSync12(path)) {
+    const path = resolve18(cwd, relative);
+    if (!existsSync14(path)) {
       throw new CounterError(
         "walkFindings",
         `no walk report at ${relative} \u2014 run \`geonosis-walk\` before measuring it`
@@ -1627,7 +1807,7 @@ var walkFindings = {
     }
     let report;
     try {
-      report = JSON.parse(readFileSync14(path, "utf8"));
+      report = JSON.parse(readFileSync16(path, "utf8"));
     } catch (error) {
       throw new CounterError(
         "walkFindings",
@@ -1649,12 +1829,14 @@ var walkFindings = {
 
 // src/counters/index.ts
 var COUNTERS = [
+  adoptionSeamLines,
   archViolations,
   boundaryIssues,
   bundleBytes,
   cloneCount,
   disabledCiJobs,
   fastTierMs,
+  floorSurface,
   knipIssues,
   lawLineCount,
   suppressionCount,

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-H4PLCM5J.js";
+} from "./chunk-IQ6TXLWC.js";
 
 // src/cli.ts
 import process from "process";

package/dist/index.d.ts

@@ -259,12 +259,6 @@ declare const envelopePath: (root: string, tool: string) => string;
 declare class UnbalancedEnvelope extends Error {
     constructor(message: string);
 }
-/**
- * Writes the envelope, or refuses. Returns the path written so a caller can print it.
- *
- * The check is before the write and not after it, because a file on disk is a verdict: the doctor
- * would read a half-true envelope and report on numbers nobody stands behind.
- */
 declare const writeEnvelope: ({ envelope, next, root, }: {
     envelope: ReportEnvelope;
     /** The command a reader should run to see the accounting for themselves. */

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-H4PLCM5J.js";
+} from "./chunk-IQ6TXLWC.js";
 export {
   CONFIG_FILE,
   COUNTERS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/ratchet",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "types": "./dist/index.d.ts",
   "description": "Debt as a number that may only shrink — one ratchet, pluggable counters.",
   "keywords": [