@geonosis/ratchet 2.1.0 → 2.3.0

package/README.md

@@ -1,5 +1,8 @@
 # @geonosis/ratchet
 
+Through the front door: `geonosis ratchet` — the metapackage pins this and every other kit tool at
+ONE version, and passes the exit code through unchanged.
+
 Debt as a number that may only shrink. It measures a repo's counters, compares each against a
 committed baseline, and fails **only** on regression — so a repo can adopt a gate the day it is
 written, with the existing debt named rather than forgiven, and nothing new can land behind it.
@@ -66,6 +69,34 @@ A counter you wrote yourself takes a `probe` beside its `run`: `{ input: (dir) =
 (dir) => string, params?, expect: number }`. `expect` is what the planted input is worth, and it is
 at least 1 — a probe that plants nothing proves nothing.
 
+### A probe proves the command, not the regex
+
+A shipped probe plants an input in the shape the counter's OWN default reads. `archViolations`
+plants a scanner that prints `✗ …` lines and exits non-zero; `sumOfCounts` plants a line its default
+`match` counts. That proves the command is spawned, its output is captured and its exit code is told
+apart from its findings — and it proves nothing whatever about a `match` YOUR config supplies,
+because the planted input was written for the default one.
+
+This was measured, not imagined: a consumer's mis-escaped `match` read 0 from a real scan, `--prove`
+said PROVEN off the shipped plant, and the ratchet lowered the baseline — ten pieces of debt erased
+with a congratulatory message (#140).
+
+So the counters that take a reading param — `archViolations` (`match`), `sumOfCounts` (`match`),
+`duplication` (`headings`), `todos` (`markers`) — require a sample from the config that supplied it:
+
+```jsonc
+{
+  "counter": "archViolations",
+  "command": "node scripts/scan-architecture.mjs",
+  "match": "^VIOLATION ",
+  "probe": { "sample": "VIOLATION a\nVIOLATION b\nfine\n", "expect": 2 }
+}
+```
+
+Without the `probe` block the line reads `UNPROVEN`, naming the param and its value. With it, the
+sample is run through YOUR match and must count `expect` — a sample your match cannot read is a
+refusal that names the match, not a zero.
+
 ### A baseline is not proof the gate still gates
 
 The ratchet compares a number against a number. Swapping the tool that produces it — a vendored lint
@@ -196,9 +227,9 @@ captured from the binary rather than guessed at:
 
 | Runner | The line | Read as |
 | --- | --- | --- |
-| vitest 3.2.7 | `      Tests  1 failed \| 1 passed (2)` | 1 |
-| vitest 3.2.7 | `      Tests  3 passed (3)` · `      Tests  2 skipped (2)` | 0 |
-| vitest 3.2.7 | `      Tests  no tests` (a suite that threw before collecting) | **refused** |
+| vitest 3.2.7 · 4.1.11 | `      Tests  1 failed \| 1 passed (2)` | 1 |
+| vitest 3.2.7 · 4.1.11 | `      Tests  3 passed (3)` · `      Tests  2 skipped (2)` | 0 |
+| vitest 3.2.7 · 4.1.11 | `      Tests  no tests` (a suite that threw before collecting) | **refused** |
 | bun 1.4.0 | ` 1 fail` on its own line | 1 |
 | bun 1.4.0 | ` 0 fail` | 0 |
 

package/dist/{chunk-H4PLCM5J.js → chunk-E55APSHM.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)}
@@ -65,8 +74,14 @@ var versionOf = (moduleUrl) => {
 import { randomUUID } from "crypto";
 import { linkSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname2, join as join2 } from "path";
-var heavyLockPath = () => process.env.GEONOSIS_HEAVY_LOCK ?? join2(homedir(), ".cache", "geonosis", "heavy.lock");
+import { dirname as dirname2, isAbsolute, join as join2 } from "path";
+var heavyLockPath = () => {
+  const named = process.env.GEONOSIS_HEAVY_LOCK;
+  if (named !== void 0 && named !== "") return named;
+  const declared = process.env.XDG_CACHE_HOME;
+  const cache = declared !== void 0 && isAbsolute(declared) ? declared : join2(homedir(), ".cache");
+  return join2(cache, "geonosis", "heavy.lock");
+};
 var sleep = (ms) => new Promise((done) => setTimeout(done, ms));
 var holderOf = (path) => {
   try {
@@ -153,11 +168,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 +204,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 +252,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 +271,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 +321,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 +448,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 +495,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`);
   }
@@ -597,6 +612,10 @@ var scannerProbe = {
 var archViolations = {
   id: "archViolations",
   probe: { ...scannerProbe, expect: 2 },
+  // #30: the shipped probe runs a scanner that prints `✗`, so it proves the COMMAND and never a
+  // `match` a repo configured for its own scanner's shape. Declared here, a customised match is
+  // UNPROVEN until the config declares a sample of its own.
+  readingParams: ["match"],
   run: async ({ params, run }) => {
     const command = stringParam("archViolations", params, "command");
     const match = new RegExp(stringParam("archViolations", params, "match", "^\u2717"));
@@ -649,7 +668,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 +683,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 +741,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);
@@ -753,9 +800,119 @@ var boundaryIssues = {
   }
 };
 
+// src/counters/dx.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve7 } from "path";
+var DEFAULT_BUMP_REPORT = ".geonosis/bump-report.json";
+var bumpFile = (id, cwd, params) => {
+  const relative = stringParam(id, params, "report", DEFAULT_BUMP_REPORT);
+  const path = resolve7(cwd, relative);
+  if (!existsSync4(path)) {
+    throw new CounterError(
+      id,
+      `no bump report at ${relative} \u2014 this repo has never run \`geonosis update\`, and a zero here would read as a bump that took no time`
+    );
+  }
+  try {
+    return JSON.parse(readFileSync6(path, "utf8"));
+  } catch (error) {
+    throw new CounterError(id, `${relative} is not readable JSON: ${error.message}`);
+  }
+};
+var REPORT_WITH_A_GREEN_DOCTOR = JSON.stringify({
+  at: "2026-09-03T09:00:00.000Z",
+  durationMs: 12e3,
+  ok: true,
+  steps: [
+    { detail: "", durationMs: 5e3, ok: true, ran: true, step: "install" },
+    { detail: "", durationMs: 7e3, ok: true, ran: true, step: "doctor" }
+  ],
+  to: "2.2.0"
+});
+var bumpDurationMs = {
+  id: "bumpDurationMs",
+  probe: {
+    expect: 12e3,
+    input: (dir) => plant(dir, DEFAULT_BUMP_REPORT, REPORT_WITH_A_GREEN_DOCTOR)
+  },
+  run: async ({ cwd, params }) => {
+    const report = bumpFile("bumpDurationMs", cwd, params);
+    if (typeof report.durationMs !== "number") {
+      throw new CounterError(
+        "bumpDurationMs",
+        "the bump report carries no durationMs \u2014 it was written by a build that did not time itself"
+      );
+    }
+    return report.durationMs;
+  },
+  tolerates: true
+};
+var timeToGreenDoctorMs = {
+  id: "timeToGreenDoctorMs",
+  probe: {
+    expect: 12e3,
+    input: (dir) => plant(dir, DEFAULT_BUMP_REPORT, REPORT_WITH_A_GREEN_DOCTOR)
+  },
+  run: async ({ cwd, params }) => {
+    const steps = bumpFile("timeToGreenDoctorMs", cwd, params).steps ?? [];
+    const at = steps.findIndex((one) => one.step === "doctor");
+    if (at === -1) {
+      throw new CounterError(
+        "timeToGreenDoctorMs",
+        "the bump report names no doctor step, so nothing in it says when this repo first read green"
+      );
+    }
+    if (steps[at]?.ok !== true) {
+      throw new CounterError(
+        "timeToGreenDoctorMs",
+        "the doctor step of the last bump was not green \u2014 there is no time to a green that never came"
+      );
+    }
+    return steps.slice(0, at + 1).reduce((total2, one) => total2 + (typeof one.durationMs === "number" ? one.durationMs : 0), 0);
+  },
+  tolerates: true
+};
+var SEPARATOR = /^\|[\s:|-]*\|\s*$/;
+var ROW = /^\|.*\|\s*$/;
+var cellsOf = (line) => line.replace(/^\|/, "").replace(/\|\s*$/, "").split("|").map((one) => one.trim());
+var openBacklogRows = {
+  id: "openBacklogRows",
+  probe: {
+    expect: 2,
+    input: (dir) => plant(
+      dir,
+      "backlog.md",
+      [
+        "| # | Finding | Status |",
+        "|---|---|---|",
+        "| 1 | closed | **DONE** |",
+        "| 2 | still here | open |",
+        "| 3 | also here | open \u2014 next |",
+        ""
+      ].join("\n")
+    ),
+    params: { path: "backlog.md" }
+  },
+  run: async ({ cwd, params }) => {
+    const relative = stringParam("openBacklogRows", params, "path");
+    const done = stringParam("openBacklogRows", params, "done", "DONE");
+    const at = resolve7(cwd, relative);
+    if (!existsSync4(at)) {
+      throw new CounterError("openBacklogRows", `no register at ${relative}`);
+    }
+    const lines = readFileSync6(at, "utf8").split("\n");
+    return lines.filter((line, index) => {
+      if (!ROW.test(line) || SEPARATOR.test(line)) return false;
+      if (SEPARATOR.test(lines[index + 1] ?? "")) return false;
+      const status = cellsOf(line).at(-1) ?? "";
+      return status !== "" && !status.includes(done);
+    }).length;
+  }
+};
+
 // src/counters/format.ts
