@geonosis/release 2.2.0 → 2.3.1

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-IPCIF5DO.js → chunk-7H7SV5EP.js}

@@ -502,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 resolve3 } 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" },
@@ -574,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;
       }
@@ -590,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 = [];
@@ -713,7 +752,8 @@ 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 = {
@@ -725,10 +765,12 @@ var runSnapshot = (input) => {
     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)}
 `);
@@ -756,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");
@@ -780,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);
@@ -868,6 +942,7 @@ var runAdoption = async ({
     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),
@@ -898,10 +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`
   ] : [];
+  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, ...seams, ...new Set(consumer.findings.map(lineOf))];
+  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"}`,
@@ -1100,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 = resolve4(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);
@@ -1672,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((resolve10, reject) => {
+    const line = await new Promise((resolve11, reject) => {
       const timer = setTimeout(() => {
         reject(
           new CannotRun(
@@ -1682,7 +1760,7 @@ var Runner = class {
       }, timeoutMs);
       this.waiting.push((answer) => {
         clearTimeout(timer);
-        resolve10(answer);
+        resolve11(answer);
       });
       this.child.on("close", () => {
         clearTimeout(timer);
@@ -1795,8 +1873,8 @@ 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 resolve8, 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 filesUnder2 = (root, dir) => {
@@ -1804,7 +1882,7 @@ var filesUnder2 = (root, dir) => {
   const walk = (at) => {
     let entries;
     try {
-      entries = readdirSync3(at, { withFileTypes: true });
+      entries = readdirSync4(at, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1815,7 +1893,7 @@ var filesUnder2 = (root, dir) => {
     }
   };
   walk(resolve8(root, dir));
-  return found.map((path) => relative3(root, path).split(sep2).join("/")).toSorted();
+  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(
@@ -1910,7 +1988,7 @@ 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 { 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 = {
@@ -1985,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));
@@ -2402,6 +2480,89 @@ 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,
@@ -2479,5 +2640,11 @@ export {
   formatBaseline,
   SMOKE_TOOL,
   SMOKE_NEXT,
-  smokeEnvelope
+  smokeEnvelope,
+  CHANGELOG,
+  emptyHeadingsIn,
+  countVersionHeadings,
+  checkChangelogs,
+  formatChangelogs,
+  publishableDirs
 };

package/dist/index.d.ts

@@ -66,6 +66,8 @@ type SnapshotRecord = {
     excluded: string[];
     files: number;
     from: string;
+    /** Absent in a recording taken before history was recorded at all. */
+    history?: RecordedHistory;
     lockfile: string;
     manager: Manager;
     manifests: {
@@ -73,11 +75,20 @@ type SnapshotRecord = {
         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 = {
@@ -101,6 +112,8 @@ 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;
@@ -684,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 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, 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-IPCIF5DO.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-IPCIF5DO.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
@@ -199,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(", ")}`);
@@ -242,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"),
@@ -487,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.2.0",
+  "version": "2.3.1",
   "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.2.0"
+    "@geonosis/ratchet": "2.3.1"
   },
   "engines": {
     "node": ">=22"