@williamthorsen/release-kit 14.2.2 → 14.2.4

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/docs/changelogs.md

@@ -93,9 +93,11 @@ A workspace's window contains every commit that touches the workspace's paths. A
 
 A scope narrows the window and never widens it: A scope that names a workspace whose window does not contain the commit doesn't route the item to any workspace, and `prepare` reports it (see [Reported diagnostics](#reported-diagnostics)). A composite's changelog, such as the project changelog, and a single-package repo take every entry, whatever its scopes.
 
-A workspace's bump reads the items routed to it, so a breaking entry scoped to one workspace does not raise a major bump in another that the same commit touched. A workspace whose window has commits but lacks a routed item doesn't call for a release.
+The window decides whether a workspace releases, and the scopes decide only what its changelog says. When none of a commit's entries routes to a workspace whose window contains the commit, release-kit reads the commit for that workspace from its title, as it reads a commit without a block: The title's type counts toward the workspace's bump, and the title's item enters its changelog. A commit with at least one entry routed to the workspace is read from its routed entries alone, even when none of them yields an item.
 
-Each `prepare` rebuilds a workspace's released windows with the same routing. When an earlier release recorded an item under a workspace that the item's scopes do not name, the rebuild removes the item from that workspace's past section. A path window does not follow a renamed directory, and legacy identities do not rename scopes: An entry scoped to a workspace's old directory name is routed to the workspace only through a `scopeAliases` entry from the old name to the new one, and until one exists, `prepare` reports the scope for each such commit in the unreleased window.
+A workspace's bump reads the items routed to it, so a breaking entry scoped to one workspace does not raise a major bump in another workspace that has a routed entry of its own. A workspace read from the title takes the title's breaking marker; the workspace to which an entry is scoped keeps the entry's level.
+
+Each `prepare` rebuilds a workspace's released windows with the same routing, the fallback to the title included. When an earlier release recorded an item under a workspace that the item's scopes do not name, the rebuild removes the item from that workspace's past section. A path window does not follow a renamed directory, and legacy identities do not rename scopes: An entry scoped to a workspace's old directory name is routed to the workspace only through a `scopeAliases` entry from the old name to the new one, and until one exists, `prepare` reports the scope for each such commit in the unreleased window.
 
 ## Change-record blocks
 
@@ -128,7 +130,7 @@ An entry whose type is excluded from the changelog doesn't yield an item. An ove
 
 ### Fallback to the title
 
-A commit is read from its title, as [Which commits appear in a changelog](#which-commits-appear-in-a-changelog) describes, when it doesn't have a block, when the block's `entries` is absent or empty, or when the block is malformed. A block is malformed when it never closes, when its payload is not valid YAML or not a mapping, when `entries` is not a list, when an entry is not a mapping, when an entry's `type` or `text` is missing, blank, or not a string, when `breaking` is not a boolean, when `scopes` is not a list of strings, when `migration` or `ticket_ref` is not a string, or when `pr_number` is not a positive integer. One defect makes the whole block malformed.
+A commit is read from its title, as [Which commits appear in a changelog](#which-commits-appear-in-a-changelog) describes, when it doesn't have a block, when the block's `entries` is absent or empty, when none of its entries routes to the workspace being read (see [Routing to workspaces](#routing-to-workspaces)), or when the block is malformed. A block is malformed when it never closes, when its payload is not valid YAML or not a mapping, when `entries` is not a list, when an entry is not a mapping, when an entry's `type` or `text` is missing, blank, or not a string, when `breaking` is not a boolean, when `scopes` is not a list of strings, when `migration` or `ticket_ref` is not a string, or when `pr_number` is not a positive integer. One defect makes the whole block malformed.
 
 ### Reported diagnostics
 
@@ -139,7 +141,7 @@ A commit is read from its title, as [Which commits appear in a changelog](#which
 - **An entry that violates its type's breaking policy**, as a policy violation at the entry's position. Its item is not marked breaking.
 - **An entry scope that doesn't name a workspace in its commit's window**, with the commit's hash, the entry's position, and the scope as the entry declares it. release-kit reports it under every workspace whose window contains the commit. A scope that names nothing, or a workspace whose window does not contain the commit, is reported; `*`, `root`, and a scope that names a workspace in the window are not. Under `--only`, a scope that names a configured workspace left out of the run is not reported either. A workspace excluded with `shouldExclude: true` or a `releases` entry of `false` is not a configured workspace, so a scope that names one is reported.
 
-The result that `prepare` returns includes these as `malformedBlocks`, `undeclaredEntryTypes`, `policyViolations` entries whose `surface` is `'entry'`, and `unroutedEntryScopes`, whether the target releases or is skipped. Because a block whose entries are all undeclared or excluded doesn't yield an item, the commit doesn't raise a bump.
+The result that `prepare` returns includes these as `malformedBlocks`, `undeclaredEntryTypes`, `policyViolations` entries whose `surface` is `'entry'`, and `unroutedEntryScopes`, whether the target releases or is skipped. Because a block whose routed entries are all undeclared or excluded doesn't yield an item, the commit doesn't raise a bump.
 
 ## Release-notes injection