-import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve8 } from "path";
 var unformattedFiles = {
   id: "unformattedFiles",
   probe: {
@@ -770,13 +927,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 && existsSync5(resolve8(cwd, line))).length;
   }
 };
 
 // src/counters/gate-report.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve9 } from "path";
 var DEFAULT_REPORT = ".geonosis/gate-report.json";
 var fastTierMs = {
   id: "fastTierMs",
@@ -799,9 +956,9 @@ 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);
-    if (!existsSync5(path)) {
+    const relative = asked !== "" ? asked : existsSync6(resolve9(cwd, own)) ? own : DEFAULT_REPORT;
+    const path = resolve9(cwd, relative);
+    if (!existsSync6(path)) {
       throw new CounterError(
         "fastTierMs",
         `no gate report at ${relative} \u2014 run \`geonosis-verify ${wanted}\` before measuring it`
@@ -809,7 +966,7 @@ var fastTierMs = {
     }
     let report;
     try {
-      report = JSON.parse(readFileSync6(path, "utf8"));
+      report = JSON.parse(readFileSync7(path, "utf8"));
     } catch (error) {
       throw new CounterError(
         "fastTierMs",
@@ -831,8 +988,8 @@ var fastTierMs = {
 };
 
 // src/counters/law.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve10 } from "path";
 var lawLineCount = {
   id: "lawLineCount",
   probe: {
@@ -842,15 +999,15 @@ var lawLineCount = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam("lawLineCount", params, "path", "CLAUDE.md");
-    const path = resolve8(cwd, relative);
-    if (!existsSync6(path)) throw new CounterError("lawLineCount", `no law file at ${relative}`);
-    return readFileSync7(path, "utf8").replace(/\n$/, "").split("\n").length;
+    const path = resolve10(cwd, relative);
+    if (!existsSync7(path)) throw new CounterError("lawLineCount", `no law file at ${relative}`);
+    return readFileSync8(path, "utf8").replace(/\n$/, "").split("\n").length;
   }
 };
 
 // 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 { existsSync as existsSync8, readFileSync as readFileSync9, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve11 } 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,26 +1170,26 @@ 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);
-    if (!existsSync7(source)) throw new CounterError("oxlintRule", `no config at ${config}`);
+    const source = resolve11(cwd, config);
+    if (!existsSync8(source)) throw new CounterError("oxlintRule", `no config at ${config}`);
     const strictName = `.oxlintrc.ratchet-${key}.json`;
-    const strict = readFileSync8(source, "utf8").replace(
+    const strict = readFileSync9(source, "utf8").replace(
       new RegExp(`("[^"]*${escapeForRegex(rule)}"\\s*:\\s*\\[?\\s*)"(warn|off)"`),
       '$1"error"'
     );
-    writeFileSync6(resolve9(cwd, strictName), strict);
+    writeFileSync6(resolve11(cwd, strictName), strict);
     try {
       return countRule(run(command.replace("{config}", strictName)), rule, expect);
     } finally {
-      rmSync3(resolve9(cwd, strictName), { force: true });
+      rmSync3(resolve11(cwd, strictName), { force: true });
     }
   }
 };
 
 // src/counters/probes.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
 import { createRequire } from "module";
-import { join as join6, resolve as resolve10 } from "path";
+import { join as join6, resolve as resolve12 } from "path";
 import { pathToFileURL } from "url";
 var ID = "probelessRules";
 var OFF = /* @__PURE__ */ new Set([0, "0", "allow", "off", false]);
@@ -1110,11 +1267,11 @@ var probelessRules = {
   },
   run: async ({ cwd, params }) => {
     const relative = stringParam(ID, params, "config", ".oxlintrc.json");
-    const path = resolve10(cwd, relative);
-    if (!existsSync8(path)) throw new CounterError(ID, `no oxlint config at ${relative}`);
+    const path = resolve12(cwd, relative);
+    if (!existsSync9(path)) throw new CounterError(ID, `no oxlint config at ${relative}`);
     let config;
     try {
-      config = JSON.parse(readFileSync9(path, "utf8"));
+      config = JSON.parse(readFileSync10(path, "utf8"));
     } catch (error) {
       throw new CounterError(ID, `${relative} does not parse: ${error.message}`);
     }
@@ -1151,8 +1308,8 @@ import { readdirSync as readdirSync3 } from "fs";
 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 { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
+import { join as join7, resolve as resolve13 } from "path";
 var SKIP = /^(node_modules|\.)/;
 var childDirs = (dir) => {
   try {
@@ -1166,14 +1323,14 @@ var expand = (root, pattern) => {
   const segments = pattern.split("/").filter((one) => one !== "" && one !== ".");
   let dirs = [root];
   for (const segment of segments) {
-    dirs = segment === "*" ? dirs.flatMap((dir) => childDirs(dir)) : segment === "**" ? dirs.flatMap((dir) => descendants(dir, 3)) : dirs.map((dir) => join7(dir, segment)).filter((dir) => existsSync9(dir));
+    dirs = segment === "*" ? dirs.flatMap((dir) => childDirs(dir)) : segment === "**" ? dirs.flatMap((dir) => descendants(dir, 3)) : dirs.map((dir) => join7(dir, segment)).filter((dir) => existsSync10(dir));
   }
   return dirs;
 };
 var QUOTED = /^['"]|['"]$/g;
 var cleaned = (value) => value.replace(/#.*$/, "").trim().replaceAll(QUOTED, "");
 var pnpmPatterns = (path) => {
-  const lines = readFileSync10(path, "utf8").split("\n");
+  const lines = readFileSync11(path, "utf8").split("\n");
   const at = lines.findIndex((line) => line.startsWith("packages:"));
   if (at === -1) return [];
   const inline = lines[at]?.slice("packages:".length).trim() ?? "";
@@ -1192,31 +1349,31 @@ var pnpmPatterns = (path) => {
   return patterns;
 };
 var npmPatterns = (path) => {
-  const parsed = JSON.parse(readFileSync10(path, "utf8"));
+  const parsed = JSON.parse(readFileSync11(path, "utf8"));
   const declared = Array.isArray(parsed.workspaces) ? parsed.workspaces : parsed.workspaces?.packages ?? [];
   return declared.filter((one) => typeof one === "string");
 };
 var nameOf = (dir) => {
   const manifest = join7(dir, "package.json");
-  if (!existsSync9(manifest)) return void 0;
+  if (!existsSync10(manifest)) return void 0;
   try {
-    const { name } = JSON.parse(readFileSync10(manifest, "utf8"));
+    const { name } = JSON.parse(readFileSync11(manifest, "utf8"));
     return typeof name === "string" && name !== "" ? name : void 0;
   } catch {
     return void 0;
   }
 };
 var workspaceDirs = (cwd) => {
-  const root = resolve11(cwd);
+  const root = resolve13(cwd);
   const pnpm = join7(root, "pnpm-workspace.yaml");
   const manifest = join7(root, "package.json");
-  const patterns = existsSync9(pnpm) ? pnpmPatterns(pnpm) : existsSync9(manifest) ? npmPatterns(manifest) : [];
-  const dirs = patterns.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => expand(root, pattern)).filter((dir) => existsSync9(join7(dir, "package.json")));
+  const patterns = existsSync10(pnpm) ? pnpmPatterns(pnpm) : existsSync10(manifest) ? npmPatterns(manifest) : [];
+  const dirs = patterns.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => expand(root, pattern)).filter((dir) => existsSync10(join7(dir, "package.json")));
   return [...new Set(dirs)];
 };
 var manifestOf = (dir) => {
   try {
-    const parsed = JSON.parse(readFileSync10(join7(dir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync11(join7(dir, "package.json"), "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : void 0;
   } catch {
     return void 0;
@@ -1283,6 +1440,56 @@ var packagesWithoutTypecheck = {
   }
 };
 
+// src/counters/seams.ts
+import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
+import { join as join9, resolve as resolve14 } 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 (!existsSync11(at)) return [];
+  try {
+    const seams = JSON.parse(readFileSync12(at, "utf8")).adoption?.seams;
+    return Array.isArray(seams) ? seams.filter((one) => typeof one === "string") : [];
+  } catch {
+    return [];
+  }
+};
+var linesIn = (path) => {
+  const body = readFileSync12(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 = resolve14(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 +1512,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 readFileSync13 } from "fs";
+import { join as join10, resolve as resolve15 } 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 +1528,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 += readFileSync13(join10(dir, entry.name), "utf8").match(SUPPRESSION)?.length ?? 0;
     } catch {
     }
   }
@@ -1340,14 +1547,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(resolve15(cwd, root)), 0);
+  }
+};
+
+// src/counters/surface.ts
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import { join as join11, resolve as resolve16 } 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 (!existsSync12(at)) {
+    throw new CounterError("floorSurface", `no package.json in ${dir} \u2014 that is not a package`);
+  }
+  const manifest = JSON.parse(readFileSync14(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 = resolve16(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 = resolve16(dir, entry);
+      if (!existsSync12(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(readFileSync14(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 existsSync13, mkdtempSync as mkdtempSync2, readFileSync as readFileSync15, 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 resolve17 } from "path";
 var COUNTER = "testFailures";
 var VITEST_LINE = /^\s*Tests {2,}(.+?)\s*$/;
 var VITEST_TOTAL = /\(\d+\)$/;
@@ -1379,7 +1679,7 @@ ${output.trim().slice(-500)}`
   );
 };
 var fromReport = (path) => {
-  if (!existsSync10(path)) {
+  if (!existsSync13(path)) {
     throw new CounterError(
       COUNTER,
       `the runner wrote no report at ${path} \u2014 a crash before the reporter is not a pass`
@@ -1387,7 +1687,7 @@ var fromReport = (path) => {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync12(path, "utf8"));
+    report = JSON.parse(readFileSync15(path, "utf8"));
   } catch (error) {
     throw new CounterError(
       COUNTER,
@@ -1411,14 +1711,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: resolve17(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 +1767,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 existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync16 } from "fs";
+import { join as join13, resolve as resolve18 } 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 (!existsSync14(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 +1790,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 +1798,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 = readFileSync16(join13(dir, entry.name), "utf8");
     } catch {
       continue;
     }
@@ -1528,22 +1828,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(resolve18(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(resolve18(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 +1873,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 existsSync15, readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve19 } from "path";
 var DEFAULT_REPORT2 = ".geonosis/walk-report.json";
 var CLASSES = /* @__PURE__ */ new Set([
   "buy-box-above-fold",
@@ -1618,8 +1918,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 = resolve19(cwd, relative);
+    if (!existsSync15(path)) {
       throw new CounterError(
         "walkFindings",
         `no walk report at ${relative} \u2014 run \`geonosis-walk\` before measuring it`
@@ -1627,7 +1927,7 @@ var walkFindings = {
     }
     let report;
     try {
-      report = JSON.parse(readFileSync14(path, "utf8"));
+      report = JSON.parse(readFileSync17(path, "utf8"));
     } catch (error) {
       throw new CounterError(
         "walkFindings",
@@ -1649,14 +1949,18 @@ var walkFindings = {
 
 // src/counters/index.ts
 var COUNTERS = [
+  adoptionSeamLines,
   archViolations,
   boundaryIssues,
+  bumpDurationMs,
   bundleBytes,
   cloneCount,
   disabledCiJobs,
   fastTierMs,
+  floorSurface,
   knipIssues,
   lawLineCount,
+  openBacklogRows,
   suppressionCount,
   oxlintErrors,
   oxlintRule,
@@ -1668,6 +1972,7 @@ var COUNTERS = [
   sumOfCounts,
   testFailures,
   testsWithoutRunner,
+  timeToGreenDoctorMs,
   typecheckErrors,
   unformattedFiles,
   walkFindings

package/dist/cli.js

@@ -7,11 +7,11 @@ import {
   runRatchet,
   versionOf,
   writeEnvelope
-} from "./chunk-H4PLCM5J.js";
+} from "./chunk-E55APSHM.js";
 
 // src/cli.ts
 import process from "process";
-var USAGE = `geonosis-ratchet [--cwd <dir>] [--tier <name>] [--prove] [--exclusive]
+var USAGE = `geonosis-ratchet [--cwd <dir>] [--tier <name>] [--prove] [--exclusive] [--json]
 
 Debt as a number that may only shrink. Runs the counters named in geonosis.ratchet.json, compares
 each against gate-baseline.json, and REWRITES the baseline down when a number shrank \u2014 so the win is
@@ -23,6 +23,7 @@ locked in the same commit that earned it.
   --exclusive                  hold the machine-wide heavy lock for the run
   --exclusive-timeout <secs>   how long to wait for that lock
   --hold <ms>                  take the lock, wait, give it back \u2014 the --prove self-test's slow thing
+  --json                       the run's own report on stdout, for a caller that parses it
   --help, -h                   this text
 
 Exit codes: 0 no counter grew \xB7 1 a counter grew \xB7 2 the run could not measure.
@@ -35,6 +36,7 @@ var KNOWN = /* @__PURE__ */ new Set([
   "--exclusive",
   "--exclusive-timeout",
   "--hold",
+  "--json",
   "--prove",
   "--tier"
 ]);
@@ -91,6 +93,7 @@ var tierFlag = process.argv.indexOf("--tier");
 var tier = tierFlag === -1 ? void 0 : process.argv[tierFlag + 1];
 var proving = process.argv.includes("--prove");
 var exclusive = process.argv.includes("--exclusive");
+var json = process.argv.includes("--json");
 var timeoutFlag = process.argv.indexOf("--exclusive-timeout");
 var timeoutSeconds = timeoutFlag === -1 ? void 0 : Number(process.argv[timeoutFlag + 1] ?? Number.NaN);
 var holdMs = numberAfter("--hold");
@@ -124,18 +127,20 @@ var measure = async () => {
       exclusiveVia: process.argv[1],
       tier
     });
-    process.stdout.write(formatProve(proof));
+    process.stdout.write(json ? `${JSON.stringify(proof, void 0, 2)}
+` : formatProve(proof));
     return proof.proven ? 0 : 2;
   }
   const startedAt = Date.now();
   const result = await runRatchet({ counters: COUNTERS, cwd, tier });
-  process.stdout.write(formatReport(result));
+  if (!json) process.stdout.write(formatReport(result));
   const at = writeEnvelope({
     envelope: envelopeOf(result, Date.now() - startedAt),
     next: ENVELOPE_NEXT,
     root: cwd
   });
-  process.stdout.write(`envelope: ${at}
+  process.stdout.write(json ? `${JSON.stringify(result, void 0, 2)}
+` : `envelope: ${at}
 `);
   if (result.refusals.length > 0) return 2;
   return result.measurements.some((one) => one.verdict === "grew") ? 1 : 0;

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-E55APSHM.js";
 export {
   CONFIG_FILE,
   COUNTERS,

package/package.json

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