@williamthorsen/release-kit 10.9.0 → 12.0.0

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
@@ -37,7 +40,7 @@ export interface RootPackageInfo {
  *   removes the workspace; unlisted packages keep defaults.
  * - `workTypes`: shallow merge — consumer entries override or add to defaults by key.
  * - `versionPatterns`: consumer value replaces defaults entirely.
- * - `formatCommand`, `cliffConfigPath`, `scopeAliases`: consumer value wins.
+ * - `formatCommand`, `scopeAliases`: consumer value wins.
  * - `project`: present iff `userConfig.project` is declared. Resolves `tagPrefix` to
  *   `DEFAULT_PROJECT_TAG_PREFIX` and `paths` to the union of the retained workspaces' `paths`
  *   when omitted. Requires `rootPackage` to be passed and to contain a valid `version` field;

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;
@@ -96,9 +99,6 @@ function applyOptionalPassthroughFields(result, userConfig) {
     if (userConfig?.formatCommand !== undefined) {
         result.formatCommand = userConfig.formatCommand;
     }
-    if (userConfig?.cliffConfigPath !== undefined) {
-        result.cliffConfigPath = userConfig.cliffConfigPath;
-    }
     if (userConfig?.scopeAliases !== undefined) {
         result.scopeAliases = userConfig.scopeAliases;
     }
@@ -212,7 +212,7 @@ function assertNoTagPrefixCollisions(workspaces, retiredPackages, project) {
             if (isPrefixCollision(a.prefix, b.prefix)) {
                 throw new Error(`Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). ` +
                     'One prefix is identical to or a strict prefix of the other; ' +
-                    'this would cause `git describe --match=<prefix>*` to return cross-matches.');
+                    'a tag under the longer prefix can then match the shorter one, whose releases would absorb it.');
             }
         }
     }

package/dist/esm/loadValidatedConfig.d.ts

