@williamthorsen/release-kit 11.0.0 → 13.0.0

package/dist/esm/classifyChangelogCommit.js

@@ -0,0 +1,34 @@
+import { TICKET_PREFIX_PATTERNS } from '@williamthorsen/change-grammar';
+import { parseCommitMessage } from "./parseCommitMessage.js";
+const RELEASE_SUBJECT_PATTERN = /^release:/;
+const MERGE_SUBJECT_PATTERN = /^Merge/;
+export function classifyChangelogCommit(commit, workTypes, options) {
+    const subject = commit.message.split('\n', 1)[0] ?? '';
+    if (isNonChangeSubject(subject)) {
+        return { kind: 'excluded' };
+    }
+    if (!hasTicketPrefix(subject)) {
+        return { kind: 'unparseable' };
+    }
+    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, undefined, options);
+    if (parsed === undefined) {
+        return { kind: 'unparseable' };
+    }
+    const config = workTypes[parsed.type];
+    if (config === undefined) {
+        return { kind: 'unparseable' };
+    }
+    if (config.excludedFromChangelog === true) {
+        return { kind: 'excluded' };
+    }
+    return { kind: 'header', header: config.header, type: parsed.type, breaking: parsed.breaking };
+}
+export function isNonChangeSubject(subject) {
+    return isReleaseSubject(subject) || MERGE_SUBJECT_PATTERN.test(subject);
+}
+export function isReleaseSubject(subject) {
+    return RELEASE_SUBJECT_PATTERN.test(subject);
+}
+function hasTicketPrefix(subject) {
+    return TICKET_PREFIX_PATTERNS.some((pattern) => pattern.test(subject));
+}

package/dist/esm/commitCommand.d.ts

@@ -1,7 +1,5 @@
 /**
- * Orchestrate the CLI `commit` command.
- *
- * Reads the tags and summary files produced by `prepare`, stages all
- * changes, and creates a release commit with a formatted message.
+ * Runs the CLI `commit` command: reads the tags and summary files written by `prepare`, stages all changes, and
+ * creates the release commit.
  */
 export declare function commitCommand(argv: string[]): void;

package/dist/esm/compareVersions.d.ts

@@ -1,8 +1,14 @@
 /**
- * Return true when `target` is strictly greater than `current`, comparing major, minor, then patch.
+ * Compares two version strings in descending order (newest first).
  *
- * Equal versions return false. Comparison is numeric (not lexical), so `0.10.0` is greater than `0.9.0`.
- *
- * @throws If either version is not canonical `N.N.N` semver.
+ * Valid SemVer inputs are ordered per SemVer §11 (delegated to `semver.rcompare`): prerelease
+ * versions precede the corresponding release (`1.2.3-alpha < 1.2.3`), and build metadata is
+ * ignored for ordering. Inputs that fail `semver.valid` sort to the bottom of the descending
+ * list, ordered lexically among themselves. The comparator never throws.
+ */
+export declare function compareVersionsDescending(a: string, b: string): number;
+/**
+ * Reports whether `target` is strictly greater than `current`, comparing major, minor, then patch numerically; throws
+ * unless both are canonical `N.N.N` semver.
  */
 export declare function isForwardVersion(current: string, target: string): boolean;

package/dist/esm/compareVersions.js

@@ -1,3 +1,4 @@
+import semver from 'semver';
 const CANONICAL_SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/;
 function parseCanonicalSemver(version) {
     const match = version.match(CANONICAL_SEMVER_PATTERN);
@@ -11,6 +12,21 @@ function parseCanonicalSemver(version) {
         patch: Number.parseInt(patch, 10),
     };
 }
