@williamthorsen/release-kit 16.1.2 → 17.0.0

package/dist/esm/cli/maintenanceCommands.js

@@ -0,0 +1,129 @@
+import process from 'node:process';
+import { createCli } from '@williamthorsen/nmr-core/cli';
+import { enterRepoRoot } from "../enterRepoRoot.js";
+import { initCommand } from "../init/initCommand.js";
+import { updateTemplatesCommand } from "../init/updateTemplatesCommand.js";
+import { showTagPrefixesCommand } from "../showTagPrefixesCommand.js";
+import { generateCommand } from "../sync-labels/generateCommand.js";
+import { syncLabelsInitCommand } from "../sync-labels/initCommand.js";
+import { syncLabelsCommand } from "../sync-labels/syncCommand.js";
+import { validateOverridesCommand } from "../validateOverridesCommand.js";
+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.',
+    flags: CONFIG_FLAG,
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        return showTagPrefixesCommand(context.styles, flags.config);
+    }),
+});
+export const init = defineCommand({
+    summary: 'Initialize release-kit in the current repository',
+    description: 'Initialize release-kit in the current repository. By default, scaffolds only the GitHub Actions workflow files. When every package is private, skips publish.yaml and create-github-release.yaml.',
+    flags: {
+        shouldScaffoldConfig: {
+            type: 'boolean',
+            long: 'with-config',
+            description: 'Also scaffold .config/release-kit.config.ts',
+        },
+        shouldForce: { type: 'boolean', long: 'force', description: 'Overwrite existing files instead of skipping them' },
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview changes without writing files' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        return initCommand({
+            isDryRun: flags.isDryRun,
+            shouldForce: flags.shouldForce,
+            shouldScaffoldConfig: flags.shouldScaffoldConfig,
+            styles: context.styles,
+        });
+    }),
+});
+export const updateTemplates = defineCommand({
+    summary: 'Update the scaffolded workflows to the current templates',
+    description: "Update the GitHub Actions workflows that release-kit scaffolds to the templates of the installed version, showing what changed in each file. Creates a missing workflow that `init` would create, and refreshes sync-labels.yaml only when it exists. When every package is private, refreshes publish.yaml and create-github-release.yaml only when they exist. Keeps publish.yaml's provenance setting. Never touches config files.",
+    flags: {
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview changes without writing files' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        return updateTemplatesCommand({ isDryRun: flags.isDryRun, styles: context.styles });
+    }),
+});
+const overridesValidate = defineCommand({
+    summary: 'Validate every `.meta/changelog-overrides.json` file across all scopes',
+    description: 'Validate every `.meta/changelog-overrides.json` file across the project and per-workspace scopes. Reports schema/parse errors, ambiguous-prefix errors, conflicting-key errors, and stale-key warnings.',
+    flags: CONFIG_FLAG,
+    epilog: `Exit codes:
+  0    Clean: no errors, no stale keys
+  1    Stale-key warnings only (no errors)
+  2    Schema/parse, ambiguous-prefix, or conflicting-key errors (errors take precedence)`,
+    run: ({ flags, context }) => runReportingFailures(context.styles, async () => {
+        enterRepoRoot();
+        const result = await validateOverridesCommand(context.styles, flags.config);
+        if (result.exitCode === 0) {
+            process.stdout.write(`${result.message}\n`);
+        }
+        else {
+            process.stderr.write(`${result.message}\n`);
+        }
+        return result.exitCode;
+    }),
+});
+export const overrides = defineGroup({
+    summary: 'Manage editorial changelog overrides',
+    commands: { validate: overridesValidate },
+});
+const syncLabelsInit = defineCommand({
+    summary: 'Scaffold caller workflow and config, then generate labels',
+    description: 'Scaffold the sync-labels caller workflow and seed the repoLabels block of .config/release-kit.config.ts with scope labels discovered from workspaces and retired packages, then generate .github/labels.yaml. When the config file already exists, print the block for manual paste instead of rewriting the file.',
+    flags: {
+        ...CONFIG_FLAG,
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview changes without writing files' },
+        shouldForce: { type: 'boolean', long: 'force', description: 'Overwrite existing files instead of skipping them' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        return syncLabelsInitCommand({
+            ...(flags.config !== undefined && { configPath: flags.config }),
+            isDryRun: flags.isDryRun,
+            shouldForce: flags.shouldForce,
+            styles: context.styles,
+        });
+    }),
+});
+const syncLabelsGenerate = defineCommand({
+    summary: 'Regenerate .github/labels.yaml from config',
+    description: 'Regenerate .github/labels.yaml from the repoLabels block of .config/release-kit.config.ts.',
+    flags: {
+        shouldCheck: {
+            type: 'boolean',
+            long: 'check',
+            description: 'Report whether .github/labels.yaml is stale instead of writing it',
+        },
+        ...CONFIG_FLAG,
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        return generateCommand({
+            shouldCheck: flags.shouldCheck,
+            ...(flags.config !== undefined && { configPath: flags.config }),
+            styles: context.styles,
+        });
+    }),
+});
+const syncLabelsSync = defineCommand({
+    summary: 'Trigger the sync-labels workflow via gh CLI',
+    description: 'Trigger the sync-labels GitHub Actions workflow via the gh CLI.',
+    run: ({ context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        return syncLabelsCommand();
+    }),
+});
+export const syncLabels = defineGroup({
+    summary: 'Manage GitHub label synchronization',
+    description: 'Manage GitHub label synchronization via preset and custom label definitions.',
+    commands: { init: syncLabelsInit, generate: syncLabelsGenerate, sync: syncLabelsSync },
+});

