@williamthorsen/release-kit 15.0.3 → 16.1.0

package/dist/esm/changelogOverrides.js

@@ -3,15 +3,15 @@ import { applyChangelogOverrides, formatStaleOverrideKeyWarning } from "./applyC
 import { loadChangelogOverrides } from "./loadChangelogOverrides.js";
 const OVERRIDES_FILENAME = '.meta/changelog-overrides.json';
 export function applyWorkspaceOverrides(newEntries, workspacePath, overrideContext) {
-    const { project, perWorkspace, overrideWarnings, globalMatchedRootKeys } = overrideContext;
-    const workspaceOverrides = workspacePath === undefined ? undefined : perWorkspace.get(workspacePath);
-    const composed = composeOverrides(project, workspaceOverrides);
-    const applied = applyChangelogOverrides(newEntries, composed);
-    if (applied.errors.length > 0) {
-        throw new Error(`Changelog override application failed:\n  - ${applied.errors.join('\n  - ')}`);
+    const { projectOverrides, overridesByWorkspace, overrideWarnings, globalMatchedRootKeys } = overrideContext;
+    const workspaceOverrides = workspacePath === undefined ? undefined : overridesByWorkspace.get(workspacePath);
+    const composedOverrides = composeOverrides(projectOverrides, workspaceOverrides);
+    const appliedResult = applyChangelogOverrides(newEntries, composedOverrides);
+    if (appliedResult.errors.length > 0) {
+        throw new Error(`Changelog override application failed:\n  - ${appliedResult.errors.join('\n  - ')}`);
     }
-    overrideWarnings.push(...applied.warnings);
-    const matchedSet = new Set(applied.matchedKeys);
+    overrideWarnings.push(...appliedResult.warnings);
+    const matchedSet = new Set(appliedResult.matchedKeys);
     if (workspaceOverrides !== undefined) {
         for (const key of workspaceOverrides.keys()) {
             if (!matchedSet.has(key)) {
@@ -19,45 +19,45 @@ export function applyWorkspaceOverrides(newEntries, workspacePath, overrideConte
             }
         }
     }
-    for (const key of applied.matchedKeys) {
+    for (const key of appliedResult.matchedKeys) {
         if (workspaceOverrides?.has(key))
             continue;
         globalMatchedRootKeys.add(key);
     }
-    return applied;
+    return appliedResult;
 }
 export function composeOverrides(rootEntries, workspaceEntries) {
-    const composed = new Map(rootEntries);
+    const composedOverrides = new Map(rootEntries);
     if (workspaceEntries !== undefined) {
         for (const [key, value] of workspaceEntries) {
-            composed.set(key, value);
+            composedOverrides.set(key, value);
         }
     }
-    return composed;
+    return composedOverrides;
 }
 export function createOverrideContext(workspacePaths) {
-    const result = loadOverridesForScopes({ project: '.', workspaces: [...workspacePaths] });
+    const result = loadOverridesForScopes({ projectPath: '.', workspaces: [...workspacePaths] });
     if (result.errors.length > 0) {
         throw new Error(`Failed to load changelog overrides:\n  - ${result.errors.join('\n  - ')}`);
     }
     return {
-        project: result.project,
-        perWorkspace: result.perWorkspace,
+        projectOverrides: result.projectOverrides,
+        overridesByWorkspace: result.overridesByWorkspace,
         overrideWarnings: [],
         globalMatchedRootKeys: new Set(),
     };
 }
 export function loadOverridesForScopes(scopes) {
     const errors = [];
-    let project = new Map();
-    const perWorkspace = new Map();
-    if (scopes.project !== undefined) {
-        const result = loadChangelogOverrides(resolveOverridePath(scopes.project));
+    let projectOverrides = new Map();
+    const overridesByWorkspace = new Map();
+    if (scopes.projectPath !== undefined) {
+        const result = loadChangelogOverrides(resolveOverridePath(scopes.projectPath));
         if ('errors' in result) {
             errors.push(...result.errors);
         }
         else {
-            project = result.overrides;
+            projectOverrides = result.overrides;
         }
     }
     const workspacePaths = scopes.workspaces ?? [];
@@ -67,10 +67,10 @@ export function loadOverridesForScopes(scopes) {
             errors.push(...result.errors);
         }
         else if (result.overrides.size > 0) {
-            perWorkspace.set(workspacePath, result.overrides);
+            overridesByWorkspace.set(workspacePath, result.overrides);
         }
     }
-    return { project, perWorkspace, errors };
+    return { projectOverrides, overridesByWorkspace, errors };
 }
 export function resolveOverridePath(scopeRoot) {
     return path.posix.join(scopeRoot, OVERRIDES_FILENAME);

package/dist/esm/classifyChangelogCommit.js

@@ -10,18 +10,18 @@ export function classifyChangelogCommit(commit, workTypes, options) {
     if (!hasTicketPrefix(subject)) {
         return { kind: 'unparseable' };
     }
-    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, undefined, options);
-    if (parsed === undefined) {
+    const parsedCommit = parseCommitMessage(commit.message, commit.hash, workTypes, undefined, options);
+    if (parsedCommit === undefined) {
         return { kind: 'unparseable' };
     }
-    const config = workTypes[parsed.type];
+    const config = workTypes[parsedCommit.type];
     if (config === undefined) {
         return { kind: 'unparseable' };
     }
     if (config.excludedFromChangelog === true) {
         return { kind: 'excluded' };
     }
-    return { kind: 'header', header: config.header, type: parsed.type, breaking: parsed.breaking };
+    return { kind: 'header', header: config.header, type: parsedCommit.type, breaking: parsedCommit.breaking };
 }
 export function isNonChangeSubject(subject) {
     return isReleaseSubject(subject) || MERGE_SUBJECT_PATTERN.test(subject);

package/dist/esm/commitCommand.js

@@ -3,10 +3,10 @@ import { readFileSync } from 'node:fs';
 import { GIT_OUTPUT_LIMIT_BYTES, hasErrnoCode, parseArgsOrExit } from '@williamthorsen/nmr-core';
 import { readReleaseTags, RELEASE_SUMMARY_FILE, resolveReleaseTagsPath } from "./releaseFiles.js";
 const commitFlagSchema = {
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
 };
 export function commitCommand(argv) {
-    const dryRun = parseArgsOrExit(argv, commitFlagSchema).flags.dryRun;
+    const isDryRun = parseArgsOrExit(argv, commitFlagSchema).flags.isDryRun;
     const tags = readReleaseTags();
     if (tags.length === 0) {
         throw new Error(`Tags file at ${resolveReleaseTagsPath()} is empty. Run \`release-kit prepare\` first.`);
@@ -24,7 +24,7 @@ export function commitCommand(argv) {
     }
     const title = `release: ${tags.join(' ')}`;
     const message = summary.length > 0 ? `${title}\n\n${summary}` : title;
-    if (dryRun) {
+    if (isDryRun) {
         console.info('[dry-run] Would create commit with message:\n');
         console.info(message);
         try {

package/dist/esm/compareVersions.js

@@ -13,13 +13,13 @@ function parseCanonicalSemver(version) {
     };
 }
 export function compareVersionsDescending(a, b) {
-    const aValid = semver.valid(a);
-    const bValid = semver.valid(b);
-    if (aValid && bValid)
-        return semver.rcompare(aValid, bValid);
-    if (aValid)
+    const aValidVersion = semver.valid(a);
+    const bValidVersion = semver.valid(b);
+    if (aValidVersion && bValidVersion)
+        return semver.rcompare(aValidVersion, bValidVersion);
+    if (aValidVersion)
         return -1;
-    if (bValid)
+    if (bValidVersion)
         return 1;
     if (a > b)
         return -1;
@@ -28,13 +28,13 @@ export function compareVersionsDescending(a, b) {
     return 0;
 }
 export function isForwardVersion(current, target) {
-    const currentParsed = parseCanonicalSemver(current);
-    const targetParsed = parseCanonicalSemver(target);
-    if (targetParsed.major !== currentParsed.major) {
-        return targetParsed.major > currentParsed.major;
+    const currentParsedVersion = parseCanonicalSemver(current);
+    const targetParsedVersion = parseCanonicalSemver(target);
+    if (targetParsedVersion.major !== currentParsedVersion.major) {
+        return targetParsedVersion.major > currentParsedVersion.major;
     }
-    if (targetParsed.minor !== currentParsed.minor) {
-        return targetParsed.minor > currentParsed.minor;
+    if (targetParsedVersion.minor !== currentParsedVersion.minor) {
+        return targetParsedVersion.minor > currentParsedVersion.minor;
     }
-    return targetParsed.patch > currentParsed.patch;
+    return targetParsedVersion.patch > currentParsedVersion.patch;
 }

package/dist/esm/configSchema.d.ts

@@ -93,7 +93,7 @@ export declare const changelogJsonInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 /** Schema for the optional `changelogMarkdown` block (input shape, all fields optional). */
 export declare const changelogMarkdownInputSchema: z.ZodObject<{
-    keepVersions: z.ZodOptional<z.ZodNumber>;
+    keptVersionCount: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 /** Schema for the optional `releaseNotes` block (input shape, all fields optional). */
 export declare const releaseNotesInputSchema: z.ZodObject<{
@@ -164,8 +164,9 @@ export declare const releaseKitConfigSchema: z.ZodObject<{
         devOnlySections: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     changelogMarkdown: z.ZodOptional<z.ZodObject<{
-        keepVersions: z.ZodOptional<z.ZodNumber>;
+        keptVersionCount: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    devExportConditions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     formatCommand: z.ZodOptional<z.ZodString>;
     project: z.ZodOptional<z.ZodObject<{
         paths: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/esm/configSchema.js

@@ -48,7 +48,7 @@ export const changelogJsonInputSchema = z
     .strict();
 export const changelogMarkdownInputSchema = z
     .object({
-    keepVersions: z.number().int().min(1).optional(),
+    keptVersionCount: z.number().int().min(1).optional(),
 })
     .strict();
 export const releaseNotesInputSchema = z
@@ -89,6 +89,7 @@ export const releaseKitConfigSchema = z
     breakingPolicies: z.record(z.string(), breakingPolicyValueSchema).optional(),
     changelogJson: changelogJsonInputSchema.optional(),
     changelogMarkdown: changelogMarkdownInputSchema.optional(),
+    devExportConditions: z.array(z.string().min(1)).optional(),
     formatCommand: z.string().min(1).optional(),
     project: projectConfigSchema.optional(),
     releaseNotes: releaseNotesInputSchema.optional(),

package/dist/esm/createGithubRelease.d.ts

@@ -2,7 +2,7 @@
 export interface CreateGithubReleaseOptions {
     tag: string;
     changelogJsonPath: string;
-    dryRun: boolean;
+    isDryRun: boolean;
     /** Section titles in priority order. When omitted, entry order is preserved. */
     sectionOrder?: string[];
 }
@@ -29,9 +29,9 @@ export declare function createGithubRelease(options: CreateGithubReleaseOptions)
 /** Outcome of a `createGithubReleases` invocation. */
 export interface CreateGithubReleasesOutcome {
     /** Tags for which a Release was created (or would be, under `--dry-run`). */
-    created: string[];
+    createdTags: string[];
     /** Tags that were skipped, paired with the discriminated reason for each skip. */
-    skipped: Array<{
+    skippedTags: Array<{
         tag: string;
         reason: CreateReleaseSkipReason;
     }>;
@@ -40,4 +40,4 @@ export interface CreateGithubReleasesOutcome {
 export declare function createGithubReleases(tags: Array<{
     tag: string;
     workspacePath: string;
-}>, changelogJsonOutputPath: string, dryRun: boolean, sectionOrder?: string[]): CreateGithubReleasesOutcome;
+}>, changelogJsonOutputPath: string, isDryRun: boolean, sectionOrder?: string[]): CreateGithubReleasesOutcome;

package/dist/esm/createGithubRelease.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
 export function createGithubRelease(options) {
-    const { tag, changelogJsonPath, dryRun, sectionOrder } = options;
+    const { tag, changelogJsonPath, isDryRun, sectionOrder } = options;
     if (!existsSync(changelogJsonPath)) {
         console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
         return { status: 'skipped', reason: 'no-entry' };
@@ -25,37 +25,37 @@ export function createGithubRelease(options) {
     }
     const body = renderReleaseNotesSingle(entry, {
         filter: matchesAudience('all'),
-        includeHeading: false,
+        shouldIncludeHeading: false,
         ...(sectionOrder !== undefined && { sectionOrder }),
     });
     if (body.trim() === '') {
         return { status: 'skipped', reason: 'empty-body' };
     }
     const args = ['release', 'create', tag, '--title', tag, '--notes', body];
-    if (dryRun) {
+    if (isDryRun) {
         console.info(`[dry-run] Would run: gh ${args.join(' ')}`);
         return { status: 'created' };
     }
     execFileSync('gh', args, { stdio: 'inherit' });
     return { status: 'created' };
 }
-export function createGithubReleases(tags, changelogJsonOutputPath, dryRun, sectionOrder) {
-    const created = [];
-    const skipped = [];
+export function createGithubReleases(tags, changelogJsonOutputPath, isDryRun, sectionOrder) {
+    const createdTags = [];
+    const skippedTags = [];
     for (const { tag, workspacePath } of tags) {
         const changelogJsonPath = join(workspacePath, changelogJsonOutputPath);
         const result = createGithubRelease({
             tag,
             changelogJsonPath,
-            dryRun,
+            isDryRun,
             ...(sectionOrder !== undefined && { sectionOrder }),
         });
         if (result.status === 'created') {
-            created.push(tag);
+            createdTags.push(tag);
         }
         else {
-            skipped.push({ tag, reason: result.reason });
+            skippedTags.push({ tag, reason: result.reason });
         }
     }
-    return { created, skipped };
+    return { createdTags, skippedTags };
 }

package/dist/esm/createGithubReleaseCommand.js

@@ -10,15 +10,15 @@ import { resolveCommandTags } from "./resolveCommandTags.js";
 import { resolveConfigFlag } from "./resolveConfigFlag.js";
 const createGithubReleaseFlagSchema = {
     ...configFlagSchema,
-    dryRun: { long: '--dry-run', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
     tags: { long: '--tags', type: 'string' },
 };
 export async function createGithubReleaseCommand(argv, styles, invocationDir) {
-    const parsed = parseArgsOrExit(argv, createGithubReleaseFlagSchema);
-    const configPath = resolveConfigFlag(parsed.flags.config, invocationDir);
-    const { dryRun } = parsed.flags;
+    const parsedArgs = parseArgsOrExit(argv, createGithubReleaseFlagSchema);
+    const configPath = resolveConfigFlag(parsedArgs.flags.config, invocationDir);
+    const { isDryRun } = parsedArgs.flags;
     const userConfig = await loadUsableConfig(styles.stderr, configPath);
-    const requestedTags = parseRequestedTags(parsed.flags.tags);
+    const requestedTags = parseRequestedTags(parsedArgs.flags.tags);
     const resolvedTags = resolveCommandTags(requestedTags, userConfig);
     const releasableTags = resolvedTags.filter(isReleasable);
     for (const resolvedTag of resolvedTags) {
@@ -32,17 +32,17 @@ export async function createGithubReleaseCommand(argv, styles, invocationDir) {
     const { changelogJsonOutputPath, sectionOrder } = deriveReleaseNotesConfig(userConfig);
     let outcome;
     try {
-        outcome = createGithubReleases(releasableTags, changelogJsonOutputPath, dryRun, sectionOrder);
+        outcome = createGithubReleases(releasableTags, changelogJsonOutputPath, isDryRun, sectionOrder);
     }
     catch (error) {
         reportError(`Failed to create GitHub Releases: ${describeError(error)}`);
         process.exit(1);
     }
-    if (outcome.skipped.length === 0) {
+    if (outcome.skippedTags.length === 0) {
         return;
     }
-    const formatted = outcome.skipped.map((s) => `${s.tag} (${s.reason})`).join(', ');
-    console.info(`Skipped ${outcome.skipped.length} tag(s) without releasable content: ${formatted}.`);
+    const formattedSkips = outcome.skippedTags.map((s) => `${s.tag} (${s.reason})`).join(', ');
+    console.info(`Skipped ${outcome.skippedTags.length} tag(s) without releasable content: ${formattedSkips}.`);
 }
 function isReleasable(resolvedTag) {
     return resolvedTag.kind !== 'package' || resolvedTag.isPublishable;

package/dist/esm/createTags.d.ts

@@ -1,7 +1,7 @@
 import { type OutputStyle } from '@williamthorsen/nmr-core';
 export interface CreateTagsOptions {
-    dryRun: boolean;
-    noGitChecks: boolean;
+    isDryRun: boolean;
+    shouldSkipGitChecks: boolean;
     style: OutputStyle;
 }
 /**

package/dist/esm/createTags.js

@@ -4,32 +4,32 @@ import { deleteFileIfExists } from "./deleteFileIfExists.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { readReleaseTags, RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE } from "./releaseFiles.js";
 export function createTags(options) {
-    const { dryRun, noGitChecks, style } = options;
+    const { isDryRun, shouldSkipGitChecks, style } = options;
     const tags = readReleaseTags();
     if (tags.length === 0) {
         return [];
     }
-    if (!dryRun && !noGitChecks) {
+    if (!isDryRun && !shouldSkipGitChecks) {
         assertCleanWorkingTree();
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info('[dry-run] Would create tags:');
         for (const tag of tags) {
             console.info(formatGlyphLine(RELEASE_GLYPHS, style, 'tag', tag));
         }
         return tags;
     }
-    const created = [];
+    const createdTags = [];
     for (const tag of tags) {
         try {
             execFileSync('git', ['tag', '-a', tag, '-m', tag], { maxBuffer: GIT_OUTPUT_LIMIT_BYTES });
-            created.push(tag);
+            createdTags.push(tag);
         }
         catch (error) {
-            if (created.length > 0) {
+            if (createdTags.length > 0) {
                 console.warn('Tags created before failure:');
-                for (const t of created) {
-                    console.warn(`  ${t}`);
+                for (const tag of createdTags) {
+                    console.warn(`  ${tag}`);
                 }
             }
             throw error;

package/dist/esm/decideDirectReleases.d.ts

@@ -13,13 +13,13 @@ export interface DirectReleases {
     untaggedBaselines: Map<string, UntaggedBaseline>;
 }
 /**
- * Reads each planned package and directory target's history and decides its direct release. `force` applies only to
+ * Reads each planned package and directory target's history and decides its direct release. `shouldForce` applies only to
  * the targets from which the release starts.
  */
-export declare function decideDirectReleases(planned: readonly MemberTarget[], settings: TargetPrepareSettings, options: {
-    force?: boolean;
+export declare function decideDirectReleases(plannedTargets: readonly MemberTarget[], settings: TargetPrepareSettings, options: {
+    shouldForce?: boolean;
     bumpOverride?: ReleaseType;
-    setVersions?: ReadonlyMap<string, string>;
+    versionOverridesById?: ReadonlyMap<string, string>;
 }, startIds: ReadonlySet<string>): DirectReleases;
 /**
  * Records on each planned workspace's and directory's history the entry scopes that route nowhere in its unreleased
@@ -27,4 +27,4 @@ export declare function decideDirectReleases(planned: readonly MemberTarget[], s
  * targets first, in planned order, which sets the order of each target's findings. The repo-root directory target
  * renders every entry in its window, so it records none, but its window still routes the scope that names it.
  */
-export declare function reportUnroutedEntryScopes(planned: readonly MemberTarget[], direct: DirectReleases, settings: TargetPrepareSettings, memberTargets: readonly MemberTarget[]): void;
+export declare function reportUnroutedEntryScopes(plannedTargets: readonly MemberTarget[], directReleases: DirectReleases, settings: TargetPrepareSettings, memberTargets: readonly MemberTarget[]): void;

package/dist/esm/decideDirectReleases.js

@@ -3,64 +3,64 @@ import { findUnroutedEntryScopes } from "./findUnroutedEntryScopes.js";
 import { getAllTagPrefixes } from "./generateChangelogs.js";
 import { describeStage, isRepoRootTarget, readHistory, runStage } from "./prepareRunContext.js";
 import { decideTargetRelease, readTargetHistory, } from "./prepareTarget.js";
-export function decideDirectReleases(planned, settings, options, startIds) {
-    const { force, bumpOverride, setVersions } = options;
-    const direct = {
+export function decideDirectReleases(plannedTargets, settings, options, startIds) {
+    const { shouldForce, bumpOverride, versionOverridesById } = options;
+    const directReleases = {
         readings: new Map(),
         decisions: new Map(),
         bumps: new Map(),
         untaggedBaselines: new Map(),
     };
     const hintState = { emitted: false };
-    const knownPrefixes = planned.flatMap(getAllTagPrefixes);
-    for (const target of planned) {
-        const { history, untagged } = runStage(describeStage(target), () => readTargetHistory(target, settings));
-        direct.readings.set(target.id, history);
-        if (untagged !== undefined) {
-            direct.untaggedBaselines.set(target.id, untagged);
+    const knownPrefixes = plannedTargets.flatMap(getAllTagPrefixes);
+    for (const target of plannedTargets) {
+        const { history, untaggedBaseline } = runStage(describeStage(target), () => readTargetHistory(target, settings));
+        directReleases.readings.set(target.id, history);
+        if (untaggedBaseline !== undefined) {
+            directReleases.untaggedBaselines.set(target.id, untaggedBaseline);
         }
         if (history.previousTag === undefined && target.kind === 'package' && target.isWorkspace) {
-            maybeEmitBaselineHint(target, knownPrefixes, hintState);
+            emitBaselineHintOnce(target, knownPrefixes, hintState);
         }
-        const setVersion = setVersions?.get(target.id);
+        const versionOverride = versionOverridesById?.get(target.id);
         const decision = decideTargetRelease(target, history, {
-            force: force === true && startIds.has(target.id),
+            shouldForce: shouldForce === true && startIds.has(target.id),
             bumpOverride,
-            setVersion,
+            setVersion: versionOverride,
         });
-        direct.decisions.set(target.id, decision);
+        directReleases.decisions.set(target.id, decision);
         if (decision.outcome === 'skip') {
             continue;
         }
-        direct.bumps.set(target.id, decision.setVersion === undefined
+        directReleases.bumps.set(target.id, decision.setVersion === undefined
             ? { releaseType: decision.releaseType }
             : { releaseType: 'patch', newVersionOverride: decision.setVersion });
     }
-    return direct;
+    return directReleases;
 }
-export function reportUnroutedEntryScopes(planned, direct, settings, memberTargets) {
-    const releasing = planned.filter((target) => direct.decisions.get(target.id)?.outcome === 'release');
-    const windows = [...releasing, ...planned.filter((target) => !releasing.includes(target))].map((target) => ({
+export function reportUnroutedEntryScopes(plannedTargets, directReleases, settings, memberTargets) {
+    const releasingTargets = plannedTargets.filter((target) => directReleases.decisions.get(target.id)?.outcome === 'release');
+    const windows = [...releasingTargets, ...plannedTargets.filter((target) => !releasingTargets.includes(target))].map((target) => ({
         target,
-        history: readHistory(direct.readings, target),
+        history: readHistory(directReleases.readings, target),
     }));
-    const findings = findUnroutedEntryScopes(windows.map(({ target, history }) => ({ dir: target.id, commits: history.unreleased.commits })), memberTargets.map((target) => target.id), settings.scopeAliases ?? {});
+    const findings = findUnroutedEntryScopes(windows.map(({ target, history }) => ({ dir: target.id, commits: history.unreleasedReading.commits })), memberTargets.map((target) => target.id), settings.scopeAliases ?? {});
     for (const { target, history } of windows) {
-        history.unreleased.diagnostics.unroutedEntryScopes = isRepoRootTarget(target)
+        history.unreleasedReading.diagnostics.unroutedEntryScopes = isRepoRootTarget(target)
             ? []
             : (findings.get(target.id) ?? []);
     }
 }
-function maybeEmitBaselineHint(target, knownPrefixes, state) {
+function emitBaselineHintOnce(target, knownPrefixes, state) {
     if (state.emitted || (target.legacyIdentities?.length ?? 0) > 0)
         return;
     const candidates = detectUndeclaredTagPrefixes(knownPrefixes);
     if (candidates.length === 0)
         return;
     const totalTags = candidates.reduce((sum, candidate) => sum + candidate.tagCount, 0);
-    const example = candidates[0]?.exampleTags[0] ?? `${candidates[0]?.prefix ?? ''}?`;
+    const exampleTag = candidates[0]?.exampleTags[0] ?? `${candidates[0]?.prefix ?? ''}?`;
     process.stderr.write(`Hint: no baseline tag found for ${target.id} under '${target.tagPrefix}', but ` +
-        `${totalTags} candidate-shaped tags exist (e.g., ${example}). ` +
+        `${totalTags} candidate-shaped tags exist (e.g., ${exampleTag}). ` +
         "Run 'release-kit show-tag-prefixes' to check for undeclared legacy prefixes.\n");
     state.emitted = true;
 }

package/dist/esm/decideRelease.d.ts

@@ -6,7 +6,7 @@ export interface DecideReleaseArgs {
     /** The number of commits in the window, which selects the skip reason. */
     commitCount: number;
     /** True when `--force` was passed; treats absence of a natural bump as patch. Defaults to false. */
-    force?: boolean | undefined;
+    shouldForce?: boolean | undefined;
     /** Explicit `--bump=X` override. When set, the level is X regardless of the natural bump. */
     bumpOverride: ReleaseType | undefined;
     /**

package/dist/esm/decideRelease.js

@@ -1,6 +1,6 @@
 export function decideRelease(args) {
-    const { naturalBump, commitCount, force = false, bumpOverride, skipReasons } = args;
-    if (naturalBump === undefined && !force) {
+    const { naturalBump, commitCount, shouldForce = false, bumpOverride, skipReasons } = args;
+    if (naturalBump === undefined && !shouldForce) {
         const skipReason = commitCount === 0 ? skipReasons.noCommits : skipReasons.noBumpWorthy;
         return { outcome: 'skip', skipReason };
     }

package/dist/esm/deriveDirectoryConfig.d.ts

@@ -10,4 +10,4 @@ export declare const DIRECTORY_VERSION_FILE = "version.json";
  * repo root. Throws when the path isn't a directory, when the version file is missing or lacks a `version`, and when
  * the basename would not make a valid tag prefix.
  */
-export declare function deriveDirectoryConfig(declared: DeclaredDirectory, root?: string): DirectoryConfig;
+export declare function deriveDirectoryConfig(declaredDirectory: DeclaredDirectory, root?: string): DirectoryConfig;

package/dist/esm/deriveDirectoryConfig.js

@@ -4,24 +4,24 @@ import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
 import { isRecord } from "./typeGuards.js";
 export const DIRECTORY_VERSION_FILE = 'version.json';
 const TAG_PREFIX_PATTERN = /^[\w.-]+$/;
-export function deriveDirectoryConfig(declared, root = process.cwd()) {
-    const label = `releases.${declared.name}`;
-    if (statSync(path.resolve(root, declared.path), { throwIfNoEntry: false })?.isDirectory() !== true) {
-        throw new Error(`${label}: path '${declared.path}' is not a directory; declare a directory that exists in the repo`);
+export function deriveDirectoryConfig(declaredDirectory, root = process.cwd()) {
+    const label = `releases.${declaredDirectory.name}`;
+    if (statSync(path.resolve(root, declaredDirectory.path), { throwIfNoEntry: false })?.isDirectory() !== true) {
+        throw new Error(`${label}: path '${declaredDirectory.path}' is not a directory; declare a directory that exists in the repo`);
     }
-    const versionFile = resolveVersionFile(declared.path, root);
+    const versionFile = resolveVersionFile(declaredDirectory.path, root);
     assertVersionField(label, versionFile, root);
     const config = {
-        name: declared.name,
-        path: declared.path,
+        name: declaredDirectory.name,
+        path: declaredDirectory.path,
         versionFile,
-        tagPrefix: declared.tagPrefix ?? deriveTagPrefix(label, declared.path),
+        tagPrefix: declaredDirectory.tagPrefix ?? deriveTagPrefix(label, declaredDirectory.path),
     };
-    if (declared.paths !== undefined) {
-        config.paths = [...declared.paths];
+    if (declaredDirectory.paths !== undefined) {
+        config.paths = [...declaredDirectory.paths];
     }
-    if (declared.legacyIdentities !== undefined) {
-        config.legacyIdentities = declared.legacyIdentities;
+    if (declaredDirectory.legacyIdentities !== undefined) {
+        config.legacyIdentities = declaredDirectory.legacyIdentities;
     }
     return config;
 }
@@ -30,14 +30,14 @@ function assertVersionField(label, versionFile, root) {
     if (!existsSync(absolutePath)) {
         throw new Error(`${label}: ${versionFile} not found; create it with the directory's current version, such as { "version": "0.0.0" }`);
     }
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(readFileSync(absolutePath, 'utf8'));
+        parsedJson = JSON.parse(readFileSync(absolutePath, 'utf8'));
     }
     catch (error) {
         throw chainError(`${label}: failed to read ${versionFile}`, error);
     }
-    if (!isRecord(parsed) || typeof parsed['version'] !== 'string') {
+    if (!isRecord(parsedJson) || typeof parsedJson['version'] !== 'string') {
         throw new Error(`${label}: ${versionFile} does not contain a string 'version' field; add one`);
     }
 }
@@ -52,8 +52,8 @@ function deriveTagPrefix(label, directoryPath) {
     return `${basename}-v`;
 }
 function resolveVersionFile(directoryPath, root) {
-    const packageJson = path.posix.join(directoryPath, 'package.json');
-    return existsSync(path.resolve(root, packageJson))
-        ? packageJson
+    const packageJsonPath = path.posix.join(directoryPath, 'package.json');
+    return existsSync(path.resolve(root, packageJsonPath))
+        ? packageJsonPath
         : path.posix.join(directoryPath, DIRECTORY_VERSION_FILE);
 }

package/dist/esm/deriveWorkspaceConfig.js

@@ -6,19 +6,19 @@ import { isRecord } from "./typeGuards.js";
 export function deriveWorkspaceConfig(workspacePath) {
     const dir = basename(workspacePath);
     const packageJsonPath = `${workspacePath}/package.json`;
-    let parsed;
+    let parsedJson;
     try {
-        parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        parsedJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
     }
     catch (error) {
         throw chainError(`Failed to read ${packageJsonPath}`, error);
     }
-    const name = isRecord(parsed) ? parsed['name'] : undefined;
+    const name = isRecord(parsedJson) ? parsedJson['name'] : undefined;
     if (typeof name !== 'string' || name.length === 0) {
         throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
     }
     const unscopedName = stripNpmScope(name);
-    const isPublishable = isPublishableManifest(parsed);
+    const isPublishable = isPublishableManifest(parsedJson);
     return {
         dir,
         name,