@williamthorsen/release-kit 16.1.1 → 17.0.0

package/dist/esm/commitCommand.js

@@ -1,15 +1,12 @@
 import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, parseArgsOrExit } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, UserError } from '@williamthorsen/nmr-core';
 import { readReleaseTags, RELEASE_SUMMARY_FILE, resolveReleaseTagsPath } from "./releaseFiles.js";
-const commitFlagSchema = {
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-};
-export function commitCommand(argv) {
-    const isDryRun = parseArgsOrExit(argv, commitFlagSchema).flags.isDryRun;
+import { asUserError } from "./user-error-chaining.js";
+export function commitCommand({ isDryRun }) {
     const tags = readReleaseTags();
     if (tags.length === 0) {
-        throw new Error(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);
+        throw new UserError(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);
     }
     let summary = '';
     try {
@@ -19,7 +16,7 @@ export function commitCommand(argv) {
         if (hasErrnoCode(error, 'ENOENT')) {
         }
         else {
-            throw error;
+            throw asUserError(error);
         }
     }
     const title = `release: ${tags.join(' ')}`;
@@ -42,7 +39,12 @@ export function commitCommand(argv) {
         }
         return;
     }
-    execFileSync('git', ['add', '-A'], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
-    execFileSync('git', ['commit', '-m', message], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
+    try {
+        execFileSync('git', ['add', '-A'], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
+        execFileSync('git', ['commit', '-m', message], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
+    }
+    catch (error) {
+        throw asUserError(error);
+    }
     console.info(`Created release commit: ${title}`);
 }

package/dist/esm/compareVersions.js

@@ -1,9 +1,10 @@
+import { UserError } from '@williamthorsen/nmr-core';
 import semver from 'semver';
 const CANONICAL_SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/;
 function parseCanonicalSemver(version) {
     const match = version.match(CANONICAL_SEMVER_PATTERN);
     if (!match) {
-        throw new Error(`Invalid semver version: '${version}'`);
+        throw new UserError(`Invalid semver version: '${version}'`);
     }
     const [, major = '', minor = '', patch = ''] = match;
     return {

package/dist/esm/createGithubRelease.js

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { extractVersion, readChangelogEntries } 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)) {
@@ -36,7 +37,12 @@ export function createGithubRelease(options) {
         console.info(`[dry-run] Would run: gh ${args.join(' ')}`);
         return { status: 'created' };
     }
-    execFileSync('gh', args, { stdio: 'inherit' });
+    try {
+        execFileSync('gh', args, { stdio: 'inherit' });
+    }
+    catch (error) {
+        throw asUserError(error);
+    }
     return { status: 'created' };
 }
 export function createGithubReleases(tags, changelogJsonOutputPath, isDryRun, sectionOrder) {

package/dist/esm/createGithubReleaseCommand.d.ts

@@ -1,10 +1,16 @@
-import { type StreamStyles } from '@williamthorsen/nmr-core';
+import type { StreamStyles } from '@williamthorsen/nmr-core';
+export interface CreateGithubReleaseCommandOptions {
+    configPath: string | undefined;
+    isDryRun: boolean;
+    /** The tag names that `--tags` selects, or `undefined` for every release tag on HEAD. */
+    tags: string[] | undefined;
+    styles: StreamStyles;
+}
 /**
  * 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.
  *
  * 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 project tag gets a Release whatever the root `package.json#private` says. A relative `--config` resolves
- * against `invocationDir`.
+ * no-op. A project tag gets a Release whatever the root `package.json#private` says.
  */
-export declare function createGithubReleaseCommand(argv: string[], styles: StreamStyles, invocationDir: string): Promise<void>;
+export declare function createGithubReleaseCommand({ configPath, isDryRun, tags, styles, }: CreateGithubReleaseCommandOptions): Promise<void>;

package/dist/esm/createGithubReleaseCommand.js

@@ -1,25 +1,12 @@
-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 { loadUsableConfig } from "./loadValidatedConfig.js";
-import { parseRequestedTags } from "./parseRequestedTags.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
-import { resolveConfigFlag } from "./resolveConfigFlag.js";
-const createGithubReleaseFlagSchema = {
-    ...configFlagSchema,
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-    tags: { long: '--tags', type: 'string' },
-};
-export async function createGithubReleaseCommand(argv, styles, invocationDir) {
-    const parsedArgs = parseArgsOrExit(argv, createGithubReleaseFlagSchema);
-    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
-    const { isDryRun } = parsedArgs.flags;
+import { prefixUserError } from "./user-error-chaining.js";
+export async function createGithubReleaseCommand({ configPath, isDryRun, tags, styles, }) {
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
-    const resolvedTags = resolveCommandTags(requestedTags, userConfig);
+    const resolvedTags = resolveCommandTags(tags, userConfig);
     const releasableTags = resolvedTags.filter(isReleasable);
     for (const resolvedTag of resolvedTags) {
         if (!isReleasable(resolvedTag)) {
@@ -35,8 +22,7 @@ export async function createGithubReleaseCommand(argv, styles, invocationDir) {
         outcome = createGithubReleases(releasableTags, changelogJsonOutputPath, isDryRun, sectionOrder);
     }
     catch (error) {
-        reportError(`Failed to create GitHub Releases: ${describeError(error)}`);
-        process.exit(1);
+        throw prefixUserError('Failed to create GitHub Releases', error);
     }
     if (outcome.skippedTags.length === 0) {
         return;

package/dist/esm/createTags.js

@@ -1,8 +1,9 @@
 import { execFileSync } from 'node:child_process';
-import { formatGlyphLine, GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, UserError, } from '@williamthorsen/nmr-core';
 import { deleteFileIfExists } from "./deleteFileIfExists.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) {
     const { isDryRun, shouldSkipGitChecks, style } = options;
     const tags = readReleaseTags();
@@ -26,13 +27,14 @@ export function createTags(options) {
             createdTags.push(tag);
         }
         catch (error) {
+            const failure = asUserError(error);
             if (createdTags.length > 0) {
                 console.warn('Tags created before failure:');
                 for (const tag of createdTags) {
                     console.warn(`  ${tag}`);
                 }
             }
-            throw error;
+            throw failure;
         }
     }
     console.info('Created tags:');
@@ -50,8 +52,8 @@ function assertCleanWorkingTree() {
     }
     catch (error) {
         if (hasErrnoCode(error, 'ENOENT')) {
-            throw error;
+            throw asUserError(error);
         }
-        throw new Error('Working tree is dirty. Commit or stash changes before tagging, or use `--no-git-checks` to skip this check.', { cause: 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 });
     }
 }

package/dist/esm/deleteFileIfExists.js

@@ -1,5 +1,6 @@
 import { unlinkSync } from 'node:fs';
 import { hasErrnoCode } from '@williamthorsen/nmr-core';
+import { asUserError } from "./user-error-chaining.js";
 export function deleteFileIfExists(filePath) {
     try {
         unlinkSync(filePath);
@@ -8,6 +9,6 @@ export function deleteFileIfExists(filePath) {
         if (hasErrnoCode(error, 'ENOENT')) {
             return;
         }
-        throw error;
+        throw asUserError(error);
     }
 }

package/dist/esm/deriveDirectoryConfig.js

@@ -1,13 +1,13 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
-import { isRecord } from "./typeGuards.js";
+import { isRecord, UserError } from '@williamthorsen/nmr-core';
+import { chainUserError } from "./user-error-chaining.js";
 export const DIRECTORY_VERSION_FILE = 'version.json';
 const TAG_PREFIX_PATTERN = /^[\w.-]+$/;
 export function deriveDirectoryConfig(declaredDirectory, root = process.cwd()) {
     const label = `releases.${declaredDirectory.name}`;
     if (statSync(path.resolve(root, declaredDirectory.path), { throwIfNoEntry: false })?.isDirectory() !== true) {
-        throw new Error(`${label}: path '${declaredDirectory.path}' is not a directory; declare a directory that exists in the repo`);
+        throw new UserError(`${label}: path '${declaredDirectory.path}' is not a directory; declare a directory that exists in the repo`);
     }
     const versionFile = resolveVersionFile(declaredDirectory.path, root);
     assertVersionField(label, versionFile, root);
@@ -28,17 +28,17 @@ export function deriveDirectoryConfig(declaredDirectory, root = process.cwd()) {
 function assertVersionField(label, versionFile, root) {
     const absolutePath = path.resolve(root, versionFile);
     if (!existsSync(absolutePath)) {
-        throw new Error(`${label}: ${versionFile} not found; create it with the directory's current version, such as { "version": "0.0.0" }`);
+        throw new UserError(`${label}: ${versionFile} not found; create it with the directory's current version, such as { "version": "0.0.0" }`);
     }
     let parsedJson;
     try {
         parsedJson = JSON.parse(readFileSync(absolutePath, 'utf8'));
     }
     catch (error) {
-        throw chainError(`${label}: failed to read ${versionFile}`, error);
+        throw chainUserError(`${label}: failed to read ${versionFile}`, error);
     }
     if (!isRecord(parsedJson) || typeof parsedJson['version'] !== 'string') {
-        throw new Error(`${label}: ${versionFile} does not contain a string 'version' field; add one`);
+        throw new UserError(`${label}: ${versionFile} does not contain a string 'version' field; add one`);
     }
 }
 function deriveTagPrefix(label, directoryPath) {
@@ -47,7 +47,7 @@ function deriveTagPrefix(label, directoryPath) {
     }
     const basename = path.posix.basename(directoryPath);
     if (!TAG_PREFIX_PATTERN.test(basename)) {
-        throw new Error(`${label}: the directory name '${basename}' cannot form a tag prefix; set tagPrefix, such as '${basename.replaceAll(/[^\w.-]+/g, '-')}-v'`);
+        throw new UserError(`${label}: the directory name '${basename}' cannot form a tag prefix; set tagPrefix, such as '${basename.replaceAll(/[^\w.-]+/g, '-')}-v'`);
     }
     return `${basename}-v`;
 }

package/dist/esm/deriveWorkspaceConfig.js

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

package/dist/esm/detectPackageManager.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { isRecord } from "./typeGuards.js";
+import { isRecord } from '@williamthorsen/nmr-core';
 export function detectPackageManager() {
     const packageJsonPath = join(process.cwd(), 'package.json');
     try {

package/dist/esm/enterRepoRoot.js

@@ -1,11 +1,12 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { UserError } from '@williamthorsen/nmr-core';
 import { findMonorepoRoot } from '@williamthorsen/nmr-core/workspace';
 export function enterRepoRoot(startDir = process.cwd()) {
     const invocationDir = path.resolve(startDir);
     const root = findMonorepoRoot(invocationDir) ?? findSinglePackageRoot(invocationDir);
     if (root === undefined) {
-        throw new Error(`No repo root found from ${invocationDir}: expected a pnpm-workspace.yaml in it or any parent directory, ` +
+        throw new UserError(`No repo root found from ${invocationDir}: expected a pnpm-workspace.yaml in it or any parent directory, ` +
             'or a package.json in it. Run release-kit from inside a monorepo or at the root of a single-package repo.');
     }
     process.chdir(root);

package/dist/esm/enumerateReleaseWindows.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { matchesTagPrefix } from "./matchesTagPrefix.js";
+import { chainUserError } from "./user-error-chaining.js";
 const FIELD_SEPARATOR = '\u{1F}';
 const RECORD_SEPARATOR = '\u{1E}';
 export function enumerateReleaseWindows(options) {
@@ -117,6 +117,6 @@ function runGit(args, description) {
         }).trim();
     }
     catch (error) {
-        throw chainError(`Failed to run ${description}`, error);
+        throw chainUserError(`Failed to run ${description}`, error);
     }
 }

package/dist/esm/findMissingManifestPaths.js

@@ -1,4 +1,4 @@
-import { isRecord } from "./typeGuards.js";
+import { isRecord } from '@williamthorsen/nmr-core';
 const BUILT_IN_DEV_CONDITION = 'source';
 export function findMissingManifestPaths(manifest, packedFiles, devExportConditions) {
     const packedSet = new Set(packedFiles);

package/dist/esm/hasPrettierConfig.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-import { isRecord } from "./typeGuards.js";
+import { isRecord } from '@williamthorsen/nmr-core';
 export function hasPrettierConfig() {
     const cwd = process.cwd();
     for (const file of PRETTIER_CONFIG_FILES) {

package/dist/esm/init/initCommand.js

@@ -1,4 +1,4 @@
-import { printError, printSkip, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
+import { isAnticipatedFailure, printError, printSkip, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { hasPackageJson, isGitRepo, usesPnpm } from "./checks.js";
 import { detectRepoType } from "./detectRepoType.js";
@@ -19,6 +19,9 @@ export function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfi
         eligible = checkEligibility(styles);
     }
     catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
         printError(`Eligibility check failed: ${describeError(error)}`, styles.stderr);
         return 1;
     }
@@ -30,6 +33,9 @@ export function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfi
         repoType = detectRepoType();
     }
     catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
         printError(`Failed to detect repo type: ${describeError(error)}`, styles.stderr);
         return 1;
     }
@@ -46,6 +52,9 @@ export function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfi
         results = scaffoldFiles({ repoType, isDryRun, shouldOverwrite: shouldForce, publishable, shouldScaffoldConfig });
     }
     catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
         printError(`Failed to scaffold files: ${describeError(error)}`, styles.stderr);
         return 1;
     }

package/dist/esm/init/parseJsonRecord.js

@@ -1,4 +1,4 @@
-import { isRecord } from "../typeGuards.js";
+import { isRecord } from '@williamthorsen/nmr-core';
 export function parseJsonRecord(jsonText) {
     let parsedJson;
     try {

package/dist/esm/init/updateTemplatesCommand.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { printError, printSkip, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
+import { isAnticipatedFailure, printError, printSkip, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { readSyncLabelsWorkflowTemplate } from "../sync-labels/templates.js";
 import { detectRepoType } from "./detectRepoType.js";
@@ -18,6 +18,9 @@ export function updateTemplatesCommand({ isDryRun, styles }) {
         eligible = checkEligibility(styles);
     }
     catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
         printError(`Eligibility check failed: ${describeError(error)}`, styles.stderr);
         return 1;
     }
@@ -29,6 +32,9 @@ export function updateTemplatesCommand({ isDryRun, styles }) {
         repoType = detectRepoType();
     }
     catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
         printError(`Failed to detect repo type: ${describeError(error)}`, styles.stderr);
         return 1;
     }
@@ -43,6 +49,9 @@ export function updateTemplatesCommand({ isDryRun, styles }) {
         results = files.map(([filePath, content]) => updateManagedFile(filePath, content, { isDryRun }));
     }
     catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
         printError(`Failed to render workflows: ${describeError(error)}`, styles.stderr);
         return 1;
     }

package/dist/esm/isPublishableManifest.js

@@ -1,4 +1,4 @@
-import { isRecord } from "./typeGuards.js";
+import { isRecord } from '@williamthorsen/nmr-core';
 export function isPublishableManifest(manifest) {
     const privateField = isRecord(manifest) ? manifest['private'] : undefined;
     return privateField === undefined || privateField === false;

package/dist/esm/loadChangelogOverrides.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { isRecord } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { isRecord } from "./typeGuards.js";
 const VALID_AUDIENCE_VALUES = new Set(['all', 'dev', 'skip']);
 const V1_SUPPORTED_AUDIENCE_VALUES = new Set(['skip']);
 const SCHEMA_KEY = '$schema';

package/dist/esm/loadConfig.js

@@ -9,8 +9,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
-import { isRecord } from "./typeGuards.js";
+import { isRecord, UserError } from '@williamthorsen/nmr-core';
+import { chainUserError } from "./user-error-chaining.js";
 export const ROOT_PACKAGE_JSON_PATH = 'package.json';
 export function readRootPackageVersion() {
     const absolutePath = path.resolve(process.cwd(), ROOT_PACKAGE_JSON_PATH);
@@ -22,14 +22,14 @@ export function readRootPackageVersion() {
         contents = readFileSync(absolutePath, 'utf8');
     }
     catch (error) {
-        throw chainError(`Failed to read root ${ROOT_PACKAGE_JSON_PATH}`, error);
+        throw chainUserError(`Failed to read root ${ROOT_PACKAGE_JSON_PATH}`, error);
     }
     let parsedJson;
     try {
         parsedJson = JSON.parse(contents);
     }
     catch (error) {
-        throw chainError(`Failed to parse root ${ROOT_PACKAGE_JSON_PATH}`, error);
+        throw chainUserError(`Failed to parse root ${ROOT_PACKAGE_JSON_PATH}`, error);
     }
     if (!isRecord(parsedJson)) {
         return { doesExist: true, version: undefined };
@@ -43,12 +43,12 @@ export async function loadConfig(configPath) {
         if (configPath === undefined) {
             return undefined;
         }
-        throw new Error(`Config file not found: ${absoluteConfigPath}`);
+        throw new UserError(`Config file not found: ${absoluteConfigPath}`);
     }
     const importedModule = await import(__rewriteRelativeImportExtension(pathToFileURL(absoluteConfigPath).href));
     const resolvedConfig = isRecord(importedModule) ? (importedModule['default'] ?? importedModule['config']) : undefined;
     if (resolvedConfig === undefined) {
-        throw new Error('Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)');
+        throw new UserError('Config file must have a default export or a named `config` export (e.g., `export default { ... }` or `export const config = { ... }`)');
     }
     return resolvedConfig;
 }

package/dist/esm/loadValidatedConfig.d.ts

@@ -12,6 +12,11 @@ export type ConfigProblem = {
     kind: 'validation';
     errors: string[];
 };
+/** Reports a config file that a CLI command cannot use, carrying the problem for `reportConfigProblem` to render. */
+export declare class ConfigProblemError extends Error {
+    readonly problem: ConfigProblem;
+    constructor(problem: ConfigProblem);
+}
 /**
  * Outcome of loading and validating the consumer config file. `missing` is not an error here; the caller decides
  * whether an absent config file is one.
@@ -47,7 +52,7 @@ export declare function loadValidatedConfig(configPath?: string): Promise<LoadVa
  * Loads and validates the config for a CLI command, returning it, or `undefined` when the default config file does
  * not exist.
  *
- * Reports an unusable config to stderr and exits 1, whether the file failed to load or failed validation, and
+ * Throws a `ConfigProblemError` for an unusable config, whether the file failed to load or failed validation, and
  * whether it was named by the caller or the default one. Validation warnings print to stderr.
  */
 export declare function loadUsableConfig(stderrStyle: OutputStyle, configPath?: string): Promise<ReleaseKitConfig | undefined>;

package/dist/esm/loadValidatedConfig.js

@@ -1,7 +1,16 @@
 import { formatStatusLine, printError, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
+import { BIN } from "./bin.js";
 import { CONFIG_FILE_PATH, loadConfig } from "./loadConfig.js";
 import { validateConfig } from "./validateConfig.js";
+export class ConfigProblemError extends Error {
+    problem;
+    constructor(problem) {
+        super('Invalid config');
+        this.name = 'ConfigProblemError';
+        this.problem = problem;
+    }
+}
 export async function loadValidatedConfig(configPath) {
     const configFilePath = configPath ?? CONFIG_FILE_PATH;
     let rawConfig;
@@ -23,8 +32,7 @@ export async function loadValidatedConfig(configPath) {
 export async function loadUsableConfig(stderrStyle, configPath) {
     const result = await loadValidatedConfig(configPath);
     if (result.status === 'invalid') {
-        reportConfigProblem(result.problem, stderrStyle);
-        process.exit(1);
+        throw new ConfigProblemError(result.problem);
     }
     if (result.status === 'missing') {
         return undefined;
@@ -34,7 +42,7 @@ export async function loadUsableConfig(stderrStyle, configPath) {
 }
 export function reportConfigProblem(problem, stderrStyle) {
     if (problem.kind === 'load') {
-        reportError(`Failed to load config: ${problem.message}`);
+        reportError(BIN, `Failed to load config: ${problem.message}`);
         return;
     }
     process.stderr.write('Invalid config:\n');

package/dist/esm/mergeConfig.js

@@ -1,3 +1,4 @@
+import { UserError } from '@williamthorsen/nmr-core';
 import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_PROJECT_TAG_PREFIX, DEFAULT_RELEASE_NOTES_CONFIG, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES, } from "./defaults.js";
 import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
@@ -45,10 +46,10 @@ export function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
 }
 export function mergeSinglePackageConfig(userConfig) {
     if (userConfig?.project !== undefined) {
-        throw new Error('project block is not supported in single-package mode');
+        throw new UserError('project block is not supported in single-package mode');
     }
     if (userConfig?.releases !== undefined) {
-        throw new Error('releases block is not supported in single-package mode');
+        throw new UserError('releases block is not supported in single-package mode');
     }
     const workTypes = resolveWorkTypes(userConfig?.workTypes);
     const versionPatterns = userConfig?.versionPatterns === undefined ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
@@ -104,10 +105,10 @@ function resolveProjectConfig(declaredComposite, rootPackage, workspaces) {
     }
     const subject = declaredComposite.name === undefined ? 'project block' : `composite release '${declaredComposite.name}'`;
     if (rootPackage === undefined || !rootPackage.doesExist) {
-        throw new Error(`${subject} requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`);
+        throw new UserError(`${subject} requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`);
     }
     if (rootPackage.version === undefined) {
-        throw new Error(`${subject} requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to the root package.json`);
+        throw new UserError(`${subject} requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to the root package.json`);
     }
     return {
         paths: declaredComposite.paths ?? workspaces.flatMap((workspace) => workspace.paths),

package/dist/esm/monorepoConfigAssertions.js

@@ -1,9 +1,10 @@
+import { UserError } from '@williamthorsen/nmr-core';
 import { ROOT_PACKAGE_JSON_PATH } from "./loadConfig.js";
 import { getTargetName, normalizeWorkspacePath } from "./resolveReleaseDeclaration.js";
 export function assertLegacyIdentityDoesNotMatchCurrent(dir, currentName, currentTagPrefix, legacyIdentities) {
     for (const identity of legacyIdentities) {
         if (identity.name === currentName && identity.tagPrefix === currentTagPrefix) {
-            throw new Error(`Workspace '${dir}': legacyIdentities must not match the current identity ` +
+            throw new UserError(`Workspace '${dir}': legacyIdentities must not match the current identity ` +
                 `(name='${currentName}', tagPrefix='${currentTagPrefix}'). ` +
                 'The current identity is always searched; listing it again is a no-op.');
         }
@@ -31,7 +32,7 @@ export function assertNoSharedVersionFiles(workspaces, directories, project) {
     for (const [index, directory] of directories.entries()) {
         const peer = owners.slice(index + 1).find((owner) => owner.versionFiles.includes(directory.versionFile));
         if (peer !== undefined) {
-            throw new Error(`directory release '${directory.name}' and ${peer.label} share the version file '${directory.versionFile}', ` +
+            throw new UserError(`directory release '${directory.name}' and ${peer.label} share the version file '${directory.versionFile}', ` +
                 "so each release would overwrite the other's version and changelog; declare only one of them");
         }
     }
@@ -84,7 +85,7 @@ export function assertNoTagPrefixCollisions(workspaces, directories, retiredPack
             if (a === undefined || b === undefined || a.owner === b.owner)
                 continue;
             if (isPrefixCollision(a.prefix, b.prefix)) {
-                throw new Error(`Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). ` +
+                throw new UserError(`Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). ` +
                     'One prefix is identical to or a strict prefix of the other; ' +
                     'a tag under the longer prefix can then match the shorter one and be counted among its releases.');
             }
@@ -99,7 +100,7 @@ export function assertRetiredPackagesDoNotCollideWithActive(workspaces, retiredP
     for (const retiredPackage of retiredPackages) {
         const activeWorkspace = workspaceByDerivedPrefix.get(retiredPackage.tagPrefix);
         if (activeWorkspace !== undefined) {
-            throw new Error(`retiredPackages: tagPrefix '${retiredPackage.tagPrefix}' collides with active workspace '${activeWorkspace.dir}' ` +
+            throw new UserError(`retiredPackages: tagPrefix '${retiredPackage.tagPrefix}' collides with active workspace '${activeWorkspace.dir}' ` +
                 `(derived prefix '${activeWorkspace.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`);
         }
     }
@@ -117,7 +118,7 @@ export function assertUniqueTagPrefixes(workspaces) {
     }
     for (const [prefix, paths] of pathsByPrefix) {
         if (paths.length > 1) {
-            throw new Error(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(', ')}`);
+            throw new UserError(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(', ')}`);
         }
     }
 }

package/dist/esm/npmRegistry.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { isRecord } from "./typeGuards.js";
+import { isRecord } from '@williamthorsen/nmr-core';
 export const AUTH_ERROR_CODES = new Set(['E401', 'ENEEDAUTH']);
 export const UNREACHABLE_ERROR_CODES = new Set([
     'EAI_AGAIN',