@williamthorsen/release-kit 15.0.3 → 16.0.0

package/dist/esm/releasePlan.js

@@ -4,17 +4,17 @@ import { deleteFileIfExists } from "./deleteFileIfExists.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 const HANDOFF_FILES = new Set([RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE]);
 export function applyReleasePlan(plan) {
-    const ordered = orderPlannedSteps(plan);
-    const applied = [];
-    for (const [index, step] of ordered.entries()) {
+    const orderedSteps = orderPlannedSteps(plan);
+    const appliedWrites = [];
+    for (const [index, step] of orderedSteps.entries()) {
         const outcome = applyStep(step);
         if (outcome.outcome === 'failed') {
-            const unwritten = ordered.slice(index).map((pending) => pending.path);
-            throw new Error(describeApplyFailure({ failedStep: step, error: outcome.error, applied, unwritten }));
+            const unwrittenPaths = orderedSteps.slice(index).map((pending) => pending.path);
+            throw new Error(describeApplyFailure({ failedStep: step, error: outcome.error, appliedWrites, unwrittenPaths }));
         }
-        applied.push({ path: step.path, created: outcome.outcome === 'created' });
+        appliedWrites.push({ path: step.path, created: outcome.outcome === 'created' });
     }
-    return applied.map((write) => write.path);
+    return appliedWrites.map((write) => write.path);
 }
 function applyStep(step) {
     if (step.kind === 'remove') {
@@ -33,43 +33,43 @@ function applyStep(step) {
     return { outcome: result.outcome === 'created' ? 'created' : 'applied' };
 }
 function orderPlannedSteps(plan) {
-    const ordered = [
+    const orderedSteps = [
         ...plan.writes.map((write) => ({ kind: 'write', ...write })),
         ...plan.removals.map((path) => ({ kind: 'remove', path })),
     ];
     if (plan.summary.length > 0) {
-        ordered.push({ kind: 'write', path: RELEASE_SUMMARY_FILE, content: plan.summary });
+        orderedSteps.push({ kind: 'write', path: RELEASE_SUMMARY_FILE, content: plan.summary });
     }
     if (plan.tags.length > 0) {
-        ordered.push({ kind: 'write', path: RELEASE_TAGS_FILE, content: plan.tags.join('\n') });
+        orderedSteps.push({ kind: 'write', path: RELEASE_TAGS_FILE, content: plan.tags.join('\n') });
     }
-    return ordered;
+    return orderedSteps;
 }
 function describeApplyFailure(args) {
-    const { failedStep, error, applied, unwritten } = args;
-    const total = applied.length + unwritten.length;
+    const { failedStep, error, appliedWrites, unwrittenPaths } = args;
+    const totalCount = appliedWrites.length + unwrittenPaths.length;
     const verb = failedStep.kind === 'remove' ? 'remove' : 'write';
     const lines = [`Failed to ${verb} ${failedStep.path}: ${error ?? 'unknown error'}`, ''];
-    if (applied.length === 0) {
-        lines.push(`The release was not applied. None of its ${total} files were written.`);
+    if (appliedWrites.length === 0) {
+        lines.push(`The release was not applied. None of its ${totalCount} files were written.`);
         return lines.join('\n');
     }
-    lines.push(`The release was partially applied. ${applied.length} of ${total} files were written:`, ...applied.map((write) => `  ${write.path}`), '', 'Not written:', ...unwritten.map((path) => `  ${path}`), ...describeRecovery(applied));
+    lines.push(`The release was partially applied. ${appliedWrites.length} of ${totalCount} files were written:`, ...appliedWrites.map((write) => `  ${write.path}`), '', 'Not written:', ...unwrittenPaths.map((path) => `  ${path}`), ...describeRecovery(appliedWrites));
     return lines.join('\n');
 }
-function describeRecovery(applied) {
-    const releaseWrites = applied.filter((write) => !HANDOFF_FILES.has(write.path));
-    const replaced = releaseWrites.filter((write) => !write.created).map((write) => write.path);
-    const created = releaseWrites.filter((write) => write.created).map((write) => write.path);
-    if (replaced.length === 0 && created.length === 0) {
+function describeRecovery(appliedWrites) {
+    const releaseWrites = appliedWrites.filter((write) => !HANDOFF_FILES.has(write.path));
+    const replacedPaths = releaseWrites.filter((write) => !write.created).map((write) => write.path);
+    const createdPaths = releaseWrites.filter((write) => write.created).map((write) => write.path);
+    if (replacedPaths.length === 0 && createdPaths.length === 0) {
         return [];
     }
     const lines = ['', 'Undo the written release files before re-running `release-kit prepare`:'];
-    if (replaced.length > 0) {
-        lines.push(`  git restore ${replaced.join(' ')}`);
+    if (replacedPaths.length > 0) {
+        lines.push(`  git restore ${replacedPaths.join(' ')}`);
     }
-    if (created.length > 0) {
-        lines.push(`  rm ${created.join(' ')}`);
+    if (createdPaths.length > 0) {
+        lines.push(`  rm ${createdPaths.join(' ')}`);
     }
     return lines;
 }

package/dist/esm/renderChangelogMarkdown.d.ts

@@ -13,7 +13,7 @@ export interface RenderChangelogMarkdownOptions {
 /** Options for `renderChangelogFiles`. */
 export interface RenderChangelogFilesOptions extends RenderChangelogMarkdownOptions {
     /** How many of the newest sections the main file keeps; every section when omitted. Must be at least 1. */
-    keepVersions?: number;
+    keptVersionCount?: number;
 }
 /** A rendered archive file: the sections of one major version that the main file does not keep. */
 export interface RenderedChangelogArchive {
@@ -28,9 +28,9 @@ export interface RenderedChangelogFiles {
 /**
  * Renders entries and preserved sections into `CHANGELOG.md` and its per-major archive files.
  *
- * The main file keeps the newest `keepVersions` sections, counting preserved sections, and links to each archive file
- * from a paragraph below its header. Each older section goes to the archive file of its major version. Every file
- * has the same header and footer.
+ * The main file keeps as many of the newest sections as `keptVersionCount` names, counting preserved sections, and
+ * links to each archive file from a paragraph below its header. Each older section goes to the archive file of its
+ * major version. Every file has the same header and footer.
  */
 export declare function renderChangelogFiles(entries: ChangelogEntry[], options?: RenderChangelogFilesOptions): RenderedChangelogFiles;
 /**

package/dist/esm/renderChangelogMarkdown.js

@@ -8,19 +8,25 @@ All notable changes to this project will be documented in this file.`;
 const CHANGELOG_FOOTER = `<!-- Generated by release-kit. Do not edit this file. Use .meta/changelog-overrides.json to override entries. -->`;
 export function renderChangelogFiles(entries, options) {
     const sections = interleavePreservedSections(entries.map((entry) => ({ version: entry.version, text: renderReleaseNotesSingle(entry, options) })), options?.preservedSections ?? []).filter((section) => section.text.length > 0);
-    const keepVersions = options?.keepVersions;
-    if (keepVersions === undefined || sections.length <= keepVersions) {
+    const keptVersionCount = options?.keptVersionCount;
+    if (keptVersionCount === undefined || sections.length <= keptVersionCount) {
         return { main: renderFile(sections), archives: [] };
     }
-    const archived = groupByMajor(sections.slice(keepVersions));
+    const archivedGroups = groupByMajor(sections.slice(keptVersionCount));
     return {
-        main: renderFile(sections.slice(0, keepVersions), describeArchivePointer(archived.map(({ major }) => major))),
-        archives: archived.map(({ major, sections: majorSections }) => ({ major, content: renderFile(majorSections) })),
+        main: renderFile(sections.slice(0, keptVersionCount), describeArchivePointer(archivedGroups.map(({ major }) => major))),
+        archives: archivedGroups.map(({ major, sections: majorSections }) => ({
+            major,
+            content: renderFile(majorSections),
+        })),
     };
 }
 export function renderChangelogMarkdown(entries, options) {
     return renderChangelogFiles(entries, options).main;
 }
+function appendTrailingNewline(section) {
+    return { version: section.version, text: `${section.text}\n` };
+}
 function describeArchivePointer(majors) {
     const links = majors.map((major) => `[v${major}](${describeArchivePath(major)})`);
     return `Earlier versions: ${links.join(', ')}.`;
@@ -39,21 +45,21 @@ function groupByMajor(sections) {
     }
     return Array.from(groups, ([major, majorSections]) => ({ major, sections: majorSections })).toSorted((a, b) => b.major - a.major);
 }
-function interleavePreservedSections(rendered, preserved) {
-    const sorted = preserved.toSorted((a, b) => compareVersionsDescending(a.version, b.version));
-    const pending = sorted.map(withTrailingNewline);
+function interleavePreservedSections(renderedSections, preservedSections) {
+    const sortedSections = preservedSections.toSorted((a, b) => compareVersionsDescending(a.version, b.version));
+    const pendingSections = sortedSections.map(appendTrailingNewline);
     const result = [];
     let index = 0;
-    for (const part of rendered) {
-        let section = pending[index];
+    for (const part of renderedSections) {
+        let section = pendingSections[index];
         while (section !== undefined && compareVersionsDescending(section.version, part.version) < 0) {
             result.push(section);
             index++;
-            section = pending[index];
+            section = pendingSections[index];
         }
         result.push(part);
     }
-    result.push(...pending.slice(index));
+    result.push(...pendingSections.slice(index));
     return result;
 }
 function renderFile(sections, paragraph) {
@@ -71,6 +77,3 @@ function renderFile(sections, paragraph) {
     parts.push(CHANGELOG_FOOTER);
     return parts.join('\n\n') + '\n';
 }
-function withTrailingNewline(section) {
-    return { version: section.version, text: `${section.text}\n` };
-}

package/dist/esm/renderReleaseNotes.d.ts

@@ -4,7 +4,7 @@ export interface RenderOptions {
     /** Predicate to filter sections. When absent, all sections are included. */
     filter?: (section: ChangelogSection) => boolean;
     /** Whether to include the version/date heading. Defaults to `true`. */
-    includeHeading?: boolean;
+    shouldIncludeHeading?: boolean;
     /**
      * Section titles in desired priority order. Known titles are emitted first in this order;
      * titles not listed preserve their relative position after known ones. When absent, section

package/dist/esm/renderReleaseNotes.js

@@ -3,26 +3,26 @@ function getBreakingPrefix() {
     const { emoji, label } = CANONICAL_TAXONOMY.markers.breaking;
     return `${emoji} **${label}:** `;
 }
-function allSections() {
+function matchAllSections() {
     return true;
 }
-function publicSections(section) {
+function matchPublicSections(section) {
     return section.audience === 'all';
 }
 export function matchesAudience(audience) {
-    return audience === 'dev' ? allSections : publicSections;
+    return audience === 'dev' ? matchAllSections : matchPublicSections;
 }
 export function renderReleaseNotesSingle(entry, options) {
     const filter = options?.filter;
-    const includeHeading = options?.includeHeading ?? true;
+    const shouldIncludeHeading = options?.shouldIncludeHeading ?? true;
     const sectionOrder = options?.sectionOrder;
-    const filtered = filter !== undefined ? entry.sections.filter(filter) : entry.sections;
-    const sections = sectionOrder !== undefined ? sortSectionsByOrder(filtered, sectionOrder) : filtered;
+    const filteredSections = filter !== undefined ? entry.sections.filter(filter) : entry.sections;
+    const sections = sectionOrder !== undefined ? sortSectionsByOrder(filteredSections, sectionOrder) : filteredSections;
     if (sections.length === 0) {
         return '';
     }
     const lines = [];
-    if (includeHeading) {
+    if (shouldIncludeHeading) {
         lines.push(`## ${entry.version} — ${entry.date}`);
     }
     for (const section of sections) {
@@ -45,20 +45,20 @@ export function renderReleaseNotesSingle(entry, options) {
     return lines.join('\n') + '\n';
 }
 function sortSectionsByOrder(sections, order) {
-    const priority = new Map();
+    const priorityByTitle = new Map();
     for (const [index, title] of order.entries()) {
-        priority.set(title, index);
+        priorityByTitle.set(title, index);
     }
-    const indexed = sections.map((section, index) => ({ section, index }));
-    indexed.sort((a, b) => {
-        const priorityA = priority.get(a.section.title) ?? Infinity;
-        const priorityB = priority.get(b.section.title) ?? Infinity;
-        if (priorityA !== priorityB) {
-            return priorityA - priorityB;
+    const indexedSections = sections.map((section, index) => ({ section, index }));
+    indexedSections.sort((a, b) => {
+        const aPriority = priorityByTitle.get(a.section.title) ?? Infinity;
+        const bPriority = priorityByTitle.get(b.section.title) ?? Infinity;
+        if (aPriority !== bPriority) {
+            return aPriority - bPriority;
         }
         return a.index - b.index;
     });
-    return indexed.map(({ section }) => section);
+    return indexedSections.map(({ section }) => section);
 }
 function indentBodyLines(body) {
     return body.split('\n').map((line) => (line.length === 0 ? '' : `  ${line}`));

package/dist/esm/reportPrepare.js

@@ -1,5 +1,5 @@
 import { formatGlyphLine, formatStatusLine, measureGlyphColumn, STATUS_GLYPHS, } from '@williamthorsen/nmr-core';
-import { bold, dim, sectionHeader } from "./format.js";
+import { bold, dim, renderSectionHeader } from "./format.js";
 import { formatBumpFiles, formatChangelogFiles, formatPreviewFiles } from "./formatPrepareFiles.js";
 import { formatChangeRecordWarnings, formatPolicyViolations, formatUnparseableWarning, formatWarnings, } from "./formatPrepareWarnings.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
@@ -12,15 +12,15 @@ export function reportPrepare(plan, options) {
     return formatSingleWorkspace(plan, options);
 }
 function formatSingleWorkspace(result, options) {
-    const dryRun = !options.applied;
+    const isDryRun = !options.applied;
     const { style } = options;
     const lines = [];
     const workspace = result.targets[0];
     if (workspace === undefined || workspace.kind === 'composite') {
         return '';
     }
-    const since = workspace.previousTag === undefined ? 'the beginning' : workspace.previousTag;
-    lines.push(dim(`Found ${workspace.commitCount} commits since ${since}`));
+    const sinceLabel = workspace.previousTag === undefined ? 'the beginning' : workspace.previousTag;
+    lines.push(dim(`Found ${workspace.commitCount} commits since ${sinceLabel}`));
     if (workspace.parsedCommitCount !== undefined) {
         lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
     }
@@ -32,8 +32,8 @@ function formatSingleWorkspace(result, options) {
         formatWarnings(lines, result, style);
         return lines.join('\n');
     }
-    if (workspace.setVersion !== undefined) {
-        lines.push(`  Using version override: ${workspace.setVersion}`);
+    if (workspace.versionOverride !== undefined) {
+        lines.push(`  Using version override: ${workspace.versionOverride}`);
     }
     else if (workspace.bumpOverride !== undefined) {
         lines.push(`  Using bump override: ${workspace.bumpOverride}`);
@@ -41,35 +41,35 @@ function formatSingleWorkspace(result, options) {
     if (workspace.releaseType !== undefined) {
         lines.push(dim(`Bumping versions (${workspace.releaseType})...`));
     }
-    else if (workspace.setVersion !== undefined) {
+    else if (workspace.versionOverride !== undefined) {
         lines.push(dim(`Bumping versions (version override)...`));
     }
-    if (workspace.setVersion !== undefined) {
+    if (workspace.versionOverride !== undefined) {
         lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (version override)`));
     }
     else if (workspace.releaseType !== undefined) {
         lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType})`));
     }
     formatChangeRecordWarnings(lines, workspace, style);
-    formatBumpFiles(lines, workspace, dryRun);
+    formatBumpFiles(lines, workspace, isDryRun);
     lines.push(dim('Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, dryRun, style);
-    formatPreviewFiles(lines, workspace, dryRun);
+    formatChangelogFiles(lines, workspace, isDryRun, style);
+    formatPreviewFiles(lines, workspace, isDryRun);
     formatFormatCommand(lines, result, options);
     formatWarnings(lines, result, style);
     lines.push(formatStatusLine(style, 'passed', 'Release preparation complete.'), `   ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
     return lines.join('\n');
 }
 function formatMultiWorkspace(result, options) {
-    const dryRun = !options.applied;
+    const isDryRun = !options.applied;
     const { style } = options;
     const lines = [];
     for (const target of result.targets) {
         if (target.kind === 'composite') {
-            formatProjectSection(lines, target, dryRun, style);
+            formatProjectSection(lines, target, isDryRun, style);
         }
         else {
-            formatWorkspaceSection(lines, target, dryRun, style);
+            formatWorkspaceSection(lines, target, isDryRun, style);
         }
     }
     formatFormatCommand(lines, result, options);
@@ -85,10 +85,10 @@ function formatMultiWorkspace(result, options) {
     }
     return lines.join('\n');
 }
-function formatProjectSection(lines, project, dryRun, style) {
-    lines.push(`\n${sectionHeader(project.targetId === PROJECT_TARGET_ID ? 'project' : project.targetId)}`);
-    const since = project.previousTag === undefined ? '(no previous release found)' : `since ${project.previousTag}`;
-    lines.push(dim(`  Found ${project.commitCount} commits ${since}`));
+function formatProjectSection(lines, project, isDryRun, style) {
+    lines.push(`\n${renderSectionHeader(project.targetId === PROJECT_TARGET_ID ? 'project' : project.targetId)}`);
+    const sinceLabel = project.previousTag === undefined ? '(no previous release found)' : `since ${project.previousTag}`;
+    lines.push(dim(`  Found ${project.commitCount} commits ${sinceLabel}`));
     formatPolicyViolations(lines, project.policyViolations, style, '  ');
     if (project.status === 'skipped') {
         formatUnparseableWarning(lines, project, style, '  ');
@@ -107,7 +107,7 @@ function formatProjectSection(lines, project, dryRun, style) {
     formatChangeRecordWarnings(lines, project, style, '  ');
     lines.push(dim(`  Bumping versions (${releaseType})...`), `  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${currentVersion} → ${bold(newVersion)} (${releaseType})`)}`);
     for (const file of project.bumpedFiles) {
-        if (dryRun) {
+        if (isDryRun) {
             lines.push(dim(`    [dry-run] Would bump ${file}`));
         }
         else {
@@ -115,16 +115,16 @@ function formatProjectSection(lines, project, dryRun, style) {
         }
     }
     lines.push(dim('  Generating changelogs...'));
-    formatChangelogFiles(lines, project, dryRun, style, '  ');
-    formatPreviewFiles(lines, project, dryRun, '  ');
+    formatChangelogFiles(lines, project, isDryRun, style, '  ');
+    formatPreviewFiles(lines, project, isDryRun, '  ');
     lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(tag))}`);
 }
-function formatWorkspaceSection(lines, workspace, dryRun, style) {
+function formatWorkspaceSection(lines, workspace, isDryRun, style) {
     if (workspace.name !== undefined) {
-        lines.push(`\n${sectionHeader(workspace.name)}`);
+        lines.push(`\n${renderSectionHeader(workspace.name)}`);
     }
-    const since = workspace.previousTag === undefined ? '(no previous release found)' : `since ${workspace.previousTag}`;
-    lines.push(dim(`  Found ${workspace.commitCount} commits ${since}`));
+    const sinceLabel = workspace.previousTag === undefined ? '(no previous release found)' : `since ${workspace.previousTag}`;
+    lines.push(dim(`  Found ${workspace.commitCount} commits ${sinceLabel}`));
     if (workspace.status === 'skipped') {
         formatUnparseableWarning(lines, workspace, style, '  ');
         formatPolicyViolations(lines, workspace.policyViolations, style, '  ');
@@ -140,24 +140,24 @@ function formatWorkspaceSection(lines, workspace, dryRun, style) {
     formatChangeRecordWarnings(lines, workspace, style, '  ');
     formatBumpLabels(lines, workspace, isPropagatedOnly);
     formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style);
-    formatBumpFiles(lines, workspace, dryRun, '  ');
+    formatBumpFiles(lines, workspace, isDryRun, '  ');
     lines.push(dim('  Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, dryRun, style, '  ');
-    formatPreviewFiles(lines, workspace, dryRun, '  ');
+    formatChangelogFiles(lines, workspace, isDryRun, style, '  ');
+    formatPreviewFiles(lines, workspace, isDryRun, '  ');
     lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
 }
 function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
     if (isPropagatedOnly && propagatedFrom !== undefined) {
-        const depNames = propagatedFrom.map((p) => p.packageName).join(', ');
-        lines.push(dim(`  Bumped via dependency: ${depNames}`));
+        const dependencyNames = propagatedFrom.map((p) => p.packageName).join(', ');
+        lines.push(dim(`  Bumped via dependency: ${dependencyNames}`));
     }
     else if (workspace.parsedCommitCount !== undefined && workspace.parsedCommitCount > 0) {
         lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
     }
 }
 function formatBumpLabels(lines, workspace, isPropagatedOnly) {
-    if (workspace.setVersion !== undefined) {
-        lines.push(`  Using version override: ${workspace.setVersion}`);
+    if (workspace.versionOverride !== undefined) {
+        lines.push(`  Using version override: ${workspace.versionOverride}`);
     }
     else if (workspace.bumpOverride !== undefined && !isPropagatedOnly) {
         lines.push(`  Using bump override: ${workspace.bumpOverride}`);
@@ -165,13 +165,13 @@ function formatBumpLabels(lines, workspace, isPropagatedOnly) {
     if (workspace.releaseType !== undefined) {
         lines.push(dim(`  Bumping versions (${workspace.releaseType})...`));
     }
-    else if (workspace.setVersion !== undefined) {
+    else if (workspace.versionOverride !== undefined) {
         lines.push(dim(`  Bumping versions (version override)...`));
     }
 }
 function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style) {
     const versions = `${workspace.currentVersion} → ${bold(workspace.newVersion)}`;
-    if (workspace.setVersion !== undefined) {
+    if (workspace.versionOverride !== undefined) {
         lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (version override)`)}`);
     }
     else if (workspace.releaseType !== undefined) {

package/dist/esm/resolveCommandTags.js

@@ -29,12 +29,12 @@ export function resolveCommandTags(tags, userConfig) {
             singleWorkspace = deriveWorkspaceConfig('.');
         }
         else {
-            const merged = mergeMonorepoConfig(workspace.packageDirs, userConfig, readRootPackageVersion());
-            const excluded = merged.excludedWorkspaces ?? [];
-            workspaces = [...merged.workspaces, ...excluded];
-            directories = merged.directories ?? [];
-            project = merged.project;
-            excludedPaths = new Set(excluded.map((excludedWorkspace) => excludedWorkspace.workspacePath));
+            const mergedConfig = mergeMonorepoConfig(workspace.packageDirs, userConfig, readRootPackageVersion());
+            const excludedWorkspaces = mergedConfig.excludedWorkspaces ?? [];
+            workspaces = [...mergedConfig.workspaces, ...excludedWorkspaces];
+            directories = mergedConfig.directories ?? [];
+            project = mergedConfig.project;
+            excludedPaths = new Set(excludedWorkspaces.map((excludedWorkspace) => excludedWorkspace.workspacePath));
         }
     }
     catch (error) {
@@ -69,15 +69,15 @@ export function resolveCommandTags(tags, userConfig) {
     return dropExcludedTags(resolvedTags, excludedPaths, userConfig?.releases === undefined ? 'legacy' : 'releases');
 }
 function dropExcludedTags(resolvedTags, excludedPaths, surface) {
-    const retained = [];
+    const retainedTags = [];
     for (const resolvedTag of resolvedTags) {
         if (resolvedTag.kind === 'package' && excludedPaths.has(resolvedTag.workspacePath)) {
             const setting = surface === 'releases' ? `releases.${resolvedTag.dir}: false` : undefined;
             console.warn(formatExcludedSkip(resolvedTag, setting));
         }
         else {
-            retained.push(resolvedTag);
+            retainedTags.push(resolvedTag);
         }
     }
-    return retained;
+    return retainedTags;
 }

package/dist/esm/resolveReleaseDeclaration.d.ts

@@ -24,9 +24,9 @@ export interface DeclaredDirectory {
 /** The release targets that a config declares over the discovered workspaces. */
 export interface ReleaseDeclaration {
     /** Retained workspaces in discovery order, each with its target name and legacy identities applied. */
-    retained: WorkspaceConfig[];
+    retainedWorkspaces: WorkspaceConfig[];
     /** Discovered workspaces that the config excludes, in discovery order. */
-    excluded: WorkspaceConfig[];
+    excludedWorkspaces: WorkspaceConfig[];
     /** Directories that `releases` entries declare as targets, in config order. */
     directories: DeclaredDirectory[];
     composite?: DeclaredComposite;

package/dist/esm/resolveReleaseDeclaration.js

@@ -3,8 +3,8 @@ export function getTargetName(workspace) {
     return workspace.targetName ?? workspace.dir;
 }
 export function normalizeWorkspacePath(configuredPath) {
-    const normalized = path.posix.normalize(configuredPath.replaceAll('\\', '/'));
-    return normalized.replace(/^\.\//, '').replace(/\/+$/, '');
+    const normalizedPath = path.posix.normalize(configuredPath.replaceAll('\\', '/'));
+    return normalizedPath.replace(/^\.\//, '').replace(/\/+$/, '');
 }
 export function resolveReleaseDeclaration(workspaces, userConfig) {
     if (userConfig?.releases !== undefined) {
@@ -19,9 +19,9 @@ function applyLegacyIdentities(workspace, legacyIdentities) {
     return { ...workspace, legacyIdentities: legacyIdentities.map((identity) => ({ ...identity })) };
 }
 function claimPath(entryByPath, name, claimedPath, kind) {
-    const claimedBy = entryByPath.get(claimedPath);
-    if (claimedBy !== undefined) {
-        throw new Error(`releases.${name}: ${kind} '${claimedPath}' is already declared by releases.${claimedBy}; declare each ${kind} once`);
+    const claimingEntryName = entryByPath.get(claimedPath);
+    if (claimingEntryName !== undefined) {
+        throw new Error(`releases.${name}: ${kind} '${claimedPath}' is already declared by releases.${claimingEntryName}; declare each ${kind} once`);
     }
     entryByPath.set(claimedPath, name);
 }
@@ -40,9 +40,9 @@ function declareDirectory(name, entry, normalizedPath) {
         }),
     };
 }
-function resolveCompositeMembers(composite, retained, excluded, directories) {
+function resolveCompositeMembers(composite, retainedWorkspaces, excludedWorkspaces, directories) {
     const membersByName = new Map([
-        ...retained.map((workspace) => [getTargetName(workspace), { name: getTargetName(workspace), paths: workspace.paths }]),
+        ...retainedWorkspaces.map((workspace) => [getTargetName(workspace), { name: getTargetName(workspace), paths: workspace.paths }]),
         ...directories.map((directory) => [directory.name, { name: directory.name, paths: directory.paths }]),
     ]);
     return composite.includes.map((memberName) => {
@@ -54,7 +54,7 @@ function resolveCompositeMembers(composite, retained, excluded, directories) {
         if (memberName === composite.name) {
             throw new Error(`${label} is the composite itself; a composite includes package and directory targets only`);
         }
-        if (excluded.some((workspace) => workspace.dir === memberName)) {
+        if (excludedWorkspaces.some((workspace) => workspace.dir === memberName)) {
             throw new Error(`${label} is excluded, so the composite cannot include it`);
         }
         throw new Error(`${label} is not a release target. Known targets: ${membersByName.keys().toArray().join(', ')}`);
@@ -62,18 +62,18 @@ function resolveCompositeMembers(composite, retained, excluded, directories) {
 }
 function resolveLegacyBlocks(workspaces, overrides, project) {
     const overridesByDir = new Map(overrides.map((override) => [override.dir, override]));
-    const retained = [];
-    const excluded = [];
+    const retainedWorkspaces = [];
+    const excludedWorkspaces = [];
     for (const workspace of workspaces) {
         const override = overridesByDir.get(workspace.dir);
         if (override?.shouldExclude === true) {
-            excluded.push(workspace);
+            excludedWorkspaces.push(workspace);
         }
         else {
-            retained.push(applyLegacyIdentities(workspace, override?.legacyIdentities));
+            retainedWorkspaces.push(applyLegacyIdentities(workspace, override?.legacyIdentities));
         }
     }
-    const declaration = { retained, excluded, directories: [] };
+    const declaration = { retainedWorkspaces, excludedWorkspaces, directories: [] };
     if (project !== undefined) {
         declaration.composite = {
             ...(project.paths !== undefined && { paths: [...project.paths] }),
@@ -87,7 +87,7 @@ function resolveReleasesBlock(workspaces, releases) {
     const workspaceByDir = new Map(workspaces.map((workspace) => [workspace.dir, workspace]));
     const entryByPath = new Map();
     const excludedPaths = new Set();
-    const renamed = new Map();
+    const renamedWorkspaces = new Map();
     const directories = [];
     let composite;
     for (const [name, entry] of Object.entries(releases)) {
@@ -126,22 +126,22 @@ function resolveReleasesBlock(workspaces, releases) {
                 "whose tag prefix derives from its package name; declare the workspace's earlier prefixes in legacyIdentities");
         }
         claimPath(entryByPath, name, workspace.workspacePath, 'workspace');
-        const named = applyLegacyIdentities(workspace, entry.legacyIdentities);
-        renamed.set(workspace.workspacePath, name === workspace.dir ? named : { ...named, targetName: name });
+        const identifiedWorkspace = applyLegacyIdentities(workspace, entry.legacyIdentities);
+        renamedWorkspaces.set(workspace.workspacePath, name === workspace.dir ? identifiedWorkspace : { ...identifiedWorkspace, targetName: name });
     }
-    const retained = [];
-    const excluded = [];
+    const retainedWorkspaces = [];
+    const excludedWorkspaces = [];
     for (const workspace of workspaces) {
         if (excludedPaths.has(workspace.workspacePath)) {
-            excluded.push(workspace);
+            excludedWorkspaces.push(workspace);
         }
         else {
-            retained.push(renamed.get(workspace.workspacePath) ?? workspace);
+            retainedWorkspaces.push(renamedWorkspaces.get(workspace.workspacePath) ?? workspace);
         }
     }
-    const declaration = { retained, excluded, directories };
+    const declaration = { retainedWorkspaces, excludedWorkspaces, directories };
     if (composite !== undefined) {
-        const members = resolveCompositeMembers(composite, retained, excluded, directories);
+        const members = resolveCompositeMembers(composite, retainedWorkspaces, excludedWorkspaces, directories);
         declaration.composite = {
             name: composite.name,
             members: members.map((member) => member.name),