@williamthorsen/release-kit 15.0.3 → 16.1.0

package/dist/esm/prepareComposite.d.ts

@@ -5,12 +5,12 @@ import type { CompositeTarget, ReleaseType, TargetPrepareResult } from './types.
  * prepares it: every run that `only` doesn't narrow, and every one that names it. A `project` block's composite
  * cannot be named.
  */
-export declare function describeCompositeSkip(composite: CompositeTarget, only: readonly string[] | undefined): string | undefined;
+export declare function describeCompositeSkip(compositeTarget: CompositeTarget, onlyNames: readonly string[] | undefined): string | undefined;
 /**
  * Prepares a composite target: reads its history, asserts its baseline, and decides and plans its release, appending
  * its tag, writes, and modified files to the run's collection and its preview warnings to `warnings`.
  */
-export declare function prepareComposite(composite: CompositeTarget, context: RunContext, options: {
-    force?: boolean;
+export declare function prepareComposite(compositeTarget: CompositeTarget, context: RunContext, options: {
+    shouldForce?: boolean;
     bumpOverride?: ReleaseType;
-}, collected: CollectedReleases, warnings: string[]): TargetPrepareResult;
+}, collectedReleases: CollectedReleases, warnings: string[]): TargetPrepareResult;

package/dist/esm/prepareComposite.js

@@ -2,38 +2,38 @@ import { assertTaggedBaseline } from "./assertTaggedBaseline.js";
 import { collect } from "./prepareRunContext.js";
 import { buildSkippedTargetResult, decideTargetRelease, planTargetRelease, readTargetHistory, } from "./prepareTarget.js";
 import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
