@williamthorsen/release-kit 6.0.0 → 8.0.0

package/dist/esm/changelogOverrides.js

@@ -1,424 +1,421 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
 import { isRecord } from "./typeGuards.js";
-const OVERRIDES_FILENAME = ".meta/changelog-overrides.json";
-const VALID_AUDIENCE_VALUES = /* @__PURE__ */ new Set(["all", "dev", "skip"]);
-const V1_SUPPORTED_AUDIENCE_VALUES = /* @__PURE__ */ new Set(["skip"]);
-const KNOWN_OVERRIDE_FIELDS = /* @__PURE__ */ new Set(["audience", "description", "body", "breaking"]);
-function loadChangelogOverrides(path2) {
-  if (!existsSync(path2)) {
-    return { overrides: /* @__PURE__ */ new Map() };
-  }
-  let content;
-  try {
-    content = readFileSync(path2, "utf8");
-  } catch (error) {
-    return {
-      errors: [`Failed to read override file ${path2}: ${error instanceof Error ? error.message : String(error)}`]
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (error) {
-    return {
-      errors: [`Failed to parse override file ${path2}: ${error instanceof Error ? error.message : String(error)}`]
-    };
-  }
-  const result = validateChangelogOverrides(parsed);
-  if (result.errors.length > 0) {
-    return { errors: result.errors };
-  }
-  return { overrides: result.overrides };
+const OVERRIDES_FILENAME = '.meta/changelog-overrides.json';
+const VALID_AUDIENCE_VALUES = new Set(['all', 'dev', 'skip']);
+const V1_SUPPORTED_AUDIENCE_VALUES = new Set(['skip']);
+const KNOWN_OVERRIDE_FIELDS = new Set(['audience', 'description', 'body', 'breaking']);
+export function loadChangelogOverrides(path) {
+    if (!existsSync(path)) {
+        return { overrides: new Map() };
+    }
+    let content;
+    try {
+        content = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        return {
+            errors: [`Failed to read override file ${path}: ${error instanceof Error ? error.message : String(error)}`],
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        return {
+            errors: [`Failed to parse override file ${path}: ${error instanceof Error ? error.message : String(error)}`],
+        };
+    }
+    const result = validateChangelogOverrides(parsed);
+    if (result.errors.length > 0) {
+        return { errors: result.errors };
+    }
+    return { overrides: result.overrides };
 }
-function validateChangelogOverrides(raw) {
-  const overrides = /* @__PURE__ */ new Map();
-  const errors = [];
-  if (!isRecord(raw)) {
-    errors.push("Override file: top-level value must be an object keyed by commit hash");
+export function validateChangelogOverrides(raw) {
+    const overrides = new Map();
+    const errors = [];
+    if (!isRecord(raw)) {
+        errors.push('Override file: top-level value must be an object keyed by commit hash');
+        return { overrides, errors };
+    }
+    for (const [key, rawEntry] of Object.entries(raw)) {
+        if (key === '') {
+            errors.push('Override file: empty-string key is not a valid commit hash');
+            continue;
+        }
+        const validated = validateSingleOverride(key, rawEntry, errors);
+        if (validated !== undefined) {
+            overrides.set(key, validated);
+        }
+    }
     return { overrides, errors };
-  }
-  for (const [key, rawEntry] of Object.entries(raw)) {
-    if (key === "") {
-      errors.push("Override file: empty-string key is not a valid commit hash");
-      continue;
-    }
-    const validated = validateSingleOverride(key, rawEntry, errors);
-    if (validated !== void 0) {
-      overrides.set(key, validated);
-    }
-  }
-  return { overrides, errors };
 }
 function validateSingleOverride(key, rawEntry, errors) {
-  if (!isRecord(rawEntry)) {
-    errors.push(`overrides['${key}']: must be an object`);
-    return void 0;
-  }
-  let entryValid = true;
-  for (const fieldName of Object.keys(rawEntry)) {
-    if (!KNOWN_OVERRIDE_FIELDS.has(fieldName)) {
-      errors.push(`overrides['${key}']: unknown field '${fieldName}'`);
-      entryValid = false;
-    }
-  }
-  const result = {};
-  if (rawEntry.audience !== void 0) {
-    const audienceResult = validateAudience(key, rawEntry.audience, errors);
-    if (audienceResult === void 0) {
-      entryValid = false;
-    } else {
-      result.audience = audienceResult;
-    }
-  }
-  if (rawEntry.description !== void 0) {
-    if (typeof rawEntry.description !== "string") {
-      errors.push(`overrides['${key}']: 'description' must be a string`);
-      entryValid = false;
-    } else {
-      result.description = rawEntry.description;
-    }
-  }
-  if (rawEntry.body !== void 0) {
-    if (typeof rawEntry.body !== "string") {
-      errors.push(`overrides['${key}']: 'body' must be a string`);
-      entryValid = false;
-    } else {
-      result.body = rawEntry.body;
-    }
-  }
-  if (rawEntry.breaking !== void 0) {
-    if (typeof rawEntry.breaking !== "boolean") {
-      errors.push(`overrides['${key}']: 'breaking' must be a boolean`);
-      entryValid = false;
-    } else {
-      result.breaking = rawEntry.breaking;
-    }
-  }
-  if (Object.keys(result).length === 0 && entryValid) {
-    errors.push(`overrides['${key}']: at least one override field must be set`);
-    return void 0;
-  }
-  if (!entryValid) {
-    return void 0;
-  }
-  return result;
+    if (!isRecord(rawEntry)) {
+        errors.push(`overrides['${key}']: must be an object`);
+        return undefined;
+    }
+    let entryValid = true;
+    for (const fieldName of Object.keys(rawEntry)) {
+        if (!KNOWN_OVERRIDE_FIELDS.has(fieldName)) {
+            errors.push(`overrides['${key}']: unknown field '${fieldName}'`);
+            entryValid = false;
+        }
+    }
+    const result = {};
+    if (rawEntry.audience !== undefined) {
+        const audienceResult = validateAudience(key, rawEntry.audience, errors);
+        if (audienceResult === undefined) {
+            entryValid = false;
+        }
+        else {
+            result.audience = audienceResult;
+        }
+    }
+    if (rawEntry.description !== undefined) {
+        if (typeof rawEntry.description !== 'string') {
+            errors.push(`overrides['${key}']: 'description' must be a string`);
+            entryValid = false;
+        }
+        else {
+            result.description = rawEntry.description;
+        }
+    }
+    if (rawEntry.body !== undefined) {
+        if (typeof rawEntry.body !== 'string') {
+            errors.push(`overrides['${key}']: 'body' must be a string`);
+            entryValid = false;
+        }
+        else {
+            result.body = rawEntry.body;
+        }
+    }
+    if (rawEntry.breaking !== undefined) {
+        if (typeof rawEntry.breaking !== 'boolean') {
+            errors.push(`overrides['${key}']: 'breaking' must be a boolean`);
+            entryValid = false;
+        }
+        else {
+            result.breaking = rawEntry.breaking;
+        }
+    }
+    if (Object.keys(result).length === 0 && entryValid) {
+        errors.push(`overrides['${key}']: at least one override field must be set`);
+        return undefined;
+    }
+    if (!entryValid) {
+        return undefined;
+    }
+    return result;
 }
 function validateAudience(key, value, errors) {
-  if (typeof value !== "string" || !VALID_AUDIENCE_VALUES.has(value)) {
-    errors.push(`overrides['${key}']: 'audience' must be one of 'all' | 'dev' | 'skip'`);
-    return void 0;
-  }
-  if (!V1_SUPPORTED_AUDIENCE_VALUES.has(value)) {
-    errors.push(`overrides['${key}']: audience '${value}' is not yet supported; only 'skip' is currently accepted`);
-    return void 0;
-  }
-  return "skip";
+    if (typeof value !== 'string' || !VALID_AUDIENCE_VALUES.has(value)) {
+        errors.push(`overrides['${key}']: 'audience' must be one of 'all' | 'dev' | 'skip'`);
+        return undefined;
+    }
+    if (!V1_SUPPORTED_AUDIENCE_VALUES.has(value)) {
+        errors.push(`overrides['${key}']: audience '${value}' is not yet supported; only 'skip' is currently accepted`);
+        return undefined;
+    }
+    return 'skip';
 }
-function formatStaleOverrideKeyWarning(key) {
-  return `Override key '${key}' did not match any commit hash in the changelog (likely a stale reference)`;
+export function formatStaleOverrideKeyWarning(key) {
+    return `Override key '${key}' did not match any commit hash in the changelog (likely a stale reference)`;
 }
-function applyChangelogOverrides(entries, overrides) {
-  const warnings = [];
-  const errors = [];
-  const matchedKeys = [];
-  if (overrides.size === 0) {
-    return { entries: entries.map(cloneEntry), warnings, errors, matchedKeys };
-  }
-  const allHashes = [];
-  for (const entry of entries) {
-    for (const section of entry.sections) {
-      for (const item of section.items) {
-        if (item.hash !== void 0) {
-          allHashes.push(item.hash);
+export function applyChangelogOverrides(entries, overrides) {
+    const warnings = [];
+    const errors = [];
+    const matchedKeys = [];
+    if (overrides.size === 0) {
+        return { entries: entries.map(cloneEntry), warnings, errors, matchedKeys };
+    }
+    const allHashes = [];
+    for (const entry of entries) {
+        for (const section of entry.sections) {
+            for (const item of section.items) {
+                if (item.hash !== undefined) {
+                    allHashes.push(item.hash);
+                }
+            }
+        }
+    }
+    const keyToMatchedHashes = new Map();
+    for (const overrideKey of overrides.keys()) {
+        const matches = allHashes.filter((hash) => hash.startsWith(overrideKey));
+        if (matches.length === 0) {
+            continue;
+        }
+        if (matches.length > 1) {
+            errors.push(`Override key '${overrideKey}' is ambiguous: matches multiple commits (${matches.join(', ')}). ` +
+                'Use a longer prefix or the full commit hash.');
+            continue;
+        }
+        keyToMatchedHashes.set(overrideKey, matches);
+        matchedKeys.push(overrideKey);
+    }
+    const hashToOverride = new Map();
+    for (const [overrideKey, matchedHashes] of keyToMatchedHashes) {
+        const override = overrides.get(overrideKey);
+        if (override === undefined)
+            continue;
+        for (const hash of matchedHashes) {
+            hashToOverride.set(hash, override);
         }
-      }
-    }
-  }
-  const keyToMatchedHashes = /* @__PURE__ */ new Map();
-  for (const overrideKey of overrides.keys()) {
-    const matches = allHashes.filter((hash) => hash.startsWith(overrideKey));
-    if (matches.length === 0) {
-      continue;
-    }
-    if (matches.length > 1) {
-      errors.push(
-        `Override key '${overrideKey}' is ambiguous: matches multiple commits (${matches.join(", ")}). Use a longer prefix or the full commit hash.`
-      );
-      continue;
-    }
-    keyToMatchedHashes.set(overrideKey, matches);
-    matchedKeys.push(overrideKey);
-  }
-  const hashToOverride = /* @__PURE__ */ new Map();
-  for (const [overrideKey, matchedHashes] of keyToMatchedHashes) {
-    const override = overrides.get(overrideKey);
-    if (override === void 0) continue;
-    for (const hash of matchedHashes) {
-      hashToOverride.set(hash, override);
-    }
-  }
-  const transformedEntries = [];
-  for (const entry of entries) {
-    const transformedSections = [];
-    for (const section of entry.sections) {
-      const transformedItems = applyOverridesToItems(section.items, hashToOverride);
-      if (transformedItems.length === 0) {
-        continue;
-      }
-      transformedSections.push({ ...section, items: transformedItems });
-    }
-    transformedEntries.push({ ...entry, sections: transformedSections });
-  }
-  return { entries: transformedEntries, warnings, errors, matchedKeys };
+    }
+    const transformedEntries = [];
+    for (const entry of entries) {
+        const transformedSections = [];
+        for (const section of entry.sections) {
+            const transformedItems = applyOverridesToItems(section.items, hashToOverride);
+            if (transformedItems.length === 0) {
+                continue;
+            }
+            transformedSections.push({ ...section, items: transformedItems });
+        }
+        transformedEntries.push({ ...entry, sections: transformedSections });
+    }
+    return { entries: transformedEntries, warnings, errors, matchedKeys };
 }
 function applyOverridesToItems(items, hashToOverride) {
-  const result = [];
-  for (const item of items) {
-    if (item.hash === void 0) {
-      result.push(cloneItem(item));
-      continue;
-    }
-    const override = hashToOverride.get(item.hash);
-    if (override === void 0) {
-      result.push(cloneItem(item));
-      continue;
-    }
-    if (override.audience === "skip") {
-      continue;
-    }
-    result.push(applyOverrideToItem(item, override));
-  }
-  return result;
+    const result = [];
+    for (const item of items) {
+        if (item.hash === undefined) {
+            result.push(cloneItem(item));
+            continue;
+        }
+        const override = hashToOverride.get(item.hash);
+        if (override === undefined) {
+            result.push(cloneItem(item));
+            continue;
+        }
+        if (override.audience === 'skip') {
+            continue;
+        }
+        result.push(applyOverrideToItem(item, override));
+    }
+    return result;
 }
 function applyOverrideToItem(item, override) {
-  const result = { ...item };
-  if (override.description !== void 0) {
-    result.description = override.description;
-  }
-  if (override.body !== void 0) {
-    result.body = override.body;
-  }
-  if (override.breaking !== void 0) {
-    result.breaking = override.breaking;
-  }
-  return result;
+    const result = { ...item };
+    if (override.description !== undefined) {
+        result.description = override.description;
+    }
+    if (override.body !== undefined) {
+        result.body = override.body;
+    }
+    if (override.breaking !== undefined) {
+        result.breaking = override.breaking;
+    }
+    return result;
 }
 function cloneItem(item) {
-  return { ...item };
+    return { ...item };
 }
 function cloneEntry(entry) {
-  return {
-    ...entry,
-    sections: entry.sections.map((section) => ({ ...section, items: section.items.map(cloneItem) }))
-  };
-}
-function resolveOverridePath(scopeRoot) {
-  return path.posix.join(scopeRoot, OVERRIDES_FILENAME);
+    return {
+        ...entry,
+        sections: entry.sections.map((section) => ({ ...section, items: section.items.map(cloneItem) })),
+    };
 }
-function loadOverridesForScopes(scopes) {
-  const errors = [];
-  let project = /* @__PURE__ */ new Map();
-  const perWorkspace = /* @__PURE__ */ new Map();
-  if (scopes.project !== void 0) {
-    const result = loadChangelogOverrides(resolveOverridePath(scopes.project));
-    if ("errors" in result) {
-      errors.push(...result.errors);
-    } else {
-      project = result.overrides;
-    }
-  }
-  for (const workspacePath of scopes.workspaces ?? []) {
-    const result = loadChangelogOverrides(resolveOverridePath(workspacePath));
-    if ("errors" in result) {
-      errors.push(...result.errors);
-    } else if (result.overrides.size > 0) {
-      perWorkspace.set(workspacePath, result.overrides);
-    }
-  }
-  return { project, perWorkspace, errors };
+export function resolveOverridePath(scopeRoot) {
+    return path.posix.join(scopeRoot, OVERRIDES_FILENAME);
 }
-function composeOverrides(rootEntries, workspaceEntries) {
-  const composed = new Map(rootEntries);
-  if (workspaceEntries !== void 0) {
-    for (const [key, value] of workspaceEntries) {
-      composed.set(key, value);
-    }
-  }
-  return composed;
+export function loadOverridesForScopes(scopes) {
+    const errors = [];
+    let project = new Map();
+    const perWorkspace = new Map();
+    if (scopes.project !== undefined) {
+        const result = loadChangelogOverrides(resolveOverridePath(scopes.project));
+        if ('errors' in result) {
+            errors.push(...result.errors);
+        }
+        else {
+            project = result.overrides;
+        }
+    }
+    for (const workspacePath of scopes.workspaces ?? []) {
+        const result = loadChangelogOverrides(resolveOverridePath(workspacePath));
+        if ('errors' in result) {
+            errors.push(...result.errors);
+        }
+        else if (result.overrides.size > 0) {
+            perWorkspace.set(workspacePath, result.overrides);
+        }
+    }
+    return { project, perWorkspace, errors };
 }
-function createOverrideContext(workspaces) {
-  const result = loadOverridesForScopes({
-    project: ".",
-    workspaces: workspaces.map((workspace) => workspace.workspacePath)
-  });
-  if (result.errors.length > 0) {
-    throw new Error(`Failed to load changelog overrides:
-  - ${result.errors.join("\n  - ")}`);
-  }
-  return {
-    project: result.project,
-    perWorkspace: result.perWorkspace,
-    overrideWarnings: [],
-    globalMatchedRootKeys: /* @__PURE__ */ new Set()
-  };
+export function composeOverrides(rootEntries, workspaceEntries) {
+    const composed = new Map(rootEntries);
+    if (workspaceEntries !== undefined) {
+        for (const [key, value] of workspaceEntries) {
+            composed.set(key, value);
+        }
+    }
+    return composed;
 }
-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,
-    hashes: scope.hashes,
-    map: loadScopeMap(scope.filePath, errors)
-  }));
-  const globalMatchedRootKeys = /* @__PURE__ */ new Set();
-  for (const workspace of workspaceMaps) {
-    processWorkspaceScope({
-      workspace,
-      projectFilePath,
-      projectMap,
-      errors,
-      warnings,
-      globalMatchedRootKeys
+export function createOverrideContext(workspaces) {
+    const result = loadOverridesForScopes({
+        project: '.',
+        workspaces: workspaces.map((workspace) => workspace.workspacePath),
     });
-  }
-  const projectHashes = inputs.project?.hashes;
-  if (projectFilePath !== void 0 && projectHashes !== void 0) {
-    processProjectScope({ projectFilePath, projectMap, projectHashes, errors, globalMatchedRootKeys });
-  }
-  if (projectFilePath !== void 0) {
-    collectRootStaleWarnings(projectFilePath, projectMap, globalMatchedRootKeys, warnings);
-  }
-  return { errors, warnings };
+    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,
+        overrideWarnings: [],
+        globalMatchedRootKeys: new Set(),
+    };
+}
+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,
+        hashes: scope.hashes,
+        map: loadScopeMap(scope.filePath, errors),
+    }));
+    const globalMatchedRootKeys = new Set();
+    for (const workspace of workspaceMaps) {
+        processWorkspaceScope({
+            workspace,
+            projectFilePath,
+            projectMap,
+            errors,
+            warnings,
+            globalMatchedRootKeys,
+        });
+    }
+    const projectHashes = inputs.project?.hashes;
+    if (projectFilePath !== undefined && projectHashes !== undefined) {
+        processProjectScope({ projectFilePath, projectMap, projectHashes, errors, globalMatchedRootKeys });
+    }
+    if (projectFilePath !== undefined) {
+        collectRootStaleWarnings(projectFilePath, projectMap, globalMatchedRootKeys, warnings);
+    }
+    return { errors, warnings };
 }
 function processWorkspaceScope(args) {
-  const { workspace, projectFilePath, projectMap, errors, warnings, globalMatchedRootKeys } = args;
-  const { filePath, hashes, map } = workspace;
-  const workspaceApplied = applyChangelogOverrides(makeValidationEntries(hashes), map);
-  for (const message of workspaceApplied.errors) {
-    errors.push(prefixWithFilePath(filePath, message));
-  }
-  if (projectFilePath !== void 0 && projectMap.size > 0) {
-    const projectMinusShadowed = filterShadowedKeys(projectMap, map);
-    const projectApplied = applyChangelogOverrides(makeValidationEntries(hashes), projectMinusShadowed);
-    for (const message of projectApplied.errors) {
-      errors.push(prefixWithFilePath(projectFilePath, message));
-    }
-  }
-  for (const key of map.keys()) {
-    if (!hasAnyMatch(key, hashes)) {
-      warnings.push(formatWorkspaceStaleWarning(filePath, key));
-    }
-  }
-  for (const key of projectMap.keys()) {
-    if (map.has(key)) continue;
-    if (hasAnyMatch(key, hashes)) {
-      globalMatchedRootKeys.add(key);
-    }
-  }
+    const { workspace, projectFilePath, projectMap, errors, warnings, globalMatchedRootKeys } = args;
+    const { filePath, hashes, map } = workspace;
+    const workspaceApplied = applyChangelogOverrides(makeValidationEntries(hashes), 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(makeValidationEntries(hashes), projectMinusShadowed);
+        for (const message of projectApplied.errors) {
+            errors.push(prefixWithFilePath(projectFilePath, message));
+        }
+    }
+    for (const key of map.keys()) {
+        if (!hasAnyMatch(key, hashes)) {
+            warnings.push(formatWorkspaceStaleWarning(filePath, key));
+        }
+    }
+    for (const key of projectMap.keys()) {
+        if (map.has(key))
+            continue;
+        if (hasAnyMatch(key, hashes)) {
+            globalMatchedRootKeys.add(key);
+        }
+    }
 }
 function processProjectScope(args) {
-  const { projectFilePath, projectMap, projectHashes, errors, globalMatchedRootKeys } = args;
-  const applied = applyChangelogOverrides(makeValidationEntries(projectHashes), projectMap);
-  for (const message of applied.errors) {
-    errors.push(prefixWithFilePath(projectFilePath, message));
-  }
-  for (const key of projectMap.keys()) {
-    if (hasAnyMatch(key, projectHashes)) {
-      globalMatchedRootKeys.add(key);
-    }
-  }
+    const { projectFilePath, projectMap, projectHashes, errors, globalMatchedRootKeys } = args;
+    const applied = applyChangelogOverrides(makeValidationEntries(projectHashes), projectMap);
+    for (const message of applied.errors) {
+        errors.push(prefixWithFilePath(projectFilePath, message));
+    }
+    for (const key of projectMap.keys()) {
+        if (hasAnyMatch(key, projectHashes)) {
+            globalMatchedRootKeys.add(key);
+        }
+    }
 }
 function collectRootStaleWarnings(projectFilePath, projectMap, globalMatchedRootKeys, warnings) {
-  for (const key of projectMap.keys()) {
-    if (!globalMatchedRootKeys.has(key)) {
-      warnings.push(formatRootStaleWarning(projectFilePath, key));
+    for (const key of projectMap.keys()) {
+        if (!globalMatchedRootKeys.has(key)) {
+            warnings.push(formatRootStaleWarning(projectFilePath, key));
+        }
     }
-  }
 }
 function hasAnyMatch(key, hashes) {
-  return hashes.some((hash) => hash.startsWith(key));
+    return hashes.some((hash) => hash.startsWith(key));
 }
 function filterShadowedKeys(projectMap, workspaceMap) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [key, value] of projectMap) {
-    if (workspaceMap.has(key)) continue;
-    result.set(key, value);
-  }
-  return result;
+    const result = new Map();
+    for (const [key, value] of projectMap) {
+        if (workspaceMap.has(key))
+            continue;
+        result.set(key, value);
+    }
+    return result;
 }
 function loadScopeMap(filePath, errors) {
-  if (filePath === void 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  const result = loadChangelogOverrides(filePath);
-  if ("errors" in result) {
-    for (const message of result.errors) {
-      errors.push(prefixWithFilePath(filePath, message));
-    }
-    return /* @__PURE__ */ new Map();
-  }
-  return result.overrides;
+    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(hashes) {
-  return [
-    {
-      version: "0.0.0",
-      date: "0000-00-00",
-      sections: [
+    return [
         {
-          title: "Validation",
-          audience: "all",
-          items: hashes.map((hash) => ({ description: "", hash }))
-        }
-      ]
-    }
-  ];
+            version: '0.0.0',
+            date: '0000-00-00',
+            sections: [
+                {
+                    title: 'Validation',
+                    audience: 'all',
+                    items: hashes.map((hash) => ({ description: '', hash })),
+                },
+            ],
+        },
+    ];
 }
 function prefixWithFilePath(filePath, message) {
-  return `${filePath}: ${message}`;
+    return `${filePath}: ${message}`;
 }
 function formatWorkspaceStaleWarning(filePath, key) {
-  return `${filePath}: Override key '${key}' did not match any commit in this workspace's history (likely a stale reference)`;
+    return `${filePath}: Override key '${key}' did not match any commit in this workspace's history (likely a stale reference)`;
 }
 function formatRootStaleWarning(filePath, key) {
-  return `${filePath}: Override key '${key}' did not match any commit in any scope (likely a stale reference)`;
+    return `${filePath}: Override key '${key}' did not match any commit in any scope (likely a stale reference)`;
 }
-function applyWorkspaceOverrides(newEntries, workspacePath, overrideContext) {
-  const { project, perWorkspace, overrideWarnings, globalMatchedRootKeys } = overrideContext;
-  const workspaceOverrides = 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:
-  - ${applied.errors.join("\n  - ")}`);
-  }
-  overrideWarnings.push(...applied.warnings);
-  const matchedSet = new Set(applied.matchedKeys);
-  if (workspaceOverrides !== void 0) {
-    for (const key of workspaceOverrides.keys()) {
-      if (!matchedSet.has(key)) {
-        overrideWarnings.push(formatStaleOverrideKeyWarning(key));
-      }
-    }
-  }
-  for (const key of applied.matchedKeys) {
-    if (workspaceOverrides?.has(key)) continue;
-    globalMatchedRootKeys.add(key);
-  }
-  return applied;
+export function applyWorkspaceOverrides(newEntries, workspacePath, overrideContext) {
+    const { project, perWorkspace, overrideWarnings, globalMatchedRootKeys } = overrideContext;
+    const workspaceOverrides = 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  - ')}`);
+    }
+    overrideWarnings.push(...applied.warnings);
+    const matchedSet = new Set(applied.matchedKeys);
+    if (workspaceOverrides !== undefined) {
+        for (const key of workspaceOverrides.keys()) {
+            if (!matchedSet.has(key)) {
+                overrideWarnings.push(formatStaleOverrideKeyWarning(key));
+            }
+        }
+    }
+    for (const key of applied.matchedKeys) {
+        if (workspaceOverrides?.has(key))
+            continue;
+        globalMatchedRootKeys.add(key);
+    }
+    return applied;
 }
-export {
-  applyChangelogOverrides,
-  applyWorkspaceOverrides,
-  composeOverrides,
-  createOverrideContext,
-  formatStaleOverrideKeyWarning,
-  loadChangelogOverrides,
-  loadOverridesForScopes,
-  resolveOverridePath,
-  validateAllChangelogOverrides,
-  validateChangelogOverrides
-};