@williamthorsen/release-kit 15.0.2 → 16.0.0

package/dist/esm/prepareRunContext.js

@@ -1,10 +1,10 @@
 import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { isRepoRoot } from "./prepareTarget.js";
-export function collect(collected, planned) {
-    collected.tags.push(planned.tag);
-    collected.writes.push(...planned.writes);
-    collected.removals.push(...planned.removals);
-    collected.modifiedFiles.push(...planned.modifiedFiles);
+export function collect(collectedReleases, plannedRelease) {
+    collectedReleases.tags.push(plannedRelease.tag);
+    collectedReleases.writes.push(...plannedRelease.writes);
+    collectedReleases.removals.push(...plannedRelease.removals);
+    collectedReleases.modifiedFiles.push(...plannedRelease.modifiedFiles);
 }
 export function describeStage(target) {
     switch (target.kind) {

package/dist/esm/prepareTarget.d.ts

@@ -10,7 +10,7 @@ export type TargetPrepareSettings = Omit<ReleaseSettings, 'releaseNotes'>;
 /** One read of a target's release windows, and the untagged baseline that it found, if any. */
 export interface TargetReading {
     history: ReleaseHistory;
-    untagged: UntaggedBaseline | undefined;
+    untaggedBaseline: UntaggedBaseline | undefined;
 }
 /** Outcome of {@link decideTargetRelease}: a release at a decided level or at an explicit version, or a skip. */
 export type TargetDecision = {
@@ -76,10 +76,10 @@ export declare function readTargetHistory(target: ReleaseTarget, settings: Targe
 export declare function describeHistoryWindow(target: ReleaseTarget): GenerateChangelogOptions;
 /**
  * Decides a target's direct release from its window: `setVersion` releases at that version, and otherwise the
- * window's bump, `force`, and `bumpOverride` decide as {@link decideRelease} states.
+ * window's bump, `shouldForce`, and `bumpOverride` decide as {@link decideRelease} states.
  */
 export declare function decideTargetRelease(target: ReleaseTarget, history: ReleaseHistory, options: {
-    force: boolean;
+    shouldForce: boolean;
     bumpOverride: ReleaseType | undefined;
     setVersion: string | undefined;
 }): TargetDecision;

package/dist/esm/prepareTarget.js

@@ -1,6 +1,6 @@
 import { findUntaggedBaseline } from "./assertTaggedBaseline.js";
 import { attachChangelogDiagnostics } from "./attachChangelogDiagnostics.js";
-import { readReleaseHistory, toReleaseEntries } from "./buildChangelogEntries.js";
+import { convertToReleaseEntries, readReleaseHistory } from "./buildChangelogEntries.js";
 import { buildPropagationEntries, buildReleasedResult } from "./buildReleasedResult.js";
 import { applyWorkspaceOverrides } from "./changelogOverrides.js";
 import { decideRelease } from "./decideRelease.js";
@@ -12,14 +12,14 @@ import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
 export function readTargetHistory(target, settings) {
     const options = describeHistoryWindow(target);
     const history = readReleaseHistory(settings, options);
-    const untagged = findUntaggedBaseline({
+    const untaggedBaseline = findUntaggedBaseline({
         label: describeBaselineLabel(target),
         packageFiles: target.versionFiles,
         changelogPaths: [target.changelogDir],
         tagPrefixes: options.tagPrefixes,
         previousTag: history.previousTag,
     }, settings);
-    return { history, untagged };
+    return { history, untaggedBaseline };
 }
 export function describeHistoryWindow(target) {
     return {
@@ -29,21 +29,21 @@ export function describeHistoryWindow(target) {
     };
 }
 export function decideTargetRelease(target, history, options) {
-    const { force, bumpOverride, setVersion } = options;
+    const { shouldForce, bumpOverride, setVersion } = options;
     if (setVersion !== undefined) {
         return { outcome: 'release', releaseType: undefined, bumpOverride: undefined, setVersion };
     }
     const tag = history.previousTag;
-    const since = tag === undefined ? '(no previous release found)' : `since ${tag}`;
+    const sinceClause = tag === undefined ? '(no previous release found)' : `since ${tag}`;
     const subject = isScopeRouted(target) || target.kind === 'directory' ? ` for ${target.id}` : '';
     const decision = decideRelease({
-        naturalBump: history.unreleased.bump,
-        commitCount: history.unreleased.commits.length,
-        force,
+        naturalBump: history.unreleasedReading.bump,
+        commitCount: history.unreleasedReading.commits.length,
+        shouldForce,
         bumpOverride,
         skipReasons: {
-            noCommits: `No commits${subject} ${since}. Pass --force to release at patch. Skipping.`,
-            noBumpWorthy: `No bump-worthy commits${subject} ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`,
+            noCommits: `No commits${subject} ${sinceClause}. Pass --force to release at patch. Skipping.`,
+            noBumpWorthy: `No bump-worthy commits${subject} ${sinceClause}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`,
         },
     });
     if (decision.outcome === 'skip') {
@@ -54,42 +54,42 @@ export function decideTargetRelease(target, history, options) {
 export function planTargetRelease(args) {
     const { target, settings, release, decision, history, overrideContext, sectionOrder, shouldPlanPreviews, today } = args;
     const setVersion = decision?.setVersion;
-    const bump = setVersion === undefined
+    const bumpPlan = setVersion === undefined
         ? planVersionBump(target.versionFiles, release.releaseType)
         : planVersionSet(target.versionFiles, setVersion);
-    const tag = `${target.tagPrefix}${bump.newVersion}`;
-    const writes = [...bump.writes];
+    const tag = `${target.tagPrefix}${bumpPlan.newVersion}`;
+    const writes = [...bumpPlan.writes];
     const entries = decision === undefined
-        ? buildPropagationEntries(target, release, bump.newVersion, today, args.dependenciesHeader)
-        : toReleaseEntries(history, tag, today);
+        ? buildPropagationEntries(target, release, bumpPlan.newVersion, today, args.dependenciesHeader)
+        : convertToReleaseEntries(history, tag, today);
     const overrideScope = describeOverrideScope(target);
-    const applied = applyWorkspaceOverrides(entries, overrideScope, overrideContext);
-    const changelogs = planChangelogFiles(target.changelogDir, applied.entries, settings, sectionOrder);
-    writes.push(...changelogs.writes);
+    const appliedOverrides = applyWorkspaceOverrides(entries, overrideScope, overrideContext);
+    const changelogPlan = planChangelogFiles(target.changelogDir, appliedOverrides.entries, settings, sectionOrder);
+    writes.push(...changelogPlan.writes);
     const warnings = [];
     const previewFiles = [];
     if (shouldPlanPreviews) {
-        const previews = planReleaseNotesPreviews({
+        const previewsPlan = planReleaseNotesPreviews({
             workspacePath: target.changelogDir,
             tag,
-            entries: changelogs.entries,
+            entries: changelogPlan.entries,
             sectionOrder,
         });
-        writes.push(...previews.writes);
-        warnings.push(...previews.warnings);
-        previewFiles.push(...previews.writes.map((write) => write.path));
+        writes.push(...previewsPlan.writes);
+        warnings.push(...previewsPlan.warnings);
+        previewFiles.push(...previewsPlan.writes.map((write) => write.path));
     }
     const releaseFields = {
         targetId: target.id,
-        commitCount: history.unreleased.commits.length,
-        currentVersion: bump.currentVersion,
-        newVersion: bump.newVersion,
+        commitCount: history.unreleasedReading.commits.length,
+        currentVersion: bumpPlan.currentVersion,
+        newVersion: bumpPlan.newVersion,
         tag,
-        bumpedFiles: bump.writes.map((write) => write.path),
-        changelogFiles: changelogs.changelogFiles,
-        ...(changelogs.removals.length > 0 && { removedChangelogFiles: changelogs.removals }),
+        bumpedFiles: bumpPlan.writes.map((write) => write.path),
+        changelogFiles: changelogPlan.changelogFiles,
+        ...(changelogPlan.removals.length > 0 && { removedChangelogFiles: changelogPlan.removals }),
         ...(previewFiles.length > 0 && { previewFiles }),
-        ...(changelogs.preservation !== undefined && { changelogPreservation: [changelogs.preservation] }),
+        ...(changelogPlan.preservation !== undefined && { changelogPreservation: [changelogPlan.preservation] }),
         ...(history.previousTag !== undefined && { previousTag: history.previousTag }),
     };
     const result = buildReleasedResult(target, releaseFields, release, decision, history);
@@ -97,25 +97,27 @@ export function planTargetRelease(args) {
         result,
         tag,
         writes,
-        removals: changelogs.removals,
-        modifiedFiles: [...target.versionFiles, ...changelogs.changelogFiles, ...changelogs.changelogJsonFiles],
+        removals: changelogPlan.removals,
+        modifiedFiles: [...target.versionFiles, ...changelogPlan.changelogFiles, ...changelogPlan.changelogJsonFiles],
         warnings,
     };
 }
 export function buildSkippedTargetResult(target, history, skipReason) {
-    const { unreleased } = history;
+    const { unreleasedReading } = history;
     const fields = {
         targetId: target.id,
         status: 'skipped',
-        commitCount: unreleased.commits.length,
-        parsedCommitCount: unreleased.parsedCommitCount,
+        commitCount: unreleasedReading.commits.length,
+        parsedCommitCount: unreleasedReading.parsedCommitCount,
         skipReason,
         ...(history.previousTag !== undefined && { previousTag: history.previousTag }),
-        ...(unreleased.unparseableCommits !== undefined && { unparseableCommits: unreleased.unparseableCommits }),
+        ...(unreleasedReading.unparseableCommits !== undefined && {
+            unparseableCommits: unreleasedReading.unparseableCommits,
+        }),
     };
-    const skipped = labelSkippedResult(target, fields);
-    attachChangelogDiagnostics(skipped, unreleased.diagnostics);
-    return skipped;
+    const skippedResult = labelSkippedResult(target, fields);
+    attachChangelogDiagnostics(skippedResult, unreleasedReading.diagnostics);
+    return skippedResult;
 }
 export function isRepoRoot(target) {
     return target.directoryPath === '.';

package/dist/esm/previewTagPrefixes.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { basename } from 'node:path';
-import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { DEFAULT_PROJECT_TAG_PREFIX } from "./defaults.js";
 import { deriveDirectoryConfig } from "./deriveDirectoryConfig.js";
@@ -47,19 +47,19 @@ function buildOverrideMap(config, workspacePaths) {
     return map;
 }
 function buildDirectoryRows(config, workspacePaths, overridesByPath) {
-    const discovered = new Set(workspacePaths);
+    const discoveredPaths = new Set(workspacePaths);
     return Object.entries(config?.releases ?? {}).flatMap(([name, entry]) => {
         if (entry === false || !('path' in entry))
             return [];
         const directoryPath = normalizeWorkspacePath(entry.path);
-        if (discovered.has(directoryPath))
+        if (discoveredPaths.has(directoryPath))
             return [];
-        const declared = {
+        const declaredDirectory = {
             name,
             path: directoryPath,
             ...(entry.tagPrefix !== undefined && { tagPrefix: entry.tagPrefix }),
         };
-        return [buildPreviewRow(directoryPath, () => deriveDirectoryConfig(declared).tagPrefix, overridesByPath)];
+        return [buildPreviewRow(directoryPath, () => deriveDirectoryConfig(declaredDirectory).tagPrefix, overridesByPath)];
     });
 }
 function buildPreviewRow(workspacePath, derivePrefix, overridesByPath) {
@@ -91,7 +91,7 @@ function countTagsMatching(prefix) {
     try {
         const output = execFileSync('git', ['tag', '--list', `${prefix}*`], {
             encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT,
+            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         return output.split('\n').filter((line) => matchesTagPrefix(line.trim(), [prefix])).length;
@@ -105,12 +105,12 @@ function detectCollisions(rows) {
     for (const row of rows) {
         if (row.derivedPrefix === null)
             continue;
-        const existing = pathsByPrefix.get(row.derivedPrefix);
-        if (existing === undefined) {
+        const existingPaths = pathsByPrefix.get(row.derivedPrefix);
+        if (existingPaths === undefined) {
             pathsByPrefix.set(row.derivedPrefix, [row.workspacePath]);
         }
         else {
-            existing.push(row.workspacePath);
+            existingPaths.push(row.workspacePath);
         }
     }
     const collisions = [];
@@ -122,27 +122,27 @@ function detectCollisions(rows) {
     return collisions;
 }
 function collectKnownPrefixes(rows, retiredPackages, compositeTagPrefix) {
-    const known = new Set();
+    const knownPrefixes = new Set();
     for (const row of rows) {
         if (row.derivedPrefix !== null)
-            known.add(row.derivedPrefix);
+            knownPrefixes.add(row.derivedPrefix);
         for (const entry of row.legacyEntries) {
-            known.add(entry.prefix);
+            knownPrefixes.add(entry.prefix);
         }
     }
-    for (const retired of retiredPackages) {
-        known.add(retired.tagPrefix);
+    for (const retiredPackage of retiredPackages) {
+        knownPrefixes.add(retiredPackage.tagPrefix);
     }
     if (compositeTagPrefix !== undefined)
-        known.add(compositeTagPrefix);
-    return [...known];
+        knownPrefixes.add(compositeTagPrefix);
+    return [...knownPrefixes];
 }
 function buildRetiredPreviewEntries(retiredPackages) {
-    return retiredPackages.map((retired) => ({
-        name: retired.name,
-        tagPrefix: retired.tagPrefix,
-        tagCount: countTagsMatching(retired.tagPrefix),
-        ...(retired.successor !== undefined && { successor: retired.successor }),
+    return retiredPackages.map((retiredPackage) => ({
+        name: retiredPackage.name,
+        tagPrefix: retiredPackage.tagPrefix,
+        tagCount: countTagsMatching(retiredPackage.tagPrefix),
+        ...(retiredPackage.successor !== undefined && { successor: retiredPackage.successor }),
     }));
 }
 function findCompositeTagPrefix(config) {

package/dist/esm/propagateBumps.js

@@ -5,16 +5,16 @@ export function propagateBumps(directBumps, graph) {
         result.set(dir, { ...entry });
     }
     const queue = directBumps.keys().toArray();
-    const visited = new Set();
+    const visitedDirs = new Set();
     while (queue.length > 0) {
         const dir = queue.shift();
         if (dir === undefined) {
             break;
         }
-        if (visited.has(dir)) {
+        if (visitedDirs.has(dir)) {
             continue;
         }
-        visited.add(dir);
+        visitedDirs.add(dir);
         const packageName = graph.dirToPackageName.get(dir);
         if (packageName === undefined) {
             continue;
@@ -31,19 +31,19 @@ export function propagateBumps(directBumps, graph) {
         }
         for (const dependent of dependents) {
             const dependentDir = dependent.id;
-            const existing = result.get(dependentDir);
+            const existingEntry = result.get(dependentDir);
             const propagationInfo = { packageName, newVersion };
-            if (existing === undefined) {
+            if (existingEntry === undefined) {
                 result.set(dependentDir, {
                     releaseType: 'patch',
                     propagatedFrom: [propagationInfo],
                 });
             }
             else {
-                const existingPropagated = existing.propagatedFrom ?? [];
-                existing.propagatedFrom = [...existingPropagated, propagationInfo];
+                const existingSources = existingEntry.propagatedFrom ?? [];
+                existingEntry.propagatedFrom = [...existingSources, propagationInfo];
             }
-            if (!visited.has(dependentDir)) {
+            if (!visitedDirs.has(dependentDir)) {
                 queue.push(dependentDir);
             }
         }

package/dist/esm/publish.d.ts

@@ -1,8 +1,8 @@
 import type { PackageManager } from './detectPackageManager.js';
 import type { ResolvedTag } from './resolveReleaseTags.js';
 export interface PublishOptions {
-    dryRun: boolean;
-    provenance: boolean;
+    isDryRun: boolean;
+    shouldGenerateProvenance: boolean;
 }
 /** Publishes a single package by running `{pm} publish` from its workspace directory. */
 export declare function publishPackage(resolvedTag: ResolvedTag, packageManager: PackageManager, options: PublishOptions): void;

package/dist/esm/publish.js

@@ -1,9 +1,9 @@
 import { execFileSync } from 'node:child_process';
 export function publishPackage(resolvedTag, packageManager, options) {
-    const { dryRun, provenance } = options;
+    const { isDryRun, shouldGenerateProvenance } = options;
     const executable = resolveExecutable(packageManager);
-    const args = buildPublishArgs(packageManager, { dryRun, provenance });
-    console.info(`\n${dryRun ? '[dry-run] ' : ''}Running: ${executable} ${args.join(' ')} (cwd: ${resolvedTag.workspacePath})`);
+    const args = buildPublishArgs(packageManager, { isDryRun, shouldGenerateProvenance });
+    console.info(`\n${isDryRun ? '[dry-run] ' : ''}Running: ${executable} ${args.join(' ')} (cwd: ${resolvedTag.workspacePath})`);
     execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: 'inherit' });
 }
 function resolveExecutable(packageManager) {
@@ -14,13 +14,13 @@ function resolveExecutable(packageManager) {
 }
 function buildPublishArgs(packageManager, options) {
     const args = packageManager === 'yarn-berry' ? ['npm', 'publish'] : ['publish'];
-    if (options.dryRun) {
+    if (options.isDryRun) {
         args.push('--dry-run');
     }
     if (packageManager === 'pnpm') {
         args.push('--no-git-checks');
     }
-    if (options.provenance && packageManager !== 'yarn') {
+    if (options.shouldGenerateProvenance && packageManager !== 'yarn') {
         args.push('--provenance');
     }
     return args;

package/dist/esm/publishCommand.js

@@ -17,17 +17,17 @@ import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const publishFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
-    noGitChecks: { long: '--no-git-checks', type: 'boolean' },
-    provenance: { long: '--provenance', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
+    shouldSkipGitChecks: { long: '--no-git-checks', type: 'boolean' },
+    shouldGenerateProvenance: { long: '--provenance', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
 };
 export async function publishCommand(argv, styles, invocationDir) {
-    const parsed = parseArgsOrExit(argv, publishFlagSchema);
-    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
-    const { dryRun, noGitChecks, provenance } = parsed.flags;
+    const parsedArgs = parseArgsOrExit(argv, publishFlagSchema);
+    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
+    const { isDryRun, shouldSkipGitChecks, shouldGenerateProvenance } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    if (!dryRun && !noGitChecks) {
+    if (!isDryRun && !shouldSkipGitChecks) {
         try {
             assertCleanWorkingTree();
         }
@@ -36,7 +36,7 @@ export async function publishCommand(argv, styles, invocationDir) {
             process.exit(1);
         }
     }
-    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     if (resolvedTags.length === 0) {
         return;
@@ -49,11 +49,11 @@ export async function publishCommand(argv, styles, invocationDir) {
     const packageManager = detectPackageManager();
     const { releaseNotes, changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     const shouldInject = releaseNotes.shouldInjectIntoReadme;
-    console.info(dryRun ? '[dry-run] Would publish:' : 'Publishing:');
+    console.info(isDryRun ? '[dry-run] Would publish:' : 'Publishing:');
     for (const { tag, workspacePath } of publishableTags) {
         console.info(`  ${tag} (${workspacePath})`);
     }
-    const published = [];
+    const publishedTags = [];
     try {
         for (const resolvedTag of publishableTags) {
             let readmePath;
@@ -65,8 +65,8 @@ export async function publishCommand(argv, styles, invocationDir) {
                 }
             }
             try {
-                publishPackage(resolvedTag, packageManager, { dryRun, provenance });
-                published.push(resolvedTag.tag);
+                publishPackage(resolvedTag, packageManager, { isDryRun, shouldGenerateProvenance });
+                publishedTags.push(resolvedTag.tag);
             }
             finally {
                 if (readmePath !== undefined && originalReadme !== undefined) {
@@ -76,10 +76,10 @@ export async function publishCommand(argv, styles, invocationDir) {
         }
     }
     catch (error) {
-        if (published.length > 0) {
+        if (publishedTags.length > 0) {
             console.warn('Packages published before failure:');
-            for (const t of published) {
-                console.warn(`  ${t}`);
+            for (const tag of publishedTags) {
+                console.warn(`  ${tag}`);
             }
         }
         reportError(describeError(error));
@@ -87,17 +87,17 @@ export async function publishCommand(argv, styles, invocationDir) {
     }
 }
 function filterPublishableTags(resolvedTags, isExplicit) {
-    const publishable = [];
-    const unpublishable = [];
+    const publishableTags = [];
+    const unpublishableTags = [];
     for (const tag of resolvedTags) {
-        (tag.isPublishable ? publishable : unpublishable).push(tag);
+        (tag.isPublishable ? publishableTags : unpublishableTags).push(tag);
     }
     if (isExplicit) {
-        for (const resolvedTag of unpublishable) {
+        for (const resolvedTag of unpublishableTags) {
             console.warn(formatPublishSkip(resolvedTag));
         }
     }
-    return publishable;
+    return publishableTags;
 }
 function formatPublishSkip(resolvedTag) {
     switch (resolvedTag.kind) {

package/dist/esm/pushCommand.js

@@ -8,21 +8,21 @@ import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const pushFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
     tagsOnly: { long: '--tags-only', type: 'boolean' },
 };
 export async function pushCommand(argv, styles, invocationDir) {
-    const parsed = parseArgsOrExit(argv, pushFlagSchema);
-    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
-    const { dryRun, tagsOnly } = parsed.flags;
+    const parsedArgs = parseArgsOrExit(argv, pushFlagSchema);
+    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
+    const { isDryRun, tagsOnly } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     if (resolvedTags.length === 0) {
         return;
     }
-    const prefix = dryRun ? '[dry-run] Would push' : 'Pushing';
+    const prefix = isDryRun ? '[dry-run] Would push' : 'Pushing';
     if (!tagsOnly) {
         console.info(`${prefix} branch and ${resolvedTags.length} tag(s):`);
     }
@@ -33,8 +33,8 @@ export async function pushCommand(argv, styles, invocationDir) {
         console.info(`  ${tag}`);
     }
     try {
-        const steps = pushRelease(resolvedTags, { dryRun, tagsOnly });
-        if (dryRun) {
+        const steps = pushRelease(resolvedTags, { isDryRun, tagsOnly });
+        if (isDryRun) {
             for (const step of steps) {
                 console.info(`[dry-run] ${step.command.join(' ')}`);
             }

package/dist/esm/pushRelease.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedTag } from './resolveReleaseTags.js';
 export interface PushReleaseOptions {
-    dryRun?: boolean;
+    isDryRun?: boolean;
     tagsOnly?: boolean;
 }
 export interface PushStep {

package/dist/esm/pushRelease.js

@@ -1,12 +1,12 @@
 import { execFileSync } from 'node:child_process';
-import { GIT_OUTPUT_LIMIT } from '@williamthorsen/nmr-core';
+import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 export function pushRelease(resolvedTags, options = {}) {
-    const { dryRun = false, tagsOnly = false } = options;
+    const { isDryRun = false, tagsOnly = false } = options;
     const steps = [];
     if (!tagsOnly) {
         const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
             encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT,
+            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
             stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
         const command = ['git', 'push', 'origin', branch];
@@ -16,7 +16,7 @@ export function pushRelease(resolvedTags, options = {}) {
         const command = ['git', 'push', '--no-follow-tags', 'origin', tag];
         steps.push({ type: 'tag', ref: tag, command });
     }
-    if (!dryRun) {
+    if (!isDryRun) {
         for (const step of steps) {
             execFileSync(step.command[0], step.command.slice(1), { stdio: 'inherit' });
         }

package/dist/esm/readChangelogSections.d.ts

@@ -7,7 +7,7 @@ export interface VersionedMarkdownSection {
 }
 /** The `##` sections of a `CHANGELOG.md`, split by whether their heading names a version. */
 export interface ChangelogMarkdownSections {
-    versioned: VersionedMarkdownSection[];
+    versionedSections: VersionedMarkdownSection[];
     /** Headings of the `##` sections that do not name a version, as written. */
     unversionedHeadings: string[];
 }

package/dist/esm/readChangelogSections.js

@@ -9,14 +9,14 @@ export function planPreservedSections(changelogDir, entries) {
     const sections = [];
     const unversionedHeadings = [];
     for (const file of files) {
-        const read = readChangelogSections(file);
-        for (const section of read.versioned) {
+        const fileSections = readChangelogSections(file);
+        for (const section of fileSections.versionedSections) {
             if (seenVersions.has(section.version))
                 continue;
             seenVersions.add(section.version);
             sections.push(section);
         }
-        unversionedHeadings.push(...read.unversionedHeadings);
+        unversionedHeadings.push(...fileSections.unversionedHeadings);
     }
     if (sections.length === 0 && unversionedHeadings.length === 0) {
         return { sections, preservation: undefined };
@@ -32,29 +32,29 @@ export function planPreservedSections(changelogDir, entries) {
 }
 export function readChangelogSections(filePath) {
     if (!existsSync(filePath)) {
-        return { versioned: [], unversionedHeadings: [] };
+        return { versionedSections: [], unversionedHeadings: [] };
     }
     return parseChangelogSections(readFileSync(filePath, 'utf8'));
 }
 export function parseChangelogSections(content) {
     const sections = [];
-    let current;
+    let currentSection;
     let fence;
     for (const line of content.split(/\r?\n/)) {
         if (fence === undefined) {
             if (FOOTER_PATTERN.test(line)) {
-                current = undefined;
+                currentSection = undefined;
                 continue;
             }
             if (SECTION_HEADING_PATTERN.test(line)) {
-                current = { heading: line.trimEnd(), lines: [] };
-                sections.push(current);
+                currentSection = { heading: line.trimEnd(), lines: [] };
+                sections.push(currentSection);
             }
         }
         fence = updateFence(fence, line);
-        current?.lines.push(line);
+        currentSection?.lines.push(line);
     }
-    const versioned = [];
+    const versionedSections = [];
     const unversionedHeadings = [];
     for (const { heading, lines } of sections) {
         const version = extractHeadingVersion(heading);
@@ -62,10 +62,10 @@ export function parseChangelogSections(content) {
             unversionedHeadings.push(heading);
         }
         else {
-            versioned.push({ version, text: trimTrailingBlankLines(lines).join('\n') });
+            versionedSections.push({ version, text: trimTrailingBlankLines(lines).join('\n') });
         }
     }
-    return { versioned, unversionedHeadings };
+    return { versionedSections, unversionedHeadings };
 }
 const FOOTER_PATTERN = /^<!-- Generated by release-kit\b/;
 const SECTION_HEADING_PATTERN = /^## /;
@@ -78,11 +78,11 @@ function extractHeadingVersion(heading) {
     return semver.valid(token) ?? undefined;
 }
 function trimTrailingBlankLines(lines) {
-    let end = lines.length;
-    while (end > 0 && lines[end - 1]?.trim() === '') {
-        end--;
+    let endIndex = lines.length;
+    while (endIndex > 0 && lines[endIndex - 1]?.trim() === '') {
+        endIndex--;
     }
-    return lines.slice(0, end);
+    return lines.slice(0, endIndex);
 }
 function updateFence(fence, line) {
     const marker = FENCE_PATTERN.exec(line)?.[1];