@williamthorsen/release-kit 10.9.0 → 11.0.0

package/dist/esm/discoverWorkspaces.d.ts

@@ -1,13 +1,58 @@
+import { type EmptyWorkspaceCause } from '@williamthorsen/nmr-core/workspace';
+export type { EmptyWorkspaceCause } from '@williamthorsen/nmr-core/workspace';
 /**
- * Reads `pnpm-workspace.yaml` and resolves its `packages` globs to discover workspace directories.
+ * What release-kit's workspace discovery produced: the repo releases as a single package, it resolves to a
+ * set of package directories, or it declares a workspace that resolves to none and the cause says which
+ * condition emptied it.
  *
- * Returns an array of workspace-relative directory paths (e.g., `['packages/arrays', 'packages/strings']`).
- * Only directories containing a `package.json` are included.
+ * Held apart from nmr-core's `WorkspaceResolution`, whose `packageDirs` are absolute, because these are
+ * relative to the monorepo root. The two carry incompatible path contracts, and a distinct `kind` for the
+ * single-package case keeps either from standing in for the other.
+ */
+export type WorkspaceDiscovery = {
+    kind: 'empty';
+    cause: FailingWorkspaceCause;
+    patterns: string[];
+} | {
+    kind: 'packages';
+    packageDirs: string[];
+    patterns: string[];
+} | {
+    kind: 'single-package';
+};
+/** A workspace that resolved to no package directory, which every release-kit command treats as a failure. */
+export type EmptyWorkspace = Extract<WorkspaceDiscovery, {
+    kind: 'empty';
+}>;
+/**
+ * The empty-workspace causes that reach a command as a failure.
+ *
+ * `no-packages-list` is absent because a manifest declaring nothing releases as a single package, so no
+ * command ever composes a message for it.
+ */
+export type FailingWorkspaceCause = Exclude<EmptyWorkspaceCause, 'no-packages-list'>;
+/**
+ * Returns the sentence naming which of the five conditions left a workspace holding no package directory, and
+ * the remedy for that one. Each quotes the `packages` list the manifest declares, apart from the two that
+ * reach the matcher with no list to quote.
+ *
+ * The `package.json` requirement is stated under `no-package` because it is a divergence from pnpm, which
+ * recognizes two further manifests, and the reader of a workspace that pnpm resolves has no way to infer it.
+ */
+export declare function describeEmptyWorkspace(workspace: EmptyWorkspace): string;
+/**
+ * Reads `pnpm-workspace.yaml` at `monorepoRoot` and resolves its `packages` patterns, applying pnpm's
+ * semantics — `!`-prefixed exclusions included.
  *
- * Note: The returned paths are full relative paths from the repo root (e.g., `packages/arrays`,
- * `libs/core`). These paths are passed directly to `deriveWorkspaceConfig()`, which uses them for all
- * file path construction and derives the display name via `path.basename()`.
+ * A directory holding no manifest, and one whose manifest declares no `packages` list, both release as a
+ * single package: pnpm resolves each to the root package alone, and a workspace file kept for `catalog:`,
+ * `overrides:`, or `onlyBuiltDependencies:` is the second of them. Every other empty resolution is a failure,
+ * whether the reader declared patterns that matched nothing or a `packages` value the resolver could not read
+ * as patterns at all.
  *
- * @returns The discovered workspace paths, or `undefined` if no workspace config is found.
+ * `packageDirs` come back relative to `monorepoRoot` as POSIX paths, because that is what every consumer
+ * needs: `WorkspaceConfig.paths` feeds `git log -- <paths>`, and `packageFiles` and `changelogPaths` are read
+ * from disk relative to the working directory. The workspace root itself relativizes to `.`, the path
+ * `deriveWorkspaceConfig` reads a root package's manifest through.
  */
-export declare function discoverWorkspaces(): Promise<string[] | undefined>;
+export declare function discoverWorkspaces(monorepoRoot?: string): WorkspaceDiscovery;

package/dist/esm/discoverWorkspaces.js

