@williamthorsen/release-kit 10.2.1 → 10.2.2

package/dist/esm/releasePrepareMono.js

@@ -1,10 +1,10 @@
-import { execSync } from 'node:child_process';
+import { join as joinPath } from 'node:path';
 import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { buildEmptyReleaseEntry } from "./buildEmptyReleaseEntry.js";
+import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { buildSyntheticChangelogEntry } from "./buildSyntheticChangelogEntry.js";
-import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.js";
-import { mergeChangelogEntriesWithDisk, resolveChangelogJsonPath, upsertChangelogJsonAndReturn, } from "./changelogJsonFile.js";
+import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
 import { applyWorkspaceOverrides, createOverrideContext, formatStaleOverrideKeyWarning, } from "./changelogOverrides.js";
 import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { isForwardVersion } from "./compareVersions.js";
@@ -15,15 +15,17 @@ import { buildTagPattern, getAllTagPrefixes } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
 import { resolveWorkTypes } from "./loadConfig.js";
+import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
+import { planVersionBump, planVersionSet } from "./planVersionBump.js";
 import { propagateBumps } from "./propagateBumps.js";
 import { readCurrentVersion } from "./readCurrentVersion.js";
 import { releasePrepareProject } from "./releasePrepareProject.js";
-import { writeChangelogMarkdown } from "./renderChangelogMarkdown.js";
+import { renderChangelogMarkdown } from "./renderChangelogMarkdown.js";
 import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
 import { refreshGitCliffCache } from "./runGitCliff.js";
-import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
 export function releasePrepareMono(config, options) {
-    const { dryRun, withReleaseNotes } = options;
+    const { withReleaseNotes } = options;
+    const writes = [];
     if (withReleaseNotes === true && !config.changelogJson.enabled) {
         console.warn('Warning: --with-release-notes requires changelogJson.enabled; skipping preview generation');
     }
@@ -59,7 +61,8 @@ export function releasePrepareMono(config, options) {
         config,
         directResults,
         previousTags,
-        dryRun,
+        writes,
+        warnings,
         workspaces,
         previewOptions,
         overrideContext,
@@ -77,13 +80,15 @@ export function releasePrepareMono(config, options) {
             config,
             options,
             modifiedFiles,
+            writes,
             tags,
+            warnings,
             rootOverrides: overrideContext.project,
             overrideWarnings: overrideContext.overrideWarnings,
             globalMatchedRootKeys: overrideContext.globalMatchedRootKeys,
         }));
     }
