@williamthorsen/release-kit 5.0.0 → 5.2.0

package/dist/esm/releasePrepareProject.js

@@ -0,0 +1,121 @@
+import { buildChangelogEntries } from "./buildChangelogEntries.js";
+import { bumpAllVersions } from "./bumpAllVersions.js";
+import { resolveChangelogJsonPath, writeChangelogJson } from "./changelogJsonFile.js";
+import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
+import { decideRelease } from "./decideRelease.js";
+import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
+import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
+import { writeReleaseNotesPreviews } from "./writeReleaseNotesPreviews.js";
+const ROOT_PACKAGE_FILE = "./package.json";
+const ROOT_CHANGELOG_PATH = ".";
+function releasePrepareProject(args) {
+  const { config, options, modifiedFiles, tags } = args;
+  const { dryRun, bumpOverride, withReleaseNotes, force } = options;
+  const project = config.project;
+  if (project === void 0) {
+    throw new Error("releasePrepareProject called without a configured project block");
+  }
+  const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
+  const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
+  const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
+  const contributingPaths = config.workspaces.flatMap((workspace) => workspace.paths);
+  const { tag, commits } = getCommitsSinceTarget([project.tagPrefix], contributingPaths);
+  const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+  const collector = createPolicyViolationCollector();
+  const decision = decideRelease({
+    commits,
+    force,
+    bumpOverride,
+    workTypes,
+    versionPatterns,
+    scopeAliases: config.scopeAliases,
+    breakingPolicies,
+    onPolicyViolation: collector.onPolicyViolation,
+    skipReasons: {
+      noCommits: `No commits ${since}. Pass --force to release at patch. Skipping.`,
+      noBumpWorthy: `No bump-worthy commits ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`
+    }
+  });
+  const policyViolations = collector.violations.length > 0 ? collector.violations : void 0;
+  if (decision.outcome === "skip") {
+    const skipped = {
+      status: "skipped",
+      commitCount: commits.length,
+      parsedCommitCount: decision.parsedCommitCount,
+      skipReason: decision.skipReason
+    };
+    if (tag !== void 0) {
+      skipped.previousTag = tag;
+    }
+    if (decision.unparseableCommits !== void 0) {
+      skipped.unparseableCommits = decision.unparseableCommits;
+    }
+    if (policyViolations !== void 0) {
+      skipped.policyViolations = policyViolations;
+    }
+    return skipped;
+  }
+  const { releaseType, parsedCommitCount, unparseableCommits } = decision;
+  const bump = bumpAllVersions([ROOT_PACKAGE_FILE], releaseType, dryRun);
+  const newTag = `${project.tagPrefix}${bump.newVersion}`;
+  const tagPattern = buildTagPattern([project.tagPrefix]);
+  const changelogFiles = generateChangelog(config, ROOT_CHANGELOG_PATH, newTag, dryRun, {
+    tagPattern,
+    includePaths: contributingPaths
+  });
+  const changelogJsonFiles = [];
+  if (config.changelogJson.enabled) {
+    const changelogJsonPath = resolveChangelogJsonPath(config, ROOT_CHANGELOG_PATH);
+    const entries = buildChangelogEntries(config, newTag, {
+      tagPattern,
+      includePaths: contributingPaths
+    });
+    if (!dryRun) {
+      writeChangelogJson(changelogJsonPath, entries);
+    }
+    changelogJsonFiles.push(changelogJsonPath);
+  }
+  const firstChangelogJsonPath = changelogJsonFiles[0];
+  if (withReleaseNotes === true && config.changelogJson.enabled && firstChangelogJsonPath !== void 0) {
+    const sectionOrder = deriveSectionOrder(workTypes);
+    writeReleaseNotesPreviews({
+      workspacePath: ROOT_CHANGELOG_PATH,
+      tag: newTag,
+      changelogJsonPath: firstChangelogJsonPath,
+      sectionOrder,
+      dryRun
+    });
+  }
+  tags.push(newTag);
+  modifiedFiles.push(ROOT_PACKAGE_FILE, ...changelogFiles, ...changelogJsonFiles);
+  const result = {
+    status: "released",
+    commitCount: commits.length,
+    parsedCommitCount,
+    releaseType,
+    currentVersion: bump.currentVersion,
+    newVersion: bump.newVersion,
+    tag: newTag,
+    bumpedFiles: bump.files,
+    changelogFiles,
+    commits
+  };
+  if (tag !== void 0) {
+    result.previousTag = tag;
+  }
+  if (unparseableCommits !== void 0) {
+    result.unparseableCommits = unparseableCommits;
+  }
+  if (policyViolations !== void 0) {
+    result.policyViolations = policyViolations;
+  }
+  if (bumpOverride !== void 0) {
+    result.bumpOverride = bumpOverride;
+  }
+  return result;
+}
+export {
+  releasePrepareProject
+};