@@ -1,42 +1,62 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { describeError } from '@williamthorsen/toolbelt.errors';
-import { glob } from 'glob';
-import { parse } from 'yaml';
-import { isRecord } from "./typeGuards.js";
-export async function discoverWorkspaces() {
-    const workspaceFile = 'pnpm-workspace.yaml';
-    if (!existsSync(workspaceFile)) {
-        return undefined;
-    }
-    let content;
-    try {
-        content = readFileSync(workspaceFile, 'utf8');
-    }
-    catch (error) {
-        console.warn(`Warning: Failed to read ${workspaceFile}: ${describeError(error)}`);
-        return undefined;
-    }
-    const parsed = parse(content);
-    if (!isRecord(parsed)) {
-        return undefined;
+import path from 'node:path';
+import { resolveWorkspace } from '@williamthorsen/nmr-core/workspace';
+export function describeEmptyWorkspace(workspace) {
+    const declaredClause = describeDeclaredPatterns(workspace.patterns);
+    switch (workspace.cause) {
+        case 'all-excluded':
+            return (`pnpm-workspace.yaml ${declaredClause}, whose \`!\` entries exclude every directory matched by the ` +
+                'positive patterns. Drop or narrow the exclusion.');
+        case 'no-package':
+            return (`pnpm-workspace.yaml ${declaredClause}, and the matcher found no directory holding a \`package.json\`. ` +
+                'Add one to the directory that should be a package, or declare a pattern reaching a directory that ' +
+                'holds one.');
+        case 'no-pattern':
+            return (`pnpm-workspace.yaml ${declaredClause}, so no pattern reaches the matcher. Declare a positive pattern ` +
+                'such as `packages/*`, and quote any `!` entry, which YAML reads as a tag rather than a string where ' +
+                'it stands bare.');
+        case 'unreadable-manifest':
+            return ('pnpm-workspace.yaml holds no valid YAML, so nothing it declares reaches the matcher. Repair the ' +
+                'syntax error and run the command again. An unterminated quoted string and a mis-indented entry are ' +
+                'the usual ones.');
+        case 'unreadable-packages':
+            return ('pnpm-workspace.yaml declares a `packages` value that is not a list of strings, so nothing it ' +
+                'declares reaches the matcher. Make it a list whose every entry is a quoted pattern; a bare value ' +
+                'and an entry YAML read as a number or a map are the usual ones.');
+        default: {
+            const unhandledCause = workspace.cause;
+            throw new Error(`Unhandled empty-workspace cause: ${String(unhandledCause)}`);
+        }
     }
-    const packagesField = parsed['packages'];
-    if (!Array.isArray(packagesField)) {
-        return undefined;
+}
+export function discoverWorkspaces(monorepoRoot = process.cwd()) {
+    const resolution = resolveWorkspace(monorepoRoot);
+    if (resolution.kind === 'not-a-workspace') {
+        return { kind: 'single-package' };
     }
-    const patterns = packagesField.filter((p) => typeof p === 'string');
-    if (patterns.length === 0) {
-        return undefined;
+    if (resolution.kind === 'empty') {
+        const { cause, patterns } = resolution;
+        return cause === 'no-packages-list' ? { kind: 'single-package' } : { cause, kind: 'empty', patterns };
     }
-    const directories = [];
-    for (const pattern of patterns) {
-        const matches = await glob(pattern, { posix: true });
-        for (const match of matches) {
-            if (existsSync(join(match, 'package.json'))) {
-                directories.push(match);
-            }
-        }
+    return {
+        ...resolution,
+        packageDirs: resolution.packageDirs.map((packageDir) => relativizeToPosix(monorepoRoot, packageDir)),
+    };
+}
+function describeDeclaredPatterns(patterns) {
+    const quotablePatterns = patterns.filter((pattern) => pattern.trim() !== '');
+    const emptiedCount = patterns.length - quotablePatterns.length;
+    if (emptiedCount === 0) {
+        return `declares ${renderQuotedList(patterns)}`;
     }
-    return directories.length > 0 ? [...directories].sort() : undefined;
+    const emptiedClause = `${String(emptiedCount)} ${emptiedCount === 1 ? 'entry' : 'entries'} that YAML left empty`;
+    return quotablePatterns.length === 0
+        ? `declares ${emptiedClause}`
+        : `declares ${renderQuotedList(quotablePatterns)}, beside ${emptiedClause}`;
+}
+function relativizeToPosix(monorepoRoot, packageDir) {
+    const relativeDir = path.relative(monorepoRoot, packageDir);
+    return relativeDir === '' ? '.' : relativeDir.split(path.sep).join('/');
+}
+function renderQuotedList(patterns) {
+    return patterns.map((pattern) => `\`${pattern}\``).join(', ');
 }

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/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,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/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,20 @@
 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 { 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 { 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 +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: {
@@ -64,6 +66,7 @@ export function parseArgs(argv) {
         process.exit(1);
     }
     return {
+        configPath: flags.config,
         dryRun: flags.dryRun,
         force: flags.force,
         noGitChecks: flags.noGitChecks,
@@ -74,7 +77,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 +96,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) {
@@ -180,31 +196,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;

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,6 +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[], styles: StreamStyles): Promise<void>;

package/dist/esm/publishCommand.js

@@ -3,14 +3,17 @@ 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' },
@@ -19,6 +22,7 @@ const publishFlagSchema = {
 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, styles) {
         }
     }
     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, styles) {
         return;
     }
     const packageManager = detectPackageManager();
-    const { releaseNotes, changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig(styles.stderr);
+    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;