@williamthorsen/release-kit 14.2.1 → 14.2.3

package/dist/esm/types.d.ts

@@ -1,5 +1,5 @@
 import type { BreakingPolicy } from '@williamthorsen/change-grammar';
-import { z } from 'zod';
+import type { LegacyIdentity } from './configSchema.js';
 /** Semver release type for version bumping. */
 export type ReleaseType = 'major' | 'minor' | 'patch';
 /** Target audience for a changelog section. */
@@ -365,230 +365,6 @@ export interface VersionPatterns {
     /** Commit types that trigger a minor bump. */
     minor: string[];
 }
-/**
- * Schema for a single historical identity snapshot for a workspace.
- *
- * Captures what the package looked like at some earlier point: the full npm `name`
- * (e.g., `'@williamthorsen/nmr-core'`) and the `tagPrefix` under which tags were
- * published (e.g., `'core-v'`).
- */
-export declare const legacyIdentitySchema: z.ZodObject<{
-    name: z.ZodString;
-    tagPrefix: z.ZodString;
-}, z.core.$strict>;
-/**
- * A single historical identity snapshot for a workspace. Both fields are required, because a full
- * tuple stays unambiguous across any number of renames.
- */
-export type LegacyIdentity = z.infer<typeof legacyIdentitySchema>;
-/**
- * Schema for a package that once lived in this repo but has since been extracted or removed.
- *
- * Unlike `legacyIdentitySchema`, retired packages are never consulted for baseline lookup
- * or changelog attribution; they acknowledge historical tag prefixes and suppress
- * undeclared-candidate warnings.
- */
-export declare const retiredPackageSchema: z.ZodObject<{
-    name: z.ZodString;
-    tagPrefix: z.ZodString;
-    successor: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** A package that once lived in this repo but has since been extracted or removed. */
-export type RetiredPackage = z.infer<typeof retiredPackageSchema>;
-/** Schema for a single workspace override entry in the config file. */
-export declare const workspaceOverrideSchema: z.ZodObject<{
-    dir: z.ZodString;
-    shouldExclude: z.ZodOptional<z.ZodBoolean>;
-    legacyIdentities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        tagPrefix: z.ZodString;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-/** Override for a single workspace in the config file. Matches a discovered workspace by `dir`. */
-export type WorkspaceOverride = z.infer<typeof workspaceOverrideSchema>;
-/** Schema for the optional `project` block. */
-export declare const projectConfigSchema: z.ZodObject<{
-    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    tagPrefix: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** Consumer-facing project-release config (`project` block). Empty object opts in to project releases. */
-export type ProjectConfig = z.infer<typeof projectConfigSchema>;
-/**
- * Schema for a `releases` entry that names the target at `path`: the discovered workspace there, or otherwise the
- * directory, whose `tagPrefix` defaults to its basename followed by `-v`.
- */
-export declare const pathReleaseSchema: z.ZodObject<{
-    path: z.ZodString;
-    tagPrefix: z.ZodOptional<z.ZodString>;
-    legacyIdentities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        tagPrefix: z.ZodString;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-/** A `releases` entry that names the discovered workspace or the directory at `path`. */
-export type PathRelease = z.infer<typeof pathReleaseSchema>;
-/** Schema for a `releases` entry that declares a composite of the named targets. */
-export declare const compositeReleaseSchema: z.ZodObject<{
-    includes: z.ZodArray<z.ZodString>;
-    tagPrefix: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** A `releases` entry that declares a composite of the named targets, versioned by the root `package.json`. */
-export type CompositeRelease = z.infer<typeof compositeReleaseSchema>;
-/**
- * Schema for one `releases` entry: `false` excludes the discovered workspace of that name, and the object shapes name
- * a workspace or a directory, or declare the composite. `validateConfig` relies on this branch order to report a failed entry.
- */
-export declare const releaseEntrySchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
-    path: z.ZodString;
-    tagPrefix: z.ZodOptional<z.ZodString>;
-    legacyIdentities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        tagPrefix: z.ZodString;
-    }, z.core.$strict>>>;
-}, z.core.$strict>, z.ZodObject<{
-    includes: z.ZodArray<z.ZodString>;
-    tagPrefix: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>]>;
-/** One `releases` entry, keyed in the config by the target's name. */
-export type ReleaseEntry = z.infer<typeof releaseEntrySchema>;
-/** Schema for the optional `changelogJson` block (input shape, all fields optional). */
-export declare const changelogJsonInputSchema: z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    outputPath: z.ZodOptional<z.ZodString>;
-    devOnlySections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, 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>;
-}, z.core.$strict>;
-/** Schema for the optional `releaseNotes` block (input shape, all fields optional). */
-export declare const releaseNotesInputSchema: z.ZodObject<{
-    shouldInjectIntoReadme: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-/** Schema for a single `workTypes` entry. */
-export declare const workTypeConfigSchema: z.ZodObject<{
-    header: z.ZodString;
-    aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    excludedFromChangelog: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-/** Schema for the `versionPatterns` block. Both arrays are required when the field is provided. */
-export declare const versionPatternsSchema: z.ZodObject<{
-    major: z.ZodArray<z.ZodString>;
-    minor: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-/** Schema for a single `breakingPolicies` value. */
-export declare const breakingPolicyValueSchema: z.ZodEnum<{
-    optional: "optional";
-    forbidden: "forbidden";
-}>;
-/** Schema for a single label's spec in the `repoLabels.labels` record. */
-export declare const labelSpecSchema: z.ZodObject<{
-    color: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    archived: z.ZodOptional<z.ZodLiteral<true>>;
-}, z.core.$strict>;
-/**
- * A label's color, optional description, optional aliases, and optional archived mark; the name is the record key in
- * `repoLabels.labels`. An omitted description resolves to empty, which the generated labels file declares explicitly
- * so that a sync clears whatever description the label has on the repo. Each alias names an existing label that the
- * sync renames to this one in place, keeping it on the issues and pull requests that have it. `archived: true` retires
- * the label: The sync archives it, keeping it on the issues and pull requests that have it.
- */
-export type LabelSpec = z.infer<typeof labelSpecSchema>;
-/**
- * Schema for the optional `repoLabels` block, which declares the repository's label registry (the labels defined on
- * the GitHub repo, distinct from labels applied to PRs and issues).
- *
- * Resolution is an ordered fold with last-writer-wins: presets in `extends` order, then the `labels` record,
- * in which an entry adds a label, replaces one that an earlier layer defined, or removes it (`null`). Names match
- * case-insensitively, as GitHub matches them, and the replacing layer's spelling wins.
- * Three misstatements are resolve-time errors (`resolveLabels`), not schema errors: `labels` keys that differ only in
- * case, a `null` naming a label not defined by any earlier layer, and an alias that names a resolved label or repeats
- * another alias.
- */
-export declare const repoLabelsSchema: z.ZodObject<{
-    extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
-        color: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        archived: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strict>>>>;
-}, z.core.$strict>;
-/** Consumer-facing `repoLabels` block: bundled presets to extend plus per-name adjustments. */
-export type RepoLabelsConfig = z.infer<typeof repoLabelsSchema>;
-/** Schema for the consumer-facing config file shape (`.config/release-kit.config.ts`). */
-export declare const releaseKitConfigSchema: z.ZodObject<{
-    breakingPolicies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        optional: "optional";
-        forbidden: "forbidden";
-    }>>>;
-    changelogJson: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        outputPath: z.ZodOptional<z.ZodString>;
-        devOnlySections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    changelogMarkdown: z.ZodOptional<z.ZodObject<{
-        keepVersions: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
-    formatCommand: z.ZodOptional<z.ZodString>;
-    project: z.ZodOptional<z.ZodObject<{
-        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        tagPrefix: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    releaseNotes: z.ZodOptional<z.ZodObject<{
-        shouldInjectIntoReadme: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    releases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
-        path: z.ZodString;
-        tagPrefix: z.ZodOptional<z.ZodString>;
-        legacyIdentities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            tagPrefix: z.ZodString;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>, z.ZodObject<{
-        includes: z.ZodArray<z.ZodString>;
-        tagPrefix: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>]>>>;
-    repoLabels: z.ZodOptional<z.ZodObject<{
-        extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
-            color: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            archived: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strict>>>>;
-    }, z.core.$strict>>;
-    retiredPackages: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        tagPrefix: z.ZodString;
-        successor: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    scopeAliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    versionPatterns: z.ZodOptional<z.ZodObject<{
-        major: z.ZodArray<z.ZodString>;
-        minor: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    workspaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        dir: z.ZodString;
-        shouldExclude: z.ZodOptional<z.ZodBoolean>;
-        legacyIdentities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            tagPrefix: z.ZodString;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>>>;
-    workTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        header: z.ZodString;
-        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        excludedFromChangelog: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-/**
- * Consumer-facing config file shape (`.config/release-kit.config.ts`).
- * All fields are optional; defaults are applied during config merging.
- */
-export type ReleaseKitConfig = z.infer<typeof releaseKitConfigSchema>;
 /** A raw commit from the git log. */
 export interface Commit {
     /** The commit message, subject and body together. */

package/dist/esm/types.js

@@ -1,103 +1 @@
-import { z } from 'zod';
-export const legacyIdentitySchema = z
-    .object({
-    name: z.string().min(1),
-    tagPrefix: z.string().min(1),
-})
-    .strict();
-export const retiredPackageSchema = z
-    .object({
-    name: z.string().min(1),
-    tagPrefix: z.string().min(1),
-    successor: z.string().min(1).optional(),
-})
-    .strict();
-export const workspaceOverrideSchema = z
-    .object({
-    dir: z.string().min(1),
-    shouldExclude: z.boolean().optional(),
-    legacyIdentities: z.array(legacyIdentitySchema).optional(),
-})
-    .strict();
-export const projectConfigSchema = z
-    .object({
-    paths: z.array(z.string().min(1)).min(1).optional(),
-    tagPrefix: z.string().min(1).optional(),
-})
-    .strict();
-export const pathReleaseSchema = z
-    .object({
-    path: z.string().min(1),
-    tagPrefix: z.string().min(1).optional(),
-    legacyIdentities: z.array(legacyIdentitySchema).optional(),
-})
-    .strict();
-export const compositeReleaseSchema = z
-    .object({
-    includes: z.array(z.string().min(1)).min(1),
-    tagPrefix: z.string().min(1).optional(),
-})
-    .strict();
-export const releaseEntrySchema = z.union([z.literal(false), pathReleaseSchema, compositeReleaseSchema]);
-export const changelogJsonInputSchema = z
-    .object({
-    enabled: z.boolean().optional(),
-    outputPath: z.string().optional(),
-    devOnlySections: z.array(z.string()).optional(),
-})
-    .strict();
-export const changelogMarkdownInputSchema = z
-    .object({
-    keepVersions: z.number().int().min(1).optional(),
-})
-    .strict();
-export const releaseNotesInputSchema = z
-    .object({
-    shouldInjectIntoReadme: z.boolean().optional(),
-})
-    .strict();
-export const workTypeConfigSchema = z
-    .object({
-    header: z.string(),
-    aliases: z.array(z.string()).optional(),
-    excludedFromChangelog: z.boolean().optional(),
-})
-    .strict();
-export const versionPatternsSchema = z
-    .object({
-    major: z.array(z.string()),
-    minor: z.array(z.string()),
-})
-    .strict();
-export const breakingPolicyValueSchema = z.enum(['forbidden', 'optional']);
-export const labelSpecSchema = z
-    .object({
-    color: z.string().min(1),
-    description: z.string().optional(),
-    aliases: z.array(z.string().min(1)).min(1).optional(),
-    archived: z.literal(true).optional(),
-})
-    .strict();
-export const repoLabelsSchema = z
-    .object({
-    extends: z.array(z.string().min(1)).optional(),
-    labels: z.record(z.string().min(1), labelSpecSchema.nullable()).optional(),
-})
-    .strict();
-export const releaseKitConfigSchema = z
-    .object({
-    breakingPolicies: z.record(z.string(), breakingPolicyValueSchema).optional(),
-    changelogJson: changelogJsonInputSchema.optional(),
-    changelogMarkdown: changelogMarkdownInputSchema.optional(),
-    formatCommand: z.string().min(1).optional(),
-    project: projectConfigSchema.optional(),
-    releaseNotes: releaseNotesInputSchema.optional(),
-    releases: z.record(z.string().min(1), releaseEntrySchema).optional(),
-    repoLabels: repoLabelsSchema.optional(),
-    retiredPackages: z.array(retiredPackageSchema).optional(),
-    scopeAliases: z.record(z.string(), z.string()).optional(),
-    versionPatterns: versionPatternsSchema.optional(),
-    workspaces: z.array(workspaceOverrideSchema).optional(),
-    workTypes: z.record(z.string(), workTypeConfigSchema).optional(),
-})
-    .strict();
+export {};

package/dist/esm/validateAllChangelogOverrides.d.ts

@@ -0,0 +1,56 @@
+/** Per-scope input to {@link validateAllChangelogOverrides}. */
+export interface ChangelogOverrideScope {
+    /**
+     * Path to the override file, used to load the file and to attribute findings. A relative path resolves against the
+     * process working directory.
+     */
+    filePath: string;
+    /** Items in this scope's history window. Each override key is matched against these. */
+    items: readonly OverrideTargetItem[];
+}
+/** A changelog item as override matching sees it. `entry` is absent for a title-derived item. */
+export interface OverrideTargetItem {
+    hash: string;
+    entry?: number;
+}
+/**
+ * Validates every override file against the items of its scopes and returns the aggregated findings. It reads the
+ * override files but doesn't collect any items: The caller supplies each scope's items.
+ *
+ * Items built by `buildChangelogEntries`, as `release-kit prepare` builds them, yield the matches that `prepare`
+ * computes, tier asymmetry included: A workspace-tier key is stale when it matches nothing in its own workspace, and a
+ * root-tier key only when it matches nothing in any scope, the project release window included.
+ *
+ * Every returned string is prefixed with the path of the override file to which it pertains.
+ *
+ * A relative `filePath`, in any scope, resolves against the process working directory, not against the repo root.
+ * A caller running from elsewhere passes absolute paths or changes directory first.
+ */
+export declare function validateAllChangelogOverrides(inputs: ValidateAllChangelogOverridesInputs): ValidateAllChangelogOverridesResult;
+/** Inputs to {@link validateAllChangelogOverrides}. */
+export interface ValidateAllChangelogOverridesInputs {
+    /**
+     * Project-tier scope (the override file at the repo root).
+     *
+     * The file at `filePath` is loaded once and used in two ways:
+     * - Its overrides are composed into every workspace's apply (root-tier overrides apply globally).
+     * - When `items` is provided, the project map is also applied directly to those items
+     *   (project release in monorepo mode, or the package's history in single-package mode).
+     *
+     * Omit when the project file doesn't exist.
+     */
+    project?: {
+        filePath: string;
+        items?: readonly OverrideTargetItem[];
+    };
+    /** Per-workspace scopes. Each workspace's file applies only to its own items. */
+    workspaces?: readonly ChangelogOverrideScope[];
+}
+/**
+ * Result of {@link validateAllChangelogOverrides}: aggregated errors and warnings, each prefixed with the path of the
+ * file to which it pertains.
+ */
+export interface ValidateAllChangelogOverridesResult {
+    errors: string[];
+    warnings: string[];
+}

package/dist/esm/validateAllChangelogOverrides.js

@@ -0,0 +1,138 @@
+import { applyChangelogOverrides, indexItemPositions, resolveOverrideKey } from "./applyChangelogOverrides.js";
+import { composeOverrides } from "./changelogOverrides.js";
+import { loadChangelogOverrides } from "./loadChangelogOverrides.js";
+export function validateAllChangelogOverrides(inputs) {
+    const errors = [];
+    const warnings = [];
+    const projectFilePath = inputs.project?.filePath;
+    const projectMap = loadScopeMap(projectFilePath, errors);
+    const workspaceMaps = (inputs.workspaces ?? []).map((scope) => ({
+        filePath: scope.filePath,
+        items: scope.items,
+        map: loadScopeMap(scope.filePath, errors),
+    }));
+    const globalMatchedRootKeys = new Set();
+    for (const workspace of workspaceMaps) {
+        processWorkspaceScope({
+            workspace,
+            projectFilePath,
+            projectMap,
+            errors,
+            warnings,
+            globalMatchedRootKeys,
+        });
+    }
+    const projectItems = inputs.project?.items;
+    if (projectFilePath !== undefined && projectItems !== undefined) {
+        processProjectScope({ projectFilePath, projectMap, projectItems, errors, globalMatchedRootKeys });
+    }
+    if (projectFilePath !== undefined) {
+        collectRootStaleWarnings(projectFilePath, projectMap, globalMatchedRootKeys, warnings);
+    }
+    return { errors, warnings };
+}
+function collectRootStaleWarnings(projectFilePath, projectMap, globalMatchedRootKeys, warnings) {
+    for (const key of projectMap.keys()) {
+        if (!globalMatchedRootKeys.has(key)) {
+            warnings.push(formatRootStaleWarning(projectFilePath, key));
+        }
+    }
+}
+function filterShadowedKeys(projectMap, workspaceMap) {
+    const result = new Map();
+    for (const [key, value] of projectMap) {
+        if (workspaceMap.has(key))
+            continue;
+        result.set(key, value);
+    }
+    return result;
+}
+function formatRootStaleWarning(filePath, key) {
+    return `${filePath}: Override key '${key}' did not match any item in any scope (likely a stale reference)`;
+}
+function formatWorkspaceStaleWarning(filePath, key) {
+    return `${filePath}: Override key '${key}' did not match any item in this workspace's history (likely a stale reference)`;
+}
+function hasAnyMatch(key, positionsByHash) {
+    return resolveOverrideKey(key, positionsByHash).kind !== 'none';
+}
+function loadScopeMap(filePath, errors) {
+    if (filePath === undefined) {
+        return new Map();
+    }
+    const result = loadChangelogOverrides(filePath);
+    if ('errors' in result) {
+        for (const message of result.errors) {
+            errors.push(prefixWithFilePath(filePath, message));
+        }
+        return new Map();
+    }
+    return result.overrides;
+}
+function makeValidationEntries(items) {
+    return [
+        {
+            version: '0.0.0',
+            date: '0000-00-00',
+            sections: [
+                {
+                    title: 'Validation',
+                    audience: 'all',
+                    items: items.map((item) => ({ ...item, description: '' })),
+                },
+            ],
+        },
+    ];
+}
+function prefixWithFilePath(filePath, message) {
+    return `${filePath}: ${message}`;
+}
+function processProjectScope(args) {
+    const { projectFilePath, projectMap, projectItems, errors, globalMatchedRootKeys } = args;
+    const applied = applyChangelogOverrides(makeValidationEntries(projectItems), projectMap);
+    for (const message of applied.errors) {
+        errors.push(prefixWithFilePath(projectFilePath, message));
+    }
+    const positionsByHash = indexItemPositions(projectItems);
+    for (const key of projectMap.keys()) {
+        if (hasAnyMatch(key, positionsByHash)) {
+            globalMatchedRootKeys.add(key);
+        }
+    }
+}
+function processWorkspaceScope(args) {
+    const { workspace, projectFilePath, projectMap, errors, warnings, globalMatchedRootKeys } = 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) {
+        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) {
+            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) {
+            if (!perFileErrors.has(message)) {
+                errors.push(prefixWithFilePath(filePath, message));
+            }
+        }
+    }
+    for (const key of map.keys()) {
+        if (!hasAnyMatch(key, positionsByHash)) {
+            warnings.push(formatWorkspaceStaleWarning(filePath, key));
+        }
+    }
+    for (const key of projectMap.keys()) {
+        if (map.has(key))
+            continue;
+        if (hasAnyMatch(key, positionsByHash)) {
+            globalMatchedRootKeys.add(key);
+        }
+    }
+}

package/dist/esm/validateConfig.d.ts

@@ -1,4 +1,4 @@
-import { type ReleaseKitConfig } from './types.js';
+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.

package/dist/esm/validateConfig.js

@@ -1,5 +1,5 @@
+import { releaseKitConfigSchema } from "./configSchema.js";
 import { isRecord } from "./typeGuards.js";
-import { releaseKitConfigSchema } from "./types.js";
 export function validateConfig(raw) {
     if (!isRecord(raw)) {
         return { config: {}, errors: ['Config must be an object'], warnings: [] };
@@ -162,16 +162,14 @@ function detectReleasesConflicts(config, errors) {
 function listLegacyIdentityDeclarations(config) {
     const fromWorkspaces = (config.workspaces ?? []).flatMap((workspace, index) => workspace.legacyIdentities === undefined
         ? []
-        : [
-            {
-                label: `workspaces[${index}]`,
-                owner: `workspace '${workspace.dir}'`,
-                legacyIdentities: workspace.legacyIdentities,
-            },
-        ]);
+        : {
+            label: `workspaces[${index}]`,
+            owner: `workspace '${workspace.dir}'`,
+            legacyIdentities: workspace.legacyIdentities,
+        });
     const fromReleases = Object.entries(config.releases ?? {}).flatMap(([name, entry]) => entry === false || !('path' in entry) || entry.legacyIdentities === undefined
         ? []
-        : [{ label: `releases.${name}`, owner: `release '${name}'`, legacyIdentities: entry.legacyIdentities }]);
+        : { label: `releases.${name}`, owner: `release '${name}'`, legacyIdentities: entry.legacyIdentities });
     return [...fromWorkspaces, ...fromReleases];
 }
 function readAtPath(input, path) {

package/dist/esm/validateOverridesCommand.d.ts

@@ -1,10 +1,10 @@
 import { type OutputStyle, type StreamStyles } from '@williamthorsen/nmr-core';
 import { type ReleaseHistoryConfig } from './buildChangelogEntries.js';
-import { type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult } from './changelogOverrides.js';
 import { type WorkspaceDiscovery } from './discoverWorkspaces.js';
 import type { GenerateChangelogOptions } from './generateChangelogs.js';
 import { type LoadValidatedConfigResult } from './loadValidatedConfig.js';
 import type { ChangelogEntry } from './types.js';
+import { type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult } from './validateAllChangelogOverrides.js';
 /**
  * Result of {@link validateOverridesCommand}: a tiered exit code paired with a human-readable message.
  *

package/dist/esm/validateOverridesCommand.js

@@ -1,11 +1,12 @@
 import { formatErrorLine, formatStatusLine } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { buildChangelogEntries } from "./buildChangelogEntries.js";
-import { resolveOverridePath, validateAllChangelogOverrides, } from "./changelogOverrides.js";
+import { resolveOverridePath } from "./changelogOverrides.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { loadValidatedConfig } from "./loadValidatedConfig.js";
 import { describeHistoryWindow } from "./prepareTarget.js";
 import { isSinglePackageTargets, resolveReleaseTargets } from "./resolveReleaseTargets.js";
+import { validateAllChangelogOverrides, } from "./validateAllChangelogOverrides.js";
 const SYNTHETIC_VALIDATE_TAG = 'validate-only';
 export async function validateOverridesCommand(styles, configPath, dependencies = {}) {
     const discover = dependencies.discoverWorkspaces ?? discoverWorkspaces;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@williamthorsen/release-kit",
-  "version": "14.2.1",
+  "version": "14.2.3",
   "description": "Version-bumping and changelog-generation toolkit for release workflows",
   "keywords": [
     "changelog",
@@ -51,7 +51,7 @@
   ],
   "dependencies": {
     "@williamthorsen/change-grammar": "0.2.1",
-    "@williamthorsen/nmr-core": "0.13.3",
+    "@williamthorsen/nmr-core": "0.13.4",
     "@williamthorsen/toolbelt.errors": "0.8.3",
     "json-stringify-pretty-compact": "4.0.0",
     "semver": "7.8.5",
@@ -65,8 +65,8 @@
     "@williamthorsen/toolbelt.vitest": "0.10.3",
     "actionlint": "2.0.6",
     "esbuild": "0.28.2",
-    "readyup": "0.40.0",
-    "smol-toml": "1.9.0",
+    "readyup": "0.42.0",
+    "smol-toml": "1.9.1",
     "vitest": "4.1.11"
   },
   "engines": {