@williamthorsen/release-kit 18.1.1 → 18.3.0

package/dist/esm/changelogJsonUtils.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { isRecord } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { isUnknownArray } from "./typeGuards.js";
 export function isChangelogEntry(value) {
     return (isRecord(value) &&
@@ -11,19 +12,27 @@ export function extractVersion(tag) {
     const match = /(\d+\.\d+\.\d+.*)$/.exec(tag);
     return match?.[1] ?? tag;
 }
-export function readChangelogEntries(filePath) {
+export function describeChangelogFileProblem(status, filePath) {
+    return status === 'missing' ? `${filePath} not found` : `could not parse ${filePath}`;
+}
+export function loadChangelogEntries(filePath) {
     if (!existsSync(filePath)) {
-        return undefined;
+        return { status: 'missing' };
     }
+    let parsedJson;
     try {
-        const content = readFileSync(filePath, 'utf8');
-        const parsedJson = JSON.parse(content);
-        if (!isUnknownArray(parsedJson)) {
-            return undefined;
-        }
-        return parsedJson.filter(isChangelogEntry);
+        parsedJson = JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        return { status: 'unreadable', reason: describeError(error) };
     }
-    catch {
-        return undefined;
+    if (!isUnknownArray(parsedJson)) {
+        return { status: 'unreadable', reason: 'the top-level value is not an array' };
     }
+    const entries = parsedJson.filter(isChangelogEntry);
+    return { status: 'loaded', entries, rejectedCount: parsedJson.length - entries.length };
+}
+export function readChangelogEntries(filePath) {
+    const result = loadChangelogEntries(filePath);
+    return result.status === 'loaded' ? result.entries : undefined;
 }

package/dist/esm/cli/maintenanceCommands.js

@@ -12,7 +12,7 @@ import { CONFIG_FLAG, runReportingFailures } from "./commandKit.js";
 const { defineCommand, defineGroup } = createCli();
 export const showTagPrefixes = defineCommand({
     summary: 'Show derived and declared legacy tag prefixes per workspace',
-    description: 'Print a per-workspace table of derived tag prefixes, tag counts, and declared legacy tag prefixes. Reports any release-shaped tags whose prefix is neither a derived prefix nor declared in `legacyIdentities`, with a copy-pasteable config snippet.',
+    description: 'Print one block per workspace with its derived tag prefix, declared legacy identities, and tag counts, followed by the declared retired packages. Reports any release-shaped tags whose prefix is neither derived nor declared, with a copy-pasteable config snippet.',
     flags: CONFIG_FLAG,
     run: ({ flags, context }) => runReportingFailures(context.styles, () => {
         enterRepoRoot();

package/dist/esm/commitCommand.d.ts

@@ -1,3 +1,4 @@
+import { type Git } from './git.js';
 export interface CommitCommandOptions {
     isDryRun: boolean;
 }
@@ -5,4 +6,4 @@ export interface CommitCommandOptions {
  * 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({ isDryRun }: CommitCommandOptions): void;
+export declare function commitCommand({ isDryRun }: CommitCommandOptions, git?: Git): void;

package/dist/esm/commitCommand.js

@@ -1,9 +1,9 @@
-import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, UserError } from '@williamthorsen/nmr-core';
+import { hasErrnoCode, UserError } from '@williamthorsen/nmr-core';
+import { realGit } from "./git.js";
 import { readReleaseTags, RELEASE_SUMMARY_FILE, resolveReleaseTagsPath } from "./releaseFiles.js";
 import { asUserError } from "./user-error-chaining.js";
-export function commitCommand({ isDryRun }) {
+export function commitCommand({ isDryRun }, git = realGit) {
     const tags = readReleaseTags();
     if (tags.length === 0) {
         throw new UserError(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);
@@ -25,13 +25,10 @@ export function commitCommand({ isDryRun }) {
         console.info('[dry-run] Would create commit with message:\n');
         console.info(message);
         try {
-            const status = execFileSync('git', ['status', '--porcelain'], {
-                encoding: 'utf8',
-                maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-            });
-            if (status.trim().length > 0) {
+            const status = git.readStatus();
+            if (status.length > 0) {
                 console.info('\nUncommitted changes:');
-                console.info(status.trimEnd());
+                console.info(status);
             }
         }
         catch {
@@ -40,8 +37,8 @@ export function commitCommand({ isDryRun }) {
         return;
     }
     try {
-        execFileSync('git', ['add', '-A'], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
-        execFileSync('git', ['commit', '-m', message], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
+        git.addAll();
+        git.commit(message);
     }
     catch (error) {
         throw asUserError(error);

package/dist/esm/configSchema.d.ts

@@ -105,10 +105,11 @@ export declare const workTypeConfigSchema: z.ZodObject<{
     aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
     excludedFromChangelog: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
-/** Schema for the `versionPatterns` block. Both arrays are required when the field is provided. */
+/** Schema for the `versionPatterns` block. `major` and `minor` are required when the field is provided. */
 export declare const versionPatternsSchema: z.ZodObject<{
     major: z.ZodArray<z.ZodString>;
     minor: z.ZodArray<z.ZodString>;
+    none: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 /** Schema for a single `breakingPolicies` value. */
 export declare const breakingPolicyValueSchema: z.ZodEnum<{
@@ -204,6 +205,7 @@ export declare const releaseKitConfigSchema: z.ZodObject<{
     versionPatterns: z.ZodOptional<z.ZodObject<{
         major: z.ZodArray<z.ZodString>;
         minor: z.ZodArray<z.ZodString>;
+        none: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     workspaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
         dir: z.ZodString;

package/dist/esm/configSchema.js

@@ -67,6 +67,7 @@ export const versionPatternsSchema = z
     .object({
     major: z.array(z.string()),
     minor: z.array(z.string()),
+    none: z.array(z.string()).optional(),
 })
     .strict();
 export const breakingPolicyValueSchema = z.enum(['forbidden', 'optional']);

package/dist/esm/createGithubRelease.d.ts

@@ -7,10 +7,10 @@ export interface CreateGithubReleaseOptions {
     sectionOrder?: string[];
 }
 /**
- * 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.
+ * Why a tag was skipped. `'missing-file'` and `'unreadable-file'` concern the `changelog.json` itself; the others mean
+ * that the file does not contain releasable content for the tag.
  */
-export type CreateReleaseSkipReason = 'no-entry' | 'no-audience-content' | 'empty-body';
+export type CreateReleaseSkipReason = 'missing-file' | 'unreadable-file' | 'no-entry' | 'no-audience-content' | 'empty-body';
 /** Discriminated outcome of attempting to create a single GitHub Release. */
 export type CreateReleaseResult = {
     status: 'created';
@@ -22,19 +22,22 @@ export type CreateReleaseResult = {
  * 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.
  *
- * 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.
+ * Returns a skip when the changelog is missing or unreadable, the entry is missing, 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. */
 export interface CreateGithubReleasesOutcome {
     /** Tags for which a Release was created (or would be, under `--dry-run`). */
     createdTags: string[];
-    /** Tags that were skipped, paired with the discriminated reason for each skip. */
-    skippedTags: Array<{
-        tag: string;
-        reason: CreateReleaseSkipReason;
-    }>;
+    /** Tags that were skipped, each with the reason and the `changelog.json` path that was read for it. */
+    skippedTags: SkippedReleaseTag[];
+}
+/** A tag that `createGithubReleases` skipped. */
+export interface SkippedReleaseTag {
+    tag: string;
+    reason: CreateReleaseSkipReason;
+    changelogJsonPath: string;
 }
 /** 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<{

package/dist/esm/createGithubRelease.js

@@ -1,24 +1,20 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
+import { extractVersion, loadChangelogEntries } from "./changelogJsonUtils.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
 import { asUserError } from "./user-error-chaining.js";
 export function createGithubRelease(options) {
     const { tag, changelogJsonPath, isDryRun, sectionOrder } = options;
-    if (!existsSync(changelogJsonPath)) {
-        console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
-        return { status: 'skipped', reason: 'no-entry' };
+    const loaded = loadChangelogEntries(changelogJsonPath);
+    if (loaded.status === 'missing') {
+        return { status: 'skipped', reason: 'missing-file' };
     }
-    const version = extractVersion(tag);
-    const entries = readChangelogEntries(changelogJsonPath);
-    if (entries === undefined) {
-        console.warn(`Warning: could not parse ${changelogJsonPath}; skipping GitHub Release creation`);
-        return { status: 'skipped', reason: 'no-entry' };
+    if (loaded.status === 'unreadable') {
+        return { status: 'skipped', reason: 'unreadable-file' };
     }
-    const entry = entries.find((e) => e.version === version);
+    const version = extractVersion(tag);
+    const entry = loaded.entries.find((e) => e.version === version);
     if (entry === undefined) {
-        console.warn(`Warning: no changelog entry for version ${version}; skipping GitHub Release creation`);
         return { status: 'skipped', reason: 'no-entry' };
     }
     if (!entry.sections.some(matchesAudience('all'))) {
@@ -60,7 +56,7 @@ export function createGithubReleases(tags, changelogJsonOutputPath, isDryRun, se
             createdTags.push(tag);
         }
         else {
-            skippedTags.push({ tag, reason: result.reason });
+            skippedTags.push({ tag, reason: result.reason, changelogJsonPath });
         }
     }
     return { createdTags, skippedTags };

package/dist/esm/createGithubReleaseCommand.d.ts

@@ -1,4 +1,4 @@
-import type { StreamStyles } from '@williamthorsen/nmr-core';
+import { type StreamStyles } from '@williamthorsen/nmr-core';
 export interface CreateGithubReleaseCommandOptions {
     configPath: string | undefined;
     isDryRun: boolean;

package/dist/esm/createGithubReleaseCommand.js

@@ -1,3 +1,5 @@
+import { formatStatusLine } from '@williamthorsen/nmr-core';
+import { describeChangelogFileProblem } from "./changelogJsonUtils.js";
 import { createGithubReleases } from "./createGithubRelease.js";
 import { deriveReleaseNotesConfig } from "./deriveReleaseNotesConfig.js";
 import { formatPrivateSkip } from "./formatPrivateSkip.js";
@@ -24,11 +26,31 @@ export async function createGithubReleaseCommand({ configPath, isDryRun, tags, s
     catch (error) {
         throw prefixUserError('Failed to create GitHub Releases', error);
     }
-    if (outcome.skippedTags.length === 0) {
+    const contentSkips = [];
+    for (const skippedTag of outcome.skippedTags) {
+        const fileProblem = describeFileProblem(skippedTag);
+        if (fileProblem === undefined) {
+            contentSkips.push(skippedTag);
+        }
+        else {
+            console.warn(`  ${formatStatusLine(styles.stderr, 'warning', `Skipping GitHub Release for ${skippedTag.tag}: ${fileProblem}`)}`);
+        }
+    }
+    if (contentSkips.length === 0) {
         return;
     }
-    const formattedSkips = outcome.skippedTags.map((s) => `${s.tag} (${s.reason})`).join(', ');
-    console.info(`Skipped ${outcome.skippedTags.length} tag(s) without releasable content: ${formattedSkips}.`);
+    const formattedSkips = contentSkips.map((s) => `${s.tag} (${s.reason})`).join(', ');
+    console.info(`Skipped ${contentSkips.length} tag(s) without releasable content: ${formattedSkips}.`);
+}
+function describeFileProblem(skippedTag) {
+    switch (skippedTag.reason) {
+        case 'missing-file':
+            return describeChangelogFileProblem('missing', skippedTag.changelogJsonPath);
+        case 'unreadable-file':
+            return describeChangelogFileProblem('unreadable', skippedTag.changelogJsonPath);
+        default:
+            return undefined;
+    }
 }
 function isReleasable(resolvedTag) {
     return resolvedTag.kind !== 'package' || resolvedTag.isPublishable;

package/dist/esm/createTags.d.ts

@@ -1,4 +1,5 @@
 import { type OutputStyle } from '@williamthorsen/nmr-core';
+import { type Git } from './git.js';
 export interface CreateTagsOptions {
     isDryRun: boolean;
     shouldSkipGitChecks: boolean;
@@ -8,4 +9,4 @@ export interface CreateTagsOptions {
  * 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[];
+export declare function createTags(options: CreateTagsOptions, git?: Git): string[];

package/dist/esm/createTags.js

@@ -1,17 +1,17 @@
-import { execFileSync } from 'node:child_process';
-import { formatGlyphLine, GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, UserError, } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, UserError } from '@williamthorsen/nmr-core';
 import { deleteFileIfExists } from "./deleteFileIfExists.js";
+import { realGit } from "./git.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { readReleaseTags, RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 import { asUserError } from "./user-error-chaining.js";
-export function createTags(options) {
+export function createTags(options, git = realGit) {
     const { isDryRun, shouldSkipGitChecks, style } = options;
     const tags = readReleaseTags();
     if (tags.length === 0) {
         return [];
     }
     if (!isDryRun && !shouldSkipGitChecks) {
-        assertCleanWorkingTree();
+        assertCleanWorkingTree(git);
     }
     if (isDryRun) {
         console.info('[dry-run] Would create tags:');
@@ -23,7 +23,7 @@ export function createTags(options) {
     const createdTags = [];
     for (const tag of tags) {
         try {
-            execFileSync('git', ['tag', '-a', tag, '-m', tag], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
+            git.createAnnotatedTag(tag);
             createdTags.push(tag);
         }
         catch (error) {
@@ -45,15 +45,15 @@ export function createTags(options) {
     deleteFileIfExists(RELEASE_SUMMARY_FILE);
     return tags;
 }
-function assertCleanWorkingTree() {
+function assertCleanWorkingTree(git) {
+    let isDirty;
     try {
-        execFileSync('git', ['diff', '--quiet'], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
-        execFileSync('git', ['diff', '--quiet', '--cached'], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
+        isDirty = git.hasTrackedChanges();
     }
     catch (error) {
-        if (hasErrnoCode(error, 'ENOENT')) {
-            throw asUserError(error);
-        }
-        throw new UserError('Working tree is dirty. Commit or stash changes before tagging, or use `--no-git-checks` to skip this check.', { cause: error });
+        throw asUserError(error);
+    }
+    if (isDirty) {
+        throw new UserError('Working tree is dirty. Commit or stash changes before tagging, or use `--no-git-checks` to skip this check.');
     }
 }

package/dist/esm/decideDirectReleases.d.ts

@@ -1,5 +1,6 @@
 import type { UntaggedBaseline } from './assertTaggedBaseline.js';
 import type { ReleaseHistory } from './buildChangelogEntries.js';
+import type { Git } from './git.js';
 import { type MemberTarget } from './prepareRunContext.js';
 import { type TargetDecision, type TargetPrepareSettings } from './prepareTarget.js';
 import type { ReleaseEntry } from './propagateBumps.js';
@@ -20,7 +21,7 @@ export declare function decideDirectReleases(plannedTargets: readonly MemberTarg
     shouldForce?: boolean;
     bumpOverride?: ReleaseType;
     versionOverridesById?: ReadonlyMap<string, string>;
-}, startIds: ReadonlySet<string>): DirectReleases;
+}, startIds: ReadonlySet<string>, git: Git): DirectReleases;
 /**
  * Records on each planned workspace's and directory's history the entry scopes that route nowhere in its unreleased
  * window, which only a pass across every target's window can find. The windows go to the finder with the releasing

package/dist/esm/decideDirectReleases.js

@@ -3,7 +3,7 @@ import { findUnroutedEntryScopes } from "./findUnroutedEntryScopes.js";
 import { getAllTagPrefixes } from "./generateChangelogs.js";
 import { describeStage, isRepoRootTarget, readHistory, runStage } from "./prepareRunContext.js";
 import { decideTargetRelease, readTargetHistory, } from "./prepareTarget.js";
-export function decideDirectReleases(plannedTargets, settings, options, startIds) {
+export function decideDirectReleases(plannedTargets, settings, options, startIds, git) {
     const { shouldForce, bumpOverride, versionOverridesById } = options;
     const directReleases = {
         readings: new Map(),
@@ -14,13 +14,13 @@ export function decideDirectReleases(plannedTargets, settings, options, startIds
     const hintState = { emitted: false };
     const knownPrefixes = plannedTargets.flatMap(getAllTagPrefixes);
     for (const target of plannedTargets) {
-        const { history, untaggedBaseline } = runStage(describeStage(target), () => readTargetHistory(target, settings));
+        const { history, untaggedBaseline } = runStage(describeStage(target), () => readTargetHistory(target, settings, git));
         directReleases.readings.set(target.id, history);
         if (untaggedBaseline !== undefined) {
             directReleases.untaggedBaselines.set(target.id, untaggedBaseline);
         }
         if (history.previousTag === undefined && target.kind === 'package' && target.isWorkspace) {
-            emitBaselineHintOnce(target, knownPrefixes, hintState);
+            emitBaselineHintOnce(target, knownPrefixes, hintState, git);
         }
         const versionOverride = versionOverridesById?.get(target.id);
         const decision = decideTargetRelease(target, history, {
@@ -51,10 +51,10 @@ export function reportUnroutedEntryScopes(plannedTargets, directReleases, settin
             : (findings.get(target.id) ?? []);
     }
 }
-function emitBaselineHintOnce(target, knownPrefixes, state) {
+function emitBaselineHintOnce(target, knownPrefixes, state, git) {
     if (state.emitted || (target.legacyIdentities?.length ?? 0) > 0)
         return;
-    const candidates = detectUndeclaredTagPrefixes(knownPrefixes);
+    const candidates = detectUndeclaredTagPrefixes(knownPrefixes, git);
     if (candidates.length === 0)
         return;
     const totalTags = candidates.reduce((sum, candidate) => sum + candidate.tagCount, 0);

package/dist/esm/decideRelease.d.ts

@@ -11,7 +11,7 @@ export interface DecideReleaseArgs {
     bumpOverride: ReleaseType | undefined;
     /**
      * 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.
+     * calls for a bump (`noBumpWorthy`). Each path passes its own pre-rendered wordings.
      */
     skipReasons: {
         noCommits: string;

package/dist/esm/defaults.d.ts

@@ -9,8 +9,10 @@ export declare function composeHeader(entry: {
 export declare const DEFAULT_WORK_TYPES: Record<string, WorkTypeConfig>;
 /** 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 version bump patterns. The `none` types do not change the code that a consumer runs. */
+export declare const DEFAULT_VERSION_PATTERNS: VersionPatterns & {
+    none: string[];
+};
 /** Default configuration for structured changelog JSON generation. */
 export declare const DEFAULT_CHANGELOG_JSON_CONFIG: ChangelogJsonConfig;
 /** Default configuration for release notes consumption. */

package/dist/esm/defaults.js

@@ -34,6 +34,7 @@ export const DEFAULT_BREAKING_POLICIES = Object.fromEntries(CANONICAL_TAXONOMY.t
 export const DEFAULT_VERSION_PATTERNS = {
     major: ['!'],
     minor: ['feat'],
+    none: ['ai', 'ci', 'docs', 'tests', 'tooling'],
 };
 export const DEFAULT_CHANGELOG_JSON_CONFIG = {
     enabled: true,

package/dist/esm/deriveDirectoryConfig.js

@@ -1,7 +1,8 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { isRecord, UserError } from '@williamthorsen/nmr-core';
-import { chainUserError } from "./user-error-chaining.js";
+import { readJsonFile } from "./readJsonFile.js";
+import { prefixUserError } from "./user-error-chaining.js";
 export const DIRECTORY_VERSION_FILE = 'version.json';
 const TAG_PREFIX_PATTERN = /^[\w.-]+$/;
 export function deriveDirectoryConfig(declaredDirectory, root = process.cwd()) {
@@ -32,10 +33,10 @@ function assertVersionField(label, versionFile, root) {
     }
     let parsedJson;
     try {
-        parsedJson = JSON.parse(readFileSync(absolutePath, 'utf8'));
+        parsedJson = readJsonFile(absolutePath);
     }
     catch (error) {
-        throw chainUserError(`${label}: failed to read ${versionFile}`, error);
+        throw prefixUserError(label, error);
     }
     if (!isRecord(parsedJson) || typeof parsedJson['version'] !== 'string') {
         throw new UserError(`${label}: ${versionFile} does not contain a string 'version' field; add one`);

package/dist/esm/deriveWorkspaceConfig.js

@@ -1,18 +1,11 @@
-import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 import { isRecord, UserError } from '@williamthorsen/nmr-core';
 import { isPublishableManifest } from "./isPublishableManifest.js";
-import { chainUserError } from "./user-error-chaining.js";
+import { readJsonFile } from "./readJsonFile.js";
 export function deriveWorkspaceConfig(workspacePath) {
     const dir = basename(workspacePath);
     const packageJsonPath = `${workspacePath}/package.json`;
-    let parsedJson;
-    try {
-        parsedJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    }
-    catch (error) {
-        throw chainUserError(`Failed to read ${packageJsonPath}`, error);
-    }
+    const parsedJson = readJsonFile(packageJsonPath);
     const name = isRecord(parsedJson) ? parsedJson['name'] : undefined;
     if (typeof name !== 'string' || name.length === 0) {
         throw new UserError(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);

package/dist/esm/detectUndeclaredTagPrefixes.d.ts

@@ -1,3 +1,4 @@
+import type { Git } from './git.js';
 /** A candidate tag prefix found in the repo that is not in the known-prefix set. */
 export interface UndeclaredTagPrefix {
     /** The extracted prefix, including the trailing `-v` (e.g., `'core-v'`). */
@@ -20,4 +21,4 @@ export interface UndeclaredTagPrefix {
  * 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[];
+export declare function detectUndeclaredTagPrefixes(knownPrefixes: readonly string[], git: Git): UndeclaredTagPrefix[];

package/dist/esm/detectUndeclaredTagPrefixes.js

@@ -1,25 +1,16 @@
-import { execFileSync } from 'node:child_process';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 const EXAMPLE_TAG_LIMIT = 3;
 const CANDIDATE_TAG_PATTERN = /^(?<prefix>[a-z][a-z0-9-]*-v)\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/;
-export function detectUndeclaredTagPrefixes(knownPrefixes) {
+export function detectUndeclaredTagPrefixes(knownPrefixes, git) {
     const knownPrefixSet = new Set(knownPrefixes);
-    let rawOutput;
+    let tags;
     try {
-        rawOutput = execFileSync('git', ['tag', '--list'], {
-            encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        tags = git.listTags();
     }
     catch {
         return [];
     }
     const tagsByPrefix = new Map();
-    for (const line of rawOutput.split('\n')) {
-        const tag = line.trim();
-        if (tag === '')
-            continue;
+    for (const tag of tags) {
         const match = CANDIDATE_TAG_PATTERN.exec(tag);
         if (match === null)
             continue;

package/dist/esm/determineBumpType.d.ts

@@ -9,6 +9,7 @@ export interface BumpSignal {
  *
  * 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.
+ * A recognized type listed in `versionPatterns.none` (the default list when omitted) triggers no bump; any other
+ * recognized type not listed in major or minor patterns defaults to patch.
  */
 export declare function determineBumpType(changes: readonly BumpSignal[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns): ReleaseType | undefined;

package/dist/esm/determineBumpType.js

@@ -1,3 +1,4 @@
+import { DEFAULT_VERSION_PATTERNS } from "./defaults.js";
 const RELEASE_PRIORITY = {
     major: 3,
     minor: 2,
@@ -5,6 +6,7 @@ const RELEASE_PRIORITY = {
 };
 export function determineBumpType(changes, workTypes, versionPatterns) {
     const knownTypes = new Set(Object.keys(workTypes));
+    const nonBumpingTypes = new Set(versionPatterns.none ?? DEFAULT_VERSION_PATTERNS.none);
     let highestPriority = 0;
     let result;
     for (const change of changes) {
@@ -21,6 +23,9 @@ export function determineBumpType(changes, workTypes, versionPatterns) {
         else if (versionPatterns.minor.includes(change.type)) {
             bump = 'minor';
         }
+        else if (nonBumpingTypes.has(change.type)) {
+            continue;
+        }
         else {
             bump = 'patch';
         }

package/dist/esm/enumerateReleaseWindows.d.ts

@@ -1,14 +1,4 @@
-/** A commit as git records it, before any parsing or filtering. */
-export interface RawCommit {
-    /** The full 40-character hash. */
-    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 does not have a body. */
-    body: string;
-    /** The raw commit message, subject and body together. */
-    message: string;
-}
+import type { Git, RawCommit } from './git.js';
 /** The commits that one release contains, with the version and date under which they were released. */
 export interface ReleaseWindow {
     /** The tag name for a released window, the caller's unreleased-tag name for the newest one. */
@@ -20,6 +10,8 @@ export interface ReleaseWindow {
 }
 /** Inputs for {@link enumerateReleaseWindows}. */
 export interface EnumerateReleaseWindowsOptions {
+    /** The git through which the history is read. */
+    git: Git;
     /** 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 complete SemVer version. */