@williamthorsen/release-kit 10.9.0 → 12.0.0

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

@@ -6,7 +6,7 @@ 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.
+ * derivation) cannot disagree on the composition rule.
  */
 export declare function composeHeader(entry: {
     emoji: string;

package/dist/esm/defaults.js

@@ -13,6 +13,9 @@ function deriveDefaultWorkTypes() {
         if (entry.aliases.length > 0) {
             config.aliases = [...entry.aliases];
         }
+        if (entry.excludedFromChangelog === true) {
+            config.excludedFromChangelog = true;
+        }
         result[entry.key] = config;
     }
     return result;

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 has a known work type.
  *
- * 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 {

package/dist/esm/discoverWorkspaces.d.ts

@@ -1,13 +1,58 @@
+import { type EmptyWorkspaceCause } from '@williamthorsen/nmr-core/workspace';
+export type { EmptyWorkspaceCause } from '@williamthorsen/nmr-core/workspace';
 /**
- * Reads `pnpm-workspace.yaml` and resolves its `packages` globs to discover workspace directories.
+ * What release-kit's workspace discovery produced: the repo releases as a single package, it resolves to a
+ * set of package directories, or it declares a workspace that resolves to none and the cause says which
+ * condition emptied it.
  *
- * Returns an array of workspace-relative directory paths (e.g., `['packages/arrays', 'packages/strings']`).
- * Only directories containing a `package.json` are included.
+ * Held apart from nmr-core's `WorkspaceResolution`, whose `packageDirs` are absolute, because these are
+ * relative to the monorepo root. The two carry incompatible path contracts, and a distinct `kind` for the
+ * single-package case keeps either from standing in for the other.
+ */
+export type WorkspaceDiscovery = {
+    kind: 'empty';
+    cause: FailingWorkspaceCause;
+    patterns: string[];
+} | {
+    kind: 'packages';
+    packageDirs: string[];
+    patterns: string[];
+} | {
+    kind: 'single-package';
+};
+/** A workspace that resolved to no package directory, which every release-kit command treats as a failure. */
+export type EmptyWorkspace = Extract<WorkspaceDiscovery, {
+    kind: 'empty';
+}>;
+/**
+ * The empty-workspace causes that reach a command as a failure.
+ *
+ * `no-packages-list` is absent because a manifest declaring nothing releases as a single package, so no
+ * command ever composes a message for it.
+ */
+export type FailingWorkspaceCause = Exclude<EmptyWorkspaceCause, 'no-packages-list'>;
+/**
+ * Returns the sentence naming which of the five conditions left a workspace holding no package directory, and
+ * the remedy for that one. Each quotes the `packages` list the manifest declares, apart from the two that
+ * reach the matcher with no list to quote.
+ *
+ * The `package.json` requirement is stated under `no-package` because it is a divergence from pnpm, which
+ * recognizes two further manifests, and the reader of a workspace that pnpm resolves has no way to infer it.
+ */
+export declare function describeEmptyWorkspace(workspace: EmptyWorkspace): string;
+/**
+ * Reads `pnpm-workspace.yaml` at `monorepoRoot` and resolves its `packages` patterns, applying pnpm's
+ * semantics — `!`-prefixed exclusions included.
  *
- * Note: The returned paths are full relative paths from the repo root (e.g., `packages/arrays`,
- * `libs/core`). These paths are passed directly to `deriveWorkspaceConfig()`, which uses them for all
- * file path construction and derives the display name via `path.basename()`.
+ * A directory holding no manifest, and one whose manifest declares no `packages` list, both release as a
+ * single package: pnpm resolves each to the root package alone, and a workspace file kept for `catalog:`,
+ * `overrides:`, or `onlyBuiltDependencies:` is the second of them. Every other empty resolution is a failure,
+ * whether the reader declared patterns that matched nothing or a `packages` value the resolver could not read
+ * as patterns at all.
  *
- * @returns The discovered workspace paths, or `undefined` if no workspace config is found.
+ * `packageDirs` come back relative to `monorepoRoot` as POSIX paths, because that is what every consumer
+ * needs: `WorkspaceConfig.paths` feeds `git log -- <paths>`, and `packageFiles` and `changelogPaths` are read
+ * from disk relative to the working directory. The workspace root itself relativizes to `.`, the path
+ * `deriveWorkspaceConfig` reads a root package's manifest through.
  */
-export declare function discoverWorkspaces(): Promise<string[] | undefined>;
+export declare function discoverWorkspaces(monorepoRoot?: string): WorkspaceDiscovery;

package/dist/esm/discoverWorkspaces.js

@@ -1,42 +1,62 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { describeError } from '@williamthorsen/toolbelt.errors';
-import { glob } from 'glob';
-import { parse } from 'yaml';
-import { isRecord } from "./typeGuards.js";
-export async function discoverWorkspaces() {
-    const workspaceFile = 'pnpm-workspace.yaml';
-    if (!existsSync(workspaceFile)) {
-        return undefined;
-    }
-    let content;
-    try {
-        content = readFileSync(workspaceFile, 'utf8');
-    }
-    catch (error) {
-        console.warn(`Warning: Failed to read ${workspaceFile}: ${describeError(error)}`);
-        return undefined;
-    }
-    const parsed = parse(content);
-    if (!isRecord(parsed)) {
-        return undefined;
+import path from 'node:path';
+import { resolveWorkspace } from '@williamthorsen/nmr-core/workspace';
+export function describeEmptyWorkspace(workspace) {
+    const declaredClause = describeDeclaredPatterns(workspace.patterns);
+    switch (workspace.cause) {
+        case 'all-excluded':
+            return (`pnpm-workspace.yaml ${declaredClause}, whose \`!\` entries exclude every directory matched by the ` +
+                'positive patterns. Drop or narrow the exclusion.');
+        case 'no-package':
+            return (`pnpm-workspace.yaml ${declaredClause}, and the matcher found no directory holding a \`package.json\`. ` +
+                'Add one to the directory that should be a package, or declare a pattern reaching a directory that ' +
+                'holds one.');
+        case 'no-pattern':
+            return (`pnpm-workspace.yaml ${declaredClause}, so no pattern reaches the matcher. Declare a positive pattern ` +
+                'such as `packages/*`, and quote any `!` entry, which YAML reads as a tag rather than a string where ' +
+                'it stands bare.');
+        case 'unreadable-manifest':
+            return ('pnpm-workspace.yaml holds no valid YAML, so nothing it declares reaches the matcher. Repair the ' +
+                'syntax error and run the command again. An unterminated quoted string and a mis-indented entry are ' +
+                'the usual ones.');
+        case 'unreadable-packages':
+            return ('pnpm-workspace.yaml declares a `packages` value that is not a list of strings, so nothing it ' +
+                'declares reaches the matcher. Make it a list whose every entry is a quoted pattern; a bare value ' +
+                'and an entry YAML read as a number or a map are the usual ones.');
+        default: {
+            const unhandledCause = workspace.cause;
+            throw new Error(`Unhandled empty-workspace cause: ${String(unhandledCause)}`);
+        }
     }
-    const packagesField = parsed['packages'];
-    if (!Array.isArray(packagesField)) {
-        return undefined;
+}
+export function discoverWorkspaces(monorepoRoot = process.cwd()) {
+    const resolution = resolveWorkspace(monorepoRoot);
+    if (resolution.kind === 'not-a-workspace') {
+        return { kind: 'single-package' };
     }
-    const patterns = packagesField.filter((p) => typeof p === 'string');
-    if (patterns.length === 0) {
-        return undefined;
+    if (resolution.kind === 'empty') {
+        const { cause, patterns } = resolution;
+        return cause === 'no-packages-list' ? { kind: 'single-package' } : { cause, kind: 'empty', patterns };
     }
-    const directories = [];
-    for (const pattern of patterns) {
-        const matches = await glob(pattern, { posix: true });
-        for (const match of matches) {
-            if (existsSync(join(match, 'package.json'))) {
-                directories.push(match);
-            }
-        }
+    return {
+        ...resolution,
+        packageDirs: resolution.packageDirs.map((packageDir) => relativizeToPosix(monorepoRoot, packageDir)),
+    };
+}
+function describeDeclaredPatterns(patterns) {
+    const quotablePatterns = patterns.filter((pattern) => pattern.trim() !== '');
+    const emptiedCount = patterns.length - quotablePatterns.length;
+    if (emptiedCount === 0) {
+        return `declares ${renderQuotedList(patterns)}`;
     }
-    return directories.length > 0 ? [...directories].sort() : undefined;
+    const emptiedClause = `${String(emptiedCount)} ${emptiedCount === 1 ? 'entry' : 'entries'} that YAML left empty`;
+    return quotablePatterns.length === 0
+        ? `declares ${emptiedClause}`
+        : `declares ${renderQuotedList(quotablePatterns)}, beside ${emptiedClause}`;
+}
+function relativizeToPosix(monorepoRoot, packageDir) {
+    const relativeDir = path.relative(monorepoRoot, packageDir);
+    return relativeDir === '' ? '.' : relativeDir.split(path.sep).join('/');
+}
+function renderQuotedList(patterns) {
+    return patterns.map((pattern) => `\`${pattern}\``).join(', ');
 }

package/dist/esm/enumerateReleaseWindows.d.ts

@@ -0,0 +1,50 @@
+/** A commit as git records it, before any parsing or filtering. */
+export interface RawCommit {
+    /** The full 40-character hash, which `changelogOverrides` keys on. */
+    hash: string;
+    /** The first line, with a wrapped subject folded onto one line by git. */
+    subject: string;
+    /** The message after its first blank line, empty when the commit carries no body. */
+    body: string;
+    /** The raw commit message, subject and body together. */
+    message: string;
+}
+/** The commits one release contains, with the version and date under which they shipped. */
+export interface ReleaseWindow {
+    /** The tag name for a released window, the caller's unreleased-tag name for the newest one. */
+    version: string;
+    /** Unix seconds: the tag's creation date for a released window, the clock for the unreleased one. */
+    timestamp: number;
+    /** Oldest first. */
+    commits: RawCommit[];
+}
+/** Inputs for {@link enumerateReleaseWindows}. */
+export interface EnumerateReleaseWindowsOptions {
+    /** Git pathspecs restricting the enumeration to commits that touch them. */
+    paths?: readonly string[];
+    /** Tag prefixes to match as a union; a matching tag name continues with a digit. */
+    tagPrefixes: readonly string[];
+    /** The version that the unreleased window reports, such as the tag that the release being prepared will write. */
+    unreleasedTag: string;
+    /** Returns the current time in epoch milliseconds; dates the unreleased window. */
+    now?: () => number;
+}
+/**
+ * Splits the history reachable from HEAD into release windows, newest first.
+ *
+ * The newest window is always the unreleased one, empty when HEAD sits on a tag. Released
+ * windows follow in descending order, one per reachable tag matching a prefix. A tag that
+ * HEAD cannot reach is dropped.
+ *
+ * A commit belongs to the oldest matching tag that contains it, and to the unreleased window
+ * when no matching tag does. Containment is read from the ancestry graph rather than from a
+ * position in a linear walk, because a branch commit authored before a tag and merged after it
+ * is not in that tag's release.
+ *
+ * Three git invocations serve any number of tags: `git rev-list --topo-order --parents` for the
+ * ancestry graph, `git for-each-ref` for the tag names with their creation dates and target
+ * commits, and one path-filtered `git log` for the commits themselves.
+ *
+ * @throws If `tagPrefixes` is empty, or if any git invocation fails.
+ */
+export declare function enumerateReleaseWindows(options: EnumerateReleaseWindowsOptions): ReleaseWindow[];

package/dist/esm/enumerateReleaseWindows.js

@@ -0,0 +1,124 @@
+import { execFileSync } from 'node:child_process';
+import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
+import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+const FIELD_SEPARATOR = '\u{1F}';
+const RECORD_SEPARATOR = '\u{1E}';
+export function enumerateReleaseWindows(options) {
+    const { now = Date.now, paths, tagPrefixes, unreleasedTag } = options;
+    if (tagPrefixes.length === 0) {
+        throw new Error('enumerateReleaseWindows: tagPrefixes must contain at least one entry');
+    }
+    const unreleasedWindow = {
+        version: unreleasedTag,
+        timestamp: Math.floor(now() / 1_000),
+        commits: [],
+    };
+    const ancestry = readAncestry();
+    if (ancestry.parentsByHash.size === 0) {
+        return [unreleasedWindow];
+    }
+    const boundaries = readTagBoundaries(tagPrefixes, ancestry.positionByHash);
+    const releasedWindows = boundaries.map((boundary) => ({
+        version: boundary.tag,
+        timestamp: boundary.timestamp,
+        commits: [],
+    }));
+    const windowIndexByHash = claimAncestors(boundaries, ancestry.parentsByHash);
+    for (const commit of readCommits(paths).toReversed()) {
+        const windowIndex = windowIndexByHash.get(commit.hash);
+        const window = windowIndex === undefined ? unreleasedWindow : (releasedWindows[windowIndex] ?? unreleasedWindow);
+        window.commits.push(commit);
+    }
+    return [unreleasedWindow, ...releasedWindows.toReversed()];
+}
+function claimAncestors(boundaries, parentsByHash) {
+    const windowIndexByHash = new Map();
+    for (const [windowIndex, boundary] of boundaries.entries()) {
+        const pending = [boundary.hash];
+        while (pending.length > 0) {
+            const hash = pending.pop();
+            if (hash === undefined || windowIndexByHash.has(hash)) {
+                continue;
+            }
+            windowIndexByHash.set(hash, windowIndex);
+            pending.push(...(parentsByHash.get(hash) ?? []));
+        }
+    }
+    return windowIndexByHash;
+}
+function matchesTagPrefix(tagName, tagPrefixes) {
+    return tagPrefixes.some((prefix) => tagName.startsWith(prefix) && /^\d/.test(tagName.slice(prefix.length)));
+}
+function parseCommitRecord(record) {
+    const [hash, subject, message] = record.replace(/^\n+/, '').split(FIELD_SEPARATOR);
+    if (hash === undefined || subject === undefined || message === undefined || hash === '') {
+        return undefined;
+    }
+    const trimmedMessage = message.replace(/\s+$/, '');
+    const bodyStart = trimmedMessage.indexOf('\n\n');
+    const body = bodyStart === -1 ? '' : trimmedMessage.slice(bodyStart + 2);
+    return { hash, subject, body, message: trimmedMessage };
+}
+function readAncestry() {
+    const args = ['rev-list', '--topo-order', '--parents', '--ignore-missing', 'HEAD'];
+    const output = runGit(args, `'git rev-list' for HEAD`);
+    const ancestry = { parentsByHash: new Map(), positionByHash: new Map() };
+    for (const [position, line] of output.split('\n').entries()) {
+        const [hash, ...parents] = line.split(' ');
+        if (hash === undefined || hash === '') {
+            continue;
+        }
+        ancestry.parentsByHash.set(hash, parents);
+        ancestry.positionByHash.set(hash, position);
+    }
+    return ancestry;
+}
+function readCommits(paths) {
+    const format = `%H${FIELD_SEPARATOR}%s${FIELD_SEPARATOR}%B${RECORD_SEPARATOR}`;
+    const args = ['log', 'HEAD', `--pretty=format:${format}`];
+    if (paths !== undefined && paths.length > 0) {
+        args.push('--', ...paths);
+    }
+    const output = runGit(args, `'git log' for HEAD`);
+    const commits = [];
+    for (const record of output.split(RECORD_SEPARATOR)) {
+        const commit = parseCommitRecord(record);
+        if (commit !== undefined) {
+            commits.push(commit);
+        }
+    }
+    return commits;
+}
+function readTagBoundaries(tagPrefixes, positionByHash) {
+    const fields = ['%(refname:strip=2)', '%(creatordate:unix)', '%(objectname)', '%(*objectname)'];
+    const args = ['for-each-ref', `--format=${fields.join('%1f')}`, 'refs/tags'];
+    const output = runGit(args, `'git for-each-ref' for refs/tags`);
+    const boundaries = [];
+    for (const line of output.split('\n')) {
+        const [tag, creatorDate, objectName, dereferencedName] = line.split(FIELD_SEPARATOR);
+        if (tag === undefined || creatorDate === undefined || objectName === undefined) {
+            continue;
+        }
+        if (!matchesTagPrefix(tag, tagPrefixes)) {
+            continue;
+        }
+        const hash = dereferencedName || objectName;
+        const position = positionByHash.get(hash);
+        if (position !== undefined) {
+            boundaries.push({ hash, position, tag, timestamp: Number(creatorDate) });
+        }
+    }
+    return boundaries.toSorted((left, right) => right.position - left.position);
+}
+function runGit(args, description) {
+    try {
+        return execFileSync('git', args, {
+            encoding: 'utf8',
+            maxBuffer: GIT_OUTPUT_LIMIT,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch (error) {
+        throw chainError(`Failed to run ${description}`, error);
+    }
+}

package/dist/esm/generateChangelogs.d.ts

@@ -1,32 +1,14 @@
 import type { WorkspaceConfig } from './types.js';
-/**
- * Build a git-cliff tag pattern from one or more tag prefixes.
- *
- * Single-prefix input preserves the historical `<prefix>[0-9].*` shape. Multi-prefix input
- * returns `(prefix1|prefix2|...)[0-9].*` so git-cliff's regex-based `--tag-pattern` accepts
- * tags under any listed prefix. Each prefix is regex-escaped so metacharacters in operator-
- * supplied legacy prefixes cannot alter the pattern's meaning.
- *
- * @param tagPrefixes - Tag prefixes to match as a union (must contain at least one entry).
- */
-export declare function buildTagPattern(tagPrefixes: readonly string[]): string;
 /**
  * Return the workspace's derived tag prefix followed by each declared legacy-identity tag
  * prefix. Shared by `releasePrepareMono` (the production prepare path) and
  * `validateOverridesCommand` so the two compute byte-equal per-workspace tag-prefix unions.
  */
 export declare function getAllTagPrefixes(workspace: WorkspaceConfig): string[];
-/**
- * Options for `buildChangelogEntries`-driven flows that consume git-cliff output.
- *
- * The fields here mirror the subset of git-cliff CLI options that the in-package pipeline
- * still passes through (tag-pattern union, include-path filtering for monorepo workspaces).
- * `generateChangelog` and `generateChangelogs` (the prior cliff `--output` invokers) are
- * removed; markdown rendering is now handled by `renderChangelogMarkdown.ts`.
- */
+/** Options for `buildChangelogEntries`: the tag prefixes and pathspecs that bound its release windows. */
 export interface GenerateChangelogOptions {
-    /** Tag pattern to match release tags (passed as --tag-pattern to git-cliff). */
-    tagPattern?: string;
-    /** Paths to include in the changelog (passed as --include-path to git-cliff). */
-    includePaths?: string[];
+    /** Tag prefixes to match as a union; must contain at least one entry. */
+    tagPrefixes: readonly string[];
+    /** Git pathspecs restricting the history to commits that touch them; all paths when omitted. */
+    paths?: readonly string[];
 }

package/dist/esm/generateChangelogs.js

@@ -1,17 +1,3 @@
-export function buildTagPattern(tagPrefixes) {
-    if (tagPrefixes.length === 0) {
-        throw new Error('buildTagPattern: tagPrefixes must contain at least one entry');
-    }
-    if (tagPrefixes.length === 1) {
-        const single = tagPrefixes[0] ?? '';
-        return `${single}[0-9].*`;
-    }
-    const escaped = tagPrefixes.map(escapeRegex);
-    return `(${escaped.join('|')})[0-9].*`;
-}
 export function getAllTagPrefixes(workspace) {
     return [workspace.tagPrefix, ...(workspace.legacyIdentities?.map((identity) => identity.tagPrefix) ?? [])];
 }
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
-}

package/dist/esm/glyphs.d.ts

@@ -1,3 +1,3 @@
 /** Glyphs that name no status; a status marker comes from nmr-core's `STATUS_GLYPHS`. */
-export declare const RELEASE_GLYPHS: Readonly<Record<"plain" | "rich", Readonly<Record<"bump" | "dryRun" | "tag", import("@williamthorsen/toolbelt.terminal/candidate").Glyph>>>>;
+export declare const RELEASE_GLYPHS: Readonly<Record<"plain" | "rich", Readonly<Record<"tag" | "bump" | "dryRun", import("@williamthorsen/toolbelt.terminal/candidate").Glyph>>>>;
 export type ReleaseGlyphName = keyof (typeof RELEASE_GLYPHS)['rich'];

package/dist/esm/help/prepareHelp.d.ts

@@ -3,6 +3,6 @@
  * dispatcher and asserted by the help drift guard test; kept free of import-time side
  * effects so both can load it.
  */
-export declare const prepareHelpText = "\nUsage: release-kit prepare [options]\n\nRun release preparation with automatic workspace discovery.\n\nOptions:\n  --dry-run             Run without modifying any files\n  --bump=major|minor|patch  Override the bump type for all workspaces\n  --set-version=X.Y.Z   Set an explicit version; bypasses commit-derived bumps. In monorepo\n                         mode it requires --only, and is rejected when a 'project' block is configured.\n  --force               Release even when no commits or no bump-worthy commits exist\n                         since the last tag. In monorepo and project mode, defaults to\n                         patch when --bump is not given; use --bump=X for a different\n                         level. In single-package mode, a bare --force is rejected \u2014\n                         pass --bump=major|minor|patch.\n  --no-git-checks, -n   Skip the clean-working-tree check\n  --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only).\n                         When a 'project' block is configured, the project release is skipped.\n  --with-release-notes  Also write per-workspace release-notes previews under <workspacePath>/docs/\n                         (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md).\n                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).\n  --help, -h            Show this help message\n";
+export declare const prepareHelpText = "\nUsage: release-kit prepare [options]\n\nRun release preparation with automatic workspace discovery.\n\nOptions:\n  --config <path>       Path to config file (default: .config/release-kit.config.ts)\n  --dry-run             Run without modifying any files\n  --bump=major|minor|patch  Set the level of every release that happens; does not trigger one\n  --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo\n                         mode it requires --only, and is rejected when a 'project' block is configured.\n  --force               Release even when no commits or no bump-worthy commits exist\n                         since the last tag. Defaults to patch when --bump is not given;\n                         use --bump=X for a different level.\n  --no-git-checks, -n   Skip the clean-working-tree check\n  --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only).\n                         When a 'project' block is configured, the project release is skipped.\n  --with-release-notes  Also write per-workspace release-notes previews under <workspacePath>/docs/\n                         (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md).\n                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).\n  --help, -h            Show this help message\n";
 /** Prints the prepare command's help text. */
 export declare function showPrepareHelp(): void;

package/dist/esm/help/prepareHelp.js

@@ -4,15 +4,14 @@ Usage: release-kit prepare [options]
 Run release preparation with automatic workspace discovery.
 
 Options:
+  --config <path>       Path to config file (default: .config/release-kit.config.ts)
   --dry-run             Run without modifying any files
-  --bump=major|minor|patch  Override the bump type for all workspaces
-  --set-version=X.Y.Z   Set an explicit version; bypasses commit-derived bumps. In monorepo
+  --bump=major|minor|patch  Set the level of every release that happens; does not trigger one
+  --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo
                          mode it requires --only, and is rejected when a 'project' block is configured.
   --force               Release even when no commits or no bump-worthy commits exist
-                         since the last tag. In monorepo and project mode, defaults to
-                         patch when --bump is not given; use --bump=X for a different
-                         level. In single-package mode, a bare --force is rejected —
-                         pass --bump=major|minor|patch.
+                         since the last tag. Defaults to patch when --bump is not given;
+                         use --bump=X for a different level.
   --no-git-checks, -n   Skip the clean-working-tree check
   --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only).
                          When a 'project' block is configured, the project release is skipped.

package/dist/esm/index.d.ts

@@ -1,2 +1,2 @@
-export { type ChangelogOverrideScope, validateAllChangelogOverrides, type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult, } from './changelogOverrides.js';
+export { type ChangelogOverrideScope, type OverrideTargetItem, validateAllChangelogOverrides, type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult, } from './changelogOverrides.js';
 export { formatValidateOverridesResult, type ValidateOverridesCommandResult } from './validateOverridesCommand.js';

package/dist/esm/init/initCommand.js

@@ -62,7 +62,7 @@ export function initCommand({ dryRun, force, styles, withConfig }) {
     }
     printStep('Next steps');
     const configHint = withConfig
-        ? '1. (Optional) Customize .config/release-kit.config.ts and .config/git-cliff.toml.'
+        ? '1. (Optional) Customize .config/release-kit.config.ts.'
         : '1. (Optional) Run again with --with-config to scaffold config files.';
     console.info(`
   ${configHint}

package/dist/esm/init/scaffold.d.ts

@@ -6,8 +6,6 @@ interface ScaffoldOptions {
     overwrite: boolean;
     withConfig: boolean;
 }
-/** Copy the bundled cliff.toml.template to `.config/git-cliff.toml` in the target repo. */
-export declare function copyCliffTemplate(dryRun: boolean, overwrite: boolean): WriteResult;
 /** Scaffold release-kit files for the target repo. Returns a result for each file attempted. */
 export declare function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }: ScaffoldOptions): WriteResult[];
 export {};

package/dist/esm/init/scaffold.js

@@ -1,33 +1,5 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { findPackageRoot, writeFileWithCheck } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
+import { writeFileWithCheck } from '@williamthorsen/nmr-core';
 import { createGithubReleaseWorkflow, publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
-export function copyCliffTemplate(dryRun, overwrite) {
-    const destPath = '.config/git-cliff.toml';
-    let root;
-    try {
-        root = findPackageRoot(import.meta.url);
-    }
-    catch (error) {
-        const message = describeError(error);
-        return { filePath: destPath, outcome: 'failed', error: `Failed to resolve package root: ${message}` };
-    }
-    const templatePath = resolve(root, 'cliff.toml.template');
-    let content;
-    try {
-        content = readFileSync(templatePath, 'utf8');
-    }
-    catch (error) {
-        const message = describeError(error);
-        return {
-            filePath: destPath,
-            outcome: 'failed',
-            error: `Failed to read bundled template at ${templatePath}: ${message}`,
-        };
-    }
-    return writeFileWithCheck(destPath, content, { dryRun, overwrite });
-}
 export function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
     const results = [
         writeFileWithCheck('.github/workflows/create-github-release.yaml', createGithubReleaseWorkflow(repoType), {
@@ -38,7 +10,7 @@ export function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
         writeFileWithCheck('.github/workflows/release.yaml', releaseWorkflow(repoType), { dryRun, overwrite }),
     ];
     if (withConfig) {
-        results.push(writeFileWithCheck('.config/release-kit.config.ts', releaseConfigScript(repoType), { dryRun, overwrite }), copyCliffTemplate(dryRun, overwrite));
+        results.push(writeFileWithCheck('.config/release-kit.config.ts', releaseConfigScript(repoType), { dryRun, overwrite }));
     }
     return results;
 }