@williamthorsen/release-kit 4.8.0 → 5.1.0

package/dist/esm/bin/release-kit.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { commitCommand } from "../commitCommand.js";
-import { githubReleaseCommand } from "../githubReleaseCommand.js";
+import { createGithubReleaseCommand } from "../createGithubReleaseCommand.js";
 import { initCommand } from "../init/initCommand.js";
 import { prepareCommand } from "../prepareCommand.js";
 import { publishCommand } from "../publishCommand.js";
 import { pushCommand } from "../pushCommand.js";
+import { showTagPrefixesCommand } from "../showTagPrefixesCommand.js";
 import { generateCommand } from "../sync-labels/generateCommand.js";
 import { syncLabelsInitCommand } from "../sync-labels/initCommand.js";
 import { syncLabelsCommand } from "../sync-labels/syncCommand.js";
@@ -21,7 +22,8 @@ Commands:
   tag              Create annotated git tags from the tags file
   push             Push release commit and tags (one push per tag)
   publish          Publish packages with release tags on HEAD
-  github-release   Create GitHub Releases from changelog.json for tags on HEAD
+  create-github-release  Create GitHub Releases from changelog.json for tags on HEAD
+  show-tag-prefixes  Show derived and declared legacy tag prefixes per workspace
   init             Initialize release-kit in the current repository
   sync-labels      Manage GitHub label synchronization
 
@@ -100,9 +102,13 @@ Run release preparation with automatic workspace discovery.
 
 Options:
   --dry-run             Run without modifying any files
-  --bump=major|minor|patch  Override the bump type for all components
+  --bump=major|minor|patch  Override the bump type for all workspaces
+  --set-version=X.Y.Z   Set an explicit version; bypasses commit-derived bumps. Requires --only in monorepo mode.
   --no-git-checks, -n   Skip the clean-working-tree check
-  --only=name1,name2    Only process the named components (comma-separated, monorepo only)
+  --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only)
+  --with-release-notes  Also write per-workspace release-notes previews under {workspacePath}/docs/
+                         (docs/README.v{version}.md and docs/RELEASE_NOTES.v{version}.md).
+                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).
   --help, -h            Show this help message
 `);
 }
@@ -139,23 +145,36 @@ fires a separate workflow run per tag.
 
 Options:
   --dry-run              Preview without pushing
-  --only=name1,name2     Only push tags for the named packages (comma-separated, monorepo only)
+  --tags=tag1,tag2       Only push the named tags (comma-separated, full tag names)
   --tags-only            Skip the branch push (push tags only)
   --help, -h             Show this help message
 `);
 }
-function showGithubReleaseHelp() {
+function showCreateGithubReleaseHelp() {
   console.info(`
-Usage: release-kit github-release [options]
+Usage: release-kit create-github-release [options]
 
 Create GitHub Releases from changelog.json for tags on HEAD.
 
 Options:
   --dry-run              Preview without creating releases
-  --only=name1,name2     Only create releases for the named packages (comma-separated, monorepo only)
+  --tags=tag1,tag2       Only create releases for the named tags (comma-separated, full tag names)
   --help, -h             Show this help message
 `);
 }
+function showShowTagPrefixesHelp() {
+  console.info(`
+Usage: release-kit show-tag-prefixes [options]
+
+Print a per-workspace table of derived tag prefixes, tag counts, and declared
+legacy tag prefixes. Surfaces any release-shaped tags whose prefix is neither a
+derived prefix nor declared in \`legacyIdentities\`, with a copy-pasteable
+config snippet.
+
+Options:
+  --help, -h    Show this help message
+`);
+}
 function showPublishHelp() {
   console.info(`
 Usage: release-kit publish [options]
@@ -164,8 +183,8 @@ Publish packages that have release tags on HEAD.
 
 Options:
   --dry-run              Preview without publishing
-  --no-git-checks        Skip git checks (pnpm only)
-  --only=name1,name2     Only publish the named packages (comma-separated, monorepo only)
+  --no-git-checks        Skip the clean-working-tree check
+  --tags=tag1,tag2       Only publish the named tags (comma-separated, full tag names)
   --provenance           Generate provenance statement (requires OIDC, not supported by classic yarn)
   --help, -h             Show this help message
 `);
@@ -218,12 +237,12 @@ if (command === "push") {
   await pushCommand(flags);
   process.exit(0);
 }
-if (command === "github-release") {
+if (command === "create-github-release") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
-    showGithubReleaseHelp();
+    showCreateGithubReleaseHelp();
     process.exit(0);
   }
-  await githubReleaseCommand(flags);
+  await createGithubReleaseCommand(flags);
   process.exit(0);
 }
 if (command === "publish") {
@@ -234,6 +253,18 @@ if (command === "publish") {
   await publishCommand(flags);
   process.exit(0);
 }
+if (command === "show-tag-prefixes") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showShowTagPrefixesHelp();
+    process.exit(0);
+  }
+  if (flags.length > 0) {
+    console.error(`Error: Unknown option: ${flags[0]}`);
+    process.exit(1);
+  }
+  const exitCode = await showTagPrefixesCommand();
+  process.exit(exitCode);
+}
 if (command === "init") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
     showInitHelp();

