@williamthorsen/release-kit 10.8.0 → 11.0.0

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

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

package/dist/esm/help/prepareHelp.js

@@ -4,6 +4,7 @@ Usage: release-kit prepare [options]
 Run release preparation with automatic workspace discovery.
 
 Options:
+  --config <path>       Path to config file (default: .config/release-kit.config.ts)
   --dry-run             Run without modifying any files
   --bump=major|minor|patch  Override the bump type for all workspaces
   --set-version=X.Y.Z   Set an explicit version; bypasses commit-derived bumps. In monorepo

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

@@ -1,6 +1,8 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
 interface InitOptions {
     dryRun: boolean;
     force: boolean;
+    styles: StreamStyles;
     withConfig: boolean;
 }
 /**
@@ -9,5 +11,5 @@ interface InitOptions {
  * Checks eligibility, detects repo type, scaffolds files, and prints next steps.
  * Returns the process exit code (0 for success, 1 for failure).
  */
-export declare function initCommand({ dryRun, force, withConfig }: InitOptions): number;
+export declare function initCommand({ dryRun, force, styles, withConfig }: InitOptions): number;
 export {};

package/dist/esm/init/initCommand.js

@@ -1,36 +1,36 @@
-import { printError, printStep, printSuccess, reportWriteResult } from '@williamthorsen/nmr-core';
+import { printError, 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";
 import { scaffoldFiles } from "./scaffold.js";
-function runRequiredCheck(label, result) {
+function runRequiredCheck(label, result, styles) {
     if (result.ok) {
-        printSuccess(label);
+        printSuccess(label, styles.stdout);
         return true;
     }
-    printError(result.message ?? `${label} failed`);
+    printError(result.message ?? `${label} failed`, styles.stderr);
     return false;
 }
-function checkEligibility() {
+function checkEligibility(styles) {
     printStep('Checking eligibility');
-    if (!runRequiredCheck('Git repository detected', isGitRepo()))
+    if (!runRequiredCheck('Git repository detected', isGitRepo(), styles))
         return false;
-    if (!runRequiredCheck('package.json found', hasPackageJson()))
+    if (!runRequiredCheck('package.json found', hasPackageJson(), styles))
         return false;
-    if (!runRequiredCheck('pnpm detected', usesPnpm()))
+    if (!runRequiredCheck('pnpm detected', usesPnpm(), styles))
         return false;
     return true;
 }
-export function initCommand({ dryRun, force, withConfig }) {
+export function initCommand({ dryRun, force, styles, withConfig }) {
     if (dryRun) {
         console.info('[dry-run mode]');
     }
     let eligible;
     try {
-        eligible = checkEligibility();
+        eligible = checkEligibility(styles);
     }
     catch (error) {
-        printError(`Eligibility check failed: ${describeError(error)}`);
+        printError(`Eligibility check failed: ${describeError(error)}`, styles.stderr);
         return 1;
     }
     if (!eligible)
@@ -41,21 +41,21 @@ export function initCommand({ dryRun, force, withConfig }) {
         repoType = detectRepoType();
     }
     catch (error) {
-        printError(`Failed to detect repo type: ${describeError(error)}`);
+        printError(`Failed to detect repo type: ${describeError(error)}`, styles.stderr);
         return 1;
     }
-    printSuccess(`Detected: ${repoType}`);
+    printSuccess(`Detected: ${repoType}`, styles.stdout);
     printStep('Scaffolding files');
     let results;
     try {
         results = scaffoldFiles({ repoType, dryRun, overwrite: force, withConfig });
     }
     catch (error) {
-        printError(`Failed to scaffold files: ${describeError(error)}`);
+        printError(`Failed to scaffold files: ${describeError(error)}`, styles.stderr);
         return 1;
     }
     for (const result of results) {
-        reportWriteResult(result, dryRun);
+        reportWriteResult(result, dryRun, styles);
     }
     if (results.some((r) => r.outcome === 'failed')) {
         return 1;

package/dist/esm/loadConfig.d.ts

@@ -15,11 +15,14 @@ export declare function readRootPackageVersion(): {
 /** The path where the consumer-facing config file is expected. */
 export declare const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
 /**
- * Loads the config file at `.config/release-kit.config.ts`, returning the raw config object, or `undefined` when the
- * file does not exist. Throws when the file exists but cannot be imported, or exports neither a default nor a named
- * `config`.
+ * Loads the config file, returning the raw config object.
+ *
+ * `configPath` is resolved against the working directory and defaults to `CONFIG_FILE_PATH`. An absent default
+ * path returns `undefined`, because a repo that declares no config is a supported state; an absent named path
+ * throws, because the caller asked for that file by name. Also throws when the file exists but cannot be
+ * imported, or exports neither a default nor a named `config`.
  */
-export declare function loadConfig(): Promise<unknown>;
+export declare function loadConfig(configPath?: string): Promise<unknown>;
 /**
  * Information about the root `package.json` passed into `mergeMonorepoConfig` when a
  * `project` block is configured. The async I/O lives in `readRootPackageVersion`; this

package/dist/esm/loadConfig.js

@@ -39,10 +39,13 @@ export function readRootPackageVersion() {
     return { exists: true, version: typeof parsed['version'] === 'string' ? parsed['version'] : undefined };
 }
 export const CONFIG_FILE_PATH = '.config/release-kit.config.ts';
-export async function loadConfig() {
-    const absoluteConfigPath = path.resolve(process.cwd(), CONFIG_FILE_PATH);
+export async function loadConfig(configPath) {
+    const absoluteConfigPath = path.resolve(process.cwd(), configPath ?? CONFIG_FILE_PATH);
     if (!existsSync(absoluteConfigPath)) {
-        return undefined;
+        if (configPath === undefined) {
+            return undefined;
+        }
+        throw new Error(`Config file not found: ${absoluteConfigPath}`);
     }
     const imported = await import(__rewriteRelativeImportExtension(pathToFileURL(absoluteConfigPath).href));
     const resolved = isRecord(imported) ? (imported['default'] ?? imported['config']) : undefined;

package/dist/esm/loadValidatedConfig.d.ts

@@ -1,18 +1,60 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 import type { ReleaseKitConfig } from './types.js';
 /**
- * Outcome of loading and validating the consumer config file. `missing` is not reported
- * here — whether an absent config file is an error is the caller's call.
+ * Why a config file could not be used: the import threw, or the contents failed the schema.
+ *
+ * The distinction exists so that a caller can render the two differently. Every caller aborts on either.
+ */
+export type ConfigProblem = {
+    kind: 'load';
+    message: string;
+} | {
+    kind: 'validation';
+    errors: string[];
+};
+/**
+ * Outcome of loading and validating the consumer config file. `missing` is not an error
+ * here — whether an absent config file is one is the caller's call.
+ *
+ * `configFilePath` names the file the run read: the caller's `configPath`, or `CONFIG_FILE_PATH` when none was
+ * given. It stays relative to the working directory, so a message or a generated artifact that splices it reads
+ * the same on every machine.
  */
 export type LoadValidatedConfigResult = {
     status: 'invalid';
+    configFilePath: string;
+    problem: ConfigProblem;
 } | {
     status: 'missing';
+    configFilePath: string;
 } | {
     status: 'ok';
     config: ReleaseKitConfig;
+    configFilePath: string;
+    warnings: string[];
 };
 /**
- * Load `.config/release-kit.config.ts` and validate it against the shared schema,
- * reporting load failures and validation errors to stderr.
+ * Loads the consumer config file and validates it against the shared schema, returning the outcome.
+ *
+ * Writes nothing to any stream: the caller picks the sink, which is what lets a command that must stay silent
+ * reuse this loader. `reportConfigProblem` and `reportConfigWarnings` render the stderr form.
+ *
+ * `configPath` defaults to `CONFIG_FILE_PATH`. A named path that does not exist is a load failure, so it reports
+ * as `invalid` rather than `missing`.
+ */
+export declare function loadValidatedConfig(configPath?: string): Promise<LoadValidatedConfigResult>;
+/**
+ * Loads and validates the config, reporting the problem and exiting 1 when it is unusable, so that a command
+ * whose later work may never reach a loader still fails on a config that does.
+ *
+ * An absent default config returns cleanly, which is what keeps a repo that declares no config a supported state.
+ * Reports problems but never warnings: the command's own later load stays the single place that emits those, so
+ * a warning is not printed twice.
+ *
+ * The second load costs nothing: `import()` caches by URL and `validateConfig` is pure.
  */
-export declare function loadValidatedConfig(): Promise<LoadValidatedConfigResult>;
+export declare function assertConfigUsable(stderrStyle: OutputStyle, configPath?: string): Promise<void>;
+/** Writes a config problem to stderr in the form every CLI command uses. */
+export declare function reportConfigProblem(problem: ConfigProblem, stderrStyle: OutputStyle): void;
+/** Writes validation warnings to stderr as indented status lines. */
+export declare function reportConfigWarnings(warnings: readonly string[], stderrStyle: OutputStyle): void;

package/dist/esm/loadValidatedConfig.js

@@ -1,27 +1,44 @@
-import { reportError } from '@williamthorsen/nmr-core';
+import { formatStatusLine, printError, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { loadConfig } from "./loadConfig.js";
+import { CONFIG_FILE_PATH, loadConfig } from "./loadConfig.js";
 import { validateConfig } from "./validateConfig.js";
-export async function loadValidatedConfig() {
+export async function loadValidatedConfig(configPath) {
+    const configFilePath = configPath ?? CONFIG_FILE_PATH;
     let raw;
     try {
-        raw = await loadConfig();
+        raw = await loadConfig(configPath);
     }
     catch (error) {
-        const message = describeError(error);
-        reportError(`Failed to load config: ${message}`);
-        return { status: 'invalid' };
+        return { status: 'invalid', configFilePath, problem: { kind: 'load', message: describeError(error) } };
     }
     if (raw === undefined) {
-        return { status: 'missing' };
+        return { status: 'missing', configFilePath };
     }
-    const { config, errors } = validateConfig(raw);
+    const { config, errors, warnings } = validateConfig(raw);
     if (errors.length > 0) {
-        process.stderr.write('Invalid config:\n');
-        for (const err of errors) {
-            process.stderr.write(`  ❌ ${err}\n`);
-        }
-        return { status: 'invalid' };
+        return { status: 'invalid', configFilePath, problem: { kind: 'validation', errors } };
+    }
+    return { status: 'ok', config, configFilePath, warnings };
+}
+export async function assertConfigUsable(stderrStyle, configPath) {
+    const result = await loadValidatedConfig(configPath);
+    if (result.status === 'invalid') {
+        reportConfigProblem(result.problem, stderrStyle);
+        process.exit(1);
+    }
+}
+export function reportConfigProblem(problem, stderrStyle) {
+    if (problem.kind === 'load') {
+        reportError(`Failed to load config: ${problem.message}`);
+        return;
+    }
+    process.stderr.write('Invalid config:\n');
+    for (const error of problem.errors) {
+        printError(error, stderrStyle);
+    }
+}
+export function reportConfigWarnings(warnings, stderrStyle) {
+    for (const warning of warnings) {
+        console.warn(`  ${formatStatusLine(stderrStyle, 'warning', warning)}`);
     }
-    return { status: 'ok', config };
 }

package/dist/esm/prepareCommand.d.ts

@@ -1,3 +1,4 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
 import type { ReleaseType } from './types.js';
 export declare const prepareFlagSchema: {
     dryRun: {
@@ -29,9 +30,14 @@ export declare const prepareFlagSchema: {
         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;
     dryRun: boolean;
     force: boolean;
     noGitChecks: boolean;
@@ -49,4 +55,4 @@ export declare function parseArgs(argv: string[]): {
  * 4. Delegates to `releasePrepare` or `releasePrepareMono` to compute the release plan.
  * 5. Applies the plan, runs the format command, and prints the result via `reportPrepare`.
  */
-export declare function prepareCommand(argv: string[]): Promise<void>;
+export declare function prepareCommand(argv: string[], styles: StreamStyles): Promise<void>;

package/dist/esm/prepareCommand.js

@@ -1,18 +1,20 @@
 import { execSync } from 'node:child_process';
-import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, parseArgsOrExit, reportError, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { buildDependencyGraph } from "./buildDependencyGraph.js";
-import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { configFlagSchema } from "./configFlagSchema.js";
+import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
-import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.js";
+import { RELEASE_GLYPHS } from "./glyphs.js";
+import { mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.js";
+import { loadValidatedConfig, reportConfigProblem, reportConfigWarnings } from "./loadValidatedConfig.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 import { applyReleasePlan } from "./releasePlan.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
 import { reportPrepare } from "./reportPrepare.js";
-import { validateConfig } from "./validateConfig.js";
 import { validateOnlyExcludesStrandedDependents } from "./validateOnlyExcludesStrandedDependents.js";
 const VALID_BUMP_TYPES = ['major', 'minor', 'patch'];
 const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
@@ -20,6 +22,7 @@ function isReleaseType(value) {
     return VALID_BUMP_TYPES.includes(value);
 }
 export const prepareFlagSchema = {
+    ...configFlagSchema,
     dryRun: { long: '--dry-run', type: 'boolean' },
     force: { long: '--force', type: 'boolean' },
     noGitChecks: {
@@ -63,6 +66,7 @@ export function parseArgs(argv) {
         process.exit(1);
     }
     return {
+        configPath: flags.config,
         dryRun: flags.dryRun,
         force: flags.force,
         noGitChecks: flags.noGitChecks,
@@ -72,8 +76,8 @@ export function parseArgs(argv) {
         withReleaseNotes: flags.withReleaseNotes,
     };
 }
-export async function prepareCommand(argv) {
-    const { dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes } = parseArgs(argv);
+export async function prepareCommand(argv, styles) {
+    const { configPath, dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes } = parseArgs(argv);
     const options = {
         force,
         ...(bumpOverride !== undefined && { bumpOverride }),
@@ -81,7 +85,7 @@ export async function prepareCommand(argv) {
         ...(withReleaseNotes && { withReleaseNotes: true }),
     };
     if (dryRun) {
-        console.info('\n🔍 DRY RUN — no files will be modified\n');
+        console.info(`\n${formatGlyphLine(RELEASE_GLYPHS, styles.stdout, 'dryRun', 'DRY RUN — no files will be modified')}\n`);
     }
     if (!dryRun && !noGitChecks) {
         try {
@@ -92,23 +96,36 @@ export async function prepareCommand(argv) {
             process.exit(1);
         }
     }
-    const userConfig = await loadAndValidateConfig();
-    let discoveredPaths;
+    const configResult = await loadValidatedConfig(configPath);
+    if (configResult.status === 'invalid') {
+        reportConfigProblem(configResult.problem, styles.stderr);
+        process.exit(1);
+    }
+    let userConfig;
+    if (configResult.status === 'ok') {
+        reportConfigWarnings(configResult.warnings, styles.stderr);
+        userConfig = configResult.config;
+    }
+    let workspace;
     try {
-        discoveredPaths = await discoverWorkspaces();
+        workspace = discoverWorkspaces();
     }
     catch (error) {
         reportError(`Failed to discover workspaces: ${describeError(error)}`);
         process.exit(1);
     }
-    if (discoveredPaths === undefined) {
-        runSinglePackageMode(userConfig, options, only, dryRun);
+    if (workspace.kind === 'empty') {
+        reportError(`No workspace package to release. ${describeEmptyWorkspace(workspace)}`);
+        process.exit(1);
+    }
+    if (workspace.kind === 'single-package') {
+        runSinglePackageMode(userConfig, options, only, dryRun, styles.stdout);
     }
     else {
-        runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion, dryRun);
+        runMonorepoMode(workspace.packageDirs, userConfig, options, only, setVersion, dryRun, styles.stdout);
     }
 }
-function runSinglePackageMode(userConfig, options, only, dryRun) {
+function runSinglePackageMode(userConfig, options, only, dryRun, style) {
     if (only !== undefined) {
         reportError('--only is only supported for monorepo configurations');
         process.exit(1);
@@ -119,9 +136,9 @@ function runSinglePackageMode(userConfig, options, only, dryRun) {
         process.exit(1);
     }
     const config = mergeSinglePackageConfig(userConfig);
-    runAndReport(() => releasePrepare(config, options), dryRun);
+    runAndReport(() => releasePrepare(config, options), dryRun, style);
 }
-function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion, dryRun) {
+function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion, dryRun, style) {
     let config;
     try {
         const rootPackage = readRootPackageVersion();
@@ -177,34 +194,9 @@ function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion,
             process.exit(1);
         }
     }
-    runAndReport(() => releasePrepareMono(config, { ...options, ...(only !== undefined && { only }) }), dryRun);
-}
-async function loadAndValidateConfig() {
-    let rawConfig;
-    try {
-        rawConfig = await loadConfig();
-    }
-    catch (error) {
-        reportError(`Failed to load config: ${describeError(error)}`);
-        process.exit(1);
-    }
-    if (rawConfig === undefined) {
-        return undefined;
-    }
-    const { config, errors, warnings } = validateConfig(rawConfig);
-    if (errors.length > 0) {
-        process.stderr.write('Invalid config:\n');
-        for (const err of errors) {
-            process.stderr.write(`  ❌ ${err}\n`);
-        }
-        process.exit(1);
-    }
-    for (const warning of warnings) {
-        console.warn(`  ⚠️  ${warning}`);
-    }
-    return config;
+    runAndReport(() => releasePrepareMono(config, { ...options, ...(only !== undefined && { only }) }), dryRun, style);
 }
-function runAndReport(computePlan, dryRun) {
+function runAndReport(computePlan, dryRun, style) {
     let plan;
     try {
         plan = computePlan();
@@ -215,7 +207,7 @@ function runAndReport(computePlan, dryRun) {
         process.exit(1);
     }
     if (dryRun) {
-        process.stdout.write(reportPrepare(plan, { applied: false }) + '\n');
+        process.stdout.write(reportPrepare(plan, { applied: false, style }) + '\n');
         reportPlanFiles(plan, true);
         return;
     }
@@ -227,7 +219,7 @@ function runAndReport(computePlan, dryRun) {
         process.exit(1);
     }
     const formatError = runFormatCommand(plan.formatCommand);
-    process.stdout.write(reportPrepare(plan, { applied: true, ...(formatError !== undefined && { formatError }) }) + '\n');
+    process.stdout.write(reportPrepare(plan, { applied: true, style, ...(formatError !== undefined && { formatError }) }) + '\n');
     reportPlanFiles(plan, false);
     if (formatError !== undefined) {
         reportError(`The format command failed, but the release is prepared and ${RELEASE_TAGS_FILE} is written. ` +

package/dist/esm/previewTagPrefixes.d.ts

@@ -1,4 +1,5 @@
 import { type UndeclaredTagPrefix } from './detectUndeclaredTagPrefixes.js';
+import type { ReleaseKitConfig } from './types.js';
 /** One workspace's preview row in the tag-prefix preview. */
 export interface TagPrefixPreviewRow {
     /** Workspace-relative directory path (e.g., `packages/core`). */
@@ -41,10 +42,12 @@ export interface TagPrefixPreview {
 /**
  * Build a structured preview of tag-prefix state for every discovered workspace.
  *
- * Discovers workspaces via `discoverWorkspaces()`, derives each workspace's tag prefix
- * via `deriveWorkspaceConfig()`, and records the derivation error on failure rather than aborting.
- * Loads `.config/release-kit.config.ts` to surface declared legacy prefixes per workspace,
- * scans local git tags for undeclared candidate prefixes via `detectUndeclaredTagPrefixes`,
- * and reports collisions across successfully-derived prefixes.
+ * Derives each workspace's tag prefix via `deriveWorkspaceConfig()`, recording the derivation error on failure
+ * rather than aborting. A repo releasing as a single package previews no row; one declaring patterns that
+ * resolve to no package throws, because the manifest is then what needs repairing and a clean table would
+ * hide that.
+ * Reads the already-validated `config` to surface declared legacy prefixes per workspace, scans local
+ * git tags for undeclared candidate prefixes via `detectUndeclaredTagPrefixes`, and reports collisions
+ * across successfully-derived prefixes.
  */
-export declare function previewTagPrefixes(): Promise<TagPrefixPreview>;
+export declare function previewTagPrefixes(config?: ReleaseKitConfig): TagPrefixPreview;

package/dist/esm/previewTagPrefixes.js

@@ -4,38 +4,26 @@ import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
-import { discoverWorkspaces } from "./discoverWorkspaces.js";
-import { loadConfig } from "./loadConfig.js";
-import { validateConfig } from "./validateConfig.js";
-export async function previewTagPrefixes() {
-    const workspacePaths = (await discoverWorkspaces()) ?? [];
-    const userConfig = await loadUserConfig();
-    const overridesByDir = buildOverrideMap(userConfig);
+import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
+export function previewTagPrefixes(config) {
+    const workspace = discoverWorkspaces();
+    if (workspace.kind === 'empty') {
+        throw new Error(`No workspace package to preview. ${describeEmptyWorkspace(workspace)}`);
+    }
+    const workspacePaths = workspace.kind === 'packages' ? workspace.packageDirs : [];
+    const overridesByDir = buildOverrideMap(config);
     const workspaces = Array.from(workspacePaths, (workspacePath) => buildPreviewRow(workspacePath, overridesByDir));
-    const retiredPackages = buildRetiredPreviewEntries(userConfig?.retiredPackages ?? []);
+    const retiredPackages = buildRetiredPreviewEntries(config?.retiredPackages ?? []);
     const collisions = detectCollisions(workspaces);
     const knownPrefixes = collectKnownPrefixes(workspaces, retiredPackages);
     const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes);
     return { workspaces, collisions, undeclaredCandidates, retiredPackages };
 }
-async function loadUserConfig() {
-    let raw;
-    try {
-        raw = await loadConfig();
-    }
-    catch {
-        return undefined;
-    }
-    if (raw === undefined)
-        return undefined;
-    const { config, errors } = validateConfig(raw);
-    return errors.length === 0 ? config : undefined;
-}
-function buildOverrideMap(userConfig) {
+function buildOverrideMap(config) {
     const map = new Map();
-    if (userConfig?.workspaces === undefined)
+    if (config?.workspaces === undefined)
         return map;
-    for (const entry of userConfig.workspaces) {
+    for (const entry of config.workspaces) {
         if (entry.legacyIdentities !== undefined) {
             map.set(entry.dir, entry.legacyIdentities);
         }

package/dist/esm/publishCommand.d.ts

@@ -1,5 +1,6 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
 /**
- * Orchestrate the CLI `publish` command: parse flags, discover workspaces, resolve tags from HEAD,
- * detect the package manager, validate `--tags`, and publish each tag with inject/restore lifecycle.
+ * Orchestrate the CLI `publish` command: parse flags, open a named config, discover workspaces, resolve tags
+ * from HEAD, detect the package manager, validate `--tags`, and publish each tag with inject/restore lifecycle.
  */
-export declare function publishCommand(argv: string[]): Promise<void>;
+export declare function publishCommand(argv: string[], styles: StreamStyles): Promise<void>;

package/dist/esm/publishCommand.js

@@ -3,22 +3,26 @@ import { join } from 'node:path';
 import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
+import { configFlagSchema } from "./configFlagSchema.js";
 import { detectPackageManager } from "./detectPackageManager.js";
 import { formatPrivateSkip } from "./formatPrivateSkip.js";
 import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
+import { assertConfigUsable } from "./loadValidatedConfig.js";
 import { parseRequestedTags } from "./parseRequestedTags.js";
 import { publishPackage } from "./publish.js";
 import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
 const publishFlagSchema = {
+    ...configFlagSchema,
     dryRun: { long: '--dry-run', type: 'boolean' },
     noGitChecks: { long: '--no-git-checks', type: 'boolean' },
     provenance: { long: '--provenance', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
 };
-export async function publishCommand(argv) {
+export async function publishCommand(argv, styles) {
     const parsed = parseArgsOrExit(argv, publishFlagSchema);
     const { dryRun, noGitChecks, provenance } = parsed.flags;
+    await assertConfigUsable(styles.stderr, parsed.flags.config);
     if (!dryRun && !noGitChecks) {
         try {
             assertCleanWorkingTree();
@@ -29,7 +33,7 @@ export async function publishCommand(argv) {
         }
     }
     const requestedTags = parseRequestedTags(parsed.flags.tags);
-    const resolvedTags = await resolveCommandTags(requestedTags);
+    const resolvedTags = resolveCommandTags(requestedTags);
     if (resolvedTags.length === 0) {
         return;
     }
@@ -39,7 +43,9 @@ export async function publishCommand(argv) {
         return;
     }
     const packageManager = detectPackageManager();
-    const { releaseNotes, changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig();
+    const { releaseNotes, changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig(styles.stderr, {
+        ...(parsed.flags.config !== undefined && { configPath: parsed.flags.config }),
+    });
     const shouldInject = releaseNotes.shouldInjectIntoReadme;
     console.info(dryRun ? '[dry-run] Would publish:' : 'Publishing:');
     for (const { tag, workspacePath } of publishableTags) {

package/dist/esm/pushCommand.d.ts

@@ -2,4 +2,4 @@
  * Orchestrate the CLI `push` command: parse flags, resolve tags from HEAD, and push
  * the release commit and each tag individually.
  */
-export declare function pushCommand(argv: string[]): Promise<void>;
+export declare function pushCommand(argv: string[]): void;

package/dist/esm/pushCommand.js

@@ -8,11 +8,11 @@ const pushFlagSchema = {
     tags: { long: '--tags', type: 'string' },
     tagsOnly: { long: '--tags-only', type: 'boolean' },
 };
-export async function pushCommand(argv) {
+export function pushCommand(argv) {
     const parsed = parseArgsOrExit(argv, pushFlagSchema);
     const { dryRun, tagsOnly } = parsed.flags;
     const requestedTags = parseRequestedTags(parsed.flags.tags);
-    const resolvedTags = await resolveCommandTags(requestedTags);
+    const resolvedTags = resolveCommandTags(requestedTags);
     if (resolvedTags.length === 0) {
         return;
     }

package/dist/esm/reportPrepare.d.ts

@@ -1,3 +1,4 @@
+import { type OutputStyle } from '@williamthorsen/nmr-core';
 import type { PrepareResult } from './types.js';
 /** How the plan was carried out, which decides the tense the report is rendered in. */
 export interface ReportPrepareOptions {
@@ -5,6 +6,7 @@ export interface ReportPrepareOptions {
     applied: boolean;
     /** The format command's failure message, when it ran and failed. */
     formatError?: string;
+    style: OutputStyle;
 }
 /**
  * Format a release plan into styled terminal output.