@williamthorsen/release-kit 15.0.3 → 16.0.0

package/dist/esm/planVersionBump.js

@@ -6,34 +6,42 @@ function isPackageJson(value) {
     return typeof value === 'object' && value !== null && 'version' in value && typeof value.version === 'string';
 }
 export function planVersionBump(packageFiles, releaseType) {
-    const { firstFile, firstPkg } = readPrimaryPackage(packageFiles);
-    const currentVersion = firstPkg.version;
+    const { firstFile, firstPackageJson } = readPrimaryPackage(packageFiles);
+    const currentVersion = firstPackageJson.version;
     const newVersion = bumpVersion(currentVersion, releaseType);
-    return { currentVersion, newVersion, writes: renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) };
+    return {
+        currentVersion,
+        newVersion,
+        writes: renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersion),
+    };
 }
 export function planVersionSet(packageFiles, newVersion) {
-    const { firstFile, firstPkg } = readPrimaryPackage(packageFiles);
-    const currentVersion = firstPkg.version;
+    const { firstFile, firstPackageJson } = readPrimaryPackage(packageFiles);
+    const currentVersion = firstPackageJson.version;
     if (!isForwardVersion(currentVersion, newVersion)) {
         throw new Error(`--set-version ${newVersion} is not greater than current version ${currentVersion}`);
     }
-    return { currentVersion, newVersion, writes: renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) };
+    return {
+        currentVersion,
+        newVersion,
+        writes: renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersion),
+    };
 }
 export function readCurrentVersion(packageFiles) {
-    return readPrimaryPackage(packageFiles).firstPkg.version;
+    return readPrimaryPackage(packageFiles).firstPackageJson.version;
 }
 function readPrimaryPackage(packageFiles) {
     const firstFile = packageFiles[0];
     if (firstFile === undefined) {
         throw new Error('No package files specified');
     }
-    return { firstFile, firstPkg: readPackageJson(firstFile) };
+    return { firstFile, firstPackageJson: readPackageJson(firstFile) };
 }