-    const formatCommand = runFormatCommand(config, tags, modifiedFiles, dryRun);
+    const formatCommand = planFormatCommand(config, tags, modifiedFiles);
     for (const overrideKey of overrideContext.project.keys()) {
         if (!overrideContext.globalMatchedRootKeys.has(overrideKey)) {
             overrideContext.overrideWarnings.push(formatStaleOverrideKeyWarning(overrideKey));
@@ -93,8 +98,9 @@ export function releasePrepareMono(config, options) {
     return {
         workspaces,
         tags,
+        writes,
+        summary: buildReleaseSummary({ workspaces, ...(project !== undefined && { project }) }),
         formatCommand,
-        dryRun,
         ...(allWarnings.length > 0 && { warnings: allWarnings }),
         ...(project !== undefined && { project }),
     };
@@ -221,7 +227,7 @@ function collectSkippedWorkspaces(skippedResults, fullReleaseSet) {
     return workspaces;
 }
 function executeReleaseSet(args) {
-    const { sortedDirs, fullReleaseSet, config, directResults, previousTags, dryRun, workspaces, previewOptions, overrideContext, sectionOrder, } = args;
+    const { sortedDirs, fullReleaseSet, config, directResults, previousTags, writes, warnings, workspaces, previewOptions, overrideContext, sectionOrder, } = args;
     const tags = [];
     const modifiedFiles = [];
     const today = new Date().toISOString().slice(0, 10);
@@ -241,10 +247,11 @@ function executeReleaseSet(args) {
             directResult: directResults.get(dir),
             previousTags,
             config,
-            dryRun,
             today,
             tags,
             modifiedFiles,
+            writes,
+            warnings,
             workspaces,
             previewOptions,
             overrideContext,
@@ -254,17 +261,18 @@ function executeReleaseSet(args) {
     return { tags, modifiedFiles };
 }
 function executeWorkspaceRelease(args) {
-    const { dir, workspace, releaseEntry, directResult, previousTags, config, dryRun, today, tags, modifiedFiles, workspaces, previewOptions, overrideContext, sectionOrder, } = args;
+    const { dir, workspace, releaseEntry, directResult, previousTags, config, today, tags, modifiedFiles, writes, warnings, workspaces, previewOptions, overrideContext, sectionOrder, } = args;
     const setVersionTarget = directResult?.setVersion;
     const bump = setVersionTarget === undefined
-        ? bumpAllVersions(workspace.packageFiles, releaseEntry.releaseType, dryRun)
-        : setAllVersions(workspace.packageFiles, setVersionTarget, dryRun);
+        ? planVersionBump(workspace.packageFiles, releaseEntry.releaseType)
+        : planVersionSet(workspace.packageFiles, setVersionTarget);
     const newTag = `${workspace.tagPrefix}${bump.newVersion}`;
     tags.push(newTag);
-    modifiedFiles.push(...workspace.packageFiles, ...workspace.changelogPaths.map((p) => `${p}/CHANGELOG.md`));
+    writes.push(...bump.writes);
+    modifiedFiles.push(...workspace.packageFiles, ...workspace.changelogPaths.map((changelogPath) => joinPath(changelogPath, 'CHANGELOG.md')));
     const isPropagationOnly = directResult === undefined;
     const isEmptyRange = directResult !== undefined && directResult.commits.length === 0;
-    const changelogFiles = generateWorkspaceChangelogs({
+    const { changelogFiles, previewFiles } = generateWorkspaceChangelogs({
         workspace,
         releaseEntry,
         newTag,
@@ -272,9 +280,10 @@ function executeWorkspaceRelease(args) {
         isPropagationOnly,
         isEmptyRange,
         config,
-        dryRun,
         today,
         modifiedFiles,
+        writes,
+        warnings,
         previewOptions,
         overrideContext,
         sectionOrder,
@@ -286,8 +295,9 @@ function executeWorkspaceRelease(args) {
         currentVersion: bump.currentVersion,
         newVersion: bump.newVersion,
         tag: newTag,
-        bumpedFiles: bump.files,
+        bumpedFiles: bump.writes.map((write) => write.path),
         changelogFiles,
+        ...(previewFiles.length > 0 && { previewFiles }),
     };
     attachReleasedWorkspaceOptionals(released, {
         previousTag: directResult?.tag ?? previousTags.get(dir),
@@ -328,7 +338,7 @@ function attachReleasedWorkspaceOptionals(released, args) {
     }
 }
 function generateWorkspaceChangelogs(args) {
-    const { workspace, releaseEntry, newTag, newVersion, isPropagationOnly, isEmptyRange, config, dryRun, today, modifiedFiles, previewOptions, overrideContext, sectionOrder, } = args;
+    const { workspace, releaseEntry, newTag, newVersion, isPropagationOnly, isEmptyRange, config, today, modifiedFiles, writes, warnings, previewOptions, overrideContext, sectionOrder, } = args;
     const newEntries = buildWorkspaceEntries({
         workspace,
         releaseEntry,
@@ -341,26 +351,22 @@ function generateWorkspaceChangelogs(args) {
     });
     const applied = applyWorkspaceOverrides(newEntries, workspace.workspacePath, overrideContext);
     const changelogFiles = [];
-    let firstChangelogJsonPath;
+    let firstMergedEntries;
     for (const changelogPath of workspace.changelogPaths) {
         const jsonPath = resolveChangelogJsonPath(config, changelogPath);
-        const shouldWriteJson = config.changelogJson.enabled && !dryRun;
-        const mergedEntries = shouldWriteJson
-            ? upsertChangelogJsonAndReturn(jsonPath, applied.entries)
-            : mergeChangelogEntriesWithDisk(jsonPath, applied.entries);
+        const mergedEntries = mergeChangelogEntriesWithDisk(jsonPath, applied.entries);
         if (config.changelogJson.enabled) {
+            writes.push({ path: jsonPath, content: renderChangelogJson(mergedEntries) });
             modifiedFiles.push(jsonPath);
-            firstChangelogJsonPath ??= jsonPath;
+            firstMergedEntries ??= mergedEntries;
         }
-        changelogFiles.push(writeChangelogMarkdown({
-            changelogPath,
-            entries: mergedEntries,
-            sectionOrder,
-            dryRun,
-        }));
+        const changelogFile = joinPath(changelogPath, 'CHANGELOG.md');
+        writes.push({ path: changelogFile, content: renderChangelogMarkdown(mergedEntries, { sectionOrder }) });
+        changelogFiles.push(changelogFile);
     }
-    maybeWritePreviews(workspace, newTag, firstChangelogJsonPath, previewOptions, dryRun);
-    return changelogFiles;
+    const previews = planPreviews(workspace, newTag, firstMergedEntries, previewOptions, warnings);
+    writes.push(...previews);
+    return { changelogFiles, previewFiles: previews.map((write) => write.path) };
 }
 function buildWorkspaceEntries(args) {
     const { workspace, releaseEntry, newTag, newVersion, isPropagationOnly, isEmptyRange, config, today } = args;
@@ -373,35 +379,25 @@ function buildWorkspaceEntries(args) {
     const tagPattern = buildTagPattern(getAllTagPrefixes(workspace));
     return buildChangelogEntries(config, newTag, { tagPattern, includePaths: workspace.paths });
 }
-function maybeWritePreviews(workspace, newTag, changelogJsonPath, previewOptions, dryRun) {
-    if (!previewOptions.enabled || changelogJsonPath === undefined) {
-        return;
+function planPreviews(workspace, newTag, entries, previewOptions, warnings) {
+    if (!previewOptions.enabled || entries === undefined) {
+        return [];
     }
-    writeReleaseNotesPreviews({
+    const previews = planReleaseNotesPreviews({
         workspacePath: workspace.workspacePath,
         tag: newTag,
-        changelogJsonPath,
+        entries,
         sectionOrder: previewOptions.sectionOrder,
-        dryRun,
     });
+    warnings.push(...previews.warnings);
+    return previews.writes;
 }
-function runFormatCommand(config, tags, modifiedFiles, dryRun) {
+function planFormatCommand(config, tags, modifiedFiles) {
     const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
     if (tags.length === 0 || formatCommandStr === undefined) {
         return undefined;
     }
-    const fullCommand = `${formatCommandStr} ${modifiedFiles.join(' ')}`;
-    if (dryRun) {
-        return { command: fullCommand, executed: false, files: modifiedFiles };
-    }
-    try {
-        execSync(fullCommand, { stdio: 'inherit' });
-    }
-    catch (error) {
-        const baseMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`format stage: ${baseMessage} (command: '${fullCommand}')`, { cause: error });
-    }
-    return { command: fullCommand, executed: true, files: modifiedFiles };
+    return { command: `${formatCommandStr} ${modifiedFiles.join(' ')}`, files: modifiedFiles };
 }
 function findWorkspace(workspaces, dir) {
     return workspaces.find((w) => w.dir === dir);

package/dist/esm/releasePrepareProject.d.ts

@@ -1,10 +1,13 @@
+import type { PlannedWrite } from './releasePlan.js';
 import type { ReleasePrepareOptions } from './releasePrepare.js';
 import type { ChangelogOverride, MonorepoReleaseConfig, ProjectPrepareResult } from './types.js';
 export interface ReleasePrepareProjectArgs {
     config: MonorepoReleaseConfig;
     options: ReleasePrepareOptions;
     modifiedFiles: string[];
+    writes: PlannedWrite[];
     tags: string[];
+    warnings?: string[];
     rootOverrides?: Map<string, ChangelogOverride>;
     overrideWarnings?: string[];
     globalMatchedRootKeys?: Set<string>;

package/dist/esm/releasePrepareProject.js

@@ -1,22 +1,23 @@
+import { join as joinPath } from 'node:path';
 import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { buildEmptyReleaseEntry } from "./buildEmptyReleaseEntry.js";
-import { bumpAllVersions } from "./bumpAllVersions.js";
-import { mergeChangelogEntriesWithDisk, resolveChangelogJsonPath, writeChangelogJson } from "./changelogJsonFile.js";
+import { mergeChangelogEntriesWithDisk, renderChangelogJson, resolveChangelogJsonPath } from "./changelogJsonFile.js";
 import { applyChangelogOverrides } from "./changelogOverrides.js";
 import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { decideRelease } from "./decideRelease.js";
 import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { buildTagPattern } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
-import { writeChangelogMarkdown } from "./renderChangelogMarkdown.js";
+import { planReleaseNotesPreviews } from "./planReleaseNotesPreviews.js";
+import { planVersionBump } from "./planVersionBump.js";
+import { renderChangelogMarkdown } from "./renderChangelogMarkdown.js";
 import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
-import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
 const ROOT_PACKAGE_FILE = './package.json';
 const ROOT_CHANGELOG_PATH = '.';
 export function releasePrepareProject(args) {
-    const { config, options, modifiedFiles, tags } = args;
-    const { rootOverrides, overrideWarnings, globalMatchedRootKeys } = resolveOptionalOverrideArgs(args);
-    const { dryRun, bumpOverride, withReleaseNotes, force } = options;
+    const { config, options, modifiedFiles, writes, tags } = args;
+    const { rootOverrides, overrideWarnings, globalMatchedRootKeys, warnings } = resolveOptionalOverrideArgs(args);
+    const { bumpOverride, withReleaseNotes, force } = options;
     const project = config.project;
     if (project === undefined) {
         throw new Error('releasePrepareProject called without a configured project block');
@@ -62,30 +63,33 @@ export function releasePrepareProject(args) {
         return skipped;
     }
     const { releaseType, parsedCommitCount, unparseableCommits } = decision;
-    const bump = bumpAllVersions([ROOT_PACKAGE_FILE], releaseType, dryRun);
+    const bump = planVersionBump([ROOT_PACKAGE_FILE], releaseType);
+    writes.push(...bump.writes);
     const newTag = `${project.tagPrefix}${bump.newVersion}`;
-    const { changelogFiles, changelogJsonFiles } = writeProjectChangelogs({
+    const changelogs = planProjectChangelogs({
         config,
         project,
         commits,
         contributingPaths,
         newTag,
         newVersion: bump.newVersion,
-        dryRun,
         rootOverrides,
         overrideWarnings,
         globalMatchedRootKeys,
     });
-    const firstChangelogJsonPath = changelogJsonFiles[0];
-    if (withReleaseNotes === true && config.changelogJson.enabled && firstChangelogJsonPath !== undefined) {
-        const sectionOrder = deriveSectionOrder(workTypes);
-        writeReleaseNotesPreviews({
+    const { changelogFiles, changelogJsonFiles } = changelogs;
+    writes.push(...changelogs.writes);
+    const previewFiles = [];
+    if (withReleaseNotes === true && config.changelogJson.enabled && changelogJsonFiles.length > 0) {
+        const previews = planReleaseNotesPreviews({
             workspacePath: ROOT_CHANGELOG_PATH,
             tag: newTag,
-            changelogJsonPath: firstChangelogJsonPath,
-            sectionOrder,
-            dryRun,
+            entries: changelogs.entries,
+            sectionOrder: deriveSectionOrder(workTypes),
         });
+        writes.push(...previews.writes);
+        warnings.push(...previews.warnings);
+        previewFiles.push(...previews.writes.map((write) => write.path));
     }
     tags.push(newTag);
     modifiedFiles.push(ROOT_PACKAGE_FILE, ...changelogFiles, ...changelogJsonFiles);
@@ -97,10 +101,13 @@ export function releasePrepareProject(args) {
         currentVersion: bump.currentVersion,
         newVersion: bump.newVersion,
         tag: newTag,
-        bumpedFiles: bump.files,
+        bumpedFiles: bump.writes.map((write) => write.path),
         changelogFiles,
         commits,
     };
+    if (previewFiles.length > 0) {
+        result.previewFiles = previewFiles;
+    }
     if (tag !== undefined) {
         result.previousTag = tag;
     }
@@ -120,10 +127,11 @@ function resolveOptionalOverrideArgs(args) {
         rootOverrides: args.rootOverrides ?? new Map(),
         overrideWarnings: args.overrideWarnings ?? [],
         globalMatchedRootKeys: args.globalMatchedRootKeys ?? new Set(),
+        warnings: args.warnings ?? [],
     };
 }
-function writeProjectChangelogs(args) {
-    const { config, project, commits, contributingPaths, newTag, newVersion, dryRun, rootOverrides, overrideWarnings, globalMatchedRootKeys, } = args;
+function planProjectChangelogs(args) {
+    const { config, project, commits, contributingPaths, newTag, newVersion, rootOverrides, overrideWarnings, globalMatchedRootKeys, } = args;
     const isEmptyRange = commits.length === 0;
     const today = new Date().toISOString().slice(0, 10);
     const tagPattern = buildTagPattern([project.tagPrefix]);
@@ -143,25 +151,13 @@ function writeProjectChangelogs(args) {
     const renderEntries = isEmptyRange
         ? mergeChangelogEntriesWithDisk(changelogJsonPath, applied.entries)
         : applied.entries;
-    if (config.changelogJson.enabled && !dryRun) {
-        if (isEmptyRange) {
-            writeChangelogJson(changelogJsonPath, renderEntries);
-        }
-        else {
-            writeChangelogJson(changelogJsonPath, applied.entries);
-        }
-    }
-    const changelogFiles = [
-        writeChangelogMarkdown({
-            changelogPath: ROOT_CHANGELOG_PATH,
-            entries: renderEntries,
-            sectionOrder,
-            dryRun,
-        }),
-    ];
+    const writes = [];
     const changelogJsonFiles = [];
     if (config.changelogJson.enabled) {
+        writes.push({ path: changelogJsonPath, content: renderChangelogJson(renderEntries) });
         changelogJsonFiles.push(changelogJsonPath);
     }
-    return { changelogFiles, changelogJsonFiles };
+    const changelogFile = joinPath(ROOT_CHANGELOG_PATH, 'CHANGELOG.md');
+    writes.push({ path: changelogFile, content: renderChangelogMarkdown(renderEntries, { sectionOrder }) });
+    return { changelogFiles: [changelogFile], changelogJsonFiles, entries: renderEntries, writes };
 }

package/dist/esm/renderChangelogMarkdown.d.ts

@@ -3,10 +3,3 @@ export interface RenderChangelogMarkdownOptions {
     sectionOrder?: string[];
 }
 export declare function renderChangelogMarkdown(entries: ChangelogEntry[], options?: RenderChangelogMarkdownOptions): string;
-export interface WriteChangelogMarkdownParams {
-    changelogPath: string;
-    entries: ChangelogEntry[];
-    sectionOrder?: string[];
-    dryRun?: boolean;
-}
-export declare function writeChangelogMarkdown(params: WriteChangelogMarkdownParams): string;

package/dist/esm/renderChangelogMarkdown.js

@@ -1,5 +1,3 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join as joinPath } from 'node:path';
 import { renderReleaseNotesMulti } from "./renderReleaseNotes.js";
 const CHANGELOG_HEADER = `# Changelog
 
@@ -15,14 +13,3 @@ export function renderChangelogMarkdown(entries, options) {
     parts.push(CHANGELOG_FOOTER);
     return parts.join('\n\n') + '\n';
 }
-export function writeChangelogMarkdown(params) {
-    const { changelogPath, entries, sectionOrder, dryRun = false } = params;
-    const filePath = joinPath(changelogPath, 'CHANGELOG.md');
-    if (dryRun) {
-        return filePath;
-    }
-    const rendered = renderChangelogMarkdown(entries, sectionOrder !== undefined ? { sectionOrder } : undefined);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, rendered, 'utf8');
-    return filePath;
-}

package/dist/esm/reportPrepare.d.ts

@@ -1,2 +1,6 @@
 import type { PrepareResult } from './types.js';
-export declare function reportPrepare(result: PrepareResult): string;
+export interface ReportPrepareOptions {
+    applied: boolean;
+    formatError?: string;
+}
+export declare function reportPrepare(plan: PrepareResult, options: ReportPrepareOptions): string;

package/dist/esm/reportPrepare.js

@@ -1,12 +1,13 @@
 import { bold, dim, sectionHeader } from "./format.js";
-export function reportPrepare(result) {
-    const isMultiWorkspace = result.workspaces.some((w) => w.name !== undefined) || result.project !== undefined;
+export function reportPrepare(plan, options) {
+    const isMultiWorkspace = plan.workspaces.some((w) => w.name !== undefined) || plan.project !== undefined;
     if (isMultiWorkspace) {
-        return formatMultiWorkspace(result);
+        return formatMultiWorkspace(plan, options);
     }
-    return formatSingleWorkspace(result);
+    return formatSingleWorkspace(plan, options);
 }
-function formatSingleWorkspace(result) {
+function formatSingleWorkspace(result, options) {
+    const dryRun = !options.applied;
     const lines = [];
     const workspace = result.workspaces[0];
     if (workspace === undefined) {
@@ -41,22 +42,25 @@ function formatSingleWorkspace(result) {
     else if (workspace.releaseType !== undefined) {
         lines.push(`📦 ${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType})`);
     }
-    formatBumpFiles(lines, workspace, result.dryRun);
+    formatBumpFiles(lines, workspace, dryRun);
     lines.push(dim('Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, result.dryRun);
-    formatFormatCommand(lines, result);
+    formatChangelogFiles(lines, workspace, dryRun);
+    formatPreviewFiles(lines, workspace, dryRun);
+    formatFormatCommand(lines, result, options);
+    formatWarnings(lines, result);
     lines.push(`✅ Release preparation complete.`, `   🏷️  ${bold(workspace.tag)}`);
     return lines.join('\n');
 }
-function formatMultiWorkspace(result) {
+function formatMultiWorkspace(result, options) {
+    const dryRun = !options.applied;
     const lines = [];
     for (const workspace of result.workspaces) {
-        formatWorkspaceSection(lines, workspace, result.dryRun);
+        formatWorkspaceSection(lines, workspace, dryRun);
     }
     if (result.project !== undefined) {
-        formatProjectSection(lines, result.project, result.dryRun);
+        formatProjectSection(lines, result.project, dryRun);
     }
-    formatFormatCommand(lines, result);
+    formatFormatCommand(lines, result, options);
     formatWarnings(lines, result);
     if (result.tags.length > 0) {
         lines.push(`\n✅ Release preparation complete.`);
@@ -104,6 +108,7 @@ function formatProjectSection(lines, project, dryRun) {
             lines.push(dim(`    Generating changelog: ${file}`));
         }
     }
+    formatPreviewFiles(lines, project, dryRun, '  ');
     lines.push(`  🏷️  ${bold(tag)}`);
 }
 function formatProjectUnparseable(lines, project) {
@@ -141,6 +146,7 @@ function formatWorkspaceSection(lines, workspace, dryRun) {
     formatBumpFiles(lines, workspace, dryRun, '  ');
     lines.push(dim('  Generating changelogs...'));
     formatChangelogFiles(lines, workspace, dryRun, '  ');
+    formatPreviewFiles(lines, workspace, dryRun, '  ');
     lines.push(`  🏷️  ${bold(workspace.tag)}`);
 }
 function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
@@ -195,6 +201,16 @@ function formatChangelogFiles(lines, workspace, dryRun, indent = '') {
         }
     }
 }
+function formatPreviewFiles(lines, release, dryRun, indent = '') {
+    for (const file of release.previewFiles ?? []) {
+        if (dryRun) {
+            lines.push(dim(`${indent}  [dry-run] Would write ${file}`));
+        }
+        else {
+            lines.push(dim(`${indent}  Wrote ${file}`));
+        }
+    }
+}
 function formatUnparseableWarning(lines, workspace, indent = '') {
     const unparseable = workspace.unparseableCommits;
     if (unparseable === undefined || unparseable.length === 0) {
@@ -240,14 +256,17 @@ function formatWarnings(lines, result) {
         lines.push(`⚠️  ${warning}`);
     }
 }
-function formatFormatCommand(lines, result) {
+function formatFormatCommand(lines, result, options) {
     if (result.formatCommand === undefined) {
         return;
     }
-    if (result.formatCommand.executed) {
-        lines.push(dim(`\n  Running format command: ${result.formatCommand.command}`));
-    }
-    else {
+    if (!options.applied) {
         lines.push(dim(`\n  [dry-run] Would run format command: ${result.formatCommand.command}`));
+        return;
+    }
+    if (options.formatError === undefined) {
+        lines.push(dim(`\n  Running format command: ${result.formatCommand.command}`));
+        return;
     }
+    lines.push(`\n  ⚠️  Format command failed: ${result.formatCommand.command}`, `     ${options.formatError}`);
 }

package/dist/esm/types.d.ts

@@ -39,11 +39,6 @@ export interface PropagationSource {
     packageName: string;
     newVersion: string;
 }
-export interface BumpResult {
-    currentVersion: string;
-    newVersion: string;
-    files: string[];
-}
 export interface PolicyViolation {
     commitHash: string;
     commitSubject: string;
@@ -64,6 +59,7 @@ export interface ReleasedWorkspaceResult {
     tag: string;
     bumpedFiles: string[];
     changelogFiles: string[];
+    previewFiles?: string[];
     commits?: Commit[];
     bumpOverride?: ReleaseType;
     propagatedFrom?: PropagationSource[];
@@ -93,6 +89,7 @@ export interface ReleasedProjectResult {
     tag: string;
     bumpedFiles: string[];
     changelogFiles: string[];
+    previewFiles?: string[];
     commits: Commit[];
     bumpOverride?: ReleaseType;
 }
@@ -111,10 +108,8 @@ export interface PrepareResult {
     tags: string[];
     formatCommand?: {
         command: string;
-        executed: boolean;
         files: string[];
     } | undefined;
-    dryRun: boolean;
     warnings?: string[] | undefined;
     project?: ProjectPrepareResult | undefined;
 }
@@ -167,8 +162,8 @@ export declare const versionPatternsSchema: z.ZodObject<{
     minor: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export declare const breakingPolicyValueSchema: z.ZodEnum<{
-    optional: "optional";
     forbidden: "forbidden";
+    optional: "optional";
     required: "required";
 }>;
 export declare const labelSpecSchema: z.ZodObject<{
@@ -186,8 +181,8 @@ export declare const repoLabelsSchema: z.ZodObject<{
 export type RepoLabelsConfig = z.infer<typeof repoLabelsSchema>;
 export declare const releaseKitConfigSchema: z.ZodObject<{
     breakingPolicies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        optional: "optional";
         forbidden: "forbidden";
+        optional: "optional";
         required: "required";
     }>>>;
     changelogJson: z.ZodOptional<z.ZodObject<{

package/dist/esm/workTypesData.d.ts

@@ -15,8 +15,8 @@ export interface WorkTypesData {
     tiers: string[];
     types: WorkTypeEntry[];
     markers: {
-        breaking: MarkerEntry;
         [key: string]: MarkerEntry;
+        breaking: MarkerEntry;
     };
 }
 export declare const WORK_TYPES_DATA: WorkTypesData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/release-kit",
-  "version": "10.2.1",
+  "version": "10.2.2",
   "description": "Version-bumping and changelog-generation toolkit for release workflows",
   "keywords": [],
   "homepage": "https://github.com/williamthorsen/node-monorepo-tools/tree/main/packages/release-kit#readme",
@@ -44,7 +44,7 @@
     "semver": "7.8.5",
     "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@williamthorsen/nmr-core": "0.9.1"
+    "@williamthorsen/nmr-core": "0.9.2"
   },
   "devDependencies": {
     "@types/semver": "7.7.1",

package/dist/esm/bumpAllVersions.d.ts

@@ -1,3 +0,0 @@
-import type { BumpResult, ReleaseType } from './types.js';
-export declare function bumpAllVersions(packageFiles: readonly string[], releaseType: ReleaseType, dryRun: boolean): BumpResult;
-export declare function setAllVersions(packageFiles: readonly string[], newVersion: string, dryRun: boolean): BumpResult;

package/dist/esm/writeReleaseNotesPreviews.d.ts

@@ -1,18 +0,0 @@
-export interface WriteReleaseNotesPreviewsOptions {
-    workspacePath: string;
-    tag: string;
-    changelogJsonPath: string;
-    sectionOrder: string[];
-    dryRun: boolean;
-}
-export interface PreviewFileResult {
-    filePath: string;
-    outcome: 'created' | 'overwritten' | 'skipped-no-readme' | 'failed' | 'dry-run';
-    error?: string;
-}
-export interface WriteReleaseNotesPreviewsResult {
-    injectedReadme?: PreviewFileResult;
-    releaseNotes?: PreviewFileResult;
-    renderSkipped: boolean;
-}
-export declare function writeReleaseNotesPreviews(options: WriteReleaseNotesPreviewsOptions): WriteReleaseNotesPreviewsResult;