@williamthorsen/release-kit 16.1.0 → 16.1.2

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/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/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/loadConfig.js

@@ -9,8 +9,9 @@ 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 { UserError } from '@williamthorsen/nmr-core';
 import { isRecord } from "./typeGuards.js";
+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 +23,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 +44,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/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/packFromCleanCheckout.js

@@ -2,8 +2,10 @@ import { spawnSync } from 'node:child_process';
 import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { UserError } from '@williamthorsen/nmr-core';
 import { resolveExecutable } from "./detectPackageManager.js";
 import { isRecord } from "./typeGuards.js";
+import { chainUserError } from "./user-error-chaining.js";
 export function packFromCleanCheckout(workspacePaths, packageManager) {
     const repoRoot = runStep('find the repository root', 'git', ['rev-parse', '--show-toplevel'], process.cwd()).trim();
     const headSha = runStep('resolve HEAD', 'git', ['rev-parse', 'HEAD'], repoRoot).trim();
@@ -51,7 +53,14 @@ const PACKAGE_MANAGER_COMMANDS = {
     },
 };
 function declaresPrepublishOnly(packageDir) {
-    const manifest = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'));
+    const manifestPath = join(packageDir, 'package.json');
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        throw chainUserError(`Failed to parse ${manifestPath}`, error);
+    }
     const scripts = isRecord(manifest) ? manifest['scripts'] : undefined;
     return isRecord(scripts) && typeof scripts['prepublishOnly'] === 'string';
 }
@@ -59,7 +68,7 @@ function findTarball(packDir, workspacePath) {
     const tarballs = readdirSync(packDir).filter((name) => name.endsWith('.tgz'));
     const [tarball] = tarballs;
     if (tarballs.length !== 1 || tarball === undefined) {
-        throw new Error(`Could not pack ${workspacePath}: expected one tarball, found ${tarballs.length}.`);
+        throw new UserError(`Could not pack ${workspacePath}: expected one tarball, found ${tarballs.length}.`);
     }
     return join(packDir, tarball);
 }
@@ -77,5 +86,5 @@ function runStep(step, command, args, cwd) {
     }
     const outcome = result.error === undefined ? `exited with status ${result.status}` : result.error.message;
     const output = [result.stdout, result.stderr].filter((text) => text !== '').join('\n');
-    throw new Error(`Could not ${step}: \`${[command, ...args].join(' ')}\` ${outcome}.${output === '' ? '' : `\n${output}`}`);
+    throw new UserError(`Could not ${step}: \`${[command, ...args].join(' ')}\` ${outcome}.${output === '' ? '' : `\n${output}`}`);
 }

package/dist/esm/planVersionBump.js

@@ -1,7 +1,8 @@
 import { readFileSync } from 'node:fs';
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { UserError } from '@williamthorsen/nmr-core';
 import { bumpVersion } from "./bumpVersion.js";
 import { isForwardVersion } from "./compareVersions.js";
