@williamthorsen/release-kit 10.2.1 → 10.3.0

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);
@@ -476,7 +472,8 @@ function topologicalSort(releaseSet, graph) {
             break;
         }
         sorted.push(dir);
-        for (const dependent of forwardEdges.get(dir) ?? []) {
+        const dependents = forwardEdges.get(dir) ?? [];
+        for (const dependent of dependents) {
             const newDegree = (inDegree.get(dependent) ?? 1) - 1;
             inDegree.set(dependent, newDegree);
             if (newDegree === 0) {

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,17 @@ function formatChangelogFiles(lines, workspace, dryRun, indent = '') {
         }
     }
 }
+function formatPreviewFiles(lines, release, dryRun, indent = '') {
+    const previewFiles = release.previewFiles ?? [];
+    for (const file of 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 +257,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/sync-labels/generateCommand.js

@@ -10,7 +10,8 @@ import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
 export const LABELS_OUTPUT_PATH = '.github/labels.yaml';
 export function formatLabelsYaml(labels, presetHashes) {
     const headerLines = ['# Generated by release-kit sync-labels — do not edit.', `# Source: ${CONFIG_FILE_PATH}`];
-    for (const [name, hash] of [...presetHashes].sort(([a], [b]) => a.localeCompare(b))) {
+    const sortedPresetHashes = [...presetHashes].sort(([a], [b]) => a.localeCompare(b));
+    for (const [name, hash] of sortedPresetHashes) {
         headerLines.push(`# ${name} preset hash: ${hash}`);
     }
     const declared = labels.map((label) => ({ ...label, description: label.description ?? '' }));
@@ -50,7 +51,8 @@ export async function generateCommand({ check = false } = {}) {
         return 1;
     }
     const presetHashes = new Map();
-    for (const presetName of repoLabels.extends ?? []) {
+    const presetNames = repoLabels.extends ?? [];
+    for (const presetName of presetNames) {
         presetHashes.set(presetName, hashPresetFile(presetName));
     }
     const content = formatLabelsYaml(labels, presetHashes);

package/dist/esm/sync-labels/presets.js

@@ -23,7 +23,7 @@ export function loadPreset(presetName) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to read preset "${presetName}": ${message}`);
+        throw new Error(`Failed to read preset "${presetName}": ${message}`, { cause: error });
     }
     const parsed = parse(content);
     if (!Array.isArray(parsed)) {
@@ -34,13 +34,13 @@ export function loadPreset(presetName) {
         if (!isRecord(entry)) {
             throw new Error(`Preset "${presetName}" contains an invalid label entry: ${JSON.stringify(entry)}`);
         }
-        const { description } = entry;
-        if (typeof entry.name !== 'string' ||
-            typeof entry.color !== 'string' ||
+        const { color, description, name } = entry;
+        if (typeof name !== 'string' ||
+            typeof color !== 'string' ||
             (description !== undefined && typeof description !== 'string')) {
             throw new TypeError(`Preset "${presetName}" contains a label with invalid fields: ${JSON.stringify(entry)}`);
         }
-        labels.push({ name: entry.name, color: entry.color, ...(description !== undefined && { description }) });
+        labels.push({ name, color, ...(description !== undefined && { description }) });
     }
     return labels;
 }

package/dist/esm/sync-labels/resolveLabels.js

@@ -1,12 +1,14 @@
 import { loadPreset } from "./presets.js";
 export function resolveLabels(config) {
     const resolved = new Map();
-    for (const presetName of config.extends ?? []) {
+    const presetNames = config.extends ?? [];
+    for (const presetName of presetNames) {
         for (const label of loadPreset(presetName)) {
             resolved.set(label.name, label);
         }
     }
-    for (const [name, spec] of Object.entries(config.labels ?? {})) {
+    const labelEntries = Object.entries(config.labels ?? {});
+    for (const [name, spec] of labelEntries) {
         if (spec === null) {
             if (!resolved.has(name)) {
                 throw new Error(`Label '${name}' is set to null (remove), but no preset in 'extends' defines it. Fix the name or delete the entry.`);
@@ -21,7 +23,7 @@ export function resolveLabels(config) {
             });
         }
     }
-    return sortLabels([...resolved.values()]);
+    return sortLabels(resolved.values().toArray());
 }
 function sortLabels(labels) {
     return [...labels].sort((a, b) => a.name.localeCompare(b.name));

package/dist/esm/syncWorkTypes.js

@@ -20,7 +20,7 @@ function extractLocalSchemaUrl(content) {
     if (!isRecord(parsed)) {
         return undefined;
     }
-    const schema = parsed.$schema;
+    const schema = parsed['$schema'];
     return typeof schema === 'string' ? schema : undefined;
 }
 export async function syncWorkTypes(dependencies = {}) {