package/dist/esm/buildChangelogEntries.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateChangelogOptions } from './generateChangelogs.ts';
+import type { ChangelogEntry, ReleaseConfig } from './types.ts';
+export declare function buildChangelogEntries(config: Pick<ReleaseConfig, 'cliffConfigPath' | 'changelogJson'>, tag: string, options?: GenerateChangelogOptions): ChangelogEntry[];

package/dist/esm/{generateChangelogJson.js → buildChangelogEntries.js}

@@ -1,16 +1,11 @@
 import { execFileSync } from "node:child_process";
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import stringify from "json-stringify-pretty-compact";
-import { extractVersion, isChangelogEntry } from "./changelogJsonUtils.js";
+import { join } from "node:path";
+import { extractVersion } from "./changelogJsonUtils.js";
 import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
 import { isRecord, isUnknownArray } from "./typeGuards.js";
-function generateChangelogJson(config, changelogPath, tag, dryRun, options) {
-  const outputFile = join(changelogPath, config.changelogJson.outputPath);
-  if (dryRun) {
-    return [outputFile];
-  }
+function buildChangelogEntries(config, tag, options) {
   const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
   let cliffConfigPath = resolvedConfigPath;
   let tempDir;
@@ -33,15 +28,10 @@ function generateChangelogJson(config, changelogPath, tag, dryRun, options) {
     });
     const releases = parseCliffContext(contextJson);
     const devOnlySections = new Set(config.changelogJson.devOnlySections);
-    const entries = transformReleases(releases, devOnlySections);
-    const existingEntries = readExistingEntries(outputFile);
-    const merged = mergeEntries(entries, existingEntries);
-    mkdirSync(dirname(outputFile), { recursive: true });
-    writeFileSync(outputFile, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
-    return [outputFile];
+    return transformReleases(releases, devOnlySections);
   } catch (error) {
     throw new Error(
-      `Failed to generate changelog JSON for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
+      `Failed to build changelog entries for tag ${tag}: ${error instanceof Error ? error.message : String(error)}`
     );
   } finally {
     if (tempDir !== void 0) {
@@ -49,25 +39,6 @@ function generateChangelogJson(config, changelogPath, tag, dryRun, options) {
     }
   }
 }
-function generateSyntheticChangelogJson(config, changelogPath, newVersion, date, propagatedFrom, dryRun) {
-  const outputFile = join(changelogPath, config.changelogJson.outputPath);
-  if (dryRun) {
-    return [outputFile];
-  }
-  const items = propagatedFrom.map((dep) => ({
-    description: `Bumped \`${dep.packageName}\` to ${dep.newVersion}`
-  }));
-  const entry = {
-    version: newVersion,
-    date,
-    sections: [{ title: "Dependency updates", audience: "dev", items }]
-  };
-  const existingEntries = readExistingEntries(outputFile);
-  const merged = mergeEntries([entry], existingEntries);
-  mkdirSync(dirname(outputFile), { recursive: true });
-  writeFileSync(outputFile, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
-  return [outputFile];
-}
 function parseCliffContext(json) {
   const parsed = JSON.parse(json);
   if (!isUnknownArray(parsed)) {
@@ -115,12 +86,17 @@ function transformReleases(releases, devOnlySections) {
     for (const commit of release.commits ?? []) {
       const group = commit.group ?? "Other";
       const description = extractDescription(commit.message);
+      const body = extractBody(commit.message);
       let items = sectionMap.get(group);
       if (items === void 0) {
         items = [];
         sectionMap.set(group, items);
       }
-      items.push({ description });
+      const item = { description };
+      if (body !== void 0) {
+        item.body = body;
+      }
+      items.push(item);
     }
     const sections = [];
     for (const [title, items] of sectionMap) {
@@ -147,50 +123,37 @@ function extractDescription(message) {
   }
   return firstLine;
 }
-function readExistingEntries(filePath) {
-  if (!existsSync(filePath)) {
-    return [];
-  }
-  try {
-    const content = readFileSync(filePath, "utf8");
-    const parsed = JSON.parse(content);
-    if (!isUnknownArray(parsed)) {
-      return [];
+const TRAILER_PATTERNS = [
+  /^Signed-off-by:/i,
+  /^Co-authored-by:/i,
+  /^(Closes|Fixes|Resolves)\s+#\d+\s*$/i,
+  /^https?:\/\/\S+\/pull\/\d+\/?\s*$/
+];
+function extractBody(message) {
+  const lines = message.split("\n").slice(1);
+  let start = 0;
+  while (start < lines.length && (lines[start] ?? "").trim() === "") {
+    start += 1;
+  }
+  let end = lines.length;
+  while (end > start) {
+    const line = lines[end - 1] ?? "";
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      end -= 1;
+      continue;
     }
-    return parsed.filter(isChangelogEntry);
-  } catch (error) {
-    console.warn(
-      `Warning: could not parse existing ${filePath}: ${error instanceof Error ? error.message : String(error)}; treating as empty`
-    );
-    return [];
-  }
-}
-function mergeEntries(newEntries, existingEntries) {
-  const versionMap = /* @__PURE__ */ new Map();
-  for (const entry of existingEntries) {
-    versionMap.set(entry.version, entry);
+    if (TRAILER_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+      end -= 1;
+      continue;
+    }
+    break;
   }
-  for (const entry of newEntries) {
-    versionMap.set(entry.version, entry);
+  if (end <= start) {
+    return void 0;
   }
-  return [...versionMap.values()].sort((a, b) => compareVersionsDescending(a.version, b.version));
-}
-function parseVersionParts(version) {
-  return version.split(".").map((s) => {
-    const n = Number(s);
-    return Number.isNaN(n) ? 0 : n;
-  });
-}
-function compareVersionsDescending(a, b) {
-  const partsA = parseVersionParts(a);
-  const partsB = parseVersionParts(b);
-  for (let i = 0; i < 3; i++) {
-    const diff = (partsB[i] ?? 0) - (partsA[i] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
+  return lines.slice(start, end).join("\n").trim();
 }
 export {
-  generateChangelogJson,
-  generateSyntheticChangelogJson
+  buildChangelogEntries
 };

package/dist/esm/buildDependencyGraph.d.ts

@@ -1,7 +1,8 @@
-import type { ComponentConfig } from './types.ts';
+import type { WorkspaceConfig } from './types.ts';
 export interface DependencyGraph {
     packageNameToDir: Map<string, string>;
     dirToPackageName: Map<string, string>;
-    dependentsOf: Map<string, ComponentConfig[]>;
+    dependentsOf: Map<string, WorkspaceConfig[]>;
+    dependenciesOf: Map<string, Set<string>>;
 }
-export declare function buildDependencyGraph(components: readonly ComponentConfig[]): DependencyGraph;
+export declare function buildDependencyGraph(workspaces: readonly WorkspaceConfig[]): DependencyGraph;

package/dist/esm/buildDependencyGraph.js

@@ -2,25 +2,26 @@ import { readFileSync } from "node:fs";
 function isPackageJsonSubset(value) {
   return typeof value === "object" && value !== null;
 }
-function buildDependencyGraph(components) {
+function buildDependencyGraph(workspaces) {
   const packageNameToDir = /* @__PURE__ */ new Map();
   const dirToPackageName = /* @__PURE__ */ new Map();
   const dependentsOf = /* @__PURE__ */ new Map();
-  const componentPackages = /* @__PURE__ */ new Map();
-  for (const component of components) {
-    const primaryPackageFile = component.packageFiles[0];
+  const dependenciesOf = /* @__PURE__ */ new Map();
+  const workspacePackages = /* @__PURE__ */ new Map();
+  for (const workspace of workspaces) {
+    const primaryPackageFile = workspace.packageFiles[0];
     if (primaryPackageFile === void 0) {
       continue;
     }
     const pkg = readPackageJsonSubset(primaryPackageFile);
-    componentPackages.set(component, pkg);
+    workspacePackages.set(workspace, pkg);
     if (pkg.name === void 0) {
       continue;
     }
-    packageNameToDir.set(pkg.name, component.dir);
-    dirToPackageName.set(component.dir, pkg.name);
+    packageNameToDir.set(pkg.name, workspace.dir);
+    dirToPackageName.set(workspace.dir, pkg.name);
   }
-  for (const [component, pkg] of componentPackages) {
+  for (const [workspace, pkg] of workspacePackages) {
     const allDeps = { ...pkg.dependencies, ...pkg.peerDependencies };
     for (const [depName, depVersion] of Object.entries(allDeps)) {
       if (typeof depVersion !== "string" || !depVersion.startsWith("workspace:")) {
@@ -28,13 +29,19 @@ function buildDependencyGraph(components) {
       }
       const existing = dependentsOf.get(depName);
       if (existing === void 0) {
-        dependentsOf.set(depName, [component]);
+        dependentsOf.set(depName, [workspace]);
       } else {
-        existing.push(component);
+        existing.push(workspace);
+      }
+      const forward = dependenciesOf.get(workspace.dir);
+      if (forward === void 0) {
+        dependenciesOf.set(workspace.dir, /* @__PURE__ */ new Set([depName]));
+      } else {
+        forward.add(depName);
       }
     }
   }
-  return { packageNameToDir, dirToPackageName, dependentsOf };
+  return { packageNameToDir, dirToPackageName, dependentsOf, dependenciesOf };
 }
 function readPackageJsonSubset(filePath) {
   let content;

package/dist/esm/buildReleaseSummary.js

@@ -1,20 +1,28 @@
 import { stripScope } from "./stripScope.js";
 function buildReleaseSummary(result) {
   const sections = [];
-  for (const component of result.components) {
-    if (component.status !== "released" || component.tag === void 0) {
+  for (const workspace of result.workspaces) {
+    if (workspace.status !== "released") {
       continue;
     }
-    const commits = component.commits;
+    const commits = workspace.commits;
     if (commits === void 0 || commits.length === 0) {
       continue;
     }
-    const lines = [component.tag];
+    const lines = [workspace.tag];
     for (const commit of commits) {
       lines.push(`- ${stripScope(commit.message)}`);
     }
     sections.push(lines.join("\n"));
   }
+  const project = result.project;
+  if (project !== void 0 && project.status === "released" && project.commits.length > 0) {
+    const lines = [project.tag];
+    for (const commit of project.commits) {
+      lines.push(`- ${stripScope(commit.message)}`);
+    }
+    sections.push(lines.join("\n"));
+  }
   return sections.join("\n\n");
 }
 export {

package/dist/esm/buildSyntheticChangelogEntry.d.ts

@@ -0,0 +1,5 @@
+import type { ChangelogEntry } from './types.ts';
+export declare function buildSyntheticChangelogEntry(propagatedFrom: ReadonlyArray<{
+    packageName: string;
+    newVersion: string;
+}>, version: string, date: string): ChangelogEntry;

package/dist/esm/buildSyntheticChangelogEntry.js

@@ -0,0 +1,13 @@
+function buildSyntheticChangelogEntry(propagatedFrom, version, date) {
+  const items = propagatedFrom.map((dep) => ({
+    description: `Bumped \`${dep.packageName}\` to ${dep.newVersion}`
+  }));
+  return {
+    version,
+    date,
+    sections: [{ title: "Dependency updates", audience: "dev", items }]
+  };
+}
+export {
+  buildSyntheticChangelogEntry
+};

package/dist/esm/bumpAllVersions.d.ts

@@ -1,2 +1,3 @@
 import type { BumpResult, ReleaseType } from './types.ts';
 export declare function bumpAllVersions(packageFiles: readonly string[], releaseType: ReleaseType, dryRun: boolean): BumpResult;
+export declare function setAllVersions(packageFiles: readonly string[], newVersion: string, dryRun: boolean): BumpResult;

package/dist/esm/bumpAllVersions.js

@@ -11,6 +11,20 @@ function bumpAllVersions(packageFiles, releaseType, dryRun) {
   const firstPkg = readPackageJson(firstFile);
   const currentVersion = firstPkg.version;
   const newVersion = bumpVersion(currentVersion, releaseType);
+  writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
+  return { currentVersion, newVersion, files: [...packageFiles] };
+}
+function setAllVersions(packageFiles, newVersion, dryRun) {
+  const firstFile = packageFiles[0];
+  if (firstFile === void 0) {
+    throw new Error("No package files specified");
+  }
+  const firstPkg = readPackageJson(firstFile);
+  const currentVersion = firstPkg.version;
+  writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
+  return { currentVersion, newVersion, files: [...packageFiles] };
+}
+function writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun) {
   for (const filePath of packageFiles) {
     if (dryRun) {
       continue;
@@ -23,7 +37,6 @@ function bumpAllVersions(packageFiles, releaseType, dryRun) {
       throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  return { currentVersion, newVersion, files: [...packageFiles] };
 }
 function readPackageJson(filePath) {
   let content;
@@ -44,5 +57,6 @@ function readPackageJson(filePath) {
   return parsed;
 }
 export {
-  bumpAllVersions
+  bumpAllVersions,
+  setAllVersions
 };

package/dist/esm/bumpVersion.js

@@ -14,6 +14,9 @@ function bumpVersion(version, releaseType) {
   const patchNum = Number.parseInt(patch, 10);
   switch (releaseType) {
     case "major":
+      if (majorNum === 0) {
+        return `0.${minorNum + 1}.0`;
+      }
       return `${majorNum + 1}.0.0`;
     case "minor":
       return `${majorNum}.${minorNum + 1}.0`;

package/dist/esm/changelogJsonFile.d.ts

@@ -0,0 +1,4 @@
+import type { ChangelogEntry, ReleaseConfig } from './types.ts';
+export declare function resolveChangelogJsonPath(config: Pick<ReleaseConfig, 'changelogJson'>, changelogPath: string): string;
+export declare function writeChangelogJson(filePath: string, entries: ChangelogEntry[]): string;
+export declare function upsertChangelogJson(filePath: string, entries: ChangelogEntry[]): string;

package/dist/esm/changelogJsonFile.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import stringify from "json-stringify-pretty-compact";
+import semver from "semver";
+import { isChangelogEntry } from "./changelogJsonUtils.js";
+import { isUnknownArray } from "./typeGuards.js";
+function resolveChangelogJsonPath(config, changelogPath) {
+  return join(changelogPath, config.changelogJson.outputPath);
+}
+function writeChangelogJson(filePath, entries) {
+  const sorted = sortNewestFirst(entries);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, stringify(sorted, { maxLength: 100 }) + "\n", "utf8");
+  return filePath;
+}
+function upsertChangelogJson(filePath, entries) {
+  const existing = readExistingEntries(filePath);
+  const merged = mergeEntries(entries, existing);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
+  return filePath;
+}
+function sortNewestFirst(entries) {
+  return [...entries].sort((a, b) => compareVersionsDescending(a.version, b.version));
+}
+function readExistingEntries(filePath) {
+  if (!existsSync(filePath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!isUnknownArray(parsed)) {
+      return [];
+    }
+    return parsed.filter(isChangelogEntry);
+  } catch (error) {
+    console.warn(
+      `Warning: could not parse existing ${filePath}: ${error instanceof Error ? error.message : String(error)}; treating as empty`
+    );
+    return [];
+  }
+}
+function mergeEntries(newEntries, existingEntries) {
+  const versionMap = /* @__PURE__ */ new Map();
+  for (const entry of existingEntries) {
+    versionMap.set(entry.version, entry);
+  }
+  for (const entry of newEntries) {
+    versionMap.set(entry.version, entry);
+  }
+  return sortNewestFirst(versionMap.values());
+}
+function compareVersionsDescending(a, b) {
+  const aValid = semver.valid(a);
+  const bValid = semver.valid(b);
+  if (aValid && bValid) return semver.rcompare(aValid, bValid);
+  if (aValid) return -1;
+  if (bValid) return 1;
+  if (a > b) return -1;
+  if (a < b) return 1;
+  return 0;
+}
+export {
+  resolveChangelogJsonPath,
+  upsertChangelogJson,
+  writeChangelogJson
+};

package/dist/esm/commitCommand.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./prepareCommand.js";
 const commitFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" }

package/dist/esm/compareVersions.d.ts

@@ -0,0 +1 @@
+export declare function isForwardVersion(current: string, target: string): boolean;

package/dist/esm/compareVersions.js

@@ -0,0 +1,27 @@
+const CANONICAL_SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/;
+function parseCanonicalSemver(version) {
+  const match = version.match(CANONICAL_SEMVER_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid semver version: '${version}'`);
+  }
+  const [, major = "", minor = "", patch = ""] = match;
+  return {
+    major: Number.parseInt(major, 10),
+    minor: Number.parseInt(minor, 10),
+    patch: Number.parseInt(patch, 10)
+  };
+}
+function isForwardVersion(current, target) {
+  const currentParsed = parseCanonicalSemver(current);
+  const targetParsed = parseCanonicalSemver(target);
+  if (targetParsed.major !== currentParsed.major) {
+    return targetParsed.major > currentParsed.major;
+  }
+  if (targetParsed.minor !== currentParsed.minor) {
+    return targetParsed.minor > currentParsed.minor;
+  }
+  return targetParsed.patch > currentParsed.patch;
+}
+export {
+  isForwardVersion
+};

package/dist/esm/createGithubRelease.d.ts

@@ -1,11 +1,15 @@
-import type { ReleaseNotesConfig } from './types.ts';
 export interface CreateGithubReleaseOptions {
     tag: string;
     changelogJsonPath: string;
     dryRun: boolean;
+    sectionOrder?: string[];
 }
 export declare function createGithubRelease(options: CreateGithubReleaseOptions): boolean;
+export interface CreateGithubReleasesOutcome {
+    created: string[];
+    skipped: string[];
+}
 export declare function createGithubReleases(tags: Array<{
     tag: string;
     workspacePath: string;
-}>, releaseNotes: ReleaseNotesConfig, changelogJsonOutputPath: string, dryRun: boolean): void;
+}>, changelogJsonOutputPath: string, dryRun: boolean, sectionOrder?: string[]): CreateGithubReleasesOutcome;

package/dist/esm/createGithubRelease.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
 function createGithubRelease(options) {
-  const { tag, changelogJsonPath, dryRun } = options;
+  const { tag, changelogJsonPath, dryRun, sectionOrder } = options;
   if (!existsSync(changelogJsonPath)) {
     console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
     return false;
@@ -25,7 +25,8 @@ function createGithubRelease(options) {
   }
   const body = renderReleaseNotesSingle(entry, {
     filter: matchesAudience("all"),
-    includeHeading: false
+    includeHeading: false,
+    ...sectionOrder === void 0 ? {} : { sectionOrder }
   });
   if (body.trim() === "") {
     return false;
@@ -35,24 +36,23 @@ function createGithubRelease(options) {
     console.info(`[dry-run] Would run: gh ${args.join(" ")}`);
     return true;
   }
-  try {
-    execFileSync("gh", args, { stdio: "inherit" });
-    return true;
-  } catch (error) {
-    console.warn(
-      `Warning: failed to create GitHub Release for ${tag}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return false;
-  }
+  execFileSync("gh", args, { stdio: "inherit" });
+  return true;
 }
-function createGithubReleases(tags, releaseNotes, changelogJsonOutputPath, dryRun) {
-  if (!releaseNotes.shouldCreateGithubRelease) {
-    return;
-  }
+function createGithubReleases(tags, changelogJsonOutputPath, dryRun, sectionOrder) {
+  const created = [];
+  const skipped = [];
   for (const { tag, workspacePath } of tags) {
     const changelogJsonPath = join(workspacePath, changelogJsonOutputPath);
-    createGithubRelease({ tag, changelogJsonPath, dryRun });
-  }
+    const result = createGithubRelease({
+      tag,
+      changelogJsonPath,
+      dryRun,
+      ...sectionOrder === void 0 ? {} : { sectionOrder }
+    });
+    (result ? created : skipped).push(tag);
+  }
+  return { created, skipped };
 }
 export {
   createGithubRelease,