@@ -1,19 +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(stderrStyle: OutputStyle): 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 { printError, 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(stderrStyle) {
+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) {
-            printError(err, stderrStyle);
-        }
-        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/parseChangeRecordBlock.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reads the last `change-record` block in a commit message into the change entries that it records.
+ *
+ * The block's grammar is codeassembly's `change-record.md`: a fence whose info string is exactly `change-record`,
+ * containing a YAML mapping. A merge commit's block carries `entries` plus the top-level `pr_number` and `ticket_ref`.
+ * A key that the grammar does not declare is ignored, and a declared key whose value is null reads as absent. Any
+ * defect makes the whole block malformed; no entry is salvaged from a defective list.
+ */
+export declare function parseChangeRecordBlock(message: string): ChangeRecordBlockReading;
+/**
+ * Removes every `change-record` block from a message, fences included. A block that never closes runs to the end of
+ * the message, as a Markdown renderer reads it.
+ */
+export declare function stripChangeRecordBlocks(message: string): string;
+/**
+ * What a commit's last `change-record` block reads as: absent, malformed with the defect named, or the entries that
+ * it records with the merge's pull-request number and ticket reference when the block declares them.
+ */
+export type ChangeRecordBlockReading = {
+    kind: 'absent';
+} | {
+    kind: 'malformed';
+    reason: string;
+} | {
+    kind: 'read';
+    entries: ChangeRecordEntry[];
+    prNumber?: number;
+    ticketRef?: string;
+};
+/** One outcome of a change, as the block records it. */
+export interface ChangeRecordEntry {
+    breaking: boolean;
+    migration?: string;
+    scopes: string[];
+    text: string;
+    type: string;
+}

package/dist/esm/parseChangeRecordBlock.js

@@ -0,0 +1,134 @@
+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);
+    if (fence === undefined) {
+        return { kind: 'absent' };
+    }
+    if (fence.close === undefined) {
+        return { kind: 'malformed', reason: 'the block opens but never closes' };
+    }
+    const document = parseDocument(lines.slice(fence.open + 1, fence.close).join('\n'));
+    const [error] = document.errors;
+    if (error !== undefined) {
+        const detail = (error.message.split('\n', 1)[0] ?? '').replace(/:$/, '');
+        return { kind: 'malformed', reason: `the payload is not valid YAML: ${detail}` };
+    }
+    return readPayload(document.toJS());
+}
+export function stripChangeRecordBlocks(message) {
+    const lines = message.split(/\r?\n/);
+    const fences = findFences(lines);
+    return lines
+        .filter((_line, index) => fences.every((fence) => index < fence.open || index > (fence.close ?? lines.length)))
+        .join('\n');
+}
+const FENCE = '```';
+function findFences(lines) {
+    const fences = [];
+    let open;
+    for (const [index, line] of lines.entries()) {
+        if (open === undefined) {
+            if (line.trim() === `${FENCE}${INFO_STRING}`) {
+                open = index;
+            }
+        }
+        else if (line.trim() === FENCE) {
+            fences.push({ close: index, open });
+            open = undefined;
+        }
+    }
+    if (open !== undefined) {
+        fences.push({ open });
+    }
+    return fences;
+}
+const INFO_STRING = 'change-record';
+function readEntry(item, index) {
+    const at = `entries[${index}]`;
+    if (!isRecord(item)) {
+        return { reason: `\`${at}\` is not a mapping` };
+    }
+    const { breaking, migration, scopes } = item;
+    if (breaking !== undefined && breaking !== null && typeof breaking !== 'boolean') {
+        return { reason: `\`${at}.breaking\` is not a boolean` };
+    }
+    if (migration !== undefined && migration !== null && typeof migration !== 'string') {
+        return { reason: `\`${at}.migration\` is not a string` };
+    }
+    if (scopes !== undefined && scopes !== null && !Array.isArray(scopes)) {
+        return { reason: `\`${at}.scopes\` is not a list` };
+    }
+    const declaredScopes = scopes ?? [];
+    const readScopes = [];
+    for (const [position, scope] of declaredScopes.entries()) {
+        if (typeof scope !== 'string') {
+            return { reason: `\`${at}.scopes[${position}]\` is not a string` };
+        }
+        readScopes.push(scope.trim());
+    }
+    const type = readRequiredString(item, at, 'type');
+    if ('reason' in type) {
+        return type;
+    }
+    const text = readRequiredString(item, at, 'text');
+    if ('reason' in text) {
+        return text;
+    }
+    const trimmedMigration = migration?.trim();
+    return {
+        entry: {
+            breaking: breaking === true,
+            ...(trimmedMigration !== undefined && trimmedMigration !== '' && { migration: trimmedMigration }),
+            scopes: readScopes,
+            text: text.value,
+            type: type.value,
+        },
+    };
+}
+function readPayload(payload) {
+    if (!isRecord(payload)) {
+        return { kind: 'malformed', reason: 'the payload is not a mapping' };
+    }
+    const { entries, pr_number: prNumber, ticket_ref: ticketRef } = payload;
+    if (prNumber !== undefined &&
+        prNumber !== null &&
+        (typeof prNumber !== 'number' || !Number.isSafeInteger(prNumber) || prNumber <= 0)) {
+        return { kind: 'malformed', reason: '`pr_number` is not a positive integer' };
+    }
+    if (ticketRef !== undefined && ticketRef !== null && typeof ticketRef !== 'string') {
+        return { kind: 'malformed', reason: '`ticket_ref` is not a string' };
+    }
+    const readEntries = [];
+    if (entries !== undefined && entries !== null) {
+        if (!Array.isArray(entries)) {
+            return { kind: 'malformed', reason: '`entries` is not a list' };
+        }
+        for (const [index, item] of entries.entries()) {
+            const read = readEntry(item, index);
+            if ('reason' in read) {
+                return { kind: 'malformed', reason: read.reason };
+            }
+            readEntries.push(read.entry);
+        }
+    }
+    const trimmedTicketRef = ticketRef?.trim();
+    return {
+        kind: 'read',
+        entries: readEntries,
+        ...(typeof prNumber === 'number' && { prNumber }),
+        ...(trimmedTicketRef !== undefined && trimmedTicketRef !== '' && { ticketRef: trimmedTicketRef }),
+    };
+}
+function readRequiredString(item, at, name) {
+    const value = item[name];
+    if (value === undefined || value === null) {
+        return { reason: `\`${at}.${name}\` is missing` };
+    }
+    if (typeof value !== 'string') {
+        return { reason: `\`${at}.${name}\` is not a string` };
+    }
+    const trimmed = value.trim();
+    return trimmed === '' ? { reason: `\`${at}.${name}\` is blank` } : { value: trimmed };
+}