package/dist/esm/renderReleaseNotes.js

@@ -26,7 +26,8 @@ function renderReleaseNotesSingle(entry, options) {
     }
     lines.push(`### ${section.title}`, "");
     for (const [index, item] of section.items.entries()) {
-      lines.push(`- ${item.description}`);
+      const prefix = item.breaking === true ? "\u{1F6A8} **Breaking:** " : "";
+      lines.push(`- ${prefix}${item.description}`);
       if (item.body !== void 0 && item.body.length > 0) {
         lines.push("", ...indentBodyLines(item.body));
         if (index < section.items.length - 1) {

package/dist/esm/reportPrepare.js

@@ -1,6 +1,6 @@
 import { bold, dim, sectionHeader } from "./format.js";
 function reportPrepare(result) {
-  const isMultiWorkspace = result.workspaces.some((w) => w.name !== void 0);
+  const isMultiWorkspace = result.workspaces.some((w) => w.name !== void 0) || result.project !== void 0;
   if (isMultiWorkspace) {
     return formatMultiWorkspace(result);
   }
@@ -18,35 +18,31 @@ function formatSingleWorkspace(result) {
     lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
   }
   formatUnparseableWarning(lines, workspace);
+  formatPolicyViolations(lines, workspace.policyViolations);
   if (workspace.status === "skipped") {
-    lines.push(`\u23ED\uFE0F  ${workspace.skipReason ?? "Skipped"}`);
+    lines.push(`\u23ED\uFE0F  ${workspace.skipReason}`);
     return lines.join("\n");
   }
   if (workspace.setVersion !== void 0) {
     lines.push(`  Using version override: ${workspace.setVersion}`);
-  } else if (workspace.parsedCommitCount === void 0 && workspace.releaseType !== void 0) {
-    lines.push(`  Using bump override: ${workspace.releaseType}`);
+  } else if (workspace.bumpOverride !== void 0) {
+    lines.push(`  Using bump override: ${workspace.bumpOverride}`);
   }
   if (workspace.releaseType !== void 0) {
     lines.push(dim(`Bumping versions (${workspace.releaseType})...`));
   } else if (workspace.setVersion !== void 0) {
     lines.push(dim(`Bumping versions (version override)...`));
   }
-  if (workspace.currentVersion !== void 0 && workspace.newVersion !== void 0) {
-    if (workspace.setVersion !== void 0) {
-      lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
-    } else if (workspace.releaseType !== void 0) {
-      lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (${workspace.releaseType})`);
-    }
+  if (workspace.setVersion !== void 0) {
+    lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
+  } else if (workspace.releaseType !== void 0) {
+    lines.push(`\u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (${workspace.releaseType})`);
   }
   formatBumpFiles(lines, workspace, result.dryRun);
   lines.push(dim("Generating changelogs..."));
   formatChangelogFiles(lines, workspace, result.dryRun);
   formatFormatCommand(lines, result);
-  lines.push(`\u2705 Release preparation complete.`);
-  if (workspace.tag !== void 0) {
-    lines.push(`   \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
-  }
+  lines.push(`\u2705 Release preparation complete.`, `   \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
   return lines.join("\n");
 }
 function formatMultiWorkspace(result) {
@@ -54,6 +50,9 @@ function formatMultiWorkspace(result) {
   for (const workspace of result.workspaces) {
     formatWorkspaceSection(lines, workspace, result.dryRun);
   }
+  if (result.project !== void 0) {
+    formatProjectSection(lines, result.project, result.dryRun);
+  }
   formatFormatCommand(lines, result);
   formatWarnings(lines, result);
   if (result.tags.length > 0) {
@@ -68,6 +67,60 @@ function formatMultiWorkspace(result) {
   }
   return lines.join("\n");
 }
+function formatProjectSection(lines, project, dryRun) {
+  lines.push(`
+${sectionHeader("project")}`);
+  const since = project.previousTag === void 0 ? "(no previous release found)" : `since ${project.previousTag}`;
+  lines.push(dim(`  Found ${project.commitCount} commits ${since}`));
+  formatPolicyViolations(lines, project.policyViolations, "  ");
+  if (project.status === "skipped") {
+    lines.push(`  \u23ED\uFE0F  ${project.skipReason}`);
+    return;
+  }
+  const { releaseType, currentVersion, newVersion, tag } = project;
+  if (project.parsedCommitCount > 0) {
+    lines.push(dim(`  Parsed ${project.parsedCommitCount} typed commits`));
+  }
+  if (project.bumpOverride !== void 0) {
+    lines.push(`  Using bump override: ${project.bumpOverride}`);
+  }
+  formatProjectUnparseable(lines, project);
+  lines.push(
+    dim(`  Bumping versions (${releaseType})...`),
+    `  \u{1F4E6} ${currentVersion} \u2192 ${bold(newVersion)} (${releaseType})`
+  );
+  for (const file of project.bumpedFiles) {
+    if (dryRun) {
+      lines.push(dim(`    [dry-run] Would bump ${file}`));
+    } else {
+      lines.push(dim(`    Bumped ${file}`));
+    }
+  }
+  lines.push(dim("  Generating changelogs..."));
+  for (const file of project.changelogFiles) {
+    if (dryRun) {
+      lines.push(dim(`    [dry-run] Would run: npx --yes git-cliff ... --output ${file}`));
+    } else {
+      lines.push(dim(`    Generating changelog: ${file}`));
+    }
+  }
+  lines.push(`  \u{1F3F7}\uFE0F  ${bold(tag)}`);
+}
+function formatProjectUnparseable(lines, project) {
+  const unparseable = project.unparseableCommits;
+  if (unparseable === void 0 || unparseable.length === 0) {
+    return;
+  }
+  const count = unparseable.length;
+  const isPatchFloor = project.parsedCommitCount === 0;
+  const suffix = isPatchFloor ? " (defaulting to patch bump)" : "";
+  lines.push(`    \u26A0\uFE0F  ${count} commit${count === 1 ? "" : "s"} could not be parsed${suffix}`);
+  for (const commit of unparseable) {
+    const shortHash = commit.hash.slice(0, 7);
+    const truncatedMessage = commit.message.length > 72 ? `${commit.message.slice(0, 69)}...` : commit.message;
+    lines.push(`      \xB7 ${shortHash} ${truncatedMessage}`);
+  }
+}
 function formatWorkspaceSection(lines, workspace, dryRun) {
   if (workspace.name !== void 0) {
     lines.push(`
@@ -76,35 +129,34 @@ ${sectionHeader(workspace.name)}`);
   const since = workspace.previousTag === void 0 ? "(no previous release found)" : `since ${workspace.previousTag}`;
   lines.push(dim(`  Found ${workspace.commitCount} commits ${since}`));
   if (workspace.status === "skipped") {
-    lines.push(`  \u23ED\uFE0F  ${workspace.skipReason ?? "Skipped"}`);
+    lines.push(`  \u23ED\uFE0F  ${workspace.skipReason}`);
     return;
   }
   const { propagatedFrom } = workspace;
   const isPropagatedOnly = propagatedFrom !== void 0 && workspace.commitCount === 0;
   formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly);
   formatUnparseableWarning(lines, workspace, "  ");
+  formatPolicyViolations(lines, workspace.policyViolations, "  ");
   formatBumpLabels(lines, workspace, isPropagatedOnly);
   formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly);
   formatBumpFiles(lines, workspace, dryRun, "  ");
   lines.push(dim("  Generating changelogs..."));
   formatChangelogFiles(lines, workspace, dryRun, "  ");
-  if (workspace.tag !== void 0) {
-    lines.push(`  \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
-  }
+  lines.push(`  \u{1F3F7}\uFE0F  ${bold(workspace.tag)}`);
 }
 function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
   if (isPropagatedOnly && propagatedFrom !== void 0) {
     const depNames = propagatedFrom.map((p) => p.packageName).join(", ");
     lines.push(dim(`  0 commits (bumped via dependency: ${depNames})`));
-  } else if (workspace.parsedCommitCount !== void 0) {
+  } else if (workspace.parsedCommitCount !== void 0 && workspace.parsedCommitCount > 0) {
     lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
   }
 }
 function formatBumpLabels(lines, workspace, isPropagatedOnly) {
   if (workspace.setVersion !== void 0) {
     lines.push(`  Using version override: ${workspace.setVersion}`);
-  } else if (workspace.parsedCommitCount === void 0 && workspace.releaseType !== void 0 && !isPropagatedOnly) {
-    lines.push(`  Using bump override: ${workspace.releaseType}`);
+  } else if (workspace.bumpOverride !== void 0 && !isPropagatedOnly) {
+    lines.push(`  Using bump override: ${workspace.bumpOverride}`);
   }
   if (workspace.releaseType !== void 0) {
     lines.push(dim(`  Bumping versions (${workspace.releaseType})...`));
@@ -113,9 +165,6 @@ function formatBumpLabels(lines, workspace, isPropagatedOnly) {
   }
 }
 function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly) {
-  if (workspace.currentVersion === void 0 || workspace.newVersion === void 0) {
-    return;
-  }
   if (workspace.setVersion !== void 0) {
     lines.push(`  \u{1F4E6} ${workspace.currentVersion} \u2192 ${bold(workspace.newVersion)} (version override)`);
   } else if (workspace.releaseType !== void 0) {
@@ -156,6 +205,21 @@ function formatUnparseableWarning(lines, workspace, indent = "") {
     lines.push(`${indent}    \xB7 ${shortHash} ${truncatedMessage}`);
   }
 }
+function formatPolicyViolations(lines, violations, indent = "") {
+  if (violations === void 0 || violations.length === 0) {
+    return;
+  }
+  const count = violations.length;
+  lines.push(`${indent}  \u26A0\uFE0F  ${count} policy violation${count === 1 ? "" : "s"}:`);
+  for (const violation of violations) {
+    const shortHash = violation.commitHash.slice(0, 7);
+    const subject = violation.commitSubject;
+    const truncatedSubject = subject.length > 72 ? `${subject.slice(0, 69)}...` : subject;
+    lines.push(
+      `${indent}    \xB7 ${shortHash} '${truncatedSubject}' \u2014 type '${violation.type}' at ${violation.surface} surface`
+    );
+  }
+}
 function formatPropagationSuffix(propagatedFrom) {
   if (propagatedFrom === void 0 || propagatedFrom.length === 0) {
     return "";

package/dist/esm/resolveCommandTags.js

@@ -10,15 +10,25 @@ async function resolveCommandTags(tags) {
     process.exit(1);
   }
   let workspaces;
-  if (discoveredPaths !== void 0) {
-    try {
+  let singleWorkspace;
+  try {
+    if (discoveredPaths === void 0) {
+      singleWorkspace = deriveWorkspaceConfig(".");
+    } else {
       workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
-    } catch (error) {
-      console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
-      process.exit(1);
     }
+  } catch (error) {
+    console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  let resolvedTags;
+  if (workspaces !== void 0) {
+    resolvedTags = resolveReleaseTags({ workspaces });
+  } else if (singleWorkspace !== void 0) {
+    resolvedTags = resolveReleaseTags({ singleWorkspace });
+  } else {
+    throw new Error("resolveCommandTags: invariant violated \u2014 neither workspaces nor singleWorkspace was derived");
   }
-  let resolvedTags = resolveReleaseTags(workspaces);
   if (resolvedTags.length === 0) {
     console.error("Error: No release tags found on HEAD. Create tags with `release-kit tag` first.");
     process.exit(1);

package/dist/esm/resolveReleaseTags.d.ts

@@ -3,5 +3,12 @@ export interface ResolvedTag {
     tag: string;
     dir: string;
     workspacePath: string;
+    isPublishable: boolean;
 }
-export declare function resolveReleaseTags(workspaces?: readonly WorkspaceConfig[]): ResolvedTag[];
+type ResolveReleaseTagsArgs = {
+    workspaces: readonly WorkspaceConfig[];
+} | {
+    singleWorkspace: WorkspaceConfig;
+};
+export declare function resolveReleaseTags(args?: ResolveReleaseTagsArgs): ResolvedTag[];
+export {};

package/dist/esm/resolveReleaseTags.js

@@ -1,23 +1,27 @@
 import { execFileSync } from "node:child_process";
 const VERSION_PATTERN = /^v\d+\.\d+\.\d+/;
 const SEMVER_SUFFIX_PATTERN = /^\d+\.\d+\.\d+/;
-function resolveReleaseTags(workspaces) {
+function resolveReleaseTags(args) {
   const output = execFileSync("git", ["tag", "--points-at", "HEAD"], { encoding: "utf8" });
   const tags = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  if (workspaces === void 0) {
+  if (args === void 0) {
     return resolveSinglePackageTags(tags);
   }
-  return resolveMonorepoTags(tags, workspaces);
+  if ("workspaces" in args) {
+    return resolveMonorepoTags(tags, args.workspaces);
+  }
+  return resolveSinglePackageTags(tags, args.singleWorkspace);
 }
-function resolveSinglePackageTags(tags) {
+function resolveSinglePackageTags(tags, singleWorkspace) {
   const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
+  const isPublishable = singleWorkspace?.isPublishable ?? true;
   if (matched.length > 1) {
     console.warn(
       `Warning: Multiple version tags found on HEAD: ${matched.join(", ")}. Publishing the same package multiple times is almost certainly unintended. Using only the first tag.`
     );
-    return matched.slice(0, 1).map((tag) => ({ tag, dir: ".", workspacePath: "." }));
+    return matched.slice(0, 1).map((tag) => ({ tag, dir: ".", workspacePath: ".", isPublishable }));
   }
-  return matched.map((tag) => ({ tag, dir: ".", workspacePath: "." }));
+  return matched.map((tag) => ({ tag, dir: ".", workspacePath: ".", isPublishable }));
 }
 function resolveMonorepoTags(tags, workspaces) {
   const sortedWorkspaces = [...workspaces].sort((a, b) => b.tagPrefix.length - a.tagPrefix.length);
@@ -25,7 +29,7 @@ function resolveMonorepoTags(tags, workspaces) {
   for (const tag of tags) {
     const match = findMatchingWorkspace(tag, sortedWorkspaces);
     if (match !== void 0) {
-      resolved.push({ tag, dir: match.dir, workspacePath: match.workspacePath });
+      resolved.push({ tag, dir: match.dir, workspacePath: match.workspacePath, isPublishable: match.isPublishable });
     }
   }
   return resolved;

package/dist/esm/runGitCliff.d.ts

@@ -0,0 +1,2 @@
+import { type StdioOptions } from 'node:child_process';
+export declare function runGitCliff(cliffConfigPath: string, cliffArgs: readonly string[], stdio: StdioOptions): string;

package/dist/esm/runGitCliff.js

@@ -0,0 +1,27 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function runGitCliff(cliffConfigPath, cliffArgs, stdio) {
+  let configPath = cliffConfigPath;
+  let tempDir;
+  try {
+    if (cliffConfigPath.endsWith(".template")) {
+      tempDir = mkdtempSync(join(tmpdir(), "cliff-"));
+      configPath = join(tempDir, "cliff.toml");
+      copyFileSync(cliffConfigPath, configPath);
+    }
+    return execFileSync("npx", ["--prefer-offline", "--yes", "git-cliff", "--config", configPath, ...cliffArgs], {
+      encoding: "utf8",
+      stdio,
+      env: { ...process.env, npm_config_progress: "false" }
+    });
+  } finally {
+    if (tempDir !== void 0) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+}
+export {
+  runGitCliff
+};

package/dist/esm/stripEmojiPrefix.d.ts

@@ -0,0 +1 @@
+export declare function stripEmojiPrefix(value: string): string;

package/dist/esm/stripEmojiPrefix.js

@@ -0,0 +1,7 @@
+const LEADING_EMOJI = /^\p{Extended_Pictographic}️? /u;
+function stripEmojiPrefix(value) {
+  return value.replace(LEADING_EMOJI, "");
+}
+export {
+  stripEmojiPrefix
+};

package/dist/esm/syncWorkTypes.d.ts

@@ -0,0 +1,10 @@
+export interface SyncResult {
+    exitCode: 0 | 2 | 3;
+    message: string;
+}
+export interface SyncWorkTypesDependencies {
+    localPath?: string;
+    fetch?: typeof globalThis.fetch;
+    upstreamUrl?: string;
+}
+export declare function syncWorkTypes(dependencies?: SyncWorkTypesDependencies): Promise<SyncResult>;

package/dist/esm/syncWorkTypes.js

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { UPSTREAM_WORK_TYPES_URL } from "./checkWorkTypesDrift.js";
+import { isRecord } from "./typeGuards.js";
+import { errorMessage, hasExpectedTopLevelShape } from "./workTypesUtils.js";
+function resolveDefaultLocalPath() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(moduleDir, "work-types.json");
+}
+function extractLocalSchemaUrl(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) {
+    return void 0;
+  }
+  const schema = parsed.$schema;
+  return typeof schema === "string" ? schema : void 0;
+}
+async function syncWorkTypes(dependencies = {}) {
+  const localPath = dependencies.localPath ?? resolveDefaultLocalPath();
+  const fetcher = dependencies.fetch ?? globalThis.fetch;
+  const url = dependencies.upstreamUrl ?? UPSTREAM_WORK_TYPES_URL;
+  let response;
+  try {
+    response = await fetcher(url);
+  } catch (error) {
+    return {
+      exitCode: 2,
+      message: `Network error fetching upstream work-types.json: ${errorMessage(error)}`
+    };
+  }
+  if (!response.ok) {
+    return {
+      exitCode: 2,
+      message: `Failed to fetch upstream work-types.json: HTTP ${response.status} ${response.statusText}`
+    };
+  }
+  const upstreamText = await response.text();
+  let upstreamJson;
+  try {
+    upstreamJson = JSON.parse(upstreamText);
+  } catch (error) {
+    return {
+      exitCode: 3,
+      message: `Upstream work-types.json is not valid JSON: ${errorMessage(error)}`
+    };
+  }
+  if (!hasExpectedTopLevelShape(upstreamJson)) {
+    return {
+      exitCode: 3,
+      message: "Upstream work-types.json does not match the expected schema shape (missing `tiers` or `types`)."
+    };
+  }
+  let priorContent;
+  try {
+    priorContent = readFileSync(localPath, "utf8");
+  } catch {
+    priorContent = void 0;
+  }
+  const localSchemaUrl = priorContent !== void 0 ? extractLocalSchemaUrl(priorContent) : void 0;
+  const outputJson = localSchemaUrl !== void 0 ? { $schema: localSchemaUrl, ...upstreamJson } : upstreamJson;
+  const formatted = `${JSON.stringify(outputJson, null, 2)}
+`;
+  if (priorContent === formatted) {
+    return {
+      exitCode: 0,
+      message: `Local work-types.json already matches upstream (${localPath}).`
+    };
+  }
+  try {
+    writeFileSync(localPath, formatted, "utf8");
+  } catch (error) {
+    return {
+      exitCode: 2,
+      message: `Failed to write ${localPath}: ${errorMessage(error)}`
+    };
+  }
+  return {
+    exitCode: 0,
+    message: `Synced work-types.json from ${url} \u2192 ${localPath}.`
+  };
+}
+export {
+  syncWorkTypes
+};