-function renderVersionWrites(packageFiles, firstFile, firstPkg, newVersion) {
+function renderVersionWrites(packageFiles, firstFile, firstPackageJson, newVersion) {
     return packageFiles.map((filePath) => {
-        const pkg = filePath === firstFile ? firstPkg : readPackageJson(filePath);
-        pkg.version = newVersion;
-        return { path: filePath, content: JSON.stringify(pkg, null, 2) + '\n' };
+        const packageJson = filePath === firstFile ? firstPackageJson : readPackageJson(filePath);
+        packageJson.version = newVersion;
+        return { path: filePath, content: JSON.stringify(packageJson, null, 2) + '\n' };
     });
 }
 function readPackageJson(filePath) {
@@ -44,15 +52,15 @@ function readPackageJson(filePath) {
     catch (error) {
         throw chainError(`Failed to read ${filePath}`, error);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(content);
+        parsedJson = JSON.parse(content);
     }
     catch (error) {
         throw chainError(`Failed to parse JSON in ${filePath}`, error);
     }
-    if (!isPackageJson(parsed)) {
+    if (!isPackageJson(parsedJson)) {
         throw new Error(`No valid 'version' field found in ${filePath}`);
     }
-    return parsed;
+    return parsedJson;
 }

package/dist/esm/prepareArgs.d.ts

@@ -2,15 +2,15 @@ import type { ReleaseType } from './types.js';
 /** Canonical `N.N.N` semver pattern for validating `--set-version` input. */
 export declare const CANONICAL_SEMVER_PATTERN: RegExp;
 export declare const prepareFlagSchema: {
-    dryRun: {
+    isDryRun: {
         long: string;
         type: "boolean";
     };
-    force: {
+    shouldForce: {
         long: string;
         type: "boolean";
     };
-    noGitChecks: {
+    shouldSkipGitChecks: {
         long: string;
         type: "boolean";
         short: string;
@@ -27,7 +27,7 @@ export declare const prepareFlagSchema: {
         long: string;
         type: "string";
     };
-    withReleaseNotes: {
+    shouldIncludeReleaseNotes: {
         long: string;
         type: "boolean";
     };
@@ -39,14 +39,14 @@ export declare const prepareFlagSchema: {
 /** Parses CLI arguments into structured options. Prints a usage error and exits on invalid input. */
 export declare function parseArgs(argv: string[]): {
     configPath: string | undefined;
-    dryRun: boolean;
-    force: boolean;
-    noGitChecks: boolean;
+    isDryRun: boolean;
+    shouldForce: boolean;
+    shouldSkipGitChecks: boolean;
     bumpOverride: ReleaseType | undefined;
-    only: string[] | undefined;
+    onlyNames: string[] | undefined;
     /** The raw `--set-version` value, whose accepted form depends on the mode. */
     setVersion: string | undefined;
-    withReleaseNotes: boolean;
+    shouldIncludeReleaseNotes: boolean;
 };
 /**
  * Parses a monorepo `--set-version` value, a comma-separated list of `<target>@N.N.N` entries, into versions keyed by

package/dist/esm/prepareArgs.js

@@ -4,9 +4,9 @@ const VALID_BUMP_TYPES = ['major', 'minor', 'patch'];
 export const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
 export const prepareFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
-    force: { long: '--force', type: 'boolean' },
-    noGitChecks: {
+    isDryRun: { long: '--dry-run', type: 'boolean' },
+    shouldForce: { long: '--force', type: 'boolean' },
+    shouldSkipGitChecks: {
         long: '--no-git-checks',
         type: 'boolean',
         short: '-n',
@@ -14,7 +14,7 @@ export const prepareFlagSchema = {
     bump: { long: '--bump', type: 'string' },
     setVersion: { long: '--set-version', type: 'string' },
     only: { long: '--only', type: 'string' },
-    withReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
+    shouldIncludeReleaseNotes: { long: '--with-release-notes', type: 'boolean' },
 };
 export function parseArgs(argv) {
     const { flags } = parseArgsOrExit(argv, prepareFlagSchema);
@@ -26,19 +26,19 @@ export function parseArgs(argv) {
         }
         bumpOverride = flags.bump;
     }
-    let only;
+    let onlyNames;
     if (flags.only !== undefined) {
-        only = flags.only.split(',');
+        onlyNames = flags.only.split(',');
     }
     return {
         configPath: flags.config,
-        dryRun: flags.dryRun,
-        force: flags.force,
-        noGitChecks: flags.noGitChecks,
+        isDryRun: flags.isDryRun,
+        shouldForce: flags.shouldForce,
+        shouldSkipGitChecks: flags.shouldSkipGitChecks,
         bumpOverride,
-        only,
+        onlyNames,
         setVersion: flags.setVersion,
-        withReleaseNotes: flags.withReleaseNotes,
+        shouldIncludeReleaseNotes: flags.shouldIncludeReleaseNotes,
     };
 }
 export function parseSetVersions(value, knownNames) {

package/dist/esm/prepareCommand.js

@@ -8,23 +8,23 @@ import { dim } from "./format.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { loadValidatedConfig, reportConfigProblem, reportConfigWarnings } from "./loadValidatedConfig.js";
 import { CANONICAL_SEMVER_PATTERN, parseArgs, parseSetVersions } from "./prepareArgs.js";
+import { prepareReleaseTargets } from "./prepareReleaseTargets.js";
 import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 import { applyReleasePlan } from "./releasePlan.js";
-import { releasePrepareTargets } from "./releasePrepareTargets.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 import { isSinglePackageTargets, PROJECT_TARGET_ID, resolveReleaseTargets, SINGLE_PACKAGE_TARGET_ID, } from "./resolveReleaseTargets.js";
 export async function prepareCommand(argv, styles, invocationDir) {
-    const { configPath: configFlag, dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes, } = parseArgs(argv);
+    const { configPath: configFlag, isDryRun, shouldForce, shouldSkipGitChecks, bumpOverride, onlyNames, setVersion, shouldIncludeReleaseNotes, } = parseArgs(argv);
     const options = {
-        force,
+        shouldForce,
         ...(bumpOverride !== undefined && { bumpOverride }),
-        ...(withReleaseNotes && { withReleaseNotes: true }),
+        ...(shouldIncludeReleaseNotes && { shouldIncludeReleaseNotes: true }),
     };
-    if (dryRun) {
+    if (isDryRun) {
         console.info(`\n${formatGlyphLine(RELEASE_GLYPHS, styles.stdout, 'dryRun', 'DRY RUN: release-kit will not modify any files')}\n`);
     }
-    if (!dryRun && !noGitChecks) {
+    if (!isDryRun && !shouldSkipGitChecks) {
         try {
             assertCleanWorkingTree();
         }
@@ -43,37 +43,37 @@ export async function prepareCommand(argv, styles, invocationDir) {
         reportConfigWarnings(configResult.warnings, styles.stderr);
         userConfig = configResult.config;
     }
-    let workspace;
+    let workspaceDiscovery;
     try {
-        workspace = discoverWorkspaces();
+        workspaceDiscovery = discoverWorkspaces();
     }
     catch (error) {
         reportError(`Failed to discover workspaces: ${describeError(error)}`);
         process.exit(1);
     }
-    if (workspace.kind === 'empty') {
-        reportError(`No workspace package to release. ${describeEmptyWorkspace(workspace)}`);
+    if (workspaceDiscovery.kind === 'empty') {
+        reportError(`No workspace package to release. ${describeEmptyWorkspace(workspaceDiscovery)}`);
         process.exit(1);
     }
-    const config = resolveTargetsOrExit(userConfig, workspace, only, setVersion);
+    const config = resolveTargetsOrExit(userConfig, workspaceDiscovery, onlyNames, setVersion);
     const targetOptions = {
         ...options,
-        ...(only !== undefined && { only }),
-        ...(setVersion !== undefined && { setVersions: resolveSetVersions(setVersion, config.targets) }),
+        ...(onlyNames !== undefined && { onlyTargetIds: onlyNames }),
+        ...(setVersion !== undefined && { versionOverridesById: resolveSetVersions(setVersion, config.targets) }),
     };
     runAndReport(() => {
-        const plan = releasePrepareTargets(config, targetOptions);
+        const plan = prepareReleaseTargets(config, targetOptions);
         assertReleasesOnNpm(findReleasedPackagePaths(plan, config.targets));
         return plan;
-    }, dryRun, styles.stdout);
+    }, isDryRun, styles.stdout);
 }
 function findReleasedPackagePaths(plan, targets) {
     const releasedIds = new Set(plan.targets.flatMap((result) => result.status === 'released' && result.kind === 'package' ? result.targetId : []));
     return targets.flatMap((target) => target.kind === 'package' && releasedIds.has(target.id) ? target.packagePath : []);
 }
-function resolveTargetsOrExit(userConfig, discovery, only, setVersion) {
+function resolveTargetsOrExit(userConfig, discovery, onlyNames, setVersion) {
     if (discovery.kind === 'single-package') {
-        if (only !== undefined) {
+        if (onlyNames !== undefined) {
             reportError('--only is only supported for monorepo configurations');
             process.exit(1);
         }
@@ -98,8 +98,8 @@ function resolveTargetsOrExit(userConfig, discovery, only, setVersion) {
         process.exit(1);
     }
     const knownNames = listSelectableIds(config.targets);
-    const onlyNames = only ?? [];
-    for (const name of onlyNames) {
+    const requestedNames = onlyNames ?? [];
+    for (const name of requestedNames) {
         if (knownNames.includes(name)) {
             continue;
         }
@@ -120,7 +120,7 @@ function listSelectableIds(targets) {
 function listMemberIds(targets) {
     return targets.flatMap((target) => (target.kind === 'composite' ? [] : target.id));
 }
-function runAndReport(computePlan, dryRun, style) {
+function runAndReport(computePlan, isDryRun, style) {
     let plan;
     try {
         plan = computePlan();
@@ -130,7 +130,7 @@ function runAndReport(computePlan, dryRun, style) {
         process.stderr.write('The command did not write any files; the working tree is unchanged.\n');
         process.exit(1);
     }
-    if (dryRun) {
+    if (isDryRun) {
         process.stdout.write(reportPrepare(plan, { applied: false, style }) + '\n');
         reportPlanFiles(plan, true);
         return;
@@ -164,11 +164,11 @@ function runFormatCommand(formatCommand) {
         return describeError(error);
     }
 }
-function reportPlanFiles(plan, dryRun) {
+function reportPlanFiles(plan, isDryRun) {
     if (plan.tags.length === 0) {
         return;
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info(dim(`  [dry-run] Would write ${RELEASE_TAGS_FILE}: ${plan.tags.join(' ')}`));
         if (plan.summary.length > 0) {
             console.info(dim(`  [dry-run] Would write ${RELEASE_SUMMARY_FILE}`));

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;