@williamthorsen/release-kit 13.1.0 → 14.1.0

package/dist/esm/deriveWorkspaceConfig.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { isPublishableManifest } from "./isPublishableManifest.js";
 import { isRecord } from "./typeGuards.js";
 export function deriveWorkspaceConfig(workspacePath) {
     const dir = basename(workspacePath);
@@ -17,8 +18,7 @@ export function deriveWorkspaceConfig(workspacePath) {
         throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
     }
     const unscopedName = stripNpmScope(name);
-    const privateField = isRecord(parsed) ? parsed['private'] : undefined;
-    const isPublishable = privateField === undefined || privateField === false;
+    const isPublishable = isPublishableManifest(parsed);
     return {
         dir,
         name,

package/dist/esm/enumerateReleaseWindows.d.ts

@@ -22,7 +22,7 @@ export interface ReleaseWindow {
 export interface EnumerateReleaseWindowsOptions {
     /** Git pathspecs restricting the enumeration to commits that touch them. */
     paths?: readonly string[];
-    /** Tag prefixes to match as a union; a matching tag name continues with a digit. */
+    /** Tag prefixes to match as a union; a matching tag name continues with a complete SemVer version. */
     tagPrefixes: readonly string[];
     /** The version that the unreleased window reports, such as the tag that the release being prepared will write. */
     unreleasedTag: string;

package/dist/esm/enumerateReleaseWindows.js

@@ -1,6 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { matchesTagPrefix } from "./matchesTagPrefix.js";
 const FIELD_SEPARATOR = '\u{1F}';
 const RECORD_SEPARATOR = '\u{1E}';
 export function enumerateReleaseWindows(options) {
@@ -46,9 +47,6 @@ function claimAncestors(boundaries, parentsByHash) {
     }
     return windowIndexByHash;
 }
-function matchesTagPrefix(tagName, tagPrefixes) {
-    return tagPrefixes.some((prefix) => tagName.startsWith(prefix) && /^\d/.test(tagName.slice(prefix.length)));
-}
 function parseCommitRecord(record) {
     const [hash, subject, message] = record.replace(/^\n+/, '').split(FIELD_SEPARATOR);
     if (hash === undefined || subject === undefined || message === undefined || hash === '') {

package/dist/esm/findTransitiveDependents.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyGraph } from './buildDependencyGraph.js';
+/** Returns the start workspace `dir`s together with the `dir` of every workspace that depends on one, transitively. */
+export declare function findTransitiveDependents(graph: DependencyGraph, startDirs: Iterable<string>): Set<string>;

package/dist/esm/findTransitiveDependents.js

@@ -0,0 +1,20 @@
+export function findTransitiveDependents(graph, startDirs) {
+    const found = new Set(startDirs);
+    const queue = [...found];
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        if (dir === undefined)
+            break;
+        const packageName = graph.dirToPackageName.get(dir);
+        if (packageName === undefined)
+            continue;
+        const dependents = graph.dependentsOf.get(packageName) ?? [];
+        for (const dependent of dependents) {
+            if (found.has(dependent.dir))
+                continue;
+            found.add(dependent.dir);
+            queue.push(dependent.dir);
+        }
+    }
+    return found;
+}

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

@@ -2,6 +2,6 @@
  * Help text for `release-kit prepare`. The module does not have any import-time side effects, so that a test can
  * import it without running the CLI.
  */
-export declare const prepareHelpText = "\nUsage: release-kit prepare [options]\n\nRun release preparation with automatic workspace discovery.\n\nOptions:\n  --config <path>       Config file, relative to the current directory\n                         (default: .config/release-kit.config.ts at the repo root)\n  --dry-run             Run without modifying any files\n  --bump=major|minor|patch  Set the level of every release that happens; does not trigger one\n  --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo\n                         mode it requires --only, and is rejected when a 'project' block is configured.\n  --force               Release even when the last tag is not followed by any commits,\n                         or by any bump-worthy ones. Defaults to patch when --bump is not given;\n                         use --bump=X for a different level.\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>       Config file, relative to the current directory\n                         (default: .config/release-kit.config.ts at the repo root)\n  --dry-run             Run without modifying any files\n  --bump=major|minor|patch  Set the level of every release that happens; does not trigger one\n  --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo\n                         mode, name each workspace: --set-version=arrays@1.0.0[,strings@2.0.0].\n                         Rejected when a 'project' block is configured.\n  --force               Release even when the last tag is not followed by any commits,\n                         or by any bump-worthy ones. Defaults to patch when --bump is not given;\n                         use --bump=X for a different level.\n  --no-git-checks, -n   Skip the clean-working-tree check\n  --only=name1,name2    Release only the named workspaces and their dependents (comma-separated,\n                         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

@@ -9,12 +9,14 @@ Options:
   --dry-run             Run without modifying any files
   --bump=major|minor|patch  Set the level of every release that happens; does not trigger one
   --set-version=X.Y.Z   Set an explicit version; bypasses the changelog-derived bump. In monorepo
-                         mode it requires --only, and is rejected when a 'project' block is configured.
+                         mode, name each workspace: --set-version=arrays@1.0.0[,strings@2.0.0].
+                         Rejected when a 'project' block is configured.
   --force               Release even when the last tag is not followed by any commits,
                          or by any bump-worthy ones. Defaults to patch when --bump is not given;
                          use --bump=X for a different level.
   --no-git-checks, -n   Skip the clean-working-tree check
-  --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only).
+  --only=name1,name2    Release only the named workspaces and their dependents (comma-separated,
+                         monorepo only).
                          When a 'project' block is configured, the project release is skipped.
   --with-release-notes  Also write per-workspace release-notes previews under <workspacePath>/docs/
                          (docs/README.v<version>.md and docs/RELEASE_NOTES.v<version>.md).

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

@@ -0,0 +1,10 @@
+/**
+ * Reports whether the repo at `root` contains a package that can be published: a discovered workspace, or the root
+ * package of a single-package repo, whose `package.json` is not private.
+ *
+ * Returns `true` whenever the answer cannot be determined (an empty workspace, a failed discovery, or an unreadable
+ * manifest), so that the scaffolding commands keep the publish workflows in every repo that might need them.
+ */
+export declare function hasPublishablePackage(root?: string): boolean;
+/** Formats the line that reports a workflow skipped because the repo does not contain any publishable package. */
+export declare function formatPrivateWorkflowSkip(filePath: string): string;

package/dist/esm/init/hasPublishablePackage.js

@@ -0,0 +1,28 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { discoverWorkspaces } from "../discoverWorkspaces.js";
+import { isPublishableManifest } from "../isPublishableManifest.js";
+export function hasPublishablePackage(root = process.cwd()) {
+    let packageDirs;
+    try {
+        const workspace = discoverWorkspaces(root);
+        if (workspace.kind === 'empty')
+            return true;
+        packageDirs = workspace.kind === 'single-package' ? ['.'] : workspace.packageDirs;
+    }
+    catch {
+        return true;
+    }
+    return packageDirs.some((packageDir) => isPublishableAt(path.join(root, packageDir, 'package.json')));
+}
+export function formatPrivateWorkflowSkip(filePath) {
+    return `Skipping ${filePath}: every package is private`;
+}
+function isPublishableAt(manifestPath) {
+    try {
+        return isPublishableManifest(JSON.parse(readFileSync(manifestPath, 'utf8')));
+    }
+    catch {
+        return true;
+    }
+}

package/dist/esm/init/initCommand.js

@@ -1,8 +1,9 @@
-import { printError, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
+import { printError, printSkip, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { hasPackageJson, isGitRepo, usesPnpm } from "./checks.js";
 import { detectRepoType } from "./detectRepoType.js";
-import { scaffoldFiles } from "./scaffold.js";
+import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
+import { PUBLISHING_WORKFLOW_PATHS, scaffoldFiles } from "./scaffold.js";
 export function checkEligibility(styles) {
     printStep('Checking eligibility');
     if (!runRequiredCheck('Git repository detected', isGitRepo(), styles))
@@ -37,10 +38,16 @@ export function initCommand({ dryRun, force, styles, withConfig }) {
         return 1;
     }
     printSuccess(`Detected: ${repoType}`, styles.stdout);
+    const publishable = hasPublishablePackage();
     printStep('Scaffolding files');
+    if (!publishable) {
+        for (const filePath of PUBLISHING_WORKFLOW_PATHS) {
+            printSkip(formatPrivateWorkflowSkip(filePath), styles.stdout);
+        }
+    }
     let results;
     try {
-        results = scaffoldFiles({ repoType, dryRun, overwrite: force, withConfig });
+        results = scaffoldFiles({ repoType, dryRun, overwrite: force, publishable, withConfig });
     }
     catch (error) {
         printError(`Failed to scaffold files: ${describeError(error)}`, styles.stderr);
@@ -53,18 +60,21 @@ export function initCommand({ dryRun, force, styles, withConfig }) {
         return 1;
     }
     printStep('Next steps');
-    const configHint = withConfig
-        ? '1. (Optional) Customize .config/release-kit.config.ts.'
-        : '1. (Optional) Run again with --with-config to scaffold config files.';
-    console.info(`
-  ${configHint}
-  2. If this is a private repo, remove provenance: true from .github/workflows/publish.yaml.
-  3. Test by running: npx @williamthorsen/release-kit prepare --dry-run
-  4. Commit the generated files.
-  5. Register each package as a trusted publisher on npmjs.com.
-`);
+    console.info(`\n${formatNextSteps({ publishable, withConfig })}\n`);
     return 0;
 }
+function formatNextSteps({ publishable, withConfig }) {
+    const steps = [
+        withConfig
+            ? '(Optional) Customize .config/release-kit.config.ts.'
+            : '(Optional) Run again with --with-config to scaffold config files.',
+        ...(publishable ? ['If this is a private repo, remove provenance: true from .github/workflows/publish.yaml.'] : []),
+        'Test by running: npx @williamthorsen/release-kit prepare --dry-run',
+        'Commit the generated files.',
+        ...(publishable ? ['Register each package as a trusted publisher on npmjs.com.'] : []),
+    ];
+    return steps.map((step, index) => `  ${String(index + 1)}. ${step}`).join('\n');
+}
 function runRequiredCheck(label, result, styles) {
     if (result.ok) {
         printSuccess(label, styles.stdout);

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

@@ -4,8 +4,13 @@ interface ScaffoldOptions {
     repoType: RepoType;
     dryRun: boolean;
     overwrite: boolean;
+    publishable: boolean;
     withConfig: boolean;
 }
+export declare const CREATE_GITHUB_RELEASE_WORKFLOW_PATH = ".github/workflows/create-github-release.yaml";
+export declare const PUBLISH_WORKFLOW_PATH = ".github/workflows/publish.yaml";
+/** The workflows that act only on publishable packages, which a repo whose packages are all private does not get. */
+export declare const PUBLISHING_WORKFLOW_PATHS: readonly [".github/workflows/create-github-release.yaml", ".github/workflows/publish.yaml"];
 /** Scaffolds release-kit files for the target repo, returning a result for each file attempted. */
-export declare function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }: ScaffoldOptions): WriteResult[];
+export declare function scaffoldFiles({ repoType, dryRun, overwrite, publishable, withConfig, }: ScaffoldOptions): WriteResult[];
 export {};

package/dist/esm/init/scaffold.js

@@ -1,14 +1,17 @@
 import { writeFileWithCheck } from '@williamthorsen/nmr-core';
 import { createGithubReleaseWorkflow, publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
-export function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
-    const results = [
-        writeFileWithCheck('.github/workflows/create-github-release.yaml', createGithubReleaseWorkflow(repoType), {
+export const CREATE_GITHUB_RELEASE_WORKFLOW_PATH = '.github/workflows/create-github-release.yaml';
+export const PUBLISH_WORKFLOW_PATH = '.github/workflows/publish.yaml';
+export const PUBLISHING_WORKFLOW_PATHS = [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH];
+export function scaffoldFiles({ repoType, dryRun, overwrite, publishable, withConfig, }) {
+    const results = [];
+    if (publishable) {
+        results.push(writeFileWithCheck(CREATE_GITHUB_RELEASE_WORKFLOW_PATH, createGithubReleaseWorkflow(repoType), {
             dryRun,
             overwrite,
-        }),
-        writeFileWithCheck('.github/workflows/publish.yaml', publishWorkflow(repoType), { dryRun, overwrite }),
-        writeFileWithCheck('.github/workflows/release.yaml', releaseWorkflow(repoType), { dryRun, overwrite }),
-    ];
+        }), writeFileWithCheck(PUBLISH_WORKFLOW_PATH, publishWorkflow(repoType), { dryRun, overwrite }));
+    }
+    results.push(writeFileWithCheck('.github/workflows/release.yaml', releaseWorkflow(repoType), { dryRun, overwrite }));
     if (withConfig) {
         results.push(writeFileWithCheck('.config/release-kit.config.ts', releaseConfigScript(repoType), { dryRun, overwrite }));
     }

package/dist/esm/init/templates.js

@@ -89,7 +89,7 @@ on:
   workflow_dispatch:
     inputs:
       only:
-        description: 'Workspaces to release (comma-separated, leave empty for all)'
+        description: 'Workspaces to release, with their dependents (comma-separated, leave empty for all)'
         required: false
         type: string
       bump:

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

@@ -7,7 +7,8 @@ interface UpdateTemplatesOptions {
  * Runs the `release-kit update-templates` command and returns the process exit code.
  *
  * Brings each workflow that release-kit scaffolds up to date with the installed templates. The opt-in
- * `sync-labels.yaml` is refreshed only when it exists, and config files are never read or written.
+ * `sync-labels.yaml` is refreshed only when it exists, as are the publishing workflows in a repo whose packages are
+ * all private. Config files are never read or written.
  */
 export declare function updateTemplatesCommand({ dryRun, styles }: UpdateTemplatesOptions): number;
 export {};

package/dist/esm/init/updateTemplatesCommand.js

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { printError, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
+import { printError, printSkip, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { syncLabelsWorkflow } from "../sync-labels/templates.js";
 import { detectRepoType } from "./detectRepoType.js";
 import { hasProvenance } from "./hasProvenance.js";
+import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
 import { checkEligibility } from "./initCommand.js";
+import { CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH, PUBLISHING_WORKFLOW_PATHS } from "./scaffold.js";
 import { createGithubReleaseWorkflow, publishWorkflow, releaseWorkflow } from "./templates.js";
-const PUBLISH_WORKFLOW_PATH = '.github/workflows/publish.yaml';
 const SYNC_LABELS_WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
 export function updateTemplatesCommand({ dryRun, styles }) {
     if (dryRun) {
@@ -35,7 +36,11 @@ export function updateTemplatesCommand({ dryRun, styles }) {
     printStep('Updating workflows');
     let results;
     try {
-        results = buildManagedFiles(repoType).map(([filePath, content]) => updateManagedFile(filePath, content, { dryRun }));
+        const { files, skipped } = buildManagedFiles(repoType, hasPublishablePackage());
+        for (const filePath of skipped) {
+            printSkip(formatPrivateWorkflowSkip(filePath), styles.stdout);
+        }
+        results = files.map(([filePath, content]) => updateManagedFile(filePath, content, { dryRun }));
     }
     catch (error) {
         printError(`Failed to render workflows: ${describeError(error)}`, styles.stderr);
@@ -46,16 +51,17 @@ export function updateTemplatesCommand({ dryRun, styles }) {
     }
     return results.some((result) => result.outcome === 'failed') ? 1 : 0;
 }
-function buildManagedFiles(repoType) {
+function buildManagedFiles(repoType, publishable) {
+    const skipped = publishable ? [] : PUBLISHING_WORKFLOW_PATHS.filter((filePath) => !existsSync(filePath));
     const files = [
-        ['.github/workflows/create-github-release.yaml', createGithubReleaseWorkflow(repoType)],
+        [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, createGithubReleaseWorkflow(repoType)],
         [PUBLISH_WORKFLOW_PATH, publishWorkflow(repoType, { provenance: readProvenanceSetting() })],
         ['.github/workflows/release.yaml', releaseWorkflow(repoType)],
     ];
     if (existsSync(SYNC_LABELS_WORKFLOW_PATH)) {
         files.push([SYNC_LABELS_WORKFLOW_PATH, syncLabelsWorkflow()]);
     }
-    return files;
+    return { files: files.filter(([filePath]) => !skipped.includes(filePath)), skipped };
 }
 function readProvenanceSetting() {
     if (!existsSync(PUBLISH_WORKFLOW_PATH))

package/dist/esm/isPublishableManifest.d.ts

@@ -0,0 +1,2 @@
+/** Reports whether a parsed `package.json` can be published: its `private` field is absent or `false`. */
+export declare function isPublishableManifest(manifest: unknown): boolean;

package/dist/esm/isPublishableManifest.js

@@ -0,0 +1,5 @@
+import { isRecord } from "./typeGuards.js";
+export function isPublishableManifest(manifest) {
+    const privateField = isRecord(manifest) ? manifest['private'] : undefined;
+    return privateField === undefined || privateField === false;
+}

package/dist/esm/matchesTagPrefix.d.ts

@@ -0,0 +1,2 @@
+/** Checks whether a tag name is one of the prefixes followed by a complete SemVer version. */
+export declare function matchesTagPrefix(tagName: string, tagPrefixes: readonly string[]): boolean;

package/dist/esm/matchesTagPrefix.js

@@ -0,0 +1,4 @@
+const SEMVER_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+export function matchesTagPrefix(tagName, tagPrefixes) {
+    return tagPrefixes.some((prefix) => tagName.startsWith(prefix) && SEMVER_VERSION_PATTERN.test(tagName.slice(prefix.length)));
+}

package/dist/esm/npmRegistry.d.ts

@@ -0,0 +1,35 @@
+export declare const AUTH_ERROR_CODES: ReadonlySet<string>;
+export declare const UNREACHABLE_ERROR_CODES: ReadonlySet<string>;
+/**
+ * Classifies the outcome of `npm view <package> version --json`.
+ *
+ * Only `E404` means that the registry doesn't know the package; any other failure leaves the question open.
+ */
+export declare function classifyNpmPackageLookup(result: NpmCommandResult): NpmPackageLookup;
+/** Looks up whether a package exists on the npm registry, querying `registry` when one is given. */
+export declare function lookUpNpmPackage(packageName: string, registry?: string): NpmPackageLookup;
+export interface NpmCommandResult {
+    exitOk: boolean;
+    stdout: string;
+}
+export interface NpmErrorPayload {
+    code: string;
+    summary: string;
+}
+export type NpmPackageLookup = {
+    status: 'published';
+} | {
+    status: 'unpublished';
+} | {
+    status: 'unverifiable';
+    detail: string;
+};
+/** Reads npm's `--json` error envelope, which npm writes to stdout on both the success and failure paths. */
+export declare function readNpmError(stdout: string): NpmErrorPayload | undefined;
+/**
+ * Runs npm with the given arguments, capturing stdout whether or not the command exits zero.
+ *
+ * The arguments are expected to include `--json`: npm writes its machine-readable error envelope to stdout,
+ * which `execFileSync` attaches to the thrown error instead of returning it.
+ */
+export declare function runNpmJson(args: readonly string[]): NpmCommandResult;

package/dist/esm/npmRegistry.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'node:child_process';
+import { isRecord } from "./typeGuards.js";
+export const AUTH_ERROR_CODES = new Set(['E401', 'ENEEDAUTH']);
+export const UNREACHABLE_ERROR_CODES = new Set([
+    'EAI_AGAIN',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'ENETUNREACH',
+    'ENOTFOUND',
+    'ERR_SOCKET_TIMEOUT',
+    'ETIMEDOUT',
+]);
+export function classifyNpmPackageLookup(result) {
+    if (result.exitOk) {
+        return { status: 'published' };
+    }
+    const error = readNpmError(result.stdout);
+    if (error === undefined) {
+        return { status: 'unverifiable', detail: 'The npm registry query failed without a readable error payload' };
+    }
+    if (error.code === 'E404') {
+        return { status: 'unpublished' };
+    }
+    if (AUTH_ERROR_CODES.has(error.code)) {
+        return { status: 'unverifiable', detail: `The npm registry rejected the session (${error.code})` };
+    }
+    if (UNREACHABLE_ERROR_CODES.has(error.code)) {
+        return { status: 'unverifiable', detail: `Cannot reach the npm registry (${error.code})` };
+    }
+    return { status: 'unverifiable', detail: `The npm registry query failed (${error.code}): ${error.summary}` };
+}
+export function lookUpNpmPackage(packageName, registry) {
+    const args = ['view', packageName, 'version', '--json', ...(registry === undefined ? [] : ['--registry', registry])];
+    return classifyNpmPackageLookup(runNpmJson(args));
+}
+export function readNpmError(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(parsed) || !isRecord(parsed['error']) || typeof parsed['error']['code'] !== 'string') {
+        return undefined;
+    }
+    const { code, summary } = parsed['error'];
+    return { code, summary: typeof summary === 'string' ? summary : '' };
+}
+export function runNpmJson(args) {
+    try {
+        return { exitOk: true, stdout: execFileSync('npm', args, { encoding: 'utf8', stdio: 'pipe' }) };
+    }
+    catch (error) {
+        const stdout = isRecord(error) && typeof error['stdout'] === 'string' ? error['stdout'] : '';
+        return { exitOk: false, stdout };
+    }
+}

package/dist/esm/prepareCommand.d.ts

@@ -43,6 +43,7 @@ export declare function parseArgs(argv: string[]): {
     noGitChecks: boolean;
     bumpOverride: ReleaseType | undefined;
     only: string[] | undefined;
+    /** The raw `--set-version` value, whose accepted form depends on the mode. */
     setVersion: string | undefined;
     withReleaseNotes: boolean;
 };

package/dist/esm/prepareCommand.js

@@ -2,12 +2,10 @@ import { execSync } from 'node:child_process';
 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 { assertReleasesOnNpm } from "./assertReleasesOnNpm.js";
 import { configFlagSchema } from "./configFlagSchema.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
-import { getAllTagPrefixes } from "./generateChangelogs.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.js";
 import { loadValidatedConfig, reportConfigProblem, reportConfigWarnings } from "./loadValidatedConfig.js";
@@ -17,7 +15,6 @@ import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
-import { validateOnlyExcludesStrandedDependents } from "./validateOnlyExcludesStrandedDependents.js";
 const VALID_BUMP_TYPES = ['major', 'minor', 'patch'];
 const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
 function isReleaseType(value) {
@@ -47,26 +44,10 @@ export function parseArgs(argv) {
         }
         bumpOverride = flags.bump;
     }
-    let setVersion;
-    if (flags.setVersion !== undefined) {
-        if (!CANONICAL_SEMVER_PATTERN.test(flags.setVersion)) {
-            reportError(`Invalid --set-version value "${flags.setVersion}". Must be canonical semver (N.N.N, no pre-release suffix).`);
-            process.exit(1);
-        }
-        setVersion = flags.setVersion;
-    }
     let only;
     if (flags.only !== undefined) {
         only = flags.only.split(',');
     }
-    if (setVersion !== undefined && bumpOverride !== undefined) {
-        reportError('--set-version cannot be combined with --bump');
-        process.exit(1);
-    }
-    if (setVersion !== undefined && flags.force) {
-        reportError('--set-version cannot be combined with --force');
-        process.exit(1);
-    }
     return {
         configPath: flags.config,
         dryRun: flags.dryRun,
@@ -74,7 +55,7 @@ export function parseArgs(argv) {
         noGitChecks: flags.noGitChecks,
         bumpOverride,
         only,
-        setVersion,
+        setVersion: flags.setVersion,
         withReleaseNotes: flags.withReleaseNotes,
     };
 }
@@ -83,7 +64,6 @@ export async function prepareCommand(argv, styles, invocationDir) {
     const options = {
         force,
         ...(bumpOverride !== undefined && { bumpOverride }),
-        ...(setVersion !== undefined && { setVersion }),
         ...(withReleaseNotes && { withReleaseNotes: true }),
     };
     if (dryRun) {
@@ -121,19 +101,27 @@ export async function prepareCommand(argv, styles, invocationDir) {
         process.exit(1);
     }
     if (workspace.kind === 'single-package') {
-        runSinglePackageMode(userConfig, options, only, dryRun, styles.stdout);
+        runSinglePackageMode(userConfig, options, only, setVersion, dryRun, styles.stdout);
     }
     else {
         runMonorepoMode(workspace.packageDirs, userConfig, options, only, setVersion, dryRun, styles.stdout);
     }
 }
-function runSinglePackageMode(userConfig, options, only, dryRun, style) {
+function runSinglePackageMode(userConfig, options, only, setVersion, dryRun, style) {
     if (only !== undefined) {
         reportError('--only is only supported for monorepo configurations');
         process.exit(1);
     }
+    if (setVersion !== undefined && !CANONICAL_SEMVER_PATTERN.test(setVersion)) {
+        reportError(`Invalid --set-version value "${setVersion}". Must be canonical semver (N.N.N, no pre-release suffix).`);
+        process.exit(1);
+    }
     const config = mergeSinglePackageConfig(userConfig);
-    runAndReport(() => releasePrepare(config, options), dryRun, style);
+    runAndReport(() => {
+        const plan = releasePrepare(config, { ...options, ...(setVersion !== undefined && { setVersion }) });
+        assertReleasesOnNpm(plan.workspaces.some((result) => result.status === 'released') ? ['.'] : []);
+        return plan;
+    }, dryRun, style);
 }
 function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion, dryRun, style) {
     let config;
@@ -147,53 +135,56 @@ function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion,
     }
     if (setVersion !== undefined && config.project !== undefined) {
         reportError('--set-version cannot be combined with a project release. ' +
-            '--set-version operates on a single workspace; a project release rolls up every ' +
+            "--set-version sets individual workspaces' versions; a project release rolls up every " +
             'contributing workspace. To use --set-version, run on a config without a `project` block.');
         process.exit(1);
     }
-    let configuredWorkspaceDirs;
-    if (only !== undefined) {
-        const knownNames = config.workspaces.map((w) => w.dir);
-        for (const name of only) {
-            if (knownNames.includes(name)) {
-                continue;
-            }
-            reportError(`Unknown workspace "${name}". Known workspaces: ${knownNames.join(', ')}`);
-            process.exit(1);
+    const knownNames = config.workspaces.map((w) => w.dir);
+    const onlyNames = only ?? [];
+    for (const name of onlyNames) {
+        if (knownNames.includes(name)) {
+            continue;
         }
-        const graph = buildDependencyGraph(config.workspaces);
-        const violations = validateOnlyExcludesStrandedDependents(config.workspaces, only, graph, (workspace) => {
-            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.');
-            process.stderr.write('The following packages must be added to --only or have their dependencies removed:\n');
-            for (const violation of violations) {
-                const since = violation.tag ?? 'the beginning';
-                process.stderr.write(`  - ${violation.dir} (downstream of ${violation.downstreamOf}; has commits since ${since})\n`);
-            }
-            process.stderr.write('Alternatively, run `release-kit prepare` without --only to release everything.\n');
+        reportError(`Unknown workspace "${name}". Known workspaces: ${knownNames.join(', ')}`);
+        process.exit(1);
+    }
+    const monorepoOptions = {
+        ...options,
+        ...(only !== undefined && { only }),
+        ...(setVersion !== undefined && { setVersions: parseSetVersions(setVersion, knownNames) }),
+    };
+    runAndReport(() => {
+        const plan = releasePrepareMono(config, monorepoOptions);
+        assertReleasesOnNpm(findReleasedWorkspacePaths(plan, config.workspaces));
+        return plan;
+    }, dryRun, style);
+}
+function findReleasedWorkspacePaths(plan, workspaces) {
+    const releasedDirs = new Set(plan.workspaces.flatMap((result) => result.status === 'released' && result.name !== undefined ? [result.name] : []));
+    return workspaces.filter((workspace) => releasedDirs.has(workspace.dir)).map((workspace) => workspace.workspacePath);
+}
+function parseSetVersions(value, knownNames) {
+    const setVersions = new Map();
+    for (const entry of value.split(',')) {
+        const separatorIndex = entry.lastIndexOf('@');
+        const name = entry.slice(0, Math.max(0, separatorIndex));
+        const version = entry.slice(separatorIndex + 1);
+        if (separatorIndex <= 0 || !CANONICAL_SEMVER_PATTERN.test(version)) {
+            reportError(`Invalid --set-version entry "${entry}". In monorepo mode, each entry must be <workspace>@N.N.N ` +
+                '(canonical semver, no pre-release suffix), e.g. --set-version=arrays@1.0.0.');
             process.exit(1);
         }
-        configuredWorkspaceDirs = knownNames;
-        config.workspaces = config.workspaces.filter((w) => only.includes(w.dir));
-    }
-    if (setVersion !== undefined) {
-        if (only === undefined) {
-            reportError('--set-version requires --only in monorepo mode');
+        if (!knownNames.includes(name)) {
+            reportError(`Unknown workspace "${name}" in --set-version. Known workspaces: ${knownNames.join(', ')}`);
             process.exit(1);
         }
-        if (config.workspaces.length !== 1) {
-            reportError(`--set-version requires --only to match exactly one workspace; matched ${config.workspaces.length}`);
+        if (setVersions.has(name)) {
+            reportError(`--set-version names workspace "${name}" more than once`);
             process.exit(1);
         }
+        setVersions.set(name, version);
     }
-    runAndReport(() => releasePrepareMono(config, {
-        ...options,
-        ...(only !== undefined && { only }),
-        ...(configuredWorkspaceDirs !== undefined && { configuredWorkspaceDirs }),
-    }), dryRun, style);
+    return setVersions;
 }
 function runAndReport(computePlan, dryRun, style) {
     let plan;