@williamthorsen/release-kit 15.0.3 → 16.0.0

package/dist/esm/resolveReleaseTags.js

@@ -22,32 +22,34 @@ export function resolveReleaseTags(args) {
     return resolveSinglePackageTags(tags, args.singleWorkspace);
 }
 function resolveSinglePackageTags(tags, singleWorkspace) {
-    const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
+    const matchedTags = tags.filter((tag) => VERSION_PATTERN.test(tag));
     const isPublishable = singleWorkspace?.isPublishable ?? true;
-    if (matched.length > 1) {
-        console.warn(`Warning: Multiple version tags found on HEAD: ${matched.join(', ')}. ` +
+    if (matchedTags.length > 1) {
+        console.warn(`Warning: Multiple version tags found on HEAD: ${matchedTags.join(', ')}. ` +
             `Publishing the same package multiple times is almost certainly unintended. Using only the first tag.`);
-        return matched.slice(0, 1).map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
+        return matchedTags
+            .slice(0, 1)
+            .map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
     }
-    return matched.map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
+    return matchedTags.map((tag) => ({ tag, kind: 'package', dir: '.', workspacePath: '.', isPublishable }));
 }
 function resolveMonorepoTags(tags, workspaces, directories, project) {
     const sortedWorkspaces = workspaces.toSorted((a, b) => b.tagPrefix.length - a.tagPrefix.length);
-    const resolved = [];
+    const resolvedTags = [];
     for (const tag of tags) {
-        const match = findMatchingWorkspace(tag, sortedWorkspaces);
+        const matchedWorkspace = findMatchingWorkspace(tag, sortedWorkspaces);
         const directory = directories.find((candidate) => hasVersionAfterPrefix(tag, candidate.tagPrefix));
-        if (match !== undefined) {
-            resolved.push({
+        if (matchedWorkspace !== undefined) {
+            resolvedTags.push({
                 tag,
                 kind: 'package',
-                dir: getTargetName(match),
-                workspacePath: match.workspacePath,
-                isPublishable: match.isPublishable,
+                dir: getTargetName(matchedWorkspace),
+                workspacePath: matchedWorkspace.workspacePath,
+                isPublishable: matchedWorkspace.isPublishable,
             });
         }
         else if (directory !== undefined) {
-            resolved.push({
+            resolvedTags.push({
                 tag,
                 kind: 'directory',
                 dir: directory.name,
@@ -56,7 +58,7 @@ function resolveMonorepoTags(tags, workspaces, directories, project) {
             });
         }
         else if (project !== undefined && hasVersionAfterPrefix(tag, project.tagPrefix)) {
-            resolved.push({
+            resolvedTags.push({
                 tag,
                 kind: 'project',
                 dir: project.name ?? PROJECT_TARGET_ID,
@@ -65,7 +67,7 @@ function resolveMonorepoTags(tags, workspaces, directories, project) {
             });
         }
     }
-    return resolved;
+    return resolvedTags;
 }
 function findMatchingWorkspace(tag, sortedWorkspaces) {
     return sortedWorkspaces.find((workspace) => hasVersionAfterPrefix(tag, workspace.tagPrefix));

package/dist/esm/resolveReleaseTargets.js

@@ -13,8 +13,8 @@ export function resolveReleaseTargets(userConfig, discovery) {
     return projectMonorepoConfig(mergeMonorepoConfig(discovery.packageDirs, userConfig, readRootPackageVersion()));
 }
 export function isSinglePackageTargets(targets) {
-    const [only] = targets;
-    return targets.length === 1 && only?.kind === 'package' && !only.isWorkspace;
+    const [onlyTarget] = targets;
+    return targets.length === 1 && onlyTarget?.kind === 'package' && !onlyTarget.isWorkspace;
 }
 export function projectMonorepoConfig(config) {
     const targets = [

package/dist/esm/showTagPrefixesCommand.js

@@ -59,12 +59,12 @@ function renderWorkspaceRow(row, style) {
     lines.push(`  ${row.workspacePath}: derived prefix '${row.derivedPrefix}', ${statusMarker}`);
     for (const entry of row.legacyEntries) {
         if (entry.tagCount > 0) {
-            const recognized = `${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`;
-            lines.push(`      ${formatStatusLine(style, 'passed', recognized)}`);
+            const recognizedMessage = `${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`;
+            lines.push(`      ${formatStatusLine(style, 'passed', recognizedMessage)}`);
         }
         else {
-            const tagless = `recorded legacy prefix '${entry.prefix}' does not have any tags`;
-            lines.push(`      ${formatStatusLine(style, 'warning', tagless)}`);
+            const taglessMessage = `recorded legacy prefix '${entry.prefix}' does not have any tags`;
+            lines.push(`      ${formatStatusLine(style, 'warning', taglessMessage)}`);
         }
     }
     return lines;

package/dist/esm/sync-labels/generateCommand.d.ts

@@ -20,7 +20,7 @@ export declare function loadRepoLabelsConfig(stderrStyle: OutputStyle, configPat
 /** Options for the `sync-labels generate` subcommand. */
 interface GenerateOptions {
     /** Compares the regenerated content against the committed file instead of writing. */
-    check?: boolean;
+    shouldCheck?: boolean;
     /** Config file to read, relative to the working directory. Defaults to `CONFIG_FILE_PATH`. */
     configPath?: string;
     styles: StreamStyles;
@@ -28,11 +28,11 @@ interface GenerateOptions {
 /**
  * Runs the `sync-labels generate` command and returns the process exit code.
  *
- * Writes `.github/labels.yaml` from the config's `repoLabels` block, or, with `check`, reports whether the committed
+ * Writes `.github/labels.yaml` from the config's `repoLabels` block, or, with `shouldCheck`, reports whether the committed
  * file is stale and writes nothing.
  *
  * The header names the config by its POSIX path relative to the working directory, the repo root, so that the file
  * does not depend on the invocation directory or on the machine on which the command ran.
  */
-export declare function generateCommand({ check, configPath, styles }: GenerateOptions): Promise<number>;
+export declare function generateCommand({ shouldCheck, configPath, styles }: GenerateOptions): Promise<number>;
 export {};

package/dist/esm/sync-labels/generateCommand.js

@@ -15,14 +15,14 @@ export function formatLabelsYaml(labels, presetHashes, configFilePath = CONFIG_F
     for (const [name, hash] of sortedPresetHashes) {
         headerLines.push(`# ${name} preset hash: ${hash}`);
     }
-    const declared = labels.map(({ aliases, archived, color, description, name }) => ({
+    const declaredLabels = labels.map(({ aliases, archived, color, description, name }) => ({
         name,
         color,
         description: description ?? '',
         ...(aliases !== undefined && { aliases }),
         ...(archived !== undefined && { archived }),
     }));
-    const yamlBody = stringify(declared, { singleQuote: true, lineWidth: 0 });
+    const yamlBody = stringify(declaredLabels, { singleQuote: true, lineWidth: 0 });
     return headerLines.join('\n') + '\n' + yamlBody;
 }
 export async function loadRepoLabelsConfig(stderrStyle, configPath) {
@@ -41,7 +41,7 @@ export async function loadRepoLabelsConfig(stderrStyle, configPath) {
     }
     return result.config.repoLabels;
 }
-export async function generateCommand({ check = false, configPath, styles }) {
+export async function generateCommand({ shouldCheck = false, configPath, styles }) {
     if (checkRetiredSyncLabelsConfig(configPath)) {
         return 1;
     }
@@ -63,8 +63,8 @@ export async function generateCommand({ check = false, configPath, styles }) {
     for (const presetName of presetNames) {
         presetHashes.set(presetName, hashPreset(presetName));
     }
-    const content = formatLabelsYaml(labels, presetHashes, toRootRelativePosixPath(configPath ?? CONFIG_FILE_PATH));
-    if (check) {
+    const content = formatLabelsYaml(labels, presetHashes, convertToRootRelativePosixPath(configPath ?? CONFIG_FILE_PATH));
+    if (shouldCheck) {
         return compareAgainstCommittedFile(content);
     }
     try {
@@ -79,22 +79,22 @@ export async function generateCommand({ check = false, configPath, styles }) {
     console.info(`Generated ${LABELS_OUTPUT_PATH} with ${String(labels.length)} labels.`);
     return 0;
 }
-function compareAgainstCommittedFile(expected) {
-    let existing;
+function compareAgainstCommittedFile(expectedContent) {
+    let existingContent;
     try {
-        existing = readFileSync(LABELS_OUTPUT_PATH, 'utf8');
+        existingContent = readFileSync(LABELS_OUTPUT_PATH, 'utf8');
     }
     catch {
         reportError(`${LABELS_OUTPUT_PATH} is missing. Run \`release-kit sync-labels generate\` and commit the result.`);
         return 1;
     }
-    if (existing !== expected) {
+    if (existingContent !== expectedContent) {
         reportError(`${LABELS_OUTPUT_PATH} is stale. Run \`release-kit sync-labels generate\` and commit the result.`);
         return 1;
     }
     console.info(`${LABELS_OUTPUT_PATH} is up to date.`);
     return 0;
 }
-function toRootRelativePosixPath(filePath) {
+function convertToRootRelativePosixPath(filePath) {
     return path.relative(process.cwd(), path.resolve(filePath)).split(path.sep).join('/');
 }

package/dist/esm/sync-labels/initCommand.d.ts

@@ -3,8 +3,8 @@ import { type StreamStyles } from '@williamthorsen/nmr-core';
 interface InitOptions {
     /** Config file to read, relative to the working directory. Defaults to `CONFIG_FILE_PATH`. */
     configPath?: string;
-    dryRun: boolean;
-    force: boolean;
+    isDryRun: boolean;
+    shouldForce: boolean;
     styles: StreamStyles;
 }
 /**
@@ -17,5 +17,5 @@ interface InitOptions {
  * `configPath` names the config to read. Because the command fails when the named config does not exist, it
  * reaches the scaffolding branch only under the default path, and that branch always writes to `CONFIG_FILE_PATH`.
  */
-export declare function syncLabelsInitCommand({ configPath, dryRun, force, styles }: InitOptions): Promise<number>;
+export declare function syncLabelsInitCommand({ configPath, isDryRun, shouldForce, styles, }: InitOptions): Promise<number>;
 export {};

package/dist/esm/sync-labels/initCommand.js

@@ -6,14 +6,14 @@ import { CONFIG_FILE_PATH } from "../loadConfig.js";
 import { loadValidatedConfig, reportConfigProblem } from "../loadValidatedConfig.js";
 import { generateCommand, LABELS_OUTPUT_PATH } from "./generateCommand.js";
 import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
-import { buildScopeLabels, readSyncLabelsWorkflowTemplate, renderRepoLabelsBlock, repoLabelsConfigScript, } from "./templates.js";
+import { buildScopeLabels, readSyncLabelsWorkflowTemplate, renderRepoLabelsBlock, renderRepoLabelsConfigScript, } from "./templates.js";
 const WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
-export async function syncLabelsInitCommand({ configPath, dryRun, force, styles }) {
+export async function syncLabelsInitCommand({ configPath, isDryRun, shouldForce, styles, }) {
     const configFilePath = configPath ?? CONFIG_FILE_PATH;
     if (checkRetiredSyncLabelsConfig(configPath)) {
         return 1;
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info('[dry-run mode]');
     }
     console.info('\n> Discovering workspaces');
@@ -36,8 +36,8 @@ export async function syncLabelsInitCommand({ configPath, dryRun, force, styles
     else {
         console.info(`  Found ${String(workspace.packageDirs.length)} workspaces`);
     }
-    const configExists = configPath !== undefined || existsSync(CONFIG_FILE_PATH);
-    const retiredNames = configExists ? await loadRetiredPackageNames(styles, configPath) : [];
+    const doesConfigExist = configPath !== undefined || existsSync(CONFIG_FILE_PATH);
+    const retiredNames = doesConfigExist ? await loadRetiredPackageNames(styles, configPath) : [];
     if (retiredNames === undefined) {
         return 1;
     }
@@ -51,9 +51,9 @@ export async function syncLabelsInitCommand({ configPath, dryRun, force, styles
         process.stderr.write(`  ${describeError(error)}\n`);
         return 1;
     }
-    const workflowResult = writeFileWithCheck(WORKFLOW_PATH, workflow, { isDryRun: dryRun, shouldOverwrite: force });
-    reportWriteResult(workflowResult, dryRun, styles);
-    if (configExists) {
+    const workflowResult = writeFileWithCheck(WORKFLOW_PATH, workflow, { isDryRun, shouldOverwrite: shouldForce });
+    reportWriteResult(workflowResult, isDryRun, styles);
+    if (doesConfigExist) {
         console.info(`\n> ${configFilePath} already exists; add this block to the object passed to defineConfig:\n`);
         console.info(renderRepoLabelsBlock(scopeLabels));
         if (workflowResult.outcome === 'failed') {
@@ -69,16 +69,16 @@ export async function syncLabelsInitCommand({ configPath, dryRun, force, styles
 `);
         return 0;
     }
-    const configResult = writeFileWithCheck(CONFIG_FILE_PATH, repoLabelsConfigScript(scopeLabels), {
-        isDryRun: dryRun,
-        shouldOverwrite: force,
+    const configResult = writeFileWithCheck(CONFIG_FILE_PATH, renderRepoLabelsConfigScript(scopeLabels), {
+        isDryRun,
+        shouldOverwrite: shouldForce,
     });
-    reportWriteResult(configResult, dryRun, styles);
+    reportWriteResult(configResult, isDryRun, styles);
     if (workflowResult.outcome === 'failed' || configResult.outcome === 'failed') {
         process.stderr.write('Failed to scaffold one or more files.\n');
         return 1;
     }
-    if (dryRun) {
+    if (isDryRun) {
         console.info(`\n> [dry-run] Would generate ${LABELS_OUTPUT_PATH}`);
     }
     else {
@@ -109,8 +109,8 @@ async function loadRetiredPackageNames(styles, configPath) {
     if (result.status === 'missing') {
         return [];
     }
-    return (result.config.retiredPackages ?? []).map((retired) => toUnscopedName(retired.name));
+    return (result.config.retiredPackages ?? []).map((retired) => stripNpmScope(retired.name));
 }
-function toUnscopedName(name) {
+function stripNpmScope(name) {
     return name.startsWith('@') ? name.slice(name.indexOf('/') + 1) : name;
 }

package/dist/esm/sync-labels/presets.js

@@ -25,12 +25,12 @@ export function loadPreset(presetName) {
     catch (error) {
         throw chainError(`Failed to read preset "${presetName}"`, error);
     }
-    const parsed = parse(content);
-    if (!Array.isArray(parsed)) {
+    const parsedYaml = parse(content);
+    if (!Array.isArray(parsedYaml)) {
         throw new TypeError(`Preset "${presetName}" must be a YAML array of label definitions`);
     }
     const labels = [];
-    for (const entry of parsed) {
+    for (const entry of parsedYaml) {
         if (!isRecord(entry)) {
             throw new Error(`Preset "${presetName}" contains an invalid label entry: ${JSON.stringify(entry)}`);
         }

package/dist/esm/sync-labels/resolveLabels.js

@@ -6,23 +6,23 @@ export function resolveLabels(config) {
         const groupList = caseVariantGroups.map((group) => group.map((name) => `'${name}'`).join(' and ')).join('; ');
         throw new Error(`Keys in 'labels' differ only in case, which GitHub treats as the same label: ${groupList}. Keep one entry per label.`);
     }
-    const resolved = new Map();
+    const resolvedLabels = new Map();
     const presetNames = config.extends ?? [];
     for (const presetName of presetNames) {
         for (const label of loadPreset(presetName)) {
-            resolved.set(toLabelKey(label.name), label);
+            resolvedLabels.set(getLabelKey(label.name), label);
         }
     }
     for (const [name, spec] of labelEntries) {
-        const key = toLabelKey(name);
+        const key = getLabelKey(name);
         if (spec === null) {
-            if (!resolved.has(key)) {
+            if (!resolvedLabels.has(key)) {
                 throw new Error(`Label '${name}' is set to null (remove), but the presets in 'extends' don't define it. Fix the name or delete the entry.`);
             }
-            resolved.delete(key);
+            resolvedLabels.delete(key);
         }
         else {
-            resolved.set(key, {
+            resolvedLabels.set(key, {
                 name,
                 color: spec.color,
                 ...(spec.description !== undefined && { description: spec.description }),
@@ -31,7 +31,7 @@ export function resolveLabels(config) {
             });
         }
     }
-    const labels = sortLabels(resolved.values().toArray());
+    const labels = sortLabels(resolvedLabels.values().toArray());
     const aliasCollisions = findAliasCollisions(labels);
     if (aliasCollisions.length > 0) {
         throw new Error(`Aliases must name labels that are not declared and must not repeat, or the sync merges one label into another and deletes it: ${aliasCollisions.join('; ')}.`);
@@ -39,13 +39,13 @@ export function resolveLabels(config) {
     return labels;
 }
 function findAliasCollisions(labels) {
-    const labelNamesByKey = new Map(labels.map((label) => [toLabelKey(label.name), label.name]));
+    const labelNamesByKey = new Map(labels.map((label) => [getLabelKey(label.name), label.name]));
     const aliasOwnersByKey = new Map();
     const collisions = [];
     for (const label of labels) {
         const aliases = label.aliases ?? [];
         for (const alias of aliases) {
-            const key = toLabelKey(alias);
+            const key = getLabelKey(alias);
             const namedLabel = labelNamesByKey.get(key);
             const earlierOwner = aliasOwnersByKey.get(key);
             if (namedLabel !== undefined) {
@@ -62,14 +62,14 @@ function findAliasCollisions(labels) {
     return collisions;
 }
 function findCaseVariantGroups(names) {
-    return Map.groupBy(names, toLabelKey)
+    return Map.groupBy(names, getLabelKey)
         .values()
         .filter((group) => group.length > 1)
         .toArray();
 }
+function getLabelKey(name) {
+    return name.toLowerCase();
+}
 function sortLabels(labels) {
     return labels.toSorted((a, b) => a.name.localeCompare(b.name));
 }
-function toLabelKey(name) {
-    return name.toLowerCase();
-}

package/dist/esm/sync-labels/templates.d.ts

@@ -15,5 +15,5 @@ export declare function buildScopeLabels(workspacePaths: string[], retiredNames?
  * `.config/release-kit.config.ts`.
  */
 export declare function renderRepoLabelsBlock(scopeLabels: LabelDefinition[]): string;
-/** Generates a new `.config/release-kit.config.ts` containing the `repoLabels` block. */
-export declare function repoLabelsConfigScript(scopeLabels: LabelDefinition[]): string;
+/** Renders a new `.config/release-kit.config.ts` containing the `repoLabels` block. */
+export declare function renderRepoLabelsConfigScript(scopeLabels: LabelDefinition[]): string;

package/dist/esm/sync-labels/templates.js

@@ -33,7 +33,7 @@ export function renderRepoLabelsBlock(scopeLabels) {
 ${labelsBlock}
   },`;
 }
-export function repoLabelsConfigScript(scopeLabels) {
+export function renderRepoLabelsConfigScript(scopeLabels) {
     return `import { defineConfig } from '@williamthorsen/release-kit/config';
 
 export default defineConfig({

package/dist/esm/tagCommand.js

@@ -2,13 +2,13 @@ import { parseArgsOrExit, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { createTags } from "./createTags.js";
 const tagFlagSchema = {
-    dryRun: { long: '--dry-run', type: 'boolean' },
-    noGitChecks: { long: '--no-git-checks', type: 'boolean' },
+    isDryRun: { long: '--dry-run', type: 'boolean' },
+    shouldSkipGitChecks: { long: '--no-git-checks', type: 'boolean' },
 };
 export function tagCommand(argv, styles) {
-    const { dryRun, noGitChecks } = parseArgsOrExit(argv, tagFlagSchema).flags;
+    const { isDryRun, shouldSkipGitChecks } = parseArgsOrExit(argv, tagFlagSchema).flags;
     try {
-        createTags({ dryRun, noGitChecks, style: styles.stdout });
+        createTags({ isDryRun, shouldSkipGitChecks, style: styles.stdout });
     }
     catch (error) {
         reportError(describeError(error));

package/dist/esm/topologicalSort.d.ts

@@ -6,7 +6,7 @@ import type { ReleaseEntry } from './propagateBumps.js';
  * Uses Kahn's algorithm. Targets not in the release set are excluded. If the graph has
  * cycles, the remaining nodes are appended in arbitrary order and reported via `cyclicIds`.
  */
-export declare function topologicalSort(releaseSet: Map<string, ReleaseEntry>, graph: DependencyGraph): {
-    sorted: string[];
+export declare function sortTopologically(releaseSet: Map<string, ReleaseEntry>, graph: DependencyGraph): {
+    sortedIds: string[];
     cyclicIds: string[];
 };

package/dist/esm/topologicalSort.js

@@ -1,7 +1,7 @@
-export function topologicalSort(releaseSet, graph) {
+export function sortTopologically(releaseSet, graph) {
     const releaseIds = new Set(releaseSet.keys());
     if (releaseIds.size === 0) {
-        return { sorted: [], cyclicIds: [] };
+        return { sortedIds: [], cyclicIds: [] };
     }
     const inDegree = new Map();
     const forwardEdges = new Map();
@@ -31,13 +31,13 @@ export function topologicalSort(releaseSet, graph) {
             queue.push(id);
         }
     }
-    const sorted = [];
+    const sortedIds = [];
     while (queue.length > 0) {
         const id = queue.shift();
         if (id === undefined) {
             break;
         }
-        sorted.push(id);
+        sortedIds.push(id);
         const dependents = forwardEdges.get(id) ?? [];
         for (const dependent of dependents) {
             const newDegree = (inDegree.get(dependent) ?? 1) - 1;
@@ -47,14 +47,14 @@ export function topologicalSort(releaseSet, graph) {
             }
         }
     }
-    const sortedSet = new Set(sorted);
+    const sortedSet = new Set(sortedIds);
     const cyclicIds = [];
     for (const id of releaseIds) {
         if (sortedSet.has(id)) {
             continue;
         }
-        sorted.push(id);
+        sortedIds.push(id);
         cyclicIds.push(id);
     }
-    return { sorted, cyclicIds };
+    return { sortedIds, cyclicIds };
 }

package/dist/esm/types.d.ts

@@ -70,7 +70,7 @@ export interface ChangelogMarkdownConfig {
      * How many of the newest versioned sections `CHANGELOG.md` keeps; older sections go to per-major archive files
      * under `changelogs/`. When omitted, `CHANGELOG.md` keeps every section.
      */
-    keepVersions?: number;
+    keptVersionCount?: number;
 }
 /**
  * Editorial override for changelog items, keyed in the override file by `<hash>` (every item of the commit) or
@@ -245,7 +245,7 @@ export interface ReleasedPackageResult extends PackageResultFields, ReleaseField
     /** Present when propagation alone set the bump, the package's own commits having called for none. */
     propagatedOnly?: true;
     /** Present when the package was written via `--set-version`; the explicit version that was applied. */
-    setVersion?: string;
+    versionOverride?: string;
 }
 /** Result of a package target that skips: the diagnostic fields and a human-readable `skipReason`. */
 export interface SkippedPackageResult extends PackageResultFields {
@@ -280,7 +280,7 @@ export interface ReleasedDirectoryResult extends DirectoryResultFields, ReleaseF
     /** Raw commits of the directory's unreleased window. */
     commits: Commit[];
     /** Present when the directory was written via `--set-version`; the explicit version that was applied. */
-    setVersion?: string;
+    versionOverride?: string;
 }
 /** Result of a directory target that skips: the diagnostic fields and a human-readable `skipReason`. */
 export interface SkippedDirectoryResult extends DirectoryResultFields {

package/dist/esm/validateAllChangelogOverrides.js

@@ -89,8 +89,8 @@ function prefixWithFilePath(filePath, message) {
 }
 function processProjectScope(args) {
     const { projectFilePath, projectMap, projectItems, errors, globalMatchedRootKeys } = args;
-    const applied = applyChangelogOverrides(makeValidationEntries(projectItems), projectMap);
-    for (const message of applied.errors) {
+    const appliedResult = applyChangelogOverrides(makeValidationEntries(projectItems), projectMap);
+    for (const message of appliedResult.errors) {
         errors.push(prefixWithFilePath(projectFilePath, message));
     }
     const positionsByHash = indexItemPositions(projectItems);
@@ -105,19 +105,19 @@ function processWorkspaceScope(args) {
     const { filePath, items, map } = workspace;
     const validationEntries = makeValidationEntries(items);
     const positionsByHash = indexItemPositions(items);
-    const workspaceApplied = applyChangelogOverrides(validationEntries, map);
-    for (const message of workspaceApplied.errors) {
+    const workspaceAppliedResult = applyChangelogOverrides(validationEntries, map);
+    for (const message of workspaceAppliedResult.errors) {
         errors.push(prefixWithFilePath(filePath, message));
     }
     if (projectFilePath !== undefined && projectMap.size > 0) {
         const projectMinusShadowed = filterShadowedKeys(projectMap, map);
-        const projectApplied = applyChangelogOverrides(validationEntries, projectMinusShadowed);
-        for (const message of projectApplied.errors) {
+        const projectAppliedResult = applyChangelogOverrides(validationEntries, projectMinusShadowed);
+        for (const message of projectAppliedResult.errors) {
             errors.push(prefixWithFilePath(projectFilePath, message));
         }
-        const perFileErrors = new Set([...workspaceApplied.errors, ...projectApplied.errors]);
-        const composedApplied = applyChangelogOverrides(validationEntries, composeOverrides(projectMap, map));
-        for (const message of composedApplied.errors) {
+        const perFileErrors = new Set([...workspaceAppliedResult.errors, ...projectAppliedResult.errors]);
+        const composedAppliedResult = applyChangelogOverrides(validationEntries, composeOverrides(projectMap, map));
+        for (const message of composedAppliedResult.errors) {
             if (!perFileErrors.has(message)) {
                 errors.push(prefixWithFilePath(filePath, message));
             }

package/dist/esm/validateConfig.d.ts

@@ -3,7 +3,7 @@ import { type ReleaseKitConfig } from './configSchema.js';
  * Validates a raw config object loaded from `.config/release-kit.config.ts`. Returns `{}` with the errors for a config
  * that fails the schema parse, and runs the cross-field checks on one that passes.
  */
-export declare function validateConfig(raw: unknown): {
+export declare function validateConfig(rawConfig: unknown): {
     config: ReleaseKitConfig;
     errors: string[];
     warnings: string[];