@williamthorsen/release-kit 10.2.1 → 10.2.2

package/.readyup/kits/default.js

@@ -52,7 +52,7 @@ function detectRepoType() {
 
 // .readyup/kits/default.ts
 function getMinVersion() {
-  const picked = { "version": "10.2.1" };
+  const picked = { "version": "10.2.2" };
   if (typeof picked.version !== "string") {
     throw new TypeError("release-kit/package.json: 'version' must be a string");
   }

package/.readyup/kits/npm-auto-publish.js

@@ -7,7 +7,11 @@ export const __readyupVersion = "0.23.0";
 import { execSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { defineRdyChecklist, defineRdyKit, defineRdyStagedChecklist } from "readyup";
+import {
+  defineRdyChecklist,
+  defineRdyKit,
+  defineRdyStagedChecklist
+} from "readyup";
 import {
   discoverWorkspaces,
   fileContains,
@@ -17,7 +21,17 @@ import {
   readFile,
   readJsonFile
 } from "readyup/check-utils";
+var AUTH_ERROR_CODES = /* @__PURE__ */ new Set(["E401", "ENEEDAUTH"]);
 var PUBLISH_WORKFLOW_FILE = "publish.yaml";
+var UNREACHABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "ERR_SOCKET_TIMEOUT",
+  "ETIMEDOUT"
+]);
 var repoChecklist = defineRdyStagedChecklist({
   name: "repo",
   preconditions: [
@@ -62,6 +76,16 @@ var packagesChecklist = defineRdyChecklist({
       name: "At least one workspace discovered",
       check: () => discoverWorkspaces().length > 0,
       fix: "Ensure pnpm-workspace.yaml lists package globs, or that a root package.json exists"
+    },
+    {
+      name: "npm session is usable",
+      check: () => {
+        const auth = getCachedNpmAuthStatus();
+        return auth.status === "authenticated" ? { ok: true } : { ok: false, detail: auth.detail };
+      },
+      get fix() {
+        return getCachedNpmAuthStatus().status === "unreachable" ? "Restore access to the npm registry, then re-run; the trusted-publisher check queries it directly" : "Log in to npm: npm login";
+      }
     }
   ],
   get checks() {
@@ -100,7 +124,7 @@ function buildWorkspaceCheck(workspace) {
       checks: [
         {
           name: "trusted publisher configured",
-          check: () => hasTrustedPublisher(displayName, getCachedOwnerRepo(), PUBLISH_WORKFLOW_FILE),
+          check: () => checkTrustedPublisher(displayName),
           get fix() {
             return `Run: npm trust github ${displayName} --repo ${getCachedOwnerRepo()} --file ${PUBLISH_WORKFLOW_FILE}`;
           }
@@ -148,6 +172,76 @@ function checkProvenanceMatchesVisibility() {
   }
   return { ok: true };
 }
+function checkTrustedPublisher(packageName) {
+  const result = classifyTrustQuery(
+    runNpmJson(`npm trust list ${packageName} --json`),
+    getCachedOwnerRepo(),
+    PUBLISH_WORKFLOW_FILE
+  );
+  switch (result.status) {
+    case "configured":
+      return { ok: true };
+    case "not-configured":
+      return { ok: false, detail: "No trusted publisher is configured for this package" };
+    default:
+      return { ok: false, detail: result.detail };
+  }
+}
+function classifyNpmAuth(result) {
+  if (result.exitOk) {
+    return { status: "authenticated" };
+  }
+  const error = readNpmError(result.stdout);
+  if (error === void 0) {
+    return { status: "unreachable", detail: "The npm registry query failed without a readable error payload" };
+  }
+  if (AUTH_ERROR_CODES.has(error.code)) {
+    return { status: "unauthenticated", detail: `The npm registry rejected the session (${error.code})` };
+  }
+  if (UNREACHABLE_ERROR_CODES.has(error.code)) {
+    return { status: "unreachable", detail: `Cannot reach the npm registry (${error.code})` };
+  }
+  return { status: "unreachable", detail: `The npm registry query failed (${error.code}): ${error.summary}` };
+}
+function classifyTrustQuery(result, expectedRepo, expectedFile) {
+  if (!result.exitOk) {
+    const error = readNpmError(result.stdout);
+    if (error === void 0) {
+      return { status: "error", detail: "The npm trust query failed without a readable error payload" };
+    }
+    if (error.code === "E404") {
+      return { status: "not-configured" };
+    }
+    return { status: "error", detail: `The npm trust query failed (${error.code}): ${error.summary}` };
+  }
+  const relationships = readTrustRelationships(result.stdout);
+  if (relationships === void 0) {
+    return { status: "error", detail: "The npm trust query returned a payload this check cannot read" };
+  }
+  if (relationships.length === 0) {
+    return { status: "not-configured" };
+  }
+  const isMatch = relationships.some(
+    (relationship) => relationship.type === "github" && relationship.repository === expectedRepo && relationship.file === expectedFile
+  );
+  return isMatch ? { status: "configured" } : {
+    status: "mismatched",
+    detail: `Expected github ${expectedRepo} (${expectedFile}); found ${describeTrustRelationships(relationships)}`
+  };
+}
+function describeTrustRelationships(relationships) {
+  return relationships.map((relationship) => {
+    const type = typeof relationship.type === "string" ? relationship.type : "(unknown)";
+    const repository = typeof relationship.repository === "string" ? relationship.repository : "(unknown)";
+    const file = typeof relationship.file === "string" ? relationship.file : "(unknown)";
+    return `${type} ${repository} (${file})`;
+  }).join(", ");
+}
+var cachedNpmAuthStatus;
+function getCachedNpmAuthStatus() {
+  cachedNpmAuthStatus ??= classifyNpmAuth(runNpmJson("npm whoami --json"));
+  return cachedNpmAuthStatus;
+}
 var cachedOwnerRepo;
 function getCachedOwnerRepo() {
   if (cachedOwnerRepo === void 0) {
@@ -183,27 +277,6 @@ function hasTokenReferences() {
   }
   return false;
 }
-function hasTrustedPublisher(packageName, expectedRepo, expectedFile) {
-  let output;
-  try {
-    output = execSync(`npm trust list ${packageName} --json`, {
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-  } catch {
-    return false;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(output);
-  } catch {
-    return false;
-  }
-  if (!isRecord(parsed)) {
-    return false;
-  }
-  return parsed.type === "github" && parsed.repository === expectedRepo && parsed.file === expectedFile;
-}
 function isPublishedToNpm(packageName) {
   try {
     execSync(`npm view ${packageName} version`, {
@@ -225,11 +298,50 @@ function isRepoPrivate() {
 function parseProvenanceSetting(workflowContent) {
   return /^[^#]*provenance:\s*['"]?true['"]?/im.test(workflowContent);
 }
+function readNpmError(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.error) || typeof parsed.error.code !== "string") {
+    return void 0;
+  }
+  const { code, summary } = parsed.error;
+  return { code, summary: typeof summary === "string" ? summary : "" };
+}
+function readTrustRelationships(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+  if (Array.isArray(parsed)) {
+    return parsed.filter((entry) => isRecord(entry) && "type" in entry);
+  }
+  if (!isRecord(parsed)) {
+    return void 0;
+  }
+  return "type" in parsed ? [parsed] : [];
+}
+function runNpmJson(command) {
+  try {
+    return { exitOk: true, stdout: execSync(command, { encoding: "utf8", stdio: "pipe" }) };
+  } catch (error) {
+    const stdout = isRecord(error) && typeof error.stdout === "string" ? error.stdout : "";
+    return { exitOk: false, stdout };
+  }
+}
 function skipIfNotPublishable(workspace) {
   return workspace.isPackage ? false : "package.json#private is true";
 }
 export {
   buildWorkspaceCheck,
+  classifyNpmAuth,
+  classifyTrustQuery,
   npm_auto_publish_default as default,
+  packagesChecklist,
   skipIfNotPublishable
 };

package/.readyup/manifest.json

@@ -10,7 +10,7 @@
       "readyupVersion": "0.23.0",
       "source": "kits/default.ts",
       "sourceHash": "afe26920",
-      "targetHash": "5ac6d830"
+      "targetHash": "fecaa9b1"
     },
     {
       "checklists": [
@@ -21,8 +21,8 @@
       "path": "kits/npm-auto-publish.js",
       "readyupVersion": "0.23.0",
       "source": "kits/npm-auto-publish.ts",
-      "sourceHash": "71e894e6",
-      "targetHash": "c1c05255"
+      "sourceHash": "5b58afac",
+      "targetHash": "610ed8a7"
     }
   ]
 }

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file.
 
+## 10.2.2 — 2026-08-05
+
+### 🐛 Bug fixes
+
+- Report the missing npm login once, not per package (#598)
+
+  Fixes an issue where running release-kit's publish-readiness checks without an npm login reported a trusted-publisher failure for every published package. The missing login is now reported once, with `npm login` as the fix. An unreachable registry now has its own check. The trusted publisher check produces more informative failure messages.
+
+- Make prepare all-or-nothing and report the tags file by path (#601)
+
+  Fixes an issue where a failed `prepare` could leave the release flow in a broken intermediate state. A release now lands completely or not at all, and a formatting failure no longer discards one that already landed. When a write fails partway, the error names every file that reached disk, every file that did not, and the commands that undo them.
+
+  `commit` and `tag` now report the full path of the tags file they looked for, and distinguish a missing file from one that could not be read, so that running from the wrong directory or worktree is no longer reported as a release that never happened.
+
+  Runs with `--with-release-notes` now list the preview files they write, and `--dry-run` names the ones a real run would write.
+
+### 🧪 Tests
+
+- Clear the deferred vitest test rules and enforce them (#602)
+
+  Fixes a subset of previously deferred lint violations and restores the severity of Vitest lint rules to "error" for purposes strict linting.
+
 ## 10.2.1 — 2026-08-04
 
 ### 🐛 Bug fixes

package/README.md

@@ -5,13 +5,21 @@ Version-bumping and changelog-generation toolkit for release workflows.
 Provides a self-contained CLI that auto-discovers workspaces from `pnpm-workspace.yaml`, parses conventional commits, determines version bumps, updates `package.json` files, and generates changelogs from `git-cliff --context` output rendered in-process (with optional [editorial overrides](#editorial-overrides)).
 
 <!-- section:release-notes -->
-## Release notes — v10.2.1 (2026-08-04)
+## Release notes — v10.2.2 (2026-08-05)
 
 ### 🐛 Bug fixes
 
-- Remove the 1 MiB ceiling on captured git output (#596)
+- Report the missing npm login once, not per package (#598)
 
-  Fixes an issue where `release-kit prepare` began aborting once a repository's release history grew long enough, leaving that repository unable to cut another release. The fix covers, in addition to `prepare`, every other release-kit command that reads from git.
+  Fixes an issue where running release-kit's publish-readiness checks without an npm login reported a trusted-publisher failure for every published package. The missing login is now reported once, with `npm login` as the fix. An unreachable registry now has its own check. The trusted publisher check produces more informative failure messages.
+
+- Make prepare all-or-nothing and report the tags file by path (#601)
+
+  Fixes an issue where a failed `prepare` could leave the release flow in a broken intermediate state. A release now lands completely or not at all, and a formatting failure no longer discards one that already landed. When a write fails partway, the error names every file that reached disk, every file that did not, and the commands that undo them.
+  
+  `commit` and `tag` now report the full path of the tags file they looked for, and distinguish a missing file from one that could not be read, so that running from the wrong directory or worktree is no longer reported as a release that never happened.
+  
+  Runs with `--with-release-notes` now list the preview files they write, and `--dry-run` names the ones a real run would write.
 <!-- /section:release-notes -->
 
 ## Installation
@@ -890,6 +898,8 @@ rdy list --from npm:@williamthorsen/release-kit                  # what release-
 
 `--packages` is the form that survives release-kit publishing further kits. Every form needs `readyup` 0.23 or later, and `@williamthorsen/release-kit` as a _direct_ devDependency: a strict pnpm layout links nothing else into the project, so a transitive copy is unreachable.
 
+`npm-auto-publish` queries the npm registry for each package's trusted publisher, so it needs an authenticated npm session and is meant to be invoked deliberately rather than swept up by an unattended run. Without a login it reports one error naming the missing login and blocks the rest of the `packages` checklist, rather than reporting a trusted-publisher failure for every package.
+
 These kits are no longer reachable through `rdy run --from github:williamthorsen/node-monorepo-tools`. Repos still using that form should switch to one of the invocations above.
 
 ## External dependencies

package/dist/esm/buildChangelogEntries.js

@@ -79,7 +79,7 @@ function transformReleases(releases, devOnlySections) {
             continue;
         }
         const version = extractVersion(release.version);
-        const date = release.timestamp !== undefined ? new Date(release.timestamp * 1000).toISOString().slice(0, 10) : 'unreleased';
+        const date = release.timestamp !== undefined ? new Date(release.timestamp * 1_000).toISOString().slice(0, 10) : 'unreleased';
         const sectionMap = new Map();
         for (const commit of release.commits ?? []) {
             const group = stripCommentPrefix(commit.group ?? 'Other');

package/dist/esm/buildReleaseSummary.d.ts

@@ -1,2 +1,2 @@
 import type { PrepareResult } from './types.js';
-export declare function buildReleaseSummary(result: PrepareResult): string;
+export declare function buildReleaseSummary(result: Pick<PrepareResult, 'project' | 'workspaces'>): string;

package/dist/esm/changelogJsonFile.d.ts

@@ -1,6 +1,4 @@
 import type { ChangelogEntry, ReleaseConfig } from './types.js';
 export declare function resolveChangelogJsonPath(config: Pick<ReleaseConfig, 'changelogJson'>, changelogPath: string): string;
-export declare function writeChangelogJson(filePath: string, entries: ChangelogEntry[]): string;
-export declare function upsertChangelogJson(filePath: string, entries: ChangelogEntry[]): string;
-export declare function upsertChangelogJsonAndReturn(filePath: string, entries: ChangelogEntry[]): ChangelogEntry[];
+export declare function renderChangelogJson(entries: ChangelogEntry[]): string;
 export declare function mergeChangelogEntriesWithDisk(filePath: string, entries: ChangelogEntry[]): ChangelogEntry[];

package/dist/esm/changelogJsonFile.js

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import stringify from 'json-stringify-pretty-compact';
 import semver from 'semver';
 import { isChangelogEntry } from "./changelogJsonUtils.js";
@@ -7,22 +7,8 @@ import { isUnknownArray } from "./typeGuards.js";
 export function resolveChangelogJsonPath(config, changelogPath) {
     return join(changelogPath, config.changelogJson.outputPath);
 }
-export function writeChangelogJson(filePath, entries) {
-    const sorted = sortNewestFirst(entries);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, stringify(sorted, { maxLength: 100 }) + '\n', 'utf8');
-    return filePath;
-}
-export function upsertChangelogJson(filePath, entries) {
-    upsertChangelogJsonAndReturn(filePath, entries);
-    return filePath;
-}
-export function upsertChangelogJsonAndReturn(filePath, entries) {
-    const existing = readExistingEntries(filePath);
-    const merged = mergeEntries(entries, existing);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, stringify(merged, { maxLength: 100 }) + '\n', 'utf8');
-    return merged;
+export function renderChangelogJson(entries) {
+    return stringify(sortNewestFirst(entries), { maxLength: 100 }) + '\n';
 }
 export function mergeChangelogEntriesWithDisk(filePath, entries) {
     const existing = readExistingEntries(filePath);

package/dist/esm/commitCommand.js

@@ -1,25 +1,15 @@
 import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { GIT_OUTPUT_LIMIT, parseArgsOrExit } from '@williamthorsen/nmr-core';
-import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./prepareCommand.js";
+import { readReleaseTags, RELEASE_SUMMARY_FILE, resolveReleaseTagsPath } from "./releaseFiles.js";
 const commitFlagSchema = {
     dryRun: { long: '--dry-run', type: 'boolean' },
 };
 export function commitCommand(argv) {
     const dryRun = parseArgsOrExit(argv, commitFlagSchema).flags.dryRun;
-    let tagsContent;
-    try {
-        tagsContent = readFileSync(RELEASE_TAGS_FILE, 'utf8');
-    }
-    catch {
-        throw new Error('No tags file found. Run `release-kit prepare` first.');
-    }
-    const tags = tagsContent
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
+    const tags = readReleaseTags();
     if (tags.length === 0) {
-        throw new Error('Tags file is empty. Run `release-kit prepare` first.');
+        throw new Error(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);
     }
     let summary = '';
     try {

package/dist/esm/createTags.js

@@ -1,21 +1,10 @@
 import { execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
 import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
 import { deleteFileIfExists } from "./deleteFileIfExists.js";
-import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./prepareCommand.js";
+import { readReleaseTags, RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 export function createTags(options) {
     const { dryRun, noGitChecks } = options;
-    let content;
-    try {
-        content = readFileSync(RELEASE_TAGS_FILE, 'utf8');
-    }
-    catch {
-        throw new Error('No tags file found. Run `release-kit prepare` first.');
-    }
-    const tags = content
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
+    const tags = readReleaseTags();
     if (tags.length === 0) {
         return [];
     }

package/dist/esm/injectReleaseNotesIntoReadme.d.ts

@@ -1,7 +1,9 @@
+import type { ChangelogEntry } from './types.js';
 export interface RenderedInjectedReadme {
     injectedReadme: string;
     releaseNotesMarkdown: string;
 }
+export declare function renderInjectedReadmeFromEntries(readme: string, entries: readonly ChangelogEntry[], tag: string, sectionOrder?: string[]): RenderedInjectedReadme | undefined;
 export declare function renderInjectedReadme(readme: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): RenderedInjectedReadme | undefined;
 export declare function injectReleaseNotesIntoReadme(readmePath: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): string | undefined;
 export declare function resolveReadmePath(workspacePath: string): string | undefined;

package/dist/esm/injectReleaseNotesIntoReadme.js

@@ -3,17 +3,8 @@ import { join } from 'node:path';
 import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
 import { injectSection } from "./injectSection.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
-export function renderInjectedReadme(readme, changelogJsonPath, tag, sectionOrder) {
-    if (!existsSync(changelogJsonPath)) {
-        console.warn(`Warning: ${changelogJsonPath} not found; skipping README injection`);
-        return undefined;
-    }
+export function renderInjectedReadmeFromEntries(readme, entries, tag, sectionOrder) {
     const version = extractVersion(tag);
-    const entries = readChangelogEntries(changelogJsonPath);
-    if (entries === undefined) {
-        console.warn(`Warning: could not parse ${changelogJsonPath}; skipping README injection`);
-        return undefined;
-    }
     const entry = entries.find((e) => e.version === version);
     if (entry === undefined) {
         console.warn(`Warning: no changelog entry for version ${version}; skipping README injection`);
@@ -33,6 +24,18 @@ export function renderInjectedReadme(readme, changelogJsonPath, tag, sectionOrde
     const injectedReadme = injectSection(readme, 'release-notes', releaseNotesMarkdown);
     return { injectedReadme, releaseNotesMarkdown };
 }
+export function renderInjectedReadme(readme, changelogJsonPath, tag, sectionOrder) {
+    if (!existsSync(changelogJsonPath)) {
+        console.warn(`Warning: ${changelogJsonPath} not found; skipping README injection`);
+        return undefined;
+    }
+    const entries = readChangelogEntries(changelogJsonPath);
+    if (entries === undefined) {
+        console.warn(`Warning: could not parse ${changelogJsonPath}; skipping README injection`);
+        return undefined;
+    }
+    return renderInjectedReadmeFromEntries(readme, entries, tag, sectionOrder);
+}
 export function injectReleaseNotesIntoReadme(readmePath, changelogJsonPath, tag, sectionOrder) {
     const originalReadme = readFileSync(readmePath, 'utf8');
     const rendered = renderInjectedReadme(originalReadme, changelogJsonPath, tag, sectionOrder);

package/dist/esm/planReleaseNotesPreviews.d.ts

@@ -0,0 +1,13 @@
+import type { PlannedWrite } from './releasePlan.js';
+import type { ChangelogEntry } from './types.js';
+export interface PlanReleaseNotesPreviewsOptions {
+    workspacePath: string;
+    tag: string;
+    entries: readonly ChangelogEntry[];
+    sectionOrder: string[];
+}
+export interface ReleaseNotesPreviewsPlan {
+    writes: PlannedWrite[];
+    warnings: string[];
+}
+export declare function planReleaseNotesPreviews(options: PlanReleaseNotesPreviewsOptions): ReleaseNotesPreviewsPlan;

package/dist/esm/planReleaseNotesPreviews.js

@@ -0,0 +1,43 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { extractVersion } from "./changelogJsonUtils.js";
+import { renderInjectedReadmeFromEntries } from "./injectReleaseNotesIntoReadme.js";
+export function planReleaseNotesPreviews(options) {
+    const { workspacePath, tag, entries, sectionOrder } = options;
+    const warnings = [];
+    const readmePath = path.join(workspacePath, 'README.md');
+    const readme = readWorkspaceReadme(readmePath, warnings);
+    const rendered = renderInjectedReadmeFromEntries(readme.content, entries, tag, sectionOrder);
+    if (rendered === undefined) {
+        return { writes: [], warnings };
+    }
+    if (!readme.exists && !readme.unreadable) {
+        warnings.push(`${readmePath} not found; skipping injected-README preview but still writing standalone release notes`);
+    }
+    const version = extractVersion(tag);
+    const docsDir = path.join(workspacePath, 'docs');
+    const writes = [];
+    if (readme.exists) {
+        writes.push({ path: path.join(docsDir, `README.v${version}.md`), content: rendered.injectedReadme });
+    }
+    writes.push({
+        path: path.join(docsDir, `RELEASE_NOTES.v${version}.md`),
+        content: rendered.releaseNotesMarkdown.endsWith('\n')
+            ? rendered.releaseNotesMarkdown
+            : `${rendered.releaseNotesMarkdown}\n`,
+    });
+    return { writes, warnings };
+}
+function readWorkspaceReadme(readmePath, warnings) {
+    if (!existsSync(readmePath)) {
+        return { content: '', exists: false, unreadable: false };
+    }
+    try {
+        return { content: readFileSync(readmePath, 'utf8'), exists: true, unreadable: false };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`failed to read ${readmePath}: ${message}; skipping injected-README preview`);
+        return { content: '', exists: false, unreadable: true };
+    }
+}

package/dist/esm/planVersionBump.d.ts

@@ -0,0 +1,9 @@
+import type { PlannedWrite } from './releasePlan.js';
+import type { ReleaseType } from './types.js';
+export interface VersionBumpPlan {
+    currentVersion: string;
+    newVersion: string;
+    writes: PlannedWrite[];
+}
+export declare function planVersionBump(packageFiles: readonly string[], releaseType: ReleaseType): VersionBumpPlan;
+export declare function planVersionSet(packageFiles: readonly string[], newVersion: string): VersionBumpPlan;

package/dist/esm/{bumpAllVersions.js → planVersionBump.js}

@@ -1,43 +1,32 @@
-import { readFileSync, writeFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { bumpVersion } from "./bumpVersion.js";
 function isPackageJson(value) {
     return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
-export function bumpAllVersions(packageFiles, releaseType, dryRun) {
-    const firstFile = packageFiles[0];
-    if (firstFile === undefined) {
-        throw new Error('No package files specified');
-    }
-    const firstPkg = readPackageJson(firstFile);
+export function planVersionBump(packageFiles, releaseType) {
+    const { firstFile, firstPkg } = readPrimaryPackage(packageFiles);
     const currentVersion = firstPkg.version;
     const newVersion = bumpVersion(currentVersion, releaseType);
-    writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
-    return { currentVersion, newVersion, files: [...packageFiles] };
+    return { currentVersion, newVersion, writes: renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) };
 }
-export function setAllVersions(packageFiles, newVersion, dryRun) {
+export function planVersionSet(packageFiles, newVersion) {
+    const { firstFile, firstPkg } = readPrimaryPackage(packageFiles);
+    const currentVersion = firstPkg.version;
+    return { currentVersion, newVersion, writes: renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) };
+}
+function readPrimaryPackage(packageFiles) {
     const firstFile = packageFiles[0];
     if (firstFile === undefined) {
         throw new Error('No package files specified');
     }
-    const firstPkg = readPackageJson(firstFile);
-    const currentVersion = firstPkg.version;
-    writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun);
-    return { currentVersion, newVersion, files: [...packageFiles] };
+    return { firstFile, firstPkg: readPackageJson(firstFile) };
 }
-function writeVersionToAllFiles(packageFiles, firstFile, firstPkg, newVersion, dryRun) {
-    for (const filePath of packageFiles) {
-        if (dryRun) {
-            continue;
-        }
+function renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) {
+    return packageFiles.map((filePath) => {
         const pkg = filePath === firstFile ? firstPkg : readPackageJson(filePath);
         pkg.version = newVersion;
-        try {
-            writeFileSync(filePath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
-        }
-        catch (error) {
-            throw new Error(`Failed to write ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
+        return { path: filePath, content: JSON.stringify(pkg, null, 2) + '\n' };
+    });
 }
 function readPackageJson(filePath) {
     let content;

package/dist/esm/prepareCommand.d.ts

@@ -1,7 +1,4 @@
-import type { WriteResult } from '@williamthorsen/nmr-core';
 import type { ReleaseType } from './types.js';
-export declare const RELEASE_TAGS_FILE = "tmp/.release-tags";
-export declare const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
 export declare const prepareFlagSchema: {
     dryRun: {
         long: string;
@@ -42,5 +39,4 @@ export declare function parseArgs(argv: string[]): {
     setVersion: string | undefined;
     withReleaseNotes: boolean;
 };
-export declare function writeReleaseTags(tags: string[], dryRun: boolean): WriteResult | undefined;
 export declare function prepareCommand(argv: string[]): Promise<void>;