package/dist/esm/parseCommitMessage.d.ts

@@ -6,18 +6,20 @@ export declare const COMMIT_PREPROCESSOR_PATTERNS: readonly RegExp[];
  *
  * Deliberately permissive: `*` is the sanctioned structural scope for changes spanning every
  * workspace, so the atom admits any run of non-pipe characters rather than word characters.
- * `cliff.toml.template` embeds the same atom in every ticketed commit parser, and
- * `cliffConfigAlignment.unit.test.ts` asserts that parity — exported so neither side can drift.
+ * Exported because `buildChangelogEntries.ts` builds its breaking-marker pattern from the same atom.
  */
 export declare const PIPE_SCOPE_SOURCE = "[^|]+";
-/** Surface where a `!`/`BREAKING CHANGE:` policy violation was detected. */
-export type PolicyViolationSurface = 'prefix' | 'body';
+/**
+ * Surface where a breaking-policy violation was detected: a subject's `!`, a `BREAKING CHANGE:` footer, or a
+ * change-record entry's `breaking`.
+ */
+export type PolicyViolationSurface = 'prefix' | 'body' | 'entry';
 /**
  * Callback invoked when `parseCommitMessage` detects a `!`-policy violation.
  *
  * The parser warns and continues on a violation, so legacy log entries don't block releases.
- * Callers (`decideRelease`, `releasePrepareMono`, etc.) collect callback invocations and
- * surface them in the release report.
+ * `readReleaseHistory` collects the invocations for the unreleased window, and the release
+ * report lists them.
  */
 export type PolicyViolationHandler = (commit: Commit, type: string, surface: PolicyViolationSurface) => void;
 /** Optional configuration for `parseCommitMessage` beyond the core inputs. */
@@ -49,3 +51,26 @@ export interface ParseCommitMessageOptions {
  * same warning path.
  */
 export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, scopeAliases?: Record<string, string>, options?: ParseCommitMessageOptions): ParsedCommit | undefined;
+/** Inputs for {@link evaluateBreakingPolicy}. */
+export interface BreakingPolicyInputs {
+    commit: Commit;
+    resolvedType: string;
+    /** Whether the marker that `prefixSurface` names is present. */
+    hasPrefixBreaking: boolean;
+    hasFooterBreaking: boolean;
+    policy: 'forbidden' | 'optional' | 'required';
+    onPolicyViolation: PolicyViolationHandler | undefined;
+    /** The surface reported for a violation of the marker; `'prefix'` when omitted. */
+    prefixSurface?: PolicyViolationSurface;
+}
+/**
+ * Applies the `!`-policy rules and returns the effective `breaking` flag.
+ *
+ * A violation invokes `onPolicyViolation` and drops the marker (`breaking: false`); the
+ * commit still parses.
+ */
+export declare function evaluateBreakingPolicy(inputs: BreakingPolicyInputs): boolean;
+/**
+ * Resolves a raw type string to its canonical type name using the record keys and aliases.
+ */
+export declare function resolveType(rawType: string, workTypes: Record<string, WorkTypeConfig>): string | undefined;

package/dist/esm/parseCommitMessage.js

