@williamthorsen/release-kit 5.2.1 → 5.3.1

package/dist/esm/validateConfig.js

@@ -1,37 +1,23 @@
 import { isRecord } from "./typeGuards.js";
+import { releaseKitConfigSchema } from "./types.js";
 function validateConfig(raw) {
-  const errors = [];
   if (!isRecord(raw)) {
     return { config: {}, errors: ["Config must be an object"], warnings: [] };
   }
-  const config = {};
-  const knownFields = /* @__PURE__ */ new Set([
-    "changelogJson",
-    "cliffConfigPath",
-    "formatCommand",
-    "project",
-    "releaseNotes",
-    "retiredPackages",
-    "scopeAliases",
-    "versionPatterns",
-    "workspaces",
-    "workTypes"
-  ]);
-  for (const key of Object.keys(raw)) {
-    if (!knownFields.has(key)) {
-      errors.push(`Unknown field: '${key}'`);
-    }
-  }
-  validateChangelogJson(raw.changelogJson, config, errors);
-  validateWorkspaces(raw.workspaces, config, errors);
-  validateReleaseNotes(raw.releaseNotes, config, errors);
-  validateVersionPatterns(raw.versionPatterns, config, errors);
-  validateWorkTypes(raw.workTypes, config, errors);
-  validateStringField("formatCommand", raw.formatCommand, config, errors);
-  validateStringField("cliffConfigPath", raw.cliffConfigPath, config, errors);
-  validateScopeAliases(raw.scopeAliases, config, errors);
-  validateRetiredPackages(raw.retiredPackages, config, errors);
-  validateProjectConfig(raw.project, config, errors);
+  const { cleaned, deprecationErrors } = preprocessDeprecatedKeys(raw);
+  const parseResult = releaseKitConfigSchema.safeParse(cleaned);
+  if (!parseResult.success) {
+    return {
+      config: {},
+      errors: [...deprecationErrors, ...parseResult.error.issues.map(formatZodIssue)],
+      warnings: []
+    };
+  }
+  const config = parseResult.data;
+  const errors = [...deprecationErrors];
+  detectLegacyIdentityDuplicates(config, errors);
+  detectRetiredPackageDuplicates(config, errors);
+  detectRetiredVsLegacyCollisions(config, errors);
   const warnings = [];
   const changelogJsonEnabled = config.changelogJson?.enabled ?? true;
   if (!changelogJsonEnabled && config.releaseNotes?.shouldInjectIntoReadme) {
@@ -41,257 +27,93 @@ function validateConfig(raw) {
   }
   return { config, errors, warnings };
 }
-function validateChangelogJson(value, config, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push("'changelogJson' must be an object");
-    return;
-  }
-  const knownChangelogJsonFields = /* @__PURE__ */ new Set(["enabled", "outputPath", "devOnlySections"]);
-  for (const key of Object.keys(value)) {
-    if (!knownChangelogJsonFields.has(key)) {
-      errors.push(`changelogJson: unknown field '${key}'`);
-    }
-  }
-  const result = {};
-  if (value.enabled !== void 0) {
-    if (typeof value.enabled === "boolean") {
-      result.enabled = value.enabled;
-    } else {
-      errors.push("changelogJson.enabled: must be a boolean");
-    }
-  }
-  if (value.outputPath !== void 0) {
-    if (typeof value.outputPath === "string") {
-      result.outputPath = value.outputPath;
-    } else {
-      errors.push("changelogJson.outputPath: must be a string");
-    }
-  }
-  if (value.devOnlySections !== void 0) {
-    if (isStringArray(value.devOnlySections)) {
-      result.devOnlySections = value.devOnlySections;
-    } else {
-      errors.push("changelogJson.devOnlySections: must be a string array");
-    }
-  }
-  config.changelogJson = result;
-}
-function validateProjectConfig(value, config, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push("'project' must be an object");
-    return;
-  }
-  const knownProjectFields = /* @__PURE__ */ new Set(["tagPrefix"]);
-  for (const key of Object.keys(value)) {
-    if (!knownProjectFields.has(key)) {
-      errors.push(`project: unknown field '${key}'`);
-    }
-  }
-  const result = {};
-  if (value.tagPrefix !== void 0) {
-    if (typeof value.tagPrefix !== "string") {
-      errors.push("project.tagPrefix: must be a string");
-    } else if (value.tagPrefix === "") {
-      errors.push("project.tagPrefix: must be a non-empty string");
-    } else {
-      result.tagPrefix = value.tagPrefix;
-    }
-  }
-  config.project = result;
-}
-function validateReleaseNotes(value, config, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push("'releaseNotes' must be an object");
-    return;
-  }
-  const knownReleaseNotesFields = /* @__PURE__ */ new Set(["shouldInjectIntoReadme"]);
-  for (const key of Object.keys(value)) {
-    if (!knownReleaseNotesFields.has(key)) {
-      if (key === "shouldCreateGithubRelease") {
+function preprocessDeprecatedKeys(raw) {
+  if (!isRecord(raw)) return { cleaned: raw, deprecationErrors: [] };
+  const errors = [];
+  const cleaned = { ...raw };
+  if (isRecord(cleaned.releaseNotes) && "shouldCreateGithubRelease" in cleaned.releaseNotes) {
+    errors.push(
+      "releaseNotes.shouldCreateGithubRelease is no longer supported. Adoption is now signaled by installing the create-github-release workflow. Remove this field from your config; see README for the updated workflow."
+    );
+    const releaseNotesCopy = { ...cleaned.releaseNotes };
+    delete releaseNotesCopy.shouldCreateGithubRelease;
+    cleaned.releaseNotes = releaseNotesCopy;
+  }
+  if (Array.isArray(cleaned.workspaces)) {
+    cleaned.workspaces = cleaned.workspaces.map((ws, i) => {
+      if (!isRecord(ws)) return ws;
+      const wsCopy = { ...ws };
+      if ("tagPrefix" in wsCopy) {
+        const dir = typeof wsCopy.dir === "string" && wsCopy.dir !== "" ? wsCopy.dir : "<dir>";
+        errors.push(`workspaces[${i}]: 'tagPrefix' is no longer supported; remove it to use the default '${dir}-v'`);
+        delete wsCopy.tagPrefix;
+      }
+      if ("legacyTagPrefixes" in wsCopy) {
         errors.push(
-          "releaseNotes.shouldCreateGithubRelease is no longer supported. Adoption is now signaled by installing the create-github-release workflow. Remove this field from your config; see README for the updated workflow."
+          `workspaces[${i}]: 'legacyTagPrefixes' is no longer supported; use 'legacyIdentities: [{ name, tagPrefix }, ...]' instead`
         );
-      } else {
-        errors.push(`releaseNotes: unknown field '${key}'`);
+        delete wsCopy.legacyTagPrefixes;
       }
-    }
+      return wsCopy;
+    });
   }
-  const result = {};
-  if (value.shouldInjectIntoReadme !== void 0) {
-    if (typeof value.shouldInjectIntoReadme === "boolean") {
-      result.shouldInjectIntoReadme = value.shouldInjectIntoReadme;
-    } else {
-      errors.push("releaseNotes.shouldInjectIntoReadme: must be a boolean");
-    }
-  }
-  config.releaseNotes = result;
+  return { cleaned, deprecationErrors: errors };
 }
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((item) => typeof item === "string");
+function formatZodIssue(issue) {
+  const path = renderPath(issue.path);
+  const message = customizeMessage(issue);
+  return path === "" ? message : `${path}: ${message}`;
 }
-function validateWorkspaces(value, config, errors) {
-  if (value === void 0) return;
-  if (!Array.isArray(value)) {
-    errors.push("'workspaces' must be an array");
-    return;
+function customizeMessage(issue) {
+  if (issue.code === "too_small" && issue.origin === "string") {
+    return "must be a non-empty string";
   }
-  const workspaces = [];
-  const knownWorkspaceFields = /* @__PURE__ */ new Set(["dir", "shouldExclude", "legacyIdentities"]);
-  for (const [i, entry] of value.entries()) {
-    if (!isRecord(entry)) {
-      errors.push(`workspaces[${i}]: must be an object`);
-      continue;
-    }
-    if (typeof entry.dir !== "string" || entry.dir === "") {
-      errors.push(`workspaces[${i}]: 'dir' is required`);
-      continue;
-    }
-    for (const key of Object.keys(entry)) {
-      if (!knownWorkspaceFields.has(key)) {
-        if (key === "tagPrefix") {
-          errors.push(
-            `workspaces[${i}]: 'tagPrefix' is no longer supported; remove it to use the default '${entry.dir}-v'`
-          );
-        } else if (key === "legacyTagPrefixes") {
-          errors.push(
-            `workspaces[${i}]: 'legacyTagPrefixes' is no longer supported; use 'legacyIdentities: [{ name, tagPrefix }, ...]' instead`
-          );
-        } else {
-          errors.push(`workspaces[${i}]: unknown field '${key}'`);
-        }
-      }
-    }
-    const workspace = { dir: entry.dir };
-    if (entry.shouldExclude !== void 0) {
-      if (typeof entry.shouldExclude === "boolean") {
-        workspace.shouldExclude = entry.shouldExclude;
-      } else {
-        errors.push(`workspaces[${i}]: 'shouldExclude' must be a boolean`);
-      }
-    }
-    if (entry.legacyIdentities !== void 0) {
-      const identities = validateLegacyIdentities(entry.legacyIdentities, i, errors);
-      if (identities !== void 0) {
-        workspace.legacyIdentities = identities;
-      }
+  return issue.message;
+}
+function renderPath(path) {
+  let rendered = "";
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      rendered += `[${segment}]`;
+    } else if (rendered === "") {
+      rendered += String(segment);
+    } else {
+      rendered += `.${String(segment)}`;
     }
-    workspaces.push(workspace);
   }
-  config.workspaces = workspaces;
+  return rendered;
 }
-function validateLegacyIdentities(value, workspaceIndex, errors) {
-  if (!Array.isArray(value)) {
-    errors.push(`workspaces[${workspaceIndex}]: 'legacyIdentities' must be an array`);
-    return void 0;
-  }
-  const knownIdentityFields = /* @__PURE__ */ new Set(["name", "tagPrefix"]);
-  const identities = [];
-  const seenTuples = /* @__PURE__ */ new Set();
-  for (const [entryIndex, entry] of value.entries()) {
-    if (!isRecord(entry)) {
-      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: must be an object`);
-      continue;
-    }
-    let entryValid = true;
-    for (const key2 of Object.keys(entry)) {
-      if (!knownIdentityFields.has(key2)) {
-        errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: unknown field '${key2}'`);
-        entryValid = false;
+function detectLegacyIdentityDuplicates(config, errors) {
+  if (config.workspaces === void 0) return;
+  for (const [wsIndex, workspace] of config.workspaces.entries()) {
+    if (workspace.legacyIdentities === void 0) continue;
+    const seen = /* @__PURE__ */ new Set();
+    for (const [entryIndex, identity] of workspace.legacyIdentities.entries()) {
+      const key = `${identity.name}\0${identity.tagPrefix}`;
+      if (seen.has(key)) {
+        errors.push(
+          `workspaces[${wsIndex}].legacyIdentities[${entryIndex}]: duplicate identity (name='${identity.name}', tagPrefix='${identity.tagPrefix}')`
+        );
       }
+      seen.add(key);
     }
-    const { name, tagPrefix } = entry;
-    if (typeof name !== "string") {
-      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].name: must be a string`);
-      entryValid = false;
-    } else if (name === "") {
-      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].name: must be a non-empty string`);
-      entryValid = false;
-    }
-    if (typeof tagPrefix !== "string") {
-      errors.push(`workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].tagPrefix: must be a string`);
-      entryValid = false;
-    } else if (tagPrefix === "") {
-      errors.push(
-        `workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}].tagPrefix: must be a non-empty string`
-      );
-      entryValid = false;
-    }
-    if (!entryValid || typeof name !== "string" || typeof tagPrefix !== "string") {
-      continue;
-    }
-    const key = `${name}\0${tagPrefix}`;
-    if (seenTuples.has(key)) {
-      errors.push(
-        `workspaces[${workspaceIndex}].legacyIdentities[${entryIndex}]: duplicate identity (name='${name}', tagPrefix='${tagPrefix}')`
-      );
-      continue;
-    }
-    seenTuples.add(key);
-    identities.push({ name, tagPrefix });
   }
-  return identities;
 }
-function validateRetiredPackages(value, config, errors) {
-  if (value === void 0) return;
-  if (!Array.isArray(value)) {
-    errors.push("'retiredPackages' must be an array");
-    return;
-  }
-  const validEntries = [];
-  const seenTuples = /* @__PURE__ */ new Set();
-  for (const [i, entry] of value.entries()) {
-    const retired = validateRetiredPackageEntry(entry, i, errors);
-    if (retired === void 0) continue;
+function detectRetiredPackageDuplicates(config, errors) {
+  if (config.retiredPackages === void 0) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, retired] of config.retiredPackages.entries()) {
     const key = `${retired.name}\0${retired.tagPrefix}`;
-    if (seenTuples.has(key)) {
+    if (seen.has(key)) {
       errors.push(
-        `retiredPackages[${i}]: duplicate package (name='${retired.name}', tagPrefix='${retired.tagPrefix}')`
+        `retiredPackages[${index}]: duplicate package (name='${retired.name}', tagPrefix='${retired.tagPrefix}')`
       );
-      continue;
     }
-    seenTuples.add(key);
-    validEntries.push({ entry: retired, rawIndex: i });
+    seen.add(key);
   }
-  detectRetiredVsLegacyCollisions(validEntries, config, errors);
-  config.retiredPackages = validEntries.map(({ entry }) => entry);
 }
-function validateRetiredPackageEntry(entry, i, errors) {
-  if (!isRecord(entry)) {
-    errors.push(`retiredPackages[${i}]: must be an object`);
-    return void 0;
-  }
-  const knownRetiredFields = /* @__PURE__ */ new Set(["name", "tagPrefix", "successor"]);
-  let entryValid = true;
-  for (const key of Object.keys(entry)) {
-    if (!knownRetiredFields.has(key)) {
-      errors.push(`retiredPackages[${i}]: unknown field '${key}'`);
-      entryValid = false;
-    }
-  }
-  const { name, tagPrefix, successor } = entry;
-  if (!validateNonEmptyString(name, `retiredPackages[${i}].name`, errors)) {
-    entryValid = false;
-  }
-  if (!validateNonEmptyString(tagPrefix, `retiredPackages[${i}].tagPrefix`, errors)) {
-    entryValid = false;
-  }
-  if (successor !== void 0 && !validateNonEmptyString(successor, `retiredPackages[${i}].successor`, errors)) {
-    entryValid = false;
-  }
-  if (!entryValid || typeof name !== "string" || typeof tagPrefix !== "string") {
-    return void 0;
-  }
-  const retired = { name, tagPrefix };
-  if (typeof successor === "string" && successor !== "") {
-    retired.successor = successor;
-  }
-  return retired;
-}
-function detectRetiredVsLegacyCollisions(retiredPackages, config, errors) {
-  if (config.workspaces === void 0) return;
+function detectRetiredVsLegacyCollisions(config, errors) {
+  if (config.retiredPackages === void 0 || config.workspaces === void 0) return;
   const legacyPrefixToWorkspace = /* @__PURE__ */ new Map();
   for (const workspace of config.workspaces) {
     if (workspace.legacyIdentities === void 0) continue;
@@ -301,98 +123,15 @@ function detectRetiredVsLegacyCollisions(retiredPackages, config, errors) {
       }
     }
   }
-  for (const { entry: retired, rawIndex } of retiredPackages) {
+  for (const [index, retired] of config.retiredPackages.entries()) {
     const collidingDir = legacyPrefixToWorkspace.get(retired.tagPrefix);
     if (collidingDir !== void 0) {
       errors.push(
-        `retiredPackages[${rawIndex}]: tagPrefix '${retired.tagPrefix}' collides with a declared legacyIdentities[].tagPrefix on workspace '${collidingDir}'`
+        `retiredPackages[${index}]: tagPrefix '${retired.tagPrefix}' collides with a declared legacyIdentities[].tagPrefix on workspace '${collidingDir}'`
       );
     }
   }
 }
-function validateNonEmptyString(value, fieldPath, errors) {
-  if (typeof value !== "string") {
-    errors.push(`${fieldPath}: must be a string`);
-    return false;
-  }
-  if (value === "") {
-    errors.push(`${fieldPath}: must be a non-empty string`);
-    return false;
-  }
-  return true;
-}
-function validateVersionPatterns(value, config, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push("'versionPatterns' must be an object");
-    return;
-  }
-  if (!isStringArray(value.major)) {
-    errors.push("versionPatterns.major: expected string array");
-  }
-  if (!isStringArray(value.minor)) {
-    errors.push("versionPatterns.minor: expected string array");
-  }
-  if (isStringArray(value.major) && isStringArray(value.minor)) {
-    config.versionPatterns = { major: value.major, minor: value.minor };
-  }
-}
-function validateWorkTypes(value, config, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value) || Array.isArray(value)) {
-    errors.push("'workTypes' must be a record (object)");
-    return;
-  }
-  const workTypes = {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (!isRecord(entry)) {
-      errors.push(`workTypes.${key}: must be an object`);
-      continue;
-    }
-    if (typeof entry.header !== "string") {
-      errors.push(`workTypes.${key}: 'header' is required and must be a string`);
-      continue;
-    }
-    const wtEntry = { header: entry.header };
-    if (entry.aliases !== void 0) {
-      if (isStringArray(entry.aliases)) {
-        wtEntry.aliases = entry.aliases;
-      } else {
-        errors.push(`workTypes.${key}: 'aliases' must be a string array`);
-      }
-    }
-    workTypes[key] = wtEntry;
-  }
-  config.workTypes = workTypes;
-}
-function validateStringField(fieldName, value, config, errors) {
-  if (value === void 0) return;
-  if (typeof value !== "string") {
-    errors.push(`'${fieldName}' must be a string`);
-    return;
-  }
-  config[fieldName] = value;
-}
-function validateScopeAliases(value, config, errors) {
-  if (value === void 0) return;
-  if (!isRecord(value)) {
-    errors.push("'scopeAliases' must be a record (object)");
-    return;
-  }
-  const aliases = {};
-  let valid = true;
-  for (const [key, v] of Object.entries(value)) {
-    if (typeof v === "string") {
-      aliases[key] = v;
-    } else {
-      errors.push(`scopeAliases.${key}: value must be a string`);
-      valid = false;
-    }
-  }
-  if (valid) {
-    config.scopeAliases = aliases;
-  }
-}
 export {
   validateConfig
 };

package/dist/esm/validateOverridesCommand.d.ts

@@ -0,0 +1,14 @@
+import { type ValidateAllChangelogOverridesInputs, type ValidateAllChangelogOverridesResult } from './changelogOverrides.ts';
+import type { ChangelogEntry, ReleaseConfig } from './types.ts';
+export interface ValidateOverridesCommandResult {
+    exitCode: 0 | 1 | 2;
+    message: string;
+}
+export interface ValidateOverridesCommandDependencies {
+    discoverWorkspaces?: () => Promise<string[] | undefined>;
+    loadConfig?: () => Promise<unknown>;
+    buildEntries?: (config: Pick<ReleaseConfig, 'cliffConfigPath' | 'changelogJson'>, tagPattern?: string, includePaths?: string[]) => ChangelogEntry[];
+    validate?: (inputs: ValidateAllChangelogOverridesInputs) => ValidateAllChangelogOverridesResult;
+}
+export declare function validateOverridesCommand(dependencies?: ValidateOverridesCommandDependencies): Promise<ValidateOverridesCommandResult>;
+export declare function formatValidateOverridesResult(result: ValidateAllChangelogOverridesResult): ValidateOverridesCommandResult;

package/dist/esm/validateOverridesCommand.js

@@ -0,0 +1,136 @@
+import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import {
+  resolveOverridePath,
+  validateAllChangelogOverrides
+} from "./changelogOverrides.js";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { buildTagPattern, getAllTagPrefixes } from "./generateChangelogs.js";
+import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.js";
+import { validateConfig } from "./validateConfig.js";
+const SYNTHETIC_VALIDATE_TAG = "validate-only";
+async function validateOverridesCommand(dependencies = {}) {
+  const discover = dependencies.discoverWorkspaces ?? discoverWorkspaces;
+  const load = dependencies.loadConfig ?? loadConfig;
+  const buildEntries = dependencies.buildEntries ?? defaultBuildEntries;
+  const validate = dependencies.validate ?? validateAllChangelogOverrides;
+  let userConfig;
+  try {
+    userConfig = await loadAndValidateConfig(load);
+  } catch (error) {
+    return { exitCode: 2, message: errorMessage(error) };
+  }
+  let discoveredPaths;
+  try {
+    discoveredPaths = await discover();
+  } catch (error) {
+    return { exitCode: 2, message: `Error discovering workspaces: ${errorMessage(error)}` };
+  }
+  let inputs;
+  try {
+    inputs = discoveredPaths === void 0 ? buildSinglePackageInputs(userConfig, buildEntries) : buildMonorepoInputs(discoveredPaths, userConfig, buildEntries);
+  } catch (error) {
+    return { exitCode: 2, message: `Error resolving overrides scope: ${errorMessage(error)}` };
+  }
+  const result = validate(inputs);
+  return formatValidateOverridesResult(result);
+}
+function formatValidateOverridesResult(result) {
+  const { errors, warnings } = result;
+  if (errors.length === 0 && warnings.length === 0) {
+    return { exitCode: 0, message: "All override files are valid (no errors, no stale keys)." };
+  }
+  const exitCode = errors.length > 0 ? 2 : 1;
+  const summary = formatSummaryLine(errors.length, warnings.length);
+  const errorLines = errors.map((message2) => `  \u274C ${message2}`);
+  const warningLines = warnings.map((message2) => `  \u26A0\uFE0F  ${message2}`);
+  const message = [summary, "", ...errorLines, ...warningLines].join("\n");
+  return { exitCode, message };
+}
+function formatSummaryLine(errorCount, warningCount) {
+  const parts = [];
+  if (errorCount > 0) {
+    parts.push(pluralize(errorCount, "error"));
+  }
+  if (warningCount > 0) {
+    parts.push(pluralize(warningCount, "warning"));
+  }
+  return `Found ${parts.join(" and ")}:`;
+}
+function pluralize(count, noun) {
+  return count === 1 ? `${count} ${noun}` : `${count} ${noun}s`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function defaultBuildEntries(config, tagPattern, includePaths) {
+  const options = {};
+  if (tagPattern !== void 0) {
+    options.tagPattern = tagPattern;
+  }
+  if (includePaths !== void 0) {
+    options.includePaths = includePaths;
+  }
+  return buildChangelogEntries(config, SYNTHETIC_VALIDATE_TAG, options);
+}
+function flattenEntriesToHashes(entries) {
+  const hashes = [];
+  for (const entry of entries) {
+    for (const section of entry.sections) {
+      for (const item of section.items) {
+        if (item.hash !== void 0) {
+          hashes.push(item.hash);
+        }
+      }
+    }
+  }
+  return hashes;
+}
+async function loadAndValidateConfig(load) {
+  let rawConfig;
+  try {
+    rawConfig = await load();
+  } catch (error) {
+    throw new Error(`Error loading config: ${errorMessage(error)}`);
+  }
+  if (rawConfig === void 0) {
+    return void 0;
+  }
+  const { config, errors } = validateConfig(rawConfig);
+  if (errors.length > 0) {
+    throw new Error(`Invalid config:
+  - ${errors.join("\n  - ")}`);
+  }
+  return config;
+}
+function buildSinglePackageInputs(userConfig, buildEntries) {
+  const config = mergeSinglePackageConfig(userConfig);
+  const hashes = flattenEntriesToHashes(buildEntries(config));
+  return {
+    project: { filePath: resolveOverridePath("."), hashes }
+  };
+}
+function buildMonorepoInputs(discoveredPaths, userConfig, buildEntries) {
+  const rootPackage = readRootPackageVersion();
+  const config = mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage);
+  const workspaces = config.workspaces.map((workspace) => {
+    const tagPattern = buildTagPattern(getAllTagPrefixes(workspace));
+    return {
+      filePath: resolveOverridePath(workspace.workspacePath),
+      hashes: flattenEntriesToHashes(buildEntries(config, tagPattern, workspace.paths))
+    };
+  });
+  const project = config.project;
+  const projectScope = {
+    filePath: resolveOverridePath(".")
+  };
+  if (project !== void 0) {
+    const contributingPaths = config.workspaces.flatMap((workspace) => workspace.paths);
+    const projectTagPattern = buildTagPattern([project.tagPrefix]);
+    projectScope.hashes = flattenEntriesToHashes(buildEntries(config, projectTagPattern, contributingPaths));
+  }
+  return { project: projectScope, workspaces };
+}
+export {
+  formatValidateOverridesResult,
+  validateOverridesCommand
+};