package/dist/esm/cli/releaseCommands.d.ts

@@ -0,0 +1,7 @@
+import { type CommandContext } from './commandKit.js';
+export declare const prepare: import("@williamthorsen/nmr-core/cli").Command<CommandContext>;
+export declare const commit: import("@williamthorsen/nmr-core/cli").Command<CommandContext>;
+export declare const tag: import("@williamthorsen/nmr-core/cli").Command<CommandContext>;
+export declare const push: import("@williamthorsen/nmr-core/cli").Command<CommandContext>;
+export declare const publish: import("@williamthorsen/nmr-core/cli").Command<CommandContext>;
+export declare const createGithubRelease: import("@williamthorsen/nmr-core/cli").Command<CommandContext>;

package/dist/esm/cli/releaseCommands.js

@@ -0,0 +1,156 @@
+import { createCli } from '@williamthorsen/nmr-core/cli';
+import { commitCommand } from "../commitCommand.js";
+import { createGithubReleaseCommand } from "../createGithubReleaseCommand.js";
+import { enterRepoRoot } from "../enterRepoRoot.js";
+import { parseRequestedTags } from "../parseRequestedTags.js";
+import { prepareCommand } from "../prepareCommand.js";
+import { publishCommand } from "../publishCommand.js";
+import { pushCommand } from "../pushCommand.js";
+import { tagCommand } from "../tagCommand.js";
+import { CONFIG_FLAG, runReportingFailures } from "./commandKit.js";
+const { defineCommand } = createCli();
+const TAGS_FLAG = {
+    type: 'string',
+    valueHint: 'tag1,tag2',
+};
+export const prepare = defineCommand({
+    summary: 'Run release preparation (auto-discovers workspaces)',
+    description: 'Run release preparation with automatic workspace discovery.',
+    flags: {
+        ...CONFIG_FLAG,
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Run without modifying any files' },
+        bump: {
+            type: 'string',
+            description: 'Set the level of every release that happens; does not trigger one',
+            choices: ['major', 'minor', 'patch'],
+        },
+        setVersion: {
+            type: 'string',
+            long: 'set-version',
+            description: "Set an explicit version; bypasses the changelog-derived bump. In monorepo mode, name each workspace or directory target: --set-version=arrays@1.0.0[,strings@2.0.0]. Rejected when a composite (a 'project' block or a releases composite) is configured.",
+            valueHint: 'X.Y.Z',
+        },
+        shouldForce: {
+            type: 'boolean',
+            long: 'force',
+            description: 'Release even when the last tag is not followed by any commits, or by any bump-worthy ones. Defaults to patch when --bump is not given; use --bump=X for a different level.',
+        },
+        shouldSkipGitChecks: {
+            type: 'boolean',
+            long: 'no-git-checks',
+            description: 'Skip the clean-working-tree check',
+            short: 'n',
+        },
+        only: {
+            type: 'string',
+            description: "Release only the named release targets and their dependents (comma-separated, monorepo only). A composite declared under 'releases' releases only when named; a 'project' block's release is skipped.",
+            valueHint: 'name1,name2',
+        },
+        shouldIncludeReleaseNotes: {
+            type: 'boolean',
+            long: 'with-release-notes',
+            description: 'Also write per-workspace release-notes previews under <workspacePath>/docs/ (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md). Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).',
+        },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, async () => {
+        enterRepoRoot();
+        await prepareCommand({
+            bumpOverride: flags.bump,
+            configPath: flags.config,
+            isDryRun: flags.isDryRun,
+            onlyNames: flags.only?.split(','),
+            setVersion: flags.setVersion,
+            shouldForce: flags.shouldForce,
+            shouldIncludeReleaseNotes: flags.shouldIncludeReleaseNotes,
+            shouldSkipGitChecks: flags.shouldSkipGitChecks,
+            styles: context.styles,
+        });
+    }),
+});
+export const commit = defineCommand({
+    summary: 'Stage changes and create the release commit',
+    description: 'Stage all changes and create the release commit using the tags and summary produced by `prepare`.',
+    flags: {
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview the commit message without creating it' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        commitCommand({ isDryRun: flags.isDryRun });
+    }),
+});
+export const tag = defineCommand({
+    summary: 'Create annotated git tags from the tags file',
+    description: 'Create annotated git tags from the tags file produced by `prepare`.',
+    flags: {
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview without creating tags' },
+        shouldSkipGitChecks: { type: 'boolean', long: 'no-git-checks', description: 'Skip the dirty-working-tree check' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, () => {
+        enterRepoRoot();
+        tagCommand({ isDryRun: flags.isDryRun, shouldSkipGitChecks: flags.shouldSkipGitChecks, styles: context.styles });
+    }),
+});
+export const push = defineCommand({
+    summary: 'Push the release commit and tags (one push per tag)',
+    description: 'Push the release commit and each tag individually, so that GitHub Actions starts a separate workflow run for each tag.',
+    flags: {
+        ...CONFIG_FLAG,
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview without pushing' },
+        tags: { ...TAGS_FLAG, description: 'Only push the named tags (comma-separated, full tag names)' },
+        tagsOnly: { type: 'boolean', description: 'Skip the branch push (push tags only)' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, async () => {
+        enterRepoRoot();
+        await pushCommand({
+            configPath: flags.config,
+            isDryRun: flags.isDryRun,
+            tags: parseRequestedTags(flags.tags),
+            tagsOnly: flags.tagsOnly,
+            styles: context.styles,
+        });
+    }),
+});
+export const publish = defineCommand({
+    summary: 'Publish packages with release tags on HEAD',
+    description: 'Publish packages that have release tags on HEAD. Operates only on workspaces whose package.json#private is absent or false. Without --tags, unpublishable workspaces are silently filtered out. With --tags, an unpublishable tag is skipped with a warning while any publishable tags are still published. A project tag is never published.',
+    flags: {
+        ...CONFIG_FLAG,
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview without publishing' },
+        shouldSkipGitChecks: { type: 'boolean', long: 'no-git-checks', description: 'Skip the clean-working-tree check' },
+        tags: { ...TAGS_FLAG, description: 'Only publish the named tags (comma-separated, full tag names)' },
+        shouldGenerateProvenance: {
+            type: 'boolean',
+            long: 'provenance',
+            description: 'Generate a provenance statement (requires OIDC; not supported by classic yarn)',
+        },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, async () => {
+        enterRepoRoot();
+        await publishCommand({
+            configPath: flags.config,
+            isDryRun: flags.isDryRun,
+            shouldGenerateProvenance: flags.shouldGenerateProvenance,
+            shouldSkipGitChecks: flags.shouldSkipGitChecks,
+            tags: parseRequestedTags(flags.tags),
+            styles: context.styles,
+        });
+    }),
+});
+export const createGithubRelease = defineCommand({
+    summary: 'Create GitHub Releases from changelog.json for tags on HEAD',
+    description: "Create GitHub Releases from changelog.json for tags on HEAD. Private (package.json#private) workspaces are skipped with a warning, and the command doesn't create a Release for them. A project tag gets a Release even when the root package is private.",
+    flags: {
+        ...CONFIG_FLAG,
+        isDryRun: { type: 'boolean', long: 'dry-run', description: 'Preview without creating releases' },
+        tags: { ...TAGS_FLAG, description: 'Only create releases for the named tags (comma-separated, full tag names)' },
+    },
+    run: ({ flags, context }) => runReportingFailures(context.styles, async () => {
+        enterRepoRoot();
+        await createGithubReleaseCommand({
+            configPath: flags.config,
+            isDryRun: flags.isDryRun,
+            tags: parseRequestedTags(flags.tags),
+            styles: context.styles,
+        });
+    }),
+});

package/dist/esm/cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import process from 'node:process';
 import { reportFailure } from '@williamthorsen/nmr-core';
-import { runCli } from "./runCli.js";
+import { BIN } from "./bin.js";
+import { routeCommand } from "./route.js";
 try {
-    await runCli(process.argv.slice(2));
+    process.exitCode = await routeCommand(process.argv.slice(2));
 }
 catch (error) {
-    reportFailure('release-kit', error);
+    reportFailure(BIN, error);
     process.exitCode = 1;
 }

package/dist/esm/commitCommand.d.ts

@@ -1,5 +1,8 @@
+export interface CommitCommandOptions {
+    isDryRun: boolean;
+}
 /**
  * Runs the CLI `commit` command: reads the tags and summary files written by `prepare`, stages all changes, and
  * creates the release commit.
  */
-export declare function commitCommand(argv: string[]): void;
+export declare function commitCommand({ isDryRun }: CommitCommandOptions): void;

package/dist/esm/commitCommand.js

@@ -1,13 +1,9 @@
 import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, parseArgsOrExit, UserError } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, UserError } from '@williamthorsen/nmr-core';
 import { readReleaseTags, RELEASE_SUMMARY_FILE, resolveReleaseTagsPath } from "./releaseFiles.js";
 import { asUserError } from "./user-error-chaining.js";
