@geonosis/release 2.1.0 → 2.3.0

package/README.md

@@ -1,5 +1,8 @@
 # @geonosis/release
 
+Through the front door: `geonosis release` — the metapackage pins this and every other kit tool at
+ONE version, and passes the exit code through unchanged.
+
 The release contract with its proofs.
 
 A release proves its **code** before serving it. Its **schema** serves immediately, to 100 % of

package/dist/{chunk-MZWAN6WT.js → chunk-7H7SV5EP.js}

@@ -1,3 +1,6 @@
+// src/phases.ts
+var PHASES = ["typecheck", "lint", "test", "doctor"];
+
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
@@ -96,17 +99,15 @@ var parseSchema = (value2) => {
 };
 var SMOKE_KEYS = "expected { exclude?, snapshots? }";
 var SNAPSHOT_KEYS = "expected { commands?, install?, name }";
-var SMOKE_PHASES = ["doctor", "lint", "typecheck"];
+var SMOKE_PHASES = PHASES;
 var parseCommands = (value2, at) => {
   if (value2 === void 0) return {};
   if (!isRecord(value2)) {
     throw new CannotRun(
-      `${at}.commands must be an object \u2014 expected { doctor?, lint?, typecheck? }`
+      `${at}.commands must be an object \u2014 expected one command per phase: ${PHASES.map((one) => `${one}?`).join(", ")}`
     );
   }
-  const unknown = Object.keys(value2).find(
-    (key) => !SMOKE_PHASES.includes(key)
-  );
+  const unknown = Object.keys(value2).find((key) => !SMOKE_PHASES.includes(key));
   if (unknown !== void 0) {
     throw new CannotRun(
       `${at}.commands.${unknown} is not a phase the smoke runs \u2014 it runs ${SMOKE_PHASES.join(", ")}`
@@ -210,7 +211,7 @@ var readReleaseConfig = (root) => {
 
 // src/envelope.ts
 import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var ENVELOPES_DIR = ".geonosis/envelopes";
 var envelopePath = (root, tool) => join(root, ENVELOPES_DIR, `${tool}.json`);
@@ -222,6 +223,14 @@ var UnbalancedEnvelope = class extends Error {
 };
 var isCount = (value2) => Number.isSafeInteger(value2) && value2 >= 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 || resolve2(forbidden) !== resolve2(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,
@@ -245,6 +254,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)}
@@ -492,11 +502,12 @@ import {
   mkdirSync as mkdirSync2,
   readdirSync as readdirSync2,
   readFileSync as readFileSync4,
+  renameSync,
   rmSync,
   statSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { join as join3, relative as relative2, resolve as resolve2 } from "path";
+import { join as join3, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 var SNAPSHOTS_DIR = ".geonosis/consumer-snapshots";
 var LOCKFILES = [
   { file: "bun.lock", manager: "bun" },
@@ -509,6 +520,7 @@ var UNMEASURED = [
 ];
 var EXCLUDED_DIRS = [
   ".cache",
+  ".claude",
   ".geonosis",
   ".git",
   ".next",
@@ -519,7 +531,6 @@ var EXCLUDED_DIRS = [
   "node_modules",
   "storybook-static"
 ];
-var PHASES = ["typecheck", "lint", "doctor"];
 var headOf = (from) => {
   const done = spawnSync("git", ["-C", from, "rev-parse", "HEAD"], { encoding: "utf8" });
   if (done.error !== void 0) {
@@ -564,12 +575,17 @@ var scriptsIn = (manifest) => {
 var copyInto = (from, to, excluded) => {
   let bytes = 0;
   let files = 0;
+  const nested = [];
   const walk = (dir, into) => {
     mkdirSync2(into, { recursive: true });
     for (const entry of readdirSync2(dir, { withFileTypes: true })) {
       if (excluded.has(entry.name)) continue;
       const at = join3(dir, entry.name);
       if (entry.isDirectory()) {
+        if (existsSync2(join3(at, ".git"))) {
+          nested.push(relative2(from, at).split(sep2).join("/"));
+          continue;
+        }
         walk(at, join3(into, entry.name));
         continue;
       }
@@ -580,7 +596,40 @@ var copyInto = (from, to, excluded) => {
     }
   };
   walk(from, to);
-  return { bytes, files };
+  return { bytes, files, nested: nested.toSorted() };
+};
+var HISTORY_DEPTH = 50;
+var gitIn = (cwd, args) => {
+  const done = spawnSync("git", args, { cwd, encoding: "utf8" });
+  return { code: done.status ?? -1, out: `${done.stdout ?? ""}${done.stderr ?? ""}` };
+};
+var recordHistoryInto = (from, tree) => {
+  const head = gitIn(from, ["rev-parse", "HEAD"]);
+  if (head.code !== 0) {
+    return {
+      why: `${from} is not a git work tree with a commit in it, so this recording carries no history and a tier step that reads git will refuse in it: ${head.out.trim().split("\n")[0] ?? ""}`
+    };
+  }
+  const staging = `${tree}.history`;
+  const cloned = gitIn(from, [
+    "clone",
+    "--quiet",
+    "--no-checkout",
+    "--no-hardlinks",
+    "--no-single-branch",
+    "--depth",
+    String(HISTORY_DEPTH),
+    `file://${from}`,
+    staging
+  ]);
+  if (cloned.code !== 0) {
+    rmSync(staging, { force: true, recursive: true });
+    return { why: `git clone of ${from} refused: ${cloned.out.trim().split("\n").at(-1) ?? ""}` };
+  }
+  renameSync(join3(staging, ".git"), join3(tree, ".git"));
+  rmSync(staging, { force: true, recursive: true });
+  gitIn(tree, ["reset", "--quiet", "--mixed"]);
+  return { depth: HISTORY_DEPTH, head: head.out.trim() };
 };
 var manifestsUnder2 = (root) => {
   const found = [];
@@ -628,11 +677,40 @@ var commandsFor = (manifest, manifests, named) => {
   return {
     doctor: phase("doctor", doctorCommand),
     lint: phase("lint", { why: 'the tree has no "lint" script and no --lint command was named' }),
+    test: phase("test", { why: 'the tree has no "test" script and no --test command was named' }),
     typecheck: phase("typecheck", {
       why: 'the tree has no "typecheck" script and no --typecheck command was named'
     })
   };
 };
+var asPattern = (glob) => new RegExp(
+  `^${glob.split("/").map(
+    (part) => part === "**" ? ".*" : part.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("*", "[^/]*")
+  ).join("/").replaceAll(".*/", "(?:.*/)?")}$`
+);
+var filesUnder = (root, at = root) => readdirSync2(at, { withFileTypes: true }).flatMap((entry) => {
+  const full = join3(at, entry.name);
+  if (entry.isDirectory()) return filesUnder(root, full);
+  return entry.isFile() ? [full.slice(root.length + 1)] : [];
+});
+var seamsIn = (tree) => {
+  const at = join3(tree, "geonosis.json");
+  if (!existsSync2(at)) return void 0;
+  let globs;
+  try {
+    const declared = JSON.parse(readFileSync4(at, "utf8")).adoption?.seams;
+    globs = Array.isArray(declared) ? declared.filter((one) => typeof one === "string") : [];
+  } catch {
+    return void 0;
+  }
+  if (globs.length === 0) return void 0;
+  const patterns = globs.map(asPattern);
+  const lines2 = filesUnder(tree).filter((one) => patterns.some((pattern) => pattern.test(one))).reduce((total, one) => {
+    const body = readFileSync4(join3(tree, one), "utf8");
+    return total + (body === "" ? 0 : body.replace(/\n$/, "").split("\n").length);
+  }, 0);
+  return { globs, lines: lines2 };
+};
 var snapshotDir = (root, name) => join3(root, SNAPSHOTS_DIR, name);
 var readSnapshot = (root, name) => {
   const at = join3(snapshotDir(root, name), "snapshot.json");
@@ -655,7 +733,7 @@ var runSnapshot = (input) => {
       `"${input.name}" is not a snapshot name \u2014 a name is letters, digits, dots, dashes and underscores, so that ${SNAPSHOTS_DIR}/<name> is the only place the bytes can land`
     );
   }
-  const from = resolve2(input.from);
+  const from = resolve3(input.from);
   if (!existsSync2(join3(from, "package.json"))) {
     throw new CannotRun(`${from} has no package.json \u2014 that is not a tree a consumer installs`);
   }
@@ -674,20 +752,25 @@ var runSnapshot = (input) => {
   const excluded = [.../* @__PURE__ */ new Set([...EXCLUDED_DIRS, ...input.exclude ?? []])].toSorted();
   rmSync(at, { force: true, recursive: true });
   const tree = join3(at, "tree");
-  const { bytes, files } = copyInto(from, tree, new Set(excluded));
+  const { bytes, files, nested } = copyInto(from, tree, new Set(excluded));
+  const history = recordHistoryInto(from, tree);
   const manifests = manifestsUnder2(tree);
+  const seams = seamsIn(tree);
   const record = {
     at: (/* @__PURE__ */ new Date()).toISOString(),
     bytes,
+    ...seams === void 0 ? {} : { seams },
     commit: headOf(from),
     commands: commandsFor(readManifest(join3(tree, "package.json")), manifests, input.named),
     excluded,
     files,
     from,
+    history,
     lockfile,
     manager,
     manifests,
-    name: input.name
+    name: input.name,
+    ...nested.length === 0 ? {} : { nested }
   };
   writeFileSync2(join3(at, "snapshot.json"), `${JSON.stringify(record, void 0, 2)}
 `);
@@ -715,7 +798,7 @@ var formatSnapshot = (record) => [
 ].join("");
 
 // src/adoption.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
 import { join as join4 } from "path";
 var groupsOf = (root) => {
   const at = join4(root, ".changeset/config.json");
@@ -739,6 +822,38 @@ var numberIn = (spec) => {
 var declarationsIn = (record, kit) => record.manifests.flatMap(
   (manifest) => Object.entries(manifest.versions).filter(([name]) => kit.has(name)).map(([name, spec]) => ({ name, path: manifest.path, spec }))
 );
+var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
+var EXAM_IMPORT = /([$\w]*Conformance)\b/g;
+var NEVER_WALKED2 = /* @__PURE__ */ new Set([".git", "dist", "node_modules"]);
+var examsRunIn = (dir) => {
+  const found = /* @__PURE__ */ new Set();
+  const stack = [dir];
+  while (stack.length > 0) {
+    const at = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync3(at, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!NEVER_WALKED2.has(entry.name)) stack.push(join4(at, entry.name));
+        continue;
+      }
+      if (!TEST_FILE.test(entry.name)) continue;
+      let source;
+      try {
+        source = readFileSync5(join4(at, entry.name), "utf8");
+      } catch {
+        continue;
+      }
+      if (!source.includes("@geonosis/")) continue;
+      for (const match of source.matchAll(EXAM_IMPORT)) found.add(match[1]);
+    }
+  }
+  return [...found].toSorted();
+};
 var groupName = (index, total) => total > 1 ? `fixed group ${index + 1}` : "the fixed group";
 var incoherence = (consumer, groups, declarations) => groups.flatMap((group, index) => {
   const members = new Set(group);
@@ -822,9 +937,13 @@ var runAdoption = async ({
       });
       continue;
     }
-    const declarations = declarationsIn(readSnapshot(root, one.name), new Set(current.keys()));
+    const record = readSnapshot(root, one.name);
+    const declarations = declarationsIn(record, new Set(current.keys()));
+    const seams = record.seams;
     consumers.push({
       declared: declarations.length,
+      exams: examsRunIn(join4(snapshotDir(root, one.name), "tree")),
+      ...seams === void 0 ? {} : { seams },
       findings: [
         ...distance(one.name, declarations, current),
         ...incoherence(one.name, groups, declarations),
@@ -854,7 +973,13 @@ var blockFor = (consumer) => {
   const head = faults.length === 0 ? [
     `  MATCH ${consumer.name} \u2014 ${consumer.declared} spec(s) on the versions this release is cut at`
   ] : [];
-  return [...head, ...new Set(consumer.findings.map(lineOf))];
+  const exams = consumer.exams.length === 0 ? [
+    `  EXAMS ${consumer.name} \u2014 none: no test file in this recording runs a floor exam, so a floor bump that broke one would read as a green tier`
+  ] : [`  EXAMS ${consumer.name} \u2014 ${consumer.exams.join(", ")}`];
+  const seams = consumer.seams === void 0 ? [] : [
+    `  SEAMS ${consumer.name} \u2014 ${consumer.seams.lines} lines in ${consumer.seams.globs.join(", ")} at this recording; a floor is adopted the day it deletes more than it adds`
+  ];
+  return [...head, ...exams, ...seams, ...new Set(consumer.findings.map(lineOf))];
 };
 var formatAdoption = (report) => [
   `adoption \u2014 ${report.considered} declared, ${report.consumers.length} read, ${report.excused.length} excused; against ${report.registry ?? "this workspace"}`,
@@ -877,7 +1002,7 @@ var adoptionEnvelope = (report, durationMs) => ({
 
 // src/wrangler.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 var isRecord3 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 var parseJsonc = (source) => {
   let out = "";
@@ -1053,16 +1178,16 @@ var declaredIn = (config) => {
     routes: listed.map((route) => isRecord3(route) ? route["pattern"] : route).filter((pattern) => typeof pattern === "string").toSorted()
   };
 };
-var readWrangler = (root, relative5, env) => {
-  const path = resolve3(root, relative5);
+var readWrangler = (root, relative6, env) => {
+  const path = resolve4(root, relative6);
   let parsed;
   try {
     const source = readFileSync6(path, "utf8");
-    parsed = relative5.endsWith(".toml") ? parseToml(source) : parseJsonc(source);
+    parsed = relative6.endsWith(".toml") ? parseToml(source) : parseJsonc(source);
   } catch (error) {
-    throw new CannotRun(`${relative5} could not be read: ${error.message}`);
+    throw new CannotRun(`${relative6} could not be read: ${error.message}`);
   }
-  if (!isRecord3(parsed)) throw new CannotRun(`${relative5} is not a wrangler configuration`);
+  if (!isRecord3(parsed)) throw new CannotRun(`${relative6} is not a wrangler configuration`);
   const environments = parsed["env"];
   const block = env !== void 0 && isRecord3(environments) && isRecord3(environments[env]) ? environments[env] : parsed;
   return declaredIn(block);
@@ -1070,13 +1195,13 @@ var readWrangler = (root, relative5, env) => {
 
 // src/deployed.ts
 import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 var DEPLOYED_FILE = ".geonosis/deployed.json";
 var NOTHING_SAYS = "nothing here says what is deployed \u2014 .geonosis/deployed.json is written by the pipeline after promote, and its absence is not a pass";
 var listOf = (found) => Array.isArray(found) ? found.filter((one) => typeof one === "string") : [];
 var isRecord4 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 var readDeployed = (root) => {
-  const path = resolve4(root, DEPLOYED_FILE);
+  const path = resolve5(root, DEPLOYED_FILE);
   if (!existsSync4(path)) throw new CannotRun(NOTHING_SAYS);
   let parsed;
   try {
@@ -1359,18 +1484,18 @@ var refusalsIn = (path, body, firstLine = 1) => {
 // src/migrations.ts
 import { mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { basename, join as join5, resolve as resolve6 } from "path";
+import { basename, join as join5, resolve as resolve7 } from "path";
 
 // src/squawk.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { dirname as dirname2, resolve as resolve5 } from "path";
+import { dirname as dirname2, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var HERE = dirname2(fileURLToPath2(import.meta.url));
 var PINNED = "2.63.0";
 var findSquawk = (from = HERE) => {
   for (let dir = from; ; dir = dirname2(dir)) {
-    const candidate = resolve5(dir, "node_modules/.bin/squawk");
+    const candidate = resolve6(dir, "node_modules/.bin/squawk");
     if (existsSync5(candidate)) return candidate;
     if (dirname2(dir) === dir) break;
   }
@@ -1452,7 +1577,7 @@ var runMigrations = (input) => {
   const forSquawk = [];
   const states = /* @__PURE__ */ new Map();
   for (const { entry, file } of matched) {
-    const source = readFileSync8(resolve6(input.root, file), "utf8");
+    const source = readFileSync8(resolve7(input.root, file), "utf8");
     const found = markersIn(source);
     const bad = found.flatMap((one) => {
       const why = judge(one, input.root, input.since);
@@ -1480,7 +1605,7 @@ var runMigrations = (input) => {
     const staging = mkdtempSync(join5(tmpdir(), "geonosis-release-squawk-"));
     try {
       for (const one of forSquawk) {
-        const path = one.entry.dialect === "mikro-orm-ts" ? join5(staging, `${basename(one.file, ".ts")}.sql`) : resolve6(input.root, one.file);
+        const path = one.entry.dialect === "mikro-orm-ts" ? join5(staging, `${basename(one.file, ".ts")}.sql`) : resolve7(input.root, one.file);
         if (one.entry.dialect === "mikro-orm-ts") writeFileSync3(path, `${one.sql}
 `);
         const found = squawkOn({
@@ -1625,7 +1750,7 @@ var Runner = class {
     if (this.closed !== void 0) {
       throw new CannotRun(`the runner is gone before "${request.step}": ${this.closed}`);
     }
-    const line = await new Promise((resolve9, reject) => {
+    const line = await new Promise((resolve11, reject) => {
       const timer = setTimeout(() => {
         reject(
           new CannotRun(
@@ -1635,7 +1760,7 @@ var Runner = class {
       }, timeoutMs);
       this.waiting.push((answer) => {
         clearTimeout(timer);
-        resolve9(answer);
+        resolve11(answer);
       });
       this.child.on("close", () => {
         clearTimeout(timer);
@@ -1748,16 +1873,16 @@ var formatVerdict = (verdict) => verdict.ok ? `OK    prove: ${verdict.steps.join
 `;
 
 // src/schema-walls.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
-import { join as join6, relative as relative3, resolve as resolve7, sep as sep2 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
+import { join as join6, relative as relative3, resolve as resolve8, sep as sep3 } from "path";
 var MIGRATION_FILE = /\.(?:sql|ts)$/;
 var CURRENT_SETTING = /current_setting\s*\(\s*'([^']+)'/gi;
-var filesUnder = (root, dir) => {
+var filesUnder2 = (root, dir) => {
   const found = [];
   const walk = (at) => {
     let entries;
     try {
-      entries = readdirSync3(at, { withFileTypes: true });
+      entries = readdirSync4(at, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1767,8 +1892,8 @@ var filesUnder = (root, dir) => {
       else if (MIGRATION_FILE.test(entry.name)) found.push(path);
     }
   };
-  walk(resolve7(root, dir));
-  return found.map((path) => relative3(root, path).split(sep2).join("/")).toSorted();
+  walk(resolve8(root, dir));
+  return found.map((path) => relative3(root, path).split(sep3).join("/")).toSorted();
 };
 var lineOf3 = (body, index) => body.slice(0, index).split("\n").length;
 var wordFor = (table2) => new RegExp(
@@ -1820,11 +1945,11 @@ var runSchema = ({ root }) => {
     );
   }
   const dirs = schema.domains.map((one) => one.dir);
-  const files = [...new Set(dirs.flatMap((dir) => filesUnder(root, dir)))].toSorted();
+  const files = [...new Set(dirs.flatMap((dir) => filesUnder2(root, dir)))].toSorted();
   const findings = [];
   const unreadable = [];
   for (const path of files) {
-    const source = readFileSync9(resolve7(root, path), "utf8");
+    const source = readFileSync9(resolve8(root, path), "utf8");
     let sql;
     try {
       sql = sqlOf(path, source);
@@ -1863,8 +1988,8 @@ var formatSchema = (report) => {
 
 // src/smoke-run.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7, relative as relative4, resolve as resolve8 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync5, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7, relative as relative4, resolve as resolve9 } from "path";
 var BASELINE_FILE = "baseline.json";
 var INSTALL = {
   bun: ["install"],
@@ -1938,7 +2063,7 @@ var sourceManifests = (rc) => {
   const excluded = new Set(EXCLUDED_DIRS);
   const found = [];
   const walk = (dir) => {
-    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
       if (excluded.has(entry.name)) continue;
       if (entry.isDirectory()) {
         walk(join7(dir, entry.name));
@@ -2064,8 +2189,8 @@ var smokeOver = (input) => {
   rmSync3(work, { force: true, recursive: true });
   copyInto(join7(at, "tree"), work, new Set(EXCLUDED_DIRS));
   ownRepository(work);
-  const packed = input.rc === void 0 ? [] : packRc(resolve8(input.rc), join7(at, "rc"));
-  const findings = input.rc === void 0 ? [] : promisedButNotPacked(resolve8(input.rc), packed);
+  const packed = input.rc === void 0 ? [] : packRc(resolve9(input.rc), join7(at, "rc"));
+  const findings = input.rc === void 0 ? [] : promisedButNotPacked(resolve9(input.rc), packed);
   const swapped = rewriteManifests(
     work,
     record.manifests.map((one) => one.path),
@@ -2113,7 +2238,7 @@ var recordBaseline = (input) => {
     at: (/* @__PURE__ */ new Date()).toISOString(),
     packed: packed.map((one) => ({ name: one.name, version: one.version })),
     phases: outcomes,
-    rc: input.rc === void 0 ? "the versions the tree names" : resolve8(input.rc)
+    rc: input.rc === void 0 ? "the versions the tree names" : resolve9(input.rc)
   };
   writeFileSync4(baselinePath(input.root, input.name), `${JSON.stringify(baseline, void 0, 2)}
 `);
@@ -2355,7 +2480,91 @@ var smokeEnvelope = (comparison, durationMs) => {
   };
 };
 
+// src/changelog.ts
+import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join8, relative as relative5, resolve as resolve10, sep as sep4 } from "path";
+var CHANGELOG = "CHANGELOG.md";
+var VERSION_HEADING = /^##\s+v?(\d+\.\d+\.\d+.*)$/;
+var emptyHeadingsIn = (body, at) => {
+  const lines2 = body.split("\n");
+  const found = [];
+  for (const [index, line] of lines2.entries()) {
+    const heading = VERSION_HEADING.exec(line);
+    if (heading?.[1] === void 0) continue;
+    const under2 = [];
+    for (const next of lines2.slice(index + 1)) {
+      if (next.startsWith("## ")) break;
+      under2.push(next);
+    }
+    if (under2.every((one) => one.trim() === "")) found.push({ at, version: heading[1].trim() });
+  }
+  return found;
+};
+var countVersionHeadings = (body) => body.split("\n").filter((line) => VERSION_HEADING.test(line)).length;
+var checkChangelogs = ({ dirs, root }) => {
+  if (dirs.length === 0) {
+    throw new CannotRun(
+      "no package directories to read a CHANGELOG.md in \u2014 this check needs the workspaces the release covers"
+    );
+  }
+  const empty = [];
+  let read = 0;
+  let versions = 0;
+  for (const dir of dirs) {
+    const at = join8(dir, CHANGELOG);
+    if (!existsSync8(resolve10(root, at))) continue;
+    read += 1;
+    const body = readFileSync11(resolve10(root, at), "utf8");
+    versions += countVersionHeadings(body);
+    empty.push(...emptyHeadingsIn(body, at));
+  }
+  if (read === 0) {
+    throw new CannotRun(
+      `none of the ${dirs.length} package(s) has a ${CHANGELOG} \u2014 a release check that read nothing has not passed`
+    );
+  }
+  return { empty, read, versions };
+};
+var formatChangelogs = (report) => [
+  ...report.empty.map(
+    (one) => `\u2717 ${one.at} \u2192 ${one.version} says a version shipped and says nothing about it`
+  ),
+  report.empty.length === 0 ? `changelog PASS \u2014 ${report.versions} version heading(s) over ${report.read} file(s), every one of them says something` : `changelog FAIL \u2014 ${report.empty.length} of ${report.versions} version heading(s) over ${report.read} file(s) are empty`
+].join("\n");
+var NEVER_WALKED3 = /* @__PURE__ */ new Set(["build", "coverage", "dist", "node_modules", "storybook-static"]);
+var publishableDirs = (root) => {
+  const found = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync6(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !NEVER_WALKED3.has(entry.name)) {
+          walk(join8(dir, entry.name));
+        }
+        continue;
+      }
+      if (entry.name !== "package.json") continue;
+      let manifest;
+      try {
+        manifest = JSON.parse(readFileSync11(join8(dir, entry.name), "utf8"));
+      } catch {
+        continue;
+      }
+      if (manifest.private === true || typeof manifest.name !== "string") continue;
+      found.push(relative5(root, dir).split(sep4).join("/"));
+    }
+  };
+  walk(root);
+  return found.filter((one) => one !== "").toSorted();
+};
+
 export {
+  PHASES,
   CannotRun,
   parseReleaseConfig,
   readReleaseConfig,
@@ -2375,7 +2584,6 @@ export {
   formatPublished,
   SNAPSHOTS_DIR,
   EXCLUDED_DIRS,
-  PHASES,
   headOf,
   snapshotDir,
   readSnapshot,
@@ -2432,5 +2640,11 @@ export {
   formatBaseline,
   SMOKE_TOOL,
   SMOKE_NEXT,
-  smokeEnvelope
+  smokeEnvelope,
+  CHANGELOG,
+  emptyHeadingsIn,
+  countVersionHeadings,
+  checkChangelogs,
+  formatChangelogs,
+  publishableDirs
 };

package/dist/index.d.ts

@@ -1,5 +1,107 @@
 import { ReportEnvelope } from '@geonosis/ratchet';
 
+/** What a phase runs: a script of theirs, a binary their install put there, or nothing at all. */
+type Command = {
+    exec: string;
+} | {
+    run: string;
+} | {
+    why: string;
+};
+type SmokePhase = 'doctor' | 'lint' | 'test' | 'typecheck';
+/**
+ * The gates a release is read against, in the order they run.
+ *
+ * Its own module because the runner and the config reader both need it and each imports the other:
+ * read through `smoke.ts`, `PHASES` was still undefined when `config.ts` initialised, and the
+ * config refused every `geonosis.json` with `Cannot read properties of undefined`.
+ *
+ * #272: `test` is here because a floor change can keep a consumer's types and their linter green
+ * and still redden their suites — the one thing only their own tests can say. A recording taken
+ * before it existed has no baseline for the phase, and a phase with nothing to compare against is
+ * reported as uncomparable rather than as a pass.
+ */
+declare const PHASES: SmokePhase[];
+
+/**
+ * Where a consumer's bytes live while the release is being read against them.
+ *
+ * D-048: a consumer tree is private, and a copy of one that reaches a commit cannot be taken back.
+ * The directory is under `.geonosis/`, which every repo in this kit's orbit already ignores, and
+ * `smoke snapshot` asks git — in the tree it is about to write into — whether that is still true
+ * before it copies a single file.
+ */
+declare const SNAPSHOTS_DIR = ".geonosis/consumer-snapshots";
+/** The managers a snapshot can be installed with here, each measured on this machine. */
+type Manager = 'bun' | 'pnpm';
+/**
+ * Directories a consumer builds or installs into. They are excluded by name at every depth: the
+ * snapshot is the SOURCE of a tree, and the install the smoke runs is the thing under test.
+ */
+declare const EXCLUDED_DIRS: string[];
+/** Where the source tree stood, or the sentence saying why nothing here could say. */
+type RecordedCommit = {
+    sha: string;
+} | {
+    why: string;
+};
+/**
+ * The seam a consumer declared, measured on the bytes this recording holds (#280).
+ *
+ * The user's rule for a floor: it is adopted the day it deletes more than it adds. The sweep can
+ * only say so about trees it has recorded, so the number is taken WHERE the tree is read — a
+ * `.geonosis/` of theirs never reaches a snapshot (it is an excluded directory), so their own bump
+ * report is not available here and this is the figure that is.
+ */
+type RecordedSeams = {
+    globs: string[];
+    lines: number;
+};
+type SnapshotRecord = {
+    at: string;
+    bytes: number;
+    /** Absent in a recording taken before this was recorded at all. */
+    commit?: RecordedCommit;
+    commands: Record<SmokePhase, Command>;
+    excluded: string[];
+    files: number;
+    from: string;
+    /** Absent in a recording taken before history was recorded at all. */
+    history?: RecordedHistory;
+    lockfile: string;
+    manager: Manager;
+    manifests: {
+        path: string;
+        versions: Record<string, string>;
+    }[];
+    name: string;
+    /** Directories skipped because they carry their own `.git`: a different tree inside this one. */
+    nested?: string[];
+    /** Absent when this consumer declares no `adoption.seams`, or the recording predates the block. */
+    seams?: RecordedSeams;
+};
+/** git asked in THEIR tree, and only ever asked: law 5 forbids this tool writing a byte there. */
+declare const headOf: (from: string) => RecordedCommit;
+/** What the recording can answer about where it came from, or why it can answer nothing. */
+type RecordedHistory = {
+    depth: number;
+    head: string;
+} | {
+    why: string;
+};
+declare const snapshotDir: (root: string, name: string) => string;
+declare const readSnapshot: (root: string, name: string) => SnapshotRecord;
+type SnapshotInput = {
+    exclude?: string[];
+    from: string;
+    name: string;
+    named: Partial<Record<SmokePhase, string>>;
+    replace: boolean;
+    root: string;
+};
+declare const runSnapshot: (input: SnapshotInput) => SnapshotRecord;
+declare const formatSnapshot: (record: SnapshotRecord) => string;
+
 type AdoptionVerdict = 'BEHIND' | 'FLOOR UNDECLARED' | 'INCOHERENT' | 'UNJUDGED';
 type AdoptionFinding = {
     consumer: string;
@@ -10,8 +112,11 @@ type AdoptionFinding = {
 type AdoptionConsumer = {
     /** How many specs naming a package of this workspace that consumer's manifests declare. */
     declared: number;
+    /** The floor exams a test file in the recording runs. A floor nothing exams is a floor whose break their tier cannot see (#293). */
+    exams: string[];
     findings: AdoptionFinding[];
     name: string;
+    seams?: RecordedSeams;
 };
 type AdoptionReport = {
     considered: number;
@@ -412,70 +517,6 @@ declare class Runner {
     close(): void;
 }
 
-/**
- * Where a consumer's bytes live while the release is being read against them.
- *
- * D-048: a consumer tree is private, and a copy of one that reaches a commit cannot be taken back.
- * The directory is under `.geonosis/`, which every repo in this kit's orbit already ignores, and
- * `smoke snapshot` asks git — in the tree it is about to write into — whether that is still true
- * before it copies a single file.
- */
-declare const SNAPSHOTS_DIR = ".geonosis/consumer-snapshots";
-/** The managers a snapshot can be installed with here, each measured on this machine. */
-type Manager = 'bun' | 'pnpm';
-/**
- * Directories a consumer builds or installs into. They are excluded by name at every depth: the
- * snapshot is the SOURCE of a tree, and the install the smoke runs is the thing under test.
- */
-declare const EXCLUDED_DIRS: string[];
-/** What a phase runs: a script of theirs, a binary their install put there, or nothing at all. */
-type Command = {
-    exec: string;
-} | {
-    run: string;
-} | {
-    why: string;
-};
-type SmokePhase = 'doctor' | 'lint' | 'typecheck';
-declare const PHASES: SmokePhase[];
-/** Where the source tree stood, or the sentence saying why nothing here could say. */
-type RecordedCommit = {
-    sha: string;
-} | {
-    why: string;
-};
-type SnapshotRecord = {
-    at: string;
-    bytes: number;
-    /** Absent in a recording taken before this was recorded at all. */
-    commit?: RecordedCommit;
-    commands: Record<SmokePhase, Command>;
-    excluded: string[];
-    files: number;
-    from: string;
-    lockfile: string;
-    manager: Manager;
-    manifests: {
-        path: string;
-        versions: Record<string, string>;
-    }[];
-    name: string;
-};
-/** git asked in THEIR tree, and only ever asked: law 5 forbids this tool writing a byte there. */
-declare const headOf: (from: string) => RecordedCommit;
-declare const snapshotDir: (root: string, name: string) => string;
-declare const readSnapshot: (root: string, name: string) => SnapshotRecord;
-type SnapshotInput = {
-    exclude?: string[];
-    from: string;
-    name: string;
-    named: Partial<Record<SmokePhase, string>>;
-    replace: boolean;
-    root: string;
-};
-declare const runSnapshot: (input: SnapshotInput) => SnapshotRecord;
-declare const formatSnapshot: (record: SnapshotRecord) => string;
-
 /** What a phase did, or the sentence saying there was nothing of theirs to do it with. */
 type PhaseOutcome = {
     code: number;
@@ -656,4 +697,41 @@ declare const statementsOf: (sql: string) => string;
 /** One refusal per verb per file, at the line of that verb's first occurrence. */
 declare const refusalsIn: (path: string, body: string, firstLine?: number) => Refusal[];
 
-export { ADOPTION_NEXT, ADOPTION_TOOL, type AdoptionConsumer, type AdoptionFinding, type AdoptionReport, type AdoptionVerdict, BASELINE_FILE, CONSUMER_TREES_FILE, type Command, DEFAULT_REGISTRY, DEPLOYED_FILE, type Declared, type Deployed, type DeployedReport, type Dialect, type Drift, EXCLUDED_DIRS, EXISTS_BUT, type Manager, type MigrationDir, type MigrationsReport, NARROWING, NOTHING_SAYS, PHASES, PLANTS, type Packed, type Phase, type PhaseOutcome, type PlanReport, type ProveOutcome, type PublishedLine, type PublishedReport, type PublishedVerdict, type RecordedCommit, type Refusal, type RegistryAnswer, type ReleaseConfig, Runner, SMOKE_NEXT, SMOKE_TOOL, SNAPSHOTS_DIR, STEPS, type SchemaConfig, type SchemaDomain, type SchemaFinding, type SchemaReport, type SmokeBaseline, type SmokeComparison, type SmokePhase, type SmokeSweep, type SnapshotRecord, type SweepEntry, type SweepNote, type Verdict, WHY_VERSION_IDENTITY, type WantedSnapshot, addSqlIn, adoptionEnvelope, askRegistry, censusOf, compareToBaseline, comparisonsIn, declaredIn, driftBetween, formatAdoption, formatBaseline, formatDeployed, formatMigrations, formatPlan, formatProve, formatPublished, formatSchema, formatSmoke, formatSnapshot, formatSweep, formatVerdict, headOf, markersIn, packRc, parseJsonc, parseReleaseConfig, parseToml, promisedButNotPacked, prove, proveOver, readBaseline, readDeployed, readReleaseConfig, readSnapshot, readWrangler, recordBaseline, refusalsIn, registryPathOf, rewriteManifests, runAdoption, runDeployed, runMigrations, runPlan, runPublished, runSchema, runSmoke, runSnapshot, smokeEnvelope, snapshotDir, statementsOf, sweepEnvelope, sweepSmoke };
+declare const CHANGELOG = "CHANGELOG.md";
+type EmptyHeading = {
+    at: string;
+    version: string;
+};
+type ChangelogReport = {
+    /** Every `## <version>` heading with nothing under it. */
+    empty: EmptyHeading[];
+    /** How many changelogs were read. The denominator a "no findings" line is worth reading over. */
+    read: number;
+    /** Version headings seen across all of them. */
+    versions: number;
+};
+/**
+ * A version heading with nothing under it, in a file whose whole job is to say what a version
+ * changed. The audit found fourteen of twenty-two packages carrying at least one — a reader told
+ * that 1.2.0 shipped and told nothing else, in a tree that is published.
+ *
+ * A fixed publish group makes them by construction: every package moves to one number, and one that
+ * did not change has no changeset to render. That is a reason and not an excuse — a line saying so
+ * is a sentence, and a blank is a question.
+ */
+declare const emptyHeadingsIn: (body: string, at: string) => EmptyHeading[];
+declare const countVersionHeadings: (body: string) => number;
+type ChangelogInput = {
+    dirs: readonly string[];
+    root: string;
+};
+declare const checkChangelogs: ({ dirs, root }: ChangelogInput) => ChangelogReport;
+declare const formatChangelogs: (report: ChangelogReport) => string;
+/**
+ * Every publishable package's directory, by MANIFEST rather than by a glob: a package a workspace
+ * glob no longer claims still publishes a changelog, and a check whose denominator is a glob would
+ * pass it by not looking.
+ */
+declare const publishableDirs: (root: string) => string[];
+
+export { ADOPTION_NEXT, ADOPTION_TOOL, type AdoptionConsumer, type AdoptionFinding, type AdoptionReport, type AdoptionVerdict, BASELINE_FILE, CHANGELOG, CONSUMER_TREES_FILE, type ChangelogInput, type ChangelogReport, type Command, DEFAULT_REGISTRY, DEPLOYED_FILE, type Declared, type Deployed, type DeployedReport, type Dialect, type Drift, EXCLUDED_DIRS, EXISTS_BUT, type EmptyHeading, type Manager, type MigrationDir, type MigrationsReport, NARROWING, NOTHING_SAYS, PHASES, PLANTS, type Packed, type Phase, type PhaseOutcome, type PlanReport, type ProveOutcome, type PublishedLine, type PublishedReport, type PublishedVerdict, type RecordedCommit, type RecordedSeams, type Refusal, type RegistryAnswer, type ReleaseConfig, Runner, SMOKE_NEXT, SMOKE_TOOL, SNAPSHOTS_DIR, STEPS, type SchemaConfig, type SchemaDomain, type SchemaFinding, type SchemaReport, type SmokeBaseline, type SmokeComparison, type SmokePhase, type SmokeSweep, type SnapshotRecord, type SweepEntry, type SweepNote, type Verdict, WHY_VERSION_IDENTITY, type WantedSnapshot, addSqlIn, adoptionEnvelope, askRegistry, censusOf, checkChangelogs, compareToBaseline, comparisonsIn, countVersionHeadings, declaredIn, driftBetween, emptyHeadingsIn, formatAdoption, formatBaseline, formatChangelogs, formatDeployed, formatMigrations, formatPlan, formatProve, formatPublished, formatSchema, formatSmoke, formatSnapshot, formatSweep, formatVerdict, headOf, markersIn, packRc, parseJsonc, parseReleaseConfig, parseToml, promisedButNotPacked, prove, proveOver, publishableDirs, readBaseline, readDeployed, readReleaseConfig, readSnapshot, readWrangler, recordBaseline, refusalsIn, registryPathOf, rewriteManifests, runAdoption, runDeployed, runMigrations, runPlan, runPublished, runSchema, runSmoke, runSnapshot, smokeEnvelope, snapshotDir, statementsOf, sweepEnvelope, sweepSmoke };

package/dist/index.js

@@ -2,6 +2,7 @@ import {
   ADOPTION_NEXT,
   ADOPTION_TOOL,
   BASELINE_FILE,
+  CHANGELOG,
   CONSUMER_TREES_FILE,
   DEFAULT_REGISTRY,
   DEPLOYED_FILE,
@@ -21,12 +22,16 @@ import {
   adoptionEnvelope,
   askRegistry,
   censusOf,
+  checkChangelogs,
   compareToBaseline,
   comparisonsIn,
+  countVersionHeadings,
   declaredIn,
   driftBetween,
+  emptyHeadingsIn,
   formatAdoption,
   formatBaseline,
+  formatChangelogs,
   formatDeployed,
   formatMigrations,
   formatPlan,
@@ -46,6 +51,7 @@ import {
   promisedButNotPacked,
   prove,
   proveOver,
+  publishableDirs,
   readBaseline,
   readDeployed,
   readReleaseConfig,
@@ -68,11 +74,12 @@ import {
   statementsOf,
   sweepEnvelope,
   sweepSmoke
-} from "./chunk-MZWAN6WT.js";
+} from "./chunk-7H7SV5EP.js";
 export {
   ADOPTION_NEXT,
   ADOPTION_TOOL,
   BASELINE_FILE,
+  CHANGELOG,
   CONSUMER_TREES_FILE,
   DEFAULT_REGISTRY,
   DEPLOYED_FILE,
@@ -92,12 +99,16 @@ export {
   adoptionEnvelope,
   askRegistry,
   censusOf,
+  checkChangelogs,
   compareToBaseline,
   comparisonsIn,
+  countVersionHeadings,
   declaredIn,
   driftBetween,
+  emptyHeadingsIn,
   formatAdoption,
   formatBaseline,
+  formatChangelogs,
   formatDeployed,
   formatMigrations,
   formatPlan,
@@ -117,6 +128,7 @@ export {
   promisedButNotPacked,
   prove,
   proveOver,
+  publishableDirs,
   readBaseline,
   readDeployed,
   readReleaseConfig,

package/dist/release-cli.js

@@ -7,9 +7,11 @@ import {
   SCHEMA_NEXT,
   SMOKE_NEXT,
   adoptionEnvelope,
+  checkChangelogs,
   comparisonsIn,
   formatAdoption,
   formatBaseline,
+  formatChangelogs,
   formatDeployed,
   formatMigrations,
   formatPlan,
@@ -22,6 +24,7 @@ import {
   migrationsEnvelope,
   prove,
   proveOver,
+  publishableDirs,
   publishedEnvelope,
   readReleaseConfig,
   recordBaseline,
@@ -36,11 +39,24 @@ import {
   sweepEnvelope,
   sweepSmoke,
   writeEnvelope
-} from "./chunk-MZWAN6WT.js";
+} from "./chunk-7H7SV5EP.js";
 
 // src/release-cli.ts
 import { existsSync } from "fs";
 import { join, resolve } from "path";
+
+// src/since.ts
+var MEANS = {
+  date: {
+    is: (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(Date.parse(value)),
+    shape: "a YYYY-MM-DD date"
+  },
+  plan: { is: (value) => /^\d+$/.test(value), shape: "a plan number" },
+  ref: { is: (value) => value !== "" && !value.startsWith("-"), shape: "a git ref" }
+};
+var unreadableSince = (value, kind) => MEANS[kind].is(value) ? void 0 : `--since must be ${MEANS[kind].shape} \u2014 "${value}" is not one`;
+
+// src/release-cli.ts
 var USAGE = `geonosis-release <command> [options]
 
   migrations --since <ref> [--dialect <name>] [--root <dir>] [--json]
@@ -57,6 +73,15 @@ var USAGE = `geonosis-release <command> [options]
 
               Exit 0 clean, 1 refusals, 2 the run could not be made.
 
+  changelog [--root <dir>] [--json]
+
+              Every publishable package's CHANGELOG.md, and every "## <version>" heading with
+              nothing under it. A reader told that 1.2.0 shipped and told nothing else has been
+              told less than nothing; a fixed publish group makes those headings by construction,
+              which is a reason to write the sentence and not a reason to leave the blank.
+
+              Exit 0 clean, 1 an empty heading, 2 no changelog to read at all.
+
   schema [--root <dir>] [--json]
 
               The wall no oxlint rule can see. Over every migration under every directory
@@ -119,7 +144,7 @@ var USAGE = `geonosis-release <command> [options]
               from it (D-061).
 
   smoke snapshot <name> --from <their tree> [--replace] [--root <dir>] [--json]
-                        [--typecheck <cmd>] [--lint <cmd>] [--doctor <cmd>]
+                        [--typecheck <cmd>] [--lint <cmd>] [--test <cmd>] [--doctor <cmd>]
 
               Copy a consumer tree, read-only, into .geonosis/consumer-snapshots/<name>/ \u2014 the
               thing a release must be read against. Installed packages, build output and the git
@@ -137,9 +162,9 @@ var USAGE = `geonosis-release <command> [options]
               what a consumer installs, and a release that shipped no declarations shipped them in
               the tree and not in the tarball), point a COPY of the snapshot's manifests at those
               tarballs, install with the snapshot's own manager, and run the snapshot's own
-              typecheck, lint and doctor.
+              typecheck, lint, tests and doctor.
 
-              \`baseline\` records what those three answered at the versions the consumer is on.
+              \`baseline\` records what those four answered at the versions the consumer is on.
               \`run\` compares against it and refuses only what THIS release broke, in their
               compiler's and their doctor's own lines. Exit 0 nothing new, 1 a new failure,
               2 the run could not be made \u2014 including a phase the baseline cannot be compared to.
@@ -163,6 +188,7 @@ var VALUED = /* @__PURE__ */ new Set([
   "--runner",
   "--since",
   "--snapshot",
+  "--test",
   "--typecheck",
   "--wait"
 ]);
@@ -198,6 +224,8 @@ var rootOf = (parsed, cwd) => resolve(cwd, parsed.read["--root"] ?? cwd);
 var migrations = (parsed, cwd) => {
   const since = parsed.read["--since"];
   if (since === void 0) throw new CannotRun("migrations needs --since <ref>");
+  const unreadable = unreadableSince(since, "ref");
+  if (unreadable !== void 0) throw new CannotRun(unreadable);
   const dialect = parsed.read["--dialect"];
   if (dialect !== void 0 && !DIALECTS.has(dialect)) {
     throw new CannotRun(`--dialect must be one of ${[...DIALECTS].toSorted().join(", ")}`);
@@ -241,6 +269,16 @@ var schema = (parsed, cwd) => {
   if (report.unreadable.length > 0) return 2;
   return report.ok ? 0 : 1;
 };
+var changelog = (parsed, cwd) => {
+  const root = rootOf(parsed, cwd);
+  const report = checkChangelogs({ dirs: publishableDirs(root), root });
+  process.stdout.write(
+    parsed.json ? `${JSON.stringify(report, void 0, 2)}
+` : `${formatChangelogs(report)}
+`
+  );
+  return report.empty.length === 0 ? 0 : 1;
+};
 var plan = (parsed, cwd) => {
   const report = runPlan({
     accept: parsed.flags.has("--i-accept-an-unproven-smoke"),
@@ -333,6 +371,7 @@ var adoption = async (parsed, cwd) => {
 var namedCommands = (parsed) => ({
   ...parsed.read["--doctor"] === void 0 ? {} : { doctor: parsed.read["--doctor"] },
   ...parsed.read["--lint"] === void 0 ? {} : { lint: parsed.read["--lint"] },
+  ...parsed.read["--test"] === void 0 ? {} : { test: parsed.read["--test"] },
   ...parsed.read["--typecheck"] === void 0 ? {} : { typecheck: parsed.read["--typecheck"] }
 });
 var snapshot = (parsed, root) => {
@@ -485,6 +524,7 @@ var main = async () => {
   if (stray !== void 0) throw new CannotRun(`unknown argument "${stray}"`);
   if (parsed.command === "migrations") return migrations(parsed, process.cwd());
   if (parsed.command === "plan") return plan(parsed, process.cwd());
+  if (parsed.command === "changelog") return changelog(parsed, process.cwd());
   if (parsed.command === "schema") return schema(parsed, process.cwd());
   if (parsed.command === "prove") return proving(parsed, process.cwd());
   if (parsed.command === "deployed") return deployed(parsed, process.cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/release",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "types": "./dist/index.d.ts",
   "description": "The release contract with its proofs: an expand-only migration gate over three dialects, a smoke that must name the version that answered it, and declared ≠ deployed.",
   "keywords": [
@@ -45,7 +45,7 @@
   },
   "devDependencies": {
     "squawk-cli": "2.63.0",
-    "@geonosis/ratchet": "2.1.0"
+    "@geonosis/ratchet": "2.3.0"
   },
   "engines": {
     "node": ">=22"