@avi2dg/checks 0.61.0 → 0.61.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Every release of `@avi2dg/checks`, newest first, written by the release from its conventional commits.
 
+## 0.61.1
+
+Released 2026-11-02.
+
+### Fixes
+
+- **changelog:** keep a release's section when its commit gets its tag [#23](https://github.com/avi2d/checks/pull/23)
+
 ## 0.61.0
 
 Released 2026-11-01.

package/docs/gates/checks-changelog.md

@@ -27,6 +27,8 @@ It finds releases in the version bumps of `package.json` across all of `HEAD` an
 It reads a commit whose `package.json` is missing or has no version as unversioned, so the commit that adds the version is the first release and a repository that adopts a version late still writes its changelog.
 A bump to a version no newer than the release before it is a revert.
 A revert cancels every release above the version it returns to, except a release a `v` tag marks as published.
+A `v` tag publishes only the newest bump of its version that the tagged commit reaches.
+So a version bumped again after a cancel keeps its cancelled bump cancelled, and the tag leaves the changelog unchanged.
 A version older than the newest in the committed `CHANGELOG.md` and absent from it was never published, so its commits go into the next release.
 It refuses a shallow checkout, since the releases reach back past its history.
 It refuses a `package.json` with no repository address, since each entry links its pull request under it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avi2dg/checks",
-  "version": "0.61.0",
+  "version": "0.61.1",
   "description": "Deterministic checks shared across a set of TypeScript repositories",
   "author": {
     "name": "avi2d",

package/src/delivery/changelog-write.ts

@@ -64,9 +64,26 @@ const readBumps = Effect.fn("readBumps")(function* (root: string) {
   return bumps;
 });
 
-const readPublished = Effect.fn("readPublished")(function* (root: string) {
+const reaches = (root: string, ancestor: string, descendant: string) =>
+  git(["merge-base", "--is-ancestor", ancestor, descendant], root).pipe(
+    Effect.as(true),
+    Effect.catchTag("GitFailure", () => Effect.succeed(false)),
+  );
+
+// A tag publishes the newest bump of its version that it reaches, so a cancelled older bump of that version stays cancelled.
+const readPublishedShas = Effect.fn("readPublishedShas")(function* (root: string, bumps: readonly Bump[]) {
   const tags = yield* git(["for-each-ref", "--format=%(refname:strip=2)", `refs/tags/${TAG_PREFIX}*`], root);
-  return new Set(tags.split("\n").flatMap((tag) => (tag.startsWith(TAG_PREFIX) ? [tag.slice(TAG_PREFIX.length)] : [])));
+  const published = new Set<string>();
+  for (const tag of tags.split("\n").filter((line) => line.startsWith(TAG_PREFIX))) {
+    const version = tag.slice(TAG_PREFIX.length);
+    for (const bump of bumps.filter((one) => one.version === version).toReversed()) {
+      if (yield* reaches(root, bump.sha, `refs/tags/${tag}`)) {
+        published.add(bump.sha);
+        break;
+      }
+    }
+  }
+  return published;
 });
 
 const mergedTips = Effect.fn("mergedTips")(function* (root: string, through: string) {
@@ -78,11 +95,7 @@ const mergedTips = Effect.fn("mergedTips")(function* (root: string, through: str
   for (const [, ...parents] of merges.split("\n").filter((line) => line !== "").map((line) => line.split(" "))) {
     for (const parent of parents) {
       // A parent past the bump belongs to a later release, so only a parent beside it joins this one.
-      const past = yield* git(["merge-base", "--is-ancestor", through, parent], root).pipe(
-        Effect.as(true),
-        Effect.catchTag("GitFailure", () => Effect.succeed(false)),
-      );
-      if (!past) tips.push(parent);
+      if (!(yield* reaches(root, through, parent))) tips.push(parent);
     }
   }
   return tips;
@@ -113,7 +126,8 @@ const write = Effect.gen(function* () {
   }
   const recorded = (yield* fs.exists(target)) ? releaseDates(yield* fs.readFileString(target)) : new Map<string, string>();
   const pending = version === (yield* versionAt(root, "HEAD")) ? undefined : { sha: "HEAD", version, date: yield* today };
-  const released = cuts(yield* readBumps(root), recorded, yield* readPublished(root), pending);
+  const bumps = yield* readBumps(root);
+  const released = cuts(bumps, recorded, yield* readPublishedShas(root, bumps), pending);
   const tip = released.at(-1);
   const extra = tip === undefined || tip.through === "HEAD" ? [] : yield* mergedTips(root, tip.through);
   const found = (yield* Effect.forEach(released, (cut, index) => subjectsOf(root, cut, index === released.length - 1 ? extra : [])))

package/src/delivery/changelog.ts

@@ -57,12 +57,13 @@ function entryOf(subject: string, repositoryUrl: string): Entry | undefined {
 }
 
 // A bump not newer than the release before it is a revert: it cancels every release above the version it
-// returns to, except a published one.
-function standing(bumps: readonly Bump[], published: ReadonlySet<string>): readonly Bump[] {
+// returns to, except a published one. A version cancelled and bumped again holds two bumps, so a bump is
+// published by its sha and never by its version.
+function standing(bumps: readonly Bump[], publishedShas: ReadonlySet<string>): readonly Bump[] {
   return bumps.reduce<readonly Bump[]>((kept, bump) => {
     const before = kept.at(-1);
     if (before === undefined || Bun.semver.order(bump.version, before.version) === 1) return [...kept, bump];
-    return kept.filter(({ version }) => published.has(version) || Bun.semver.order(version, bump.version) !== 1);
+    return kept.filter(({ sha, version }) => publishedShas.has(sha) || Bun.semver.order(version, bump.version) !== 1);
   }, []);
 }
 
@@ -71,11 +72,11 @@ function standing(bumps: readonly Bump[], published: ReadonlySet<string>): reado
 export function cuts(
   bumps: readonly Bump[],
   recorded: ReadonlyMap<string, string>,
-  published: ReadonlySet<string>,
+  publishedShas: ReadonlySet<string>,
   pending: Bump | undefined,
 ): readonly Cut[] {
   const newest = [...recorded.keys()].toSorted(Bun.semver.order).at(-1);
-  const candidates = standing(pending === undefined ? bumps : [...bumps, pending], published);
+  const candidates = standing(pending === undefined ? bumps : [...bumps, pending], publishedShas);
   const released = candidates.filter(
     ({ version }, index) =>
       index === candidates.length - 1 || newest === undefined || recorded.has(version) || Bun.semver.order(version, newest) !== -1,