-export function describeCompositeSkip(composite, only) {
-    if (only === undefined || only.includes(composite.id)) {
+export function describeCompositeSkip(compositeTarget, onlyNames) {
+    if (onlyNames === undefined || onlyNames.includes(compositeTarget.id)) {
         return undefined;
     }
-    if (composite.id === PROJECT_TARGET_ID) {
-        return (`Project release skipped: --only narrows this run to ${only.join(', ')}. ` +
+    if (compositeTarget.id === PROJECT_TARGET_ID) {
+        return (`Project release skipped: --only narrows this run to ${onlyNames.join(', ')}. ` +
             'Run `release-kit prepare` without --only to include the project release.');
     }
-    return `Release '${composite.id}' skipped: --only does not name it. Add ${composite.id} to --only to include it.`;
+    return `Release '${compositeTarget.id}' skipped: --only does not name it. Add ${compositeTarget.id} to --only to include it.`;
 }
-export function prepareComposite(composite, context, options, collected, warnings) {
-    const { history, untagged } = readTargetHistory(composite, context.settings);
-    assertTaggedBaseline([untagged]);
-    const decision = decideTargetRelease(composite, history, {
-        force: options.force === true,
+export function prepareComposite(compositeTarget, context, options, collectedReleases, warnings) {
+    const { history, untaggedBaseline } = readTargetHistory(compositeTarget, context.settings);
+    assertTaggedBaseline([untaggedBaseline]);
+    const decision = decideTargetRelease(compositeTarget, history, {
+        shouldForce: options.shouldForce === true,
         bumpOverride: options.bumpOverride,
         setVersion: undefined,
     });
     if (decision.outcome === 'skip') {
-        return buildSkippedTargetResult(composite, history, decision.skipReason);
+        return buildSkippedTargetResult(compositeTarget, history, decision.skipReason);
     }
     if (decision.setVersion !== undefined) {
         throw new Error('A composite target cannot take --set-version');
     }
-    const planned = planTargetRelease({
+    const plannedRelease = planTargetRelease({
         ...context,
-        target: composite,
+        target: compositeTarget,
         release: { releaseType: decision.releaseType },
         decision,
         history,
     });
-    collect(collected, planned);
-    warnings.push(...planned.warnings);
-    return planned.result;
+    collect(collectedReleases, plannedRelease);
+    warnings.push(...plannedRelease.warnings);
+    return plannedRelease.result;
 }

package/dist/esm/{releasePrepareTargets.d.ts → prepareReleaseTargets.d.ts}

@@ -12,7 +12,7 @@ export interface TargetPrepareOptions {
      * Release even when the range since the last tag doesn't contain any commits or any bump-worthy commits.
      * Orthogonal to `bumpOverride`: When `bumpOverride` is not given, the release falls back to `patch`.
      */
-    force?: boolean;
+    shouldForce?: boolean;
     /** Level of the release, in place of the level that the changelog items call for; it doesn't trigger a release. */
     bumpOverride?: ReleaseType;
     /**
@@ -20,28 +20,28 @@ export interface TargetPrepareOptions {
      * `RELEASE_NOTES.v{version}.md`) from its changelog entries. Requires `changelogJson.enabled`; when disabled, the
      * plan records a warning and doesn't plan any previews.
      */
-    withReleaseNotes?: boolean;
+    shouldIncludeReleaseNotes?: boolean;
     /**
      * Ids of the targets from which the release starts; the run plans the named package targets and their transitive
      * dependents, and each named composite, which reads its own window. Present only for a narrowed run, which skips
      * every composite that it doesn't name.
      */
-    only?: readonly string[];
+    onlyTargetIds?: readonly string[];
     /**
      * Explicit versions (canonical `N.N.N`), keyed by package target id. Each named target starts the release and
-     * releases at its version, which takes precedence over `bumpOverride` and `force`.
+     * releases at its version, which takes precedence over `bumpOverride` and `shouldForce`.
      */
-    setVersions?: ReadonlyMap<string, string>;
+    versionOverridesById?: ReadonlyMap<string, string>;
 }
 /**
  * Plans a release over a list of targets, without writing any file.
  *
- * 1. Selects the planned package and directory targets: every one, or, under `only`, those named and their transitive
- *    dependents.
+ * 1. Selects the planned package and directory targets: every one, or, under `onlyTargetIds`, those named and their
+ *    transitive dependents.
  * 2. Reads each planned target's history and decides its direct release.
  * 3. Propagates bumps to dependents, asserts the baselines that matter, and sorts the release set topologically.
  * 4. Plans each release in dependency order.
- * 5. Prepares each composite after every package target, unless `only` narrowed the run without naming it.
+ * 5. Prepares each composite after every package target, unless `onlyTargetIds` narrowed the run without naming it.
  * 6. Renders the format command over the modified files.
  */
-export declare function releasePrepareTargets(config: TargetPrepareConfig, options: TargetPrepareOptions): ReleasePlan;
+export declare function prepareReleaseTargets(config: TargetPrepareConfig, options: TargetPrepareOptions): ReleasePlan;

package/dist/esm/{releasePrepareTargets.js → prepareReleaseTargets.js}

@@ -13,11 +13,11 @@ import { collect, describeStage, isRepoRootTarget, readHistory, runStage, } from
 import { buildSkippedTargetResult, planTargetRelease } from "./prepareTarget.js";
 import { propagateBumps } from "./propagateBumps.js";
 import { isSinglePackageTargets } from "./resolveReleaseTargets.js";
-import { topologicalSort } from "./topologicalSort.js";
+import { sortTopologically } from "./topologicalSort.js";
 const PREVIEWS_REQUIRE_JSON_WARNING = '--with-release-notes requires changelogJson.enabled; skipping preview generation';
-export function releasePrepareTargets(config, options) {
+export function prepareReleaseTargets(config, options) {
     const { settings } = config;
-    const { only, withReleaseNotes } = options;
+    const { onlyTargetIds, shouldIncludeReleaseNotes } = options;
     const isSinglePackage = isSinglePackageTargets(config.targets);
     const memberTargets = config.targets.filter((target) => target.kind !== 'composite');
     const compositeTargets = config.targets.filter((target) => target.kind === 'composite');
@@ -25,91 +25,91 @@ export function releasePrepareTargets(config, options) {
     const graph = buildDependencyGraph(memberTargets.filter((target) => target.kind === 'package').filter((target) => target.isWorkspace));
     const startIds = selectStartIds(memberTargets, options);
     const plannedIds = findTransitiveDependents(graph, startIds);
-    const planned = memberTargets.filter((target) => plannedIds.has(target.id));
-    const arePreviewsBlocked = withReleaseNotes === true && !settings.changelogJson.enabled;
+    const plannedTargets = memberTargets.filter((target) => plannedIds.has(target.id));
+    const arePreviewsBlocked = shouldIncludeReleaseNotes === true && !settings.changelogJson.enabled;
     if (arePreviewsBlocked && !isSinglePackage) {
         warnings.push(PREVIEWS_REQUIRE_JSON_WARNING);
     }
     const workTypes = resolveWorkTypes(settings.workTypes);
     const context = {
         settings,
-        overrideContext: createOverrideContext(planned.flatMap(listOverrideDirectory)),
+        overrideContext: createOverrideContext(plannedTargets.flatMap(listOverrideDirectory)),
         sectionOrder: deriveSectionOrder(workTypes),
         dependenciesHeader: deriveDependenciesHeader(workTypes),
-        shouldPlanPreviews: withReleaseNotes === true && settings.changelogJson.enabled,
+        shouldPlanPreviews: shouldIncludeReleaseNotes === true && settings.changelogJson.enabled,
         today: new Date().toISOString().slice(0, 10),
     };
-    const direct = decideDirectReleases(planned, settings, options, startIds);
+    const directReleases = decideDirectReleases(plannedTargets, settings, options, startIds);
     if (!isSinglePackage) {
-        reportUnroutedEntryScopes(planned, direct, settings, memberTargets);
+        reportUnroutedEntryScopes(plannedTargets, directReleases, settings, memberTargets);
     }
-    const releaseSet = propagateBumps(direct.bumps, graph);
-    assertTaggedBaseline([...direct.untaggedBaselines]
-        .filter(([id]) => direct.bumps.has(id) || !releaseSet.has(id))
+    const releaseSet = propagateBumps(directReleases.bumps, graph);
+    assertTaggedBaseline([...directReleases.untaggedBaselines]
+        .filter(([id]) => directReleases.bumps.has(id) || !releaseSet.has(id))
         .map(([, untagged]) => untagged));
-    const { sorted: sortedIds, cyclicIds } = topologicalSort(releaseSet, graph);
+    const { sortedIds, cyclicIds } = sortTopologically(releaseSet, graph);
     if (cyclicIds.length > 0) {
         warnings.push(`Circular workspace dependencies detected among: ${cyclicIds.join(', ')}. ` +
             'Propagation metadata may be incomplete for these workspaces.');
     }
     const resultsById = new Map();
-    for (const target of planned) {
-        const decision = direct.decisions.get(target.id);
+    for (const target of plannedTargets) {
+        const decision = directReleases.decisions.get(target.id);
         if (decision?.outcome === 'skip' && !releaseSet.has(target.id)) {
-            resultsById.set(target.id, buildSkippedTargetResult(target, readHistory(direct.readings, target), decision.skipReason));
+            resultsById.set(target.id, buildSkippedTargetResult(target, readHistory(directReleases.readings, target), decision.skipReason));
         }
     }
-    const collected = { tags: [], writes: [], removals: [], modifiedFiles: [] };
+    const collectedReleases = { tags: [], writes: [], removals: [], modifiedFiles: [] };
     for (const id of sortedIds) {
-        const target = planned.find((candidate) => candidate.id === id);
+        const target = plannedTargets.find((candidate) => candidate.id === id);
         const release = releaseSet.get(id);
         if (target === undefined || release === undefined) {
             continue;
         }
-        const decision = direct.decisions.get(id);
+        const decision = directReleases.decisions.get(id);
         const plannedRelease = runStage(describeStage(target), () => planTargetRelease({
             ...context,
             target,
             release,
             decision: decision?.outcome === 'release' ? decision : undefined,
-            history: readHistory(direct.readings, target),
+            history: readHistory(directReleases.readings, target),
         }));
-        collect(collected, plannedRelease);
+        collect(collectedReleases, plannedRelease);
         warnings.push(...plannedRelease.warnings);
         resultsById.set(id, plannedRelease.result);
     }
-    const results = planned.flatMap((target) => resultsById.get(target.id) ?? []);
+    const results = plannedTargets.flatMap((target) => resultsById.get(target.id) ?? []);
     for (const composite of compositeTargets) {
-        const skipWarning = describeCompositeSkip(composite, only);
+        const skipWarning = describeCompositeSkip(composite, onlyTargetIds);
         if (skipWarning !== undefined) {
             warnings.push(skipWarning);
             continue;
         }
-        const result = runStage(describeStage(composite), () => prepareComposite(composite, context, options, collected, warnings));
+        const result = runStage(describeStage(composite), () => prepareComposite(composite, context, options, collectedReleases, warnings));
         results.push(result);
     }
-    const formatCommand = planFormatCommand(settings.formatCommand, collected);
+    const formatCommand = planFormatCommand(settings.formatCommand, collectedReleases);
     const { overrideContext } = context;
-    for (const overrideKey of overrideContext.project.keys()) {
+    for (const overrideKey of overrideContext.projectOverrides.keys()) {
         if (!overrideContext.globalMatchedRootKeys.has(overrideKey)) {
             overrideContext.overrideWarnings.push(formatStaleOverrideKeyWarning(overrideKey));
         }
     }
     const allWarnings = isSinglePackage
-        ? composeSinglePackageWarnings(collected, overrideContext, arePreviewsBlocked, warnings)
+        ? composeSinglePackageWarnings(collectedReleases, overrideContext, arePreviewsBlocked, warnings)
         : [...warnings, ...overrideContext.overrideWarnings];
     return {
         targets: results,
-        tags: collected.tags,
-        writes: collected.writes,
-        removals: collected.removals,
+        tags: collectedReleases.tags,
+        writes: collectedReleases.writes,
+        removals: collectedReleases.removals,
         summary: buildReleaseSummary({ targets: results }),
         formatCommand,
         ...(allWarnings.length > 0 && { warnings: allWarnings }),
     };
 }
-function composeSinglePackageWarnings(collected, overrideContext, arePreviewsBlocked, previewWarnings) {
-    if (collected.tags.length === 0) {
+function composeSinglePackageWarnings(collectedReleases, overrideContext, arePreviewsBlocked, previewWarnings) {
+    if (collectedReleases.tags.length === 0) {
         return [];
     }
     return [
@@ -124,18 +124,18 @@ function listOverrideDirectory(target) {
     }
     return target.isWorkspace ? [target.packagePath] : [];
 }
-function planFormatCommand(configuredCommand, collected) {
-    const formatCommandStr = configuredCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
-    if (collected.tags.length === 0 || formatCommandStr === undefined) {
+function planFormatCommand(configuredCommand, collectedReleases) {
+    const baseCommand = configuredCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
+    if (collectedReleases.tags.length === 0 || baseCommand === undefined) {
         return undefined;
     }
-    const files = collected.modifiedFiles;
-    return { command: `${formatCommandStr} ${files.join(' ')}`, files };
+    const files = collectedReleases.modifiedFiles;
+    return { command: `${baseCommand} ${files.join(' ')}`, files };
 }
 function selectStartIds(memberTargets, options) {
-    const { only, setVersions } = options;
-    if (only === undefined) {
+    const { onlyTargetIds, versionOverridesById } = options;
+    if (onlyTargetIds === undefined) {
         return new Set(memberTargets.map((target) => target.id));
     }
-    return new Set([...only, ...(setVersions?.keys() ?? [])]);
+    return new Set([...onlyTargetIds, ...(versionOverridesById?.keys() ?? [])]);
 }

package/dist/esm/prepareRunContext.d.ts

@@ -4,7 +4,7 @@ import { type TargetPrepareSettings } from './prepareTarget.js';
 import type { PlannedWrite } from './releasePlan.js';
 import type { DirectoryTarget, PackageTarget, ReleaseTarget } from './types.js';
 /** Appends one planned release's tag, writes, removals, and modified files to the run's collection. */
-export declare function collect(collected: CollectedReleases, planned: {
+export declare function collect(collectedReleases: CollectedReleases, plannedRelease: {
     tag: string;
     writes: PlannedWrite[];
     removals: string[];

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

@@ -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) {
@@ -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 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;