-const commitFlagSchema = {
-    isDryRun: { long: '--dry-run', type: 'boolean' },
-};
-export function commitCommand(argv) {
-    const isDryRun = parseArgsOrExit(argv, commitFlagSchema).flags.isDryRun;
+export function commitCommand({ isDryRun }) {
     const tags = readReleaseTags();
     if (tags.length === 0) {
         throw new UserError(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);

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 } from '@williamthorsen/nmr-core';
-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";
 import { prefixUserError } from "./user-error-chaining.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;
+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)) {

package/dist/esm/deriveDirectoryConfig.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
-import { UserError } from '@williamthorsen/nmr-core';
-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.-]+$/;

package/dist/esm/deriveWorkspaceConfig.js

@@ -1,8 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
-import { UserError } from '@williamthorsen/nmr-core';
+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);

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/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/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/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,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { UserError } from '@williamthorsen/nmr-core';
-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() {

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/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',

package/dist/esm/packFromCleanCheckout.js

@@ -2,9 +2,8 @@ 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 { isRecord, 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();

package/dist/esm/parseChangeRecordBlock.js

@@ -1,5 +1,5 @@
+import { isRecord } from '@williamthorsen/nmr-core';
 import { parseDocument } from 'yaml';
-import { isRecord } from "./typeGuards.js";
 export function parseChangeRecordBlock(message) {
     const lines = message.split(/\r?\n/);
     const fence = findFences(lines).at(-1);

package/dist/esm/prepareArgs.d.ts

@@ -1,55 +1,7 @@
-import type { ReleaseType } from './types.js';
 /** Canonical `N.N.N` semver pattern for validating `--set-version` input. */
 export declare const CANONICAL_SEMVER_PATTERN: RegExp;
-export declare const prepareFlagSchema: {
-    isDryRun: {
-        long: string;
-        type: "boolean";
-    };
-    shouldForce: {
-        long: string;
-        type: "boolean";
-    };
-    shouldSkipGitChecks: {
-        long: string;
-        type: "boolean";
-        short: string;
-    };
-    bump: {
-        long: string;
-        type: "string";
-    };
-    setVersion: {
-        long: string;
-        type: "string";
-    };
-    only: {
-        long: string;
-        type: "string";
-    };
-    shouldIncludeReleaseNotes: {
-        long: string;
-        type: "boolean";
-    };
-    config: {
-        long: string;
-        type: "string";
-    };
-};
-/** Parses CLI arguments into structured options. Prints a usage error and exits on invalid input. */
-export declare function parseArgs(argv: string[]): {
-    configPath: string | undefined;
-    isDryRun: boolean;
-    shouldForce: boolean;
-    shouldSkipGitChecks: boolean;
-    bumpOverride: ReleaseType | undefined;
-    onlyNames: string[] | undefined;
-    /** The raw `--set-version` value, whose accepted form depends on the mode. */
-    setVersion: string | undefined;
-    shouldIncludeReleaseNotes: boolean;
-};
 /**
  * Parses a monorepo `--set-version` value, a comma-separated list of `<target>@N.N.N` entries, into versions keyed by
- * target name. Prints a usage error and exits on a malformed entry, an unknown target, or a repeated one.
+ * target name. Throws a `UsageError` for a malformed entry, an unknown target, or a repeated one.
  */
 export declare function parseSetVersions(value: string, knownNames: readonly string[]): Map<string, string>;