@@ -20,7 +20,7 @@ export function parseCommitMessage(message, hash, workTypes, scopeAliases, optio
     if (resolvedType === undefined) {
         return undefined;
     }
-    const commit = { message, hash };
+    const commit = { message, subject: firstLine, hash };
     const breaking = evaluateBreakingPolicy({
         commit,
         resolvedType,
@@ -40,11 +40,12 @@ export function parseCommitMessage(message, hash, workTypes, scopeAliases, optio
         ...(resolvedScope !== undefined && { scope: resolvedScope }),
     };
 }
-function evaluateBreakingPolicy(inputs) {
+export function evaluateBreakingPolicy(inputs) {
     const { commit, resolvedType, hasPrefixBreaking, hasFooterBreaking, policy, onPolicyViolation } = inputs;
+    const prefixSurface = inputs.prefixSurface ?? 'prefix';
     if (policy === 'forbidden') {
         if (hasPrefixBreaking) {
-            onPolicyViolation?.(commit, resolvedType, 'prefix');
+            onPolicyViolation?.(commit, resolvedType, prefixSurface);
         }
         if (hasFooterBreaking) {
             onPolicyViolation?.(commit, resolvedType, 'body');
@@ -53,14 +54,14 @@ function evaluateBreakingPolicy(inputs) {
     }
     if (policy === 'required') {
         if (!hasPrefixBreaking) {
-            onPolicyViolation?.(commit, resolvedType, 'prefix');
+            onPolicyViolation?.(commit, resolvedType, prefixSurface);
             return false;
         }
         return true;
     }
     return hasPrefixBreaking || hasFooterBreaking;
 }
-function resolveType(rawType, workTypes) {
+export function resolveType(rawType, workTypes) {
     const lowered = rawType.toLowerCase();
     for (const [key, config] of Object.entries(workTypes)) {
         if (key === lowered) {

package/dist/esm/prepareCommand.d.ts

@@ -30,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;

package/dist/esm/prepareCommand.js

@@ -1,19 +1,21 @@
 import { execSync } from 'node:child_process';
-import { formatGlyphLine, formatStatusLine, parseArgsOrExit, printError, 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 { readReleaseHistory } from "./buildChangelogEntries.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 { getAllTagPrefixes } from "./generateChangelogs.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
-import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.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+$/;
@@ -21,6 +23,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: {
@@ -64,6 +67,7 @@ export function parseArgs(argv) {
         process.exit(1);
     }
     return {
+        configPath: flags.config,
         dryRun: flags.dryRun,
         force: flags.force,
         noGitChecks: flags.noGitChecks,
@@ -74,7 +78,7 @@ export function parseArgs(argv) {
     };
 }
 export async function prepareCommand(argv, styles) {
-    const { dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes } = parseArgs(argv);
+    const { configPath, dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes } = parseArgs(argv);
     const options = {
         force,
         ...(bumpOverride !== undefined && { bumpOverride }),
@@ -93,20 +97,33 @@ export async function prepareCommand(argv, styles) {
             process.exit(1);
         }
     }
-    const userConfig = await loadAndValidateConfig(styles.stderr);
-    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) {
+    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, styles.stdout);
+        runMonorepoMode(workspace.packageDirs, userConfig, options, only, setVersion, dryRun, styles.stdout);
     }
 }
 function runSinglePackageMode(userConfig, options, only, dryRun, style) {
@@ -114,11 +131,6 @@ function runSinglePackageMode(userConfig, options, only, dryRun, style) {
         reportError('--only is only supported for monorepo configurations');
         process.exit(1);
     }
-    if (options.force && options.bumpOverride === undefined) {
-        reportError('--force without --bump is only supported for monorepo configurations. ' +
-            'Use --bump=major|minor|patch to set the level for a single-package release.');
-        process.exit(1);
-    }
     const config = mergeSinglePackageConfig(userConfig);
     runAndReport(() => releasePrepare(config, options), dryRun, style);
 }
@@ -149,12 +161,8 @@ function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion,
         }
         const graph = buildDependencyGraph(config.workspaces);
         const violations = validateOnlyExcludesStrandedDependents(config.workspaces, only, graph, (workspace) => {
-            const tagPrefixes = [
-                workspace.tagPrefix,
-                ...(workspace.legacyIdentities?.map((identity) => identity.tagPrefix) ?? []),
-            ];
-            const result = getCommitsSinceTarget(tagPrefixes, workspace.paths);
-            return { has: result.commits.length > 0, tag: result.tag };
+            const history = readReleaseHistory(config, { tagPrefixes: getAllTagPrefixes(workspace), paths: workspace.paths });
+            return { has: history.unreleased.commits.length > 0, tag: history.previousTag };
         });
         if (violations !== undefined) {
             reportError('--only excludes packages with changes that would be stranded by the release.');
@@ -180,31 +188,6 @@ function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion,
     }
     runAndReport(() => releasePrepareMono(config, { ...options, ...(only !== undefined && { only }) }), dryRun, style);
 }
-async function loadAndValidateConfig(stderrStyle) {
-    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) {
-            printError(err, stderrStyle);
-        }
-        process.exit(1);
-    }
-    for (const warning of warnings) {
-        console.warn(`  ${formatStatusLine(stderrStyle, 'warning', warning)}`);
-    }
-    return config;
-}
 function runAndReport(computePlan, dryRun, style) {
     let plan;
     try {

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;