+export 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 function isForwardVersion(current, target) {
     const currentParsed = parseCanonicalSemver(current);
     const targetParsed = parseCanonicalSemver(target);

package/dist/esm/configFlagSchema.d.ts

@@ -1,7 +1,7 @@
 /**
  * The `--config` flag, shared by every subcommand that reads the config file.
  *
- * Spread into a subcommand's own schema rather than repeated, so that seven subcommands cannot drift to seven
+ * Spread into a subcommand's own schema rather than repeated, so that the subcommands cannot drift to different
  * spellings of one flag.
  */
 export declare const configFlagSchema: {

package/dist/esm/createGithubRelease.d.ts

@@ -7,12 +7,8 @@ export interface CreateGithubReleaseOptions {
     sectionOrder?: string[];
 }
 /**
- * Discriminated reason a single tag was skipped.
- *
- * `'no-entry'` is the umbrella for all "data missing" sub-cases (changelog file not found,
- * JSON unparseable, version not in changelog) — distinguishing them programmatically adds no
- * value to the consumer, while the existing `console.warn` messages already discriminate them
- * for human diagnostics.
+ * Why a tag was skipped. `'no-entry'` covers every case of missing data (no changelog file, unparseable JSON, no entry
+ * for the version); the warnings that `createGithubRelease` prints tell them apart.
  */
 export type CreateReleaseSkipReason = 'no-entry' | 'no-audience-content' | 'empty-body';
 /** Discriminated outcome of attempting to create a single GitHub Release. */
@@ -23,13 +19,11 @@ export type CreateReleaseResult = {
     reason: CreateReleaseSkipReason;
 };
 /**
- * Create a GitHub Release from changelog.json using the `gh` CLI.
+ * Creates a GitHub Release for a tag through the `gh` CLI, with the all-audience notes of the tag's `changelog.json`
+ * entry as its body.
  *
- * Reads the changelog JSON, finds the entry matching the tag's version, renders all-audience
- * release notes, and creates the release. Returns a discriminated `{status: 'skipped', reason}`
- * (with a warning) when the changelog entry is missing, the entry has no all-audience content,
- * or the rendered body is empty. Throws when the `gh` CLI invocation itself fails so callers
- * can surface the failure rather than exit 0 silently.
+ * Returns a skip when the entry is missing (with a warning), doesn't have any all-audience content, or renders an empty
+ * body. Throws when `gh` fails, so that the caller does not exit 0 on a failed release.
  */
 export declare function createGithubRelease(options: CreateGithubReleaseOptions): CreateReleaseResult;
 /** Outcome of a `createGithubReleases` invocation. */
@@ -42,13 +36,7 @@ export interface CreateGithubReleasesOutcome {
         reason: CreateReleaseSkipReason;
     }>;
 }
-/**
- * Create GitHub Releases for each provided tag.
- *
- * Per-tag soft-fails (missing changelog entry, no all-audience content, empty rendered body) are
- * recorded in `skipped` with their discriminated reason and do not throw. Hard failures from the
- * `gh` CLI itself throw and short-circuit the loop so callers can surface them.
- */
+/** Creates a GitHub Release for each tag and records each skip with its reason; throws at once when `gh` fails. */
 export declare function createGithubReleases(tags: Array<{
     tag: string;
     workspacePath: string;

package/dist/esm/createGithubReleaseCommand.d.ts

@@ -1,9 +1,9 @@
 import { type StreamStyles } from '@williamthorsen/nmr-core';
 /**
- * Orchestrate the CLI `create-github-release` command: Create GitHub Releases from changelog.json
- * for tags on HEAD (or a comma-separated `--tags` subset), without requiring npm publish.
+ * Runs the CLI `create-github-release` command: creates GitHub Releases from `changelog.json` for the tags on HEAD, or
+ * a comma-separated `--tags` subset, without publishing to npm.
  *
- * Private/unpublishable workspaces are skipped with a warning and never get a Release, matching
- * `release-kit publish`; an all-private tag set is a clean no-op.
+ * A private workspace's tag is skipped with a warning and doesn't get a Release; an all-private tag set is a clean
+ * no-op. A relative `--config` resolves against `invocationDir`.
  */
-export declare function createGithubReleaseCommand(argv: string[], styles: StreamStyles): Promise<void>;
+export declare function createGithubReleaseCommand(argv: string[], styles: StreamStyles, invocationDir: string): Promise<void>;

package/dist/esm/createGithubReleaseCommand.js

@@ -2,22 +2,24 @@ import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { configFlagSchema } from "./configFlagSchema.js";
 import { createGithubReleases } from "./createGithubRelease.js";
+import { deriveReleaseNotesConfig } from "./deriveReleaseNotesConfig.js";
 import { formatPrivateSkip } from "./formatPrivateSkip.js";
-import { assertConfigUsable } from "./loadValidatedConfig.js";
+import { loadUsableConfig } from "./loadValidatedConfig.js";
 import { parseRequestedTags } from "./parseRequestedTags.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
-import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
+import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const createGithubReleaseFlagSchema = {
     ...configFlagSchema,
     dryRun: { long: '--dry-run', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
 };
-export async function createGithubReleaseCommand(argv, styles) {
+export async function createGithubReleaseCommand(argv, styles, invocationDir) {
     const parsed = parseArgsOrExit(argv, createGithubReleaseFlagSchema);
+    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
     const { dryRun } = parsed.flags;
-    await assertConfigUsable(styles.stderr, parsed.flags.config);
+    const userConfig = await loadUsableConfig(styles.stderr, configPath);
     const requestedTags = parseRequestedTags(parsed.flags.tags);
-    const resolvedTags = resolveCommandTags(requestedTags);
+    const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     const publishableTags = resolvedTags.filter((resolvedTag) => resolvedTag.isPublishable);
     for (const resolvedTag of resolvedTags) {
         if (!resolvedTag.isPublishable) {
@@ -27,9 +29,7 @@ export async function createGithubReleaseCommand(argv, styles) {
     if (publishableTags.length === 0) {
         return;
     }
-    const { changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig(styles.stderr, {
-        ...(parsed.flags.config !== undefined && { configPath: parsed.flags.config }),
-    });
+    const { changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     let outcome;
     try {
         outcome = createGithubReleases(publishableTags, changelogJsonOutputPath, dryRun, sectionOrder);
@@ -40,6 +40,6 @@ export async function createGithubReleaseCommand(argv, styles) {
     }
     if (outcome.skipped.length > 0) {
         const formatted = outcome.skipped.map((s) => `${s.tag} (${s.reason})`).join(', ');
-        console.info(`Skipped ${outcome.skipped.length} tag(s) with no releasable content: ${formatted}.`);
+        console.info(`Skipped ${outcome.skipped.length} tag(s) without releasable content: ${formatted}.`);
     }
 }

package/dist/esm/createTags.d.ts

@@ -5,8 +5,7 @@ export interface CreateTagsOptions {
     style: OutputStyle;
 }
 /**
- * Read tag names from the tags file produced by `prepare` and create annotated git tags.
- *
- * Returns the list of tag names that were created (or would be created in dry-run mode).
+ * Creates an annotated git tag for each name in the tags file written by `prepare`, then deletes the tags and summary
+ * files, and returns the tag names. In dry-run mode, it only lists the names.
  */
 export declare function createTags(options: CreateTagsOptions): string[];

package/dist/esm/decideRelease.d.ts

@@ -1,23 +1,17 @@
-import { type PolicyViolationHandler } from './parseCommitMessage.js';
-import type { Commit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.js';
-/** Inputs to the unified release decision used by both pipelines. */
+import type { ReleaseType } from './types.js';
+/** Inputs to the release decision that every release path makes. */
 export interface DecideReleaseArgs {
-    commits: readonly Commit[];
+    /** The bump that the window's changelog items call for; undefined when they call for none. */
+    naturalBump: ReleaseType | undefined;
+    /** The number of commits in the window, which selects the skip reason. */
+    commitCount: number;
     /** True when `--force` was passed; treats absence of a natural bump as patch. Defaults to false. */
     force?: boolean | undefined;
     /** Explicit `--bump=X` override. When set, the level is X regardless of the natural bump. */
     bumpOverride: ReleaseType | undefined;
-    workTypes: Record<string, WorkTypeConfig>;
-    versionPatterns: VersionPatterns;
-    scopeAliases: Record<string, string> | undefined;
-    /** Per-canonical-type breaking-policy lookup. When provided, drives `!` policy enforcement in `parseCommitMessage`. */
-    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
-    /** Receives policy-violation notifications from `parseCommitMessage`. */
-    onPolicyViolation?: PolicyViolationHandler;
     /**
-     * Skip wordings to use when no commits exist (`noCommits`) or when commits exist but
-     * none parse to a bump-worthy work type (`noBumpWorthy`). Both pipelines pass their
-     * own pre-rendered wordings (with `{name}` / `since` substitutions already applied).
+     * Skip wordings to use when the window doesn't contain any commits (`noCommits`) or when it contains commits but none
+     * yields a changelog item (`noBumpWorthy`). Each path passes its own pre-rendered wordings.
      */
     skipReasons: {
         noCommits: string;
@@ -28,38 +22,14 @@ export interface DecideReleaseArgs {
 export type DecideReleaseResult = {
     outcome: 'release';
     releaseType: ReleaseType;
-    parsedCommitCount: number;
-    unparseableCommits: Commit[] | undefined;
 } | {
     outcome: 'skip';
     skipReason: string;
-    parsedCommitCount: number;
-    unparseableCommits: Commit[] | undefined;
 };
 /**
- * Apply the unified release-decision algorithm shared by both `releasePrepareProject`
- * and the per-workspace path in `releasePrepareMono`.
+ * Decides whether a window releases, and at which level.
  *
- * Algorithm:
- *   shouldRelease = naturalBump !== undefined OR force === true
- *   releaseLevel  = bumpOverride ?? naturalBump ?? 'patch'
- *
- * "natural bump" is the raw output of `determineBumpType` over the parsed commits — it
- * is `undefined` when no commits exist or when none of the parsed commits map to a
- * bump-worthy work type. Note that this differs from `determineBumpFromCommits`, which
- * applies a patch floor whenever any commits exist; the patch floor is intentionally
- * not applied here so that `--bump=X` and `--force` remain orthogonal (the floor is
- * applied only when `--force` is set, by virtue of the `naturalBump ?? 'patch'`
- * fallback in the release-level expression above).
- *
- * `parsedCommitCount` and `unparseableCommits` are returned in both branches so callers
- * can surface diagnostic data uniformly regardless of skip/release outcome.
- *
- * Scope: this is the canonical algorithm for the orthogonal-flag model in the
- * monorepo path (`releasePrepareProject` + per-workspace `determineDirectBumps`). The
- * single-package executor (`releasePrepare`) deliberately retains
- * `determineBumpFromCommits` and the legacy patch-floor semantics; `prepareCommand`
- * rejects `--force` without `--bump` in single-package mode to surface that gap. A
- * future ticket can unify the single-package path; see #313's external plan.
+ * A window without a natural bump releases only under `--force`, so `--bump=X` chooses a level without triggering a
+ * release, and `--force` triggers one without choosing a level.
  */
 export declare function decideRelease(args: DecideReleaseArgs): DecideReleaseResult;

package/dist/esm/decideRelease.js

@@ -1,30 +1,8 @@
-import { determineBumpType } from "./determineBumpType.js";
-import { parseCommitMessage, } from "./parseCommitMessage.js";
 export function decideRelease(args) {
-    const { commits, force = false, bumpOverride, workTypes, versionPatterns, scopeAliases, breakingPolicies, onPolicyViolation, skipReasons, } = args;
-    const parseOptions = {
-        ...(breakingPolicies !== undefined && { breakingPolicies }),
-        ...(onPolicyViolation !== undefined && { onPolicyViolation }),
-    };
-    const parsedCommits = [];
-    const unparseable = [];
-    for (const commit of commits) {
-        const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases, parseOptions);
-        if (parsed === undefined) {
-            unparseable.push(commit);
-        }
-        else {
-            parsedCommits.push(parsed);
-        }
+    const { naturalBump, commitCount, force = false, bumpOverride, skipReasons } = args;
+    if (naturalBump === undefined && !force) {
+        const skipReason = commitCount === 0 ? skipReasons.noCommits : skipReasons.noBumpWorthy;
+        return { outcome: 'skip', skipReason };
     }
-    const parsedCommitCount = parsedCommits.length;
-    const unparseableCommits = unparseable.length > 0 ? unparseable : undefined;
-    const naturalBump = determineBumpType(parsedCommits, workTypes, versionPatterns);
-    const shouldRelease = naturalBump !== undefined || force;
-    if (!shouldRelease) {
-        const skipReason = commits.length === 0 ? skipReasons.noCommits : skipReasons.noBumpWorthy;
-        return { outcome: 'skip', skipReason, parsedCommitCount, unparseableCommits };
-    }
-    const releaseType = bumpOverride ?? naturalBump ?? 'patch';
-    return { outcome: 'release', releaseType, parsedCommitCount, unparseableCommits };
+    return { outcome: 'release', releaseType: bumpOverride ?? naturalBump ?? 'patch' };
 }

package/dist/esm/defaults.d.ts

@@ -1,33 +1,14 @@
+import { type BreakingPolicy } from '@williamthorsen/change-grammar';
 import type { ChangelogJsonConfig, ReleaseNotesConfig, VersionPatterns, WorkTypeConfig } from './types.js';
-/** Re-export the runtime taxonomy so consumers don't have to depend on `workTypesData.ts` directly. */
-export type { WorkTypesData } from './workTypesData.js';
-export { WORK_TYPES_DATA } from './workTypesData.js';
-/**
- * Compose the rendered section heading for a work-type entry as `${emoji} ${label}`.
- *
- * Single-sourced here so callers (DEFAULT_WORK_TYPES derivation, devOnlySections
- * derivation, cliff-template drift comparison) cannot disagree on the composition rule.
- */
+/** Composes the rendered section heading of a work-type entry as `${emoji} ${label}`. */
 export declare function composeHeader(entry: {
     emoji: string;
     label: string;
 }): string;
-/**
- * Default work types ordered by canonical priority.
- *
- * Derived from `work-types.json` (the canonical SSOT, mirrored at runtime by
- * `workTypesData.ts`). To change the taxonomy, edit `work-types.json` and update
- * `workTypesData.ts` to match — a drift test enforces lockstep.
- */
+/** Default work types, ordered by canonical priority. */
 export declare const DEFAULT_WORK_TYPES: Record<string, WorkTypeConfig>;
-/**
- * Per-canonical-type breaking-policy lookup derived from the canonical taxonomy.
- *
- * Pass this to `parseCommitMessage` (or an equivalent caller) so the parser knows which
- * types tolerate `!` and which trigger a policy-violation warning. Missing entries default
- * to `'optional'` to preserve back-compat for consumers that supply custom work-types.
- */
-export declare const DEFAULT_BREAKING_POLICIES: Record<string, 'forbidden' | 'optional' | 'required'>;
+/** The breaking policy of each canonical work type, which decides whether a `!` on it is a policy violation. */
+export declare const DEFAULT_BREAKING_POLICIES: Record<string, BreakingPolicy>;
 /** Default version bump patterns. */
 export declare const DEFAULT_VERSION_PATTERNS: VersionPatterns;
 /** Default configuration for structured changelog JSON generation. */

package/dist/esm/defaults.js

@@ -1,25 +1,27 @@
-import { WORK_TYPES_DATA } from "./workTypesData.js";
-export { WORK_TYPES_DATA } from "./workTypesData.js";
+import { CANONICAL_TAXONOMY } from '@williamthorsen/change-grammar';
 export function composeHeader(entry) {
     return `${entry.emoji} ${entry.label}`;
 }
 const DEV_ONLY_TIERS = new Set(['internal', 'process']);
 function deriveDefaultWorkTypes() {
     const result = {};
-    for (const entry of WORK_TYPES_DATA.types) {
+    for (const entry of CANONICAL_TAXONOMY.types) {
         const config = {
             header: composeHeader(entry),
         };
         if (entry.aliases.length > 0) {
             config.aliases = [...entry.aliases];
         }
+        if (entry.excludedFromChangelog === true) {
+            config.excludedFromChangelog = true;
+        }
         result[entry.key] = config;
     }
     return result;
 }
 function deriveDevOnlySections() {
     const sections = [];
-    for (const entry of WORK_TYPES_DATA.types) {
+    for (const entry of CANONICAL_TAXONOMY.types) {
         if (!DEV_ONLY_TIERS.has(entry.tier)) {
             continue;
         }
@@ -31,7 +33,7 @@ function deriveDevOnlySections() {
     return sections;
 }
 export const DEFAULT_WORK_TYPES = deriveDefaultWorkTypes();
-export const DEFAULT_BREAKING_POLICIES = Object.fromEntries(WORK_TYPES_DATA.types.map((entry) => [entry.key, entry.breakingPolicy]));
+export const DEFAULT_BREAKING_POLICIES = Object.fromEntries(CANONICAL_TAXONOMY.types.map((entry) => [entry.key, entry.breakingPolicy]));
 export const DEFAULT_VERSION_PATTERNS = {
     major: ['!'],
     minor: ['feat'],

package/dist/esm/defineConfig.d.ts

@@ -1,7 +1,7 @@
 import type { ReleaseKitConfig } from './types.js';
 export type { LabelSpec, ReleaseKitConfig, RepoLabelsConfig } from './types.js';
 /**
- * Type-safe identity function for configuration files.
+ * Returns a configuration unchanged, typing it as a `ReleaseKitConfig`.
  *
  * Usage in `.config/release-kit.config.ts`:
  * ```ts

package/dist/esm/deleteFileIfExists.d.ts

@@ -1,2 +1,2 @@
-/** Delete a file, silently ignoring the case where it does not exist. */
+/** Deletes a file, ignoring one that does not exist. */
 export declare function deleteFileIfExists(filePath: string): void;

package/dist/esm/deriveReleaseNotesConfig.d.ts

@@ -0,0 +1,20 @@
+import type { ReleaseKitConfig, ReleaseNotesConfig } from './types.js';
+export interface ResolvedReleaseNotesConfig {
+    releaseNotes: ReleaseNotesConfig;
+    changelogJsonOutputPath: string;
+    /** Section titles in priority order, derived from the merged workTypes record. */
+    sectionOrder: string[];
+}
+/**
+ * Returns the header of a merged `workTypes` record's `deps` entry, which titles the synthetic propagation section.
+ * Throws when the record lacks one, which `resolveWorkTypes` never produces.
+ */
+export declare function deriveDependenciesHeader(workTypes: Record<string, {
+    header: string;
+}>): string;
+/** Derives the release-notes settings from a loaded config, falling back to the defaults for an absent one. */
+export declare function deriveReleaseNotesConfig(config: ReleaseKitConfig | undefined): ResolvedReleaseNotesConfig;
+/** Returns the section headers of a merged `workTypes` record, in declaration order. */
+export declare function deriveSectionOrder(workTypes: Record<string, {
+    header: string;
+}>): string[];

package/dist/esm/deriveReleaseNotesConfig.js

@@ -0,0 +1,21 @@
+import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_RELEASE_NOTES_CONFIG } from "./defaults.js";
+import { resolveWorkTypes } from "./loadConfig.js";
+export function deriveDependenciesHeader(workTypes) {
+    const header = workTypes['deps']?.header;
+    if (header === undefined) {
+        throw new Error("Resolved work types do not contain a 'deps' entry");
+    }
+    return header;
+}
+export function deriveReleaseNotesConfig(config) {
+    return {
+        releaseNotes: {
+            shouldInjectIntoReadme: config?.releaseNotes?.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
+        },
+        changelogJsonOutputPath: config?.changelogJson?.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+        sectionOrder: deriveSectionOrder(resolveWorkTypes(config?.workTypes)),
+    };
+}
+export function deriveSectionOrder(workTypes) {
+    return Object.values(workTypes).map((entry) => entry.header);
+}

package/dist/esm/deriveWorkspaceConfig.d.ts

@@ -2,10 +2,8 @@ import type { WorkspaceConfig } from './types.js';
 /**
  * Derives a workspace configuration from a workspace-relative path.
  *
- * Reads `package.json` at the workspace path to derive the tag identifier from the
- * package's `name` field (with any leading `@scope/` stripped). The `dir` field remains
- * the basename of the path — it is the stable internal identifier used for `--only`,
- * config overrides, and dependency-graph lookups. The `tagPrefix` is `${unscopedName}-v`,
- * so tags reflect the package identity rather than the directory layout.
+ * The tag prefix is `${unscopedName}-v`, from the `name` in the workspace's `package.json`, so that tags follow the
+ * package's identity rather than the directory layout. `dir` is the basename of the path: the stable internal
+ * identifier for `--only`, config overrides, and dependency-graph lookups.
  */
 export declare function deriveWorkspaceConfig(workspacePath: string): WorkspaceConfig;

package/dist/esm/detectPackageManager.d.ts

@@ -1,8 +1,6 @@
 export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'yarn-berry';
 /**
- * Detect the repo's package manager by checking the `packageManager` field in root `package.json`,
- * then falling back to lockfile detection, then defaulting to `npm`.
- *
- * Yarn v2+ is returned as `'yarn-berry'` to distinguish it from Yarn Classic.
+ * Detects the repo's package manager from the `packageManager` field of the root `package.json`, then from lockfiles,
+ * and otherwise returns `npm`. Yarn v2+ is `'yarn-berry'`, to distinguish it from Yarn Classic.
  */
 export declare function detectPackageManager(): PackageManager;

package/dist/esm/detectUndeclaredTagPrefixes.d.ts

@@ -14,12 +14,10 @@ export interface UndeclaredTagPrefix {
     suggestedDir: string;
 }
 /**
- * Scan local git tags for release-shaped tags whose prefix is not in the known set.
+ * Scans local git tags for release-shaped tags whose prefix is not in `knownPrefixes`, the union of derived and
+ * declared prefixes across all workspaces.
  *
- * Reads only the local tag list; callers expecting to see recently-fetched remote tags
- * should `git fetch --tags` first. Returns an empty array when the repo has no tags
- * or no candidate-shaped tags outside the known set.
- *
- * @param knownPrefixes - Union of derived and declared prefixes across all workspaces.
+ * Reads only the local tag list, so a remote tag that has not been fetched is not reported. Returns an empty array
+ * when the repo doesn't have any tags, or any candidate-shaped tags outside the known set.
  */
 export declare function detectUndeclaredTagPrefixes(knownPrefixes: readonly string[]): UndeclaredTagPrefix[];

package/dist/esm/detectUndeclaredTagPrefixes.js

@@ -42,7 +42,7 @@ export function detectUndeclaredTagPrefixes(knownPrefixes) {
             suggestedDir: stripTrailingTagMarker(prefix),
         });
     }
-    return results.sort((a, b) => a.prefix.localeCompare(b.prefix));
+    return results.toSorted((a, b) => a.prefix.localeCompare(b.prefix));
 }
 function stripTrailingTagMarker(prefix) {
     return prefix.endsWith('-v') ? prefix.slice(0, -2) : prefix;

package/dist/esm/determineBumpType.d.ts

@@ -1,14 +1,14 @@
-import type { ParsedCommit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.js';
+import type { ReleaseType, VersionPatterns, WorkTypeConfig } from './types.js';
+/** The part of a changelog item or parsed commit that decides its bump: its resolved work type and breaking flag. */
+export interface BumpSignal {
+    type: string;
+    breaking: boolean;
+}
 /**
- * Determines the overall bump type from a set of parsed commits.
+ * Determines the overall bump type from a set of changes, returning undefined when none triggers a bump.
  *
- * Uses `versionPatterns` to decide which commit types trigger major/minor bumps.
- * The `'!'` sentinel in `versionPatterns.major` means "any breaking commit triggers major".
- * Any recognized commit type not listed in major or minor patterns defaults to patch.
- *
- * @param commits - The parsed commits to analyze.
- * @param workTypes - The work type configurations to verify recognized types.
- * @param versionPatterns - Rules for determining major and minor bumps.
- * @returns The determined release type, or undefined if no commits match a known work type.
+ * Uses `versionPatterns` to decide which types trigger major/minor bumps.
+ * The `'!'` sentinel in `versionPatterns.major` means "any breaking change triggers major".
+ * Any recognized type not listed in major or minor patterns defaults to patch.
  */
-export declare function determineBumpType(commits: readonly ParsedCommit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns): ReleaseType | undefined;
+export declare function determineBumpType(changes: readonly BumpSignal[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns): ReleaseType | undefined;

package/dist/esm/determineBumpType.js

@@ -3,23 +3,22 @@ const RELEASE_PRIORITY = {
     minor: 2,
     patch: 1,
 };
-export function determineBumpType(commits, workTypes, versionPatterns) {
+export function determineBumpType(changes, workTypes, versionPatterns) {
     const knownTypes = new Set(Object.keys(workTypes));
     let highestPriority = 0;
     let result;
-    for (const commit of commits) {
-        if (commit.breaking && versionPatterns.major.includes('!')) {
+    for (const change of changes) {
+        if (change.breaking && versionPatterns.major.includes('!')) {
             return 'major';
         }
-        const commitType = commit.type;
-        if (!knownTypes.has(commitType)) {
+        if (!knownTypes.has(change.type)) {
             continue;
         }
         let bump;
-        if (versionPatterns.major.includes(commitType)) {
+        if (versionPatterns.major.includes(change.type)) {
             bump = 'major';
         }
-        else if (versionPatterns.minor.includes(commitType)) {
+        else if (versionPatterns.minor.includes(change.type)) {
             bump = 'minor';
         }
         else {