+import { chainUserError } from "./user-error-chaining.js";
 function isPackageJson(value) {
     return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
@@ -19,7 +20,7 @@ export function planVersionSet(packageFiles, newVersion) {
     const { firstFile, firstPackageJson } = readPrimaryPackage(packageFiles);
     const currentVersion = firstPackageJson.version;
     if (!isForwardVersion(currentVersion, newVersion)) {
-        throw new Error(`--set-version ${newVersion} is not greater than current version ${currentVersion}`);
+        throw new UserError(`--set-version ${newVersion} is not greater than current version ${currentVersion}`);
     }
     return {
         currentVersion,
@@ -50,17 +51,17 @@ function readPackageJson(filePath) {
         content = readFileSync(filePath, 'utf8');
     }
     catch (error) {
-        throw chainError(`Failed to read ${filePath}`, error);
+        throw chainUserError(`Failed to read ${filePath}`, error);
     }
     let parsedJson;
     try {
         parsedJson = JSON.parse(content);
     }
     catch (error) {
-        throw chainError(`Failed to parse JSON in ${filePath}`, error);
+        throw chainUserError(`Failed to parse JSON in ${filePath}`, error);
     }
     if (!isPackageJson(parsedJson)) {
-        throw new Error(`No valid 'version' field found in ${filePath}`);
+        throw new UserError(`No valid 'version' field found in ${filePath}`);
     }
     return parsedJson;
 }

package/dist/esm/prepareCommand.js

@@ -1,5 +1,5 @@
 import { execSync } from 'node:child_process';
-import { formatGlyphLine, reportError } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, isAnticipatedFailure, reportError, UserError, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertReleasesOnNpm } from "./assertReleasesOnNpm.js";
@@ -15,6 +15,8 @@ import { applyReleasePlan } from "./releasePlan.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 import { isSinglePackageTargets, PROJECT_TARGET_ID, resolveReleaseTargets, SINGLE_PACKAGE_TARGET_ID, } from "./resolveReleaseTargets.js";
+import { prefixUserError } from "./user-error-chaining.js";
+const UNCHANGED_TREE_NOTE = 'The command did not write any files; the working tree is unchanged.';
 export async function prepareCommand(argv, styles, invocationDir) {
     const { configPath: configFlag, isDryRun, shouldForce, shouldSkipGitChecks, bumpOverride, onlyNames, setVersion, shouldIncludeReleaseNotes, } = parseArgs(argv);
     const options = {
@@ -26,13 +28,7 @@ export async function prepareCommand(argv, styles, invocationDir) {
         console.info(`\n${formatGlyphLine(RELEASE_GLYPHS, styles.stdout, 'dryRun', 'DRY RUN: release-kit will not modify any files')}\n`);
     }
     if (!isDryRun && !shouldSkipGitChecks) {
-        try {
-            assertCleanWorkingTree();
-        }
-        catch (error) {
-            reportError(describeError(error));
-            process.exit(1);
-        }
+        assertCleanWorkingTree();
     }
     const configResult = await loadValidatedConfig(resolveConfigFlag(configFlag, invocationDir));
     if (configResult.status === 'invalid') {
@@ -49,8 +45,7 @@ export async function prepareCommand(argv, styles, invocationDir) {
         workspaceDiscovery = discoverWorkspaces();
     }
     catch (error) {
-        reportError(`Failed to discover workspaces: ${describeError(error)}`);
-        process.exit(1);
+        throw prefixUserError('Failed to discover workspaces', error);
     }
     if (workspaceDiscovery.kind === 'empty') {
         reportError(`No workspace package to release. ${describeEmptyWorkspace(workspaceDiscovery)}`);
@@ -91,8 +86,7 @@ function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
         config = resolveReleaseTargets(userConfig, discovery);
     }
     catch (error) {
-        reportError(`Failed to resolve workspaces: ${describeError(error)}`);
-        process.exit(1);
+        throw prefixUserError('Failed to resolve workspaces', error);
     }
     if (setVersion !== undefined && config.targets.some((target) => target.kind === 'composite')) {
         reportError('--set-version cannot be combined with a project release. ' +
@@ -129,22 +123,18 @@ function runAndReport(computePlan, isDryRun, style) {
         plan = computePlan();
     }
     catch (error) {
-        reportError(describeError(error));
-        process.stderr.write('The command did not write any files; the working tree is unchanged.\n');
-        process.exit(1);
+        if (isAnticipatedFailure(error)) {
+            throw new UserError(`${error.message}\n${UNCHANGED_TREE_NOTE}`, { cause: error });
+        }
+        process.stderr.write(`${UNCHANGED_TREE_NOTE}\n`);
+        throw error;
     }
     if (isDryRun) {
         process.stdout.write(reportPrepare(plan, { applied: false, style }) + '\n');
         reportPlanFiles(plan, true);
         return;
     }
-    try {
-        applyReleasePlan(plan);
-    }
-    catch (error) {
-        reportError(describeError(error));
-        process.exit(1);
-    }
+    applyReleasePlan(plan);
     const formatError = runFormatCommand(plan.formatCommand);
     process.stdout.write(reportPrepare(plan, { applied: true, style, ...(formatError !== undefined && { formatError }) }) + '\n');
     reportPlanFiles(plan, false);

package/dist/esm/prepareComposite.js

@@ -1,3 +1,4 @@
+import { UserError } from '@williamthorsen/nmr-core';
 import { assertTaggedBaseline } from "./assertTaggedBaseline.js";
 import { collect } from "./prepareRunContext.js";
 import { buildSkippedTargetResult, decideTargetRelease, planTargetRelease, readTargetHistory, } from "./prepareTarget.js";
@@ -24,7 +25,7 @@ export function prepareComposite(compositeTarget, context, options, collectedRel
         return buildSkippedTargetResult(compositeTarget, history, decision.skipReason);
     }
     if (decision.setVersion !== undefined) {
-        throw new Error('A composite target cannot take --set-version');
+        throw new UserError('A composite target cannot take --set-version');
     }
     const plannedRelease = planTargetRelease({
         ...context,

package/dist/esm/prepareRunContext.js

@@ -1,5 +1,5 @@
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { isRepoRoot } from "./prepareTarget.js";
+import { prefixUserError } from "./user-error-chaining.js";
 export function collect(collectedReleases, plannedRelease) {
     collectedReleases.tags.push(plannedRelease.tag);
     collectedReleases.writes.push(...plannedRelease.writes);
@@ -34,6 +34,6 @@ export function runStage(stage, fn) {
         return fn();
     }
     catch (error) {
-        throw chainError(stage, error);
+        throw prefixUserError(stage, error);
     }
 }

package/dist/esm/previewTagPrefixes.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { basename } from 'node:path';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES, UserError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { DEFAULT_PROJECT_TAG_PREFIX } from "./defaults.js";
 import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
@@ -12,7 +12,7 @@ import { normalizeWorkspacePath } from "./resolveReleaseDeclaration.js";
 export function previewTagPrefixes(config) {
     const workspace = discoverWorkspaces();
     if (workspace.kind === 'empty') {
-        throw new Error(`No workspace package to preview. ${describeEmptyWorkspace(workspace)}`);
+        throw new UserError(`No workspace package to preview. ${describeEmptyWorkspace(workspace)}`);
     }
     const workspacePaths = workspace.kind === 'packages' ? workspace.packageDirs : [];
     const overridesByPath = buildOverrideMap(config, workspacePaths);

package/dist/esm/publish.js

@@ -1,11 +1,17 @@
 import { execFileSync } from 'node:child_process';
 import { resolveExecutable } from "./detectPackageManager.js";
+import { asUserError } from "./user-error-chaining.js";
 export function publishPackage(resolvedTag, packageManager, options) {
     const { isDryRun, shouldGenerateProvenance } = options;
     const executable = resolveExecutable(packageManager);
     const args = buildPublishArgs(packageManager, { isDryRun, shouldGenerateProvenance });
     console.info(`\n${isDryRun ? '[dry-run] ' : ''}Running: ${executable} ${args.join(' ')} (cwd: ${resolvedTag.workspacePath})`);
-    execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: 'inherit' });
+    try {
+        execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: 'inherit' });
+    }
+    catch (error) {
+        throw asUserError(error);
+    }
 }
 function buildPublishArgs(packageManager, options) {
     const args = packageManager === 'yarn-berry' ? ['npm', 'publish'] : ['publish'];

package/dist/esm/publishCommand.js

@@ -1,7 +1,6 @@
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
+import { parseArgsOrExit } from '@williamthorsen/nmr-core';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { assertTarballsComplete } from "./assertTarballsComplete.js";
 import { configFlagSchema } from "./configFlagSchema.js";
@@ -29,13 +28,7 @@ export async function publishCommand(argv, styles, invocationDir) {
     const { isDryRun, shouldSkipGitChecks, shouldGenerateProvenance } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
     if (!isDryRun && !shouldSkipGitChecks) {
-        try {
-            assertCleanWorkingTree();
-        }
-        catch (error) {
-            reportError(describeError(error));
-            process.exit(1);
-        }
+        assertCleanWorkingTree();
     }
     const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
@@ -47,13 +40,7 @@ export async function publishCommand(argv, styles, invocationDir) {
         console.info('Nothing to publish.');
         return;
     }
-    try {
-        assertTarballsComplete(publishableTags.map(({ workspacePath }) => workspacePath), userConfig?.devExportConditions ?? []);
-    }
-    catch (error) {
-        reportError(describeError(error));
-        process.exit(1);
-    }
+    assertTarballsComplete(publishableTags.map(({ workspacePath }) => workspacePath), userConfig?.devExportConditions ?? []);
     const packageManager = detectPackageManager();
     const { releaseNotes, changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     const shouldInject = releaseNotes.shouldInjectIntoReadme;
@@ -90,8 +77,7 @@ export async function publishCommand(argv, styles, invocationDir) {
                 console.warn(`  ${tag}`);
             }
         }
-        reportError(describeError(error));
-        process.exit(1);
+        throw error;
     }
 }
 function filterPublishableTags(resolvedTags, isExplicit) {

package/dist/esm/pushCommand.js

@@ -1,5 +1,4 @@
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
+import { parseArgsOrExit } from '@williamthorsen/nmr-core';
 import { configFlagSchema } from "./configFlagSchema.js";
 import { loadUsableConfig } from "./loadValidatedConfig.js";
 import { parseRequestedTags } from "./parseRequestedTags.js";
@@ -32,16 +31,10 @@ export async function pushCommand(argv, styles, invocationDir) {
     for (const { tag } of resolvedTags) {
         console.info(`  ${tag}`);
     }
-    try {
-        const steps = pushRelease(resolvedTags, { isDryRun, tagsOnly });
-        if (isDryRun) {
-            for (const step of steps) {
-                console.info(`[dry-run] ${step.command.join(' ')}`);
-            }
+    const steps = pushRelease(resolvedTags, { isDryRun, tagsOnly });
+    if (isDryRun) {
+        for (const step of steps) {
+            console.info(`[dry-run] ${step.command.join(' ')}`);
         }
     }
-    catch (error) {
-        reportError(describeError(error));
-        process.exit(1);
-    }
 }

package/dist/esm/pushRelease.js

@@ -1,14 +1,21 @@
 import { execFileSync } from 'node:child_process';
 import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
+import { asUserError } from "./user-error-chaining.js";
 export function pushRelease(resolvedTags, options = {}) {
     const { isDryRun = false, tagsOnly = false } = options;
     const steps = [];
     if (!tagsOnly) {
-        const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
+        let branch;
+        try {
+            branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+                encoding: 'utf8',
+                maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch (error) {
+            throw asUserError(error);
+        }
         const command = ['git', 'push', 'origin', branch];
         steps.push({ type: 'branch', ref: branch, command });
     }
@@ -18,7 +25,12 @@ export function pushRelease(resolvedTags, options = {}) {
     }
     if (!isDryRun) {
         for (const step of steps) {
-            execFileSync(step.command[0], step.command.slice(1), { stdio: 'inherit' });
+            try {
+                execFileSync(step.command[0], step.command.slice(1), { stdio: 'inherit' });
+            }
+            catch (error) {
+                throw asUserError(error);
+            }
         }
     }
     return steps;

package/dist/esm/releaseFiles.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { hasErrnoCode } from '@williamthorsen/nmr-core';
+import { hasErrnoCode, UserError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 export const RELEASE_TAGS_FILE = 'tmp/.release-tags';
 export const RELEASE_SUMMARY_FILE = 'tmp/.release-summary';
@@ -13,7 +13,7 @@ export function readReleaseTags() {
         content = readFileSync(RELEASE_TAGS_FILE, 'utf8');
     }
     catch (error) {
-        throw new Error(describeTagsReadFailure(error), { cause: error });
+        throw new UserError(describeTagsReadFailure(error), { cause: error });
     }
     return content
         .split('\n')

package/dist/esm/releasePlan.js

@@ -1,4 +1,4 @@
-import { writeFileWithCheck } from '@williamthorsen/nmr-core';
+import { UserError, writeFileWithCheck } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { deleteFileIfExists } from "./deleteFileIfExists.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
@@ -10,7 +10,7 @@ export function applyReleasePlan(plan) {
         const outcome = applyStep(step);
         if (outcome.outcome === 'failed') {
             const unwrittenPaths = orderedSteps.slice(index).map((pending) => pending.path);
-            throw new Error(describeApplyFailure({ failedStep: step, error: outcome.error, appliedWrites, unwrittenPaths }));
+            throw new UserError(describeApplyFailure({ failedStep: step, error: outcome.error, appliedWrites, unwrittenPaths }));
         }
         appliedWrites.push({ path: step.path, created: outcome.outcome === 'created' });
     }

package/dist/esm/resolveCommandTags.d.ts

@@ -2,10 +2,10 @@ import type { ReleaseKitConfig } from './configSchema.js';
 import { type ResolvedTag } from './resolveReleaseTags.js';
 /**
  * Discovers workspaces, resolves release tags from HEAD, validates `--tags` names against the full resolved tag
- * names (e.g., `nmr-core-v1.3.0`), and returns the filtered tag list. Exits with an error message on any validation
- * failure, including a workspace whose `package.json` does not have a `name` field, a config that
- * `mergeMonorepoConfig` rejects, and a workspace that does not resolve to any package, which is not single-package
- * mode.
+ * names (e.g., `nmr-core-v1.3.0`), and returns the filtered tag list. Throws a `UserError` when workspace discovery
+ * fails, when a workspace's `package.json` does not have a `name` field, and when `mergeMonorepoConfig` rejects the
+ * config. Exits with an error message on any other validation failure, including a workspace that does not resolve to
+ * any package, which is not single-package mode.
  *
  * In monorepo mode the workspace list is `userConfig` merged over the discovered workspaces, as `prepare` builds it,
  * and each directory target and a declared composite (a `project` block or a `releases` composite) contribute their