@mnaoumov/typescript-dev-toolkit 3.2.0 → 3.4.0

package/dist/lib/esm/upstream-sync.mjs

@@ -0,0 +1,268 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import {
+  readFileSync,
+  writeFileSync
+} from "node:fs";
+import { matchesGlob } from "node:path";
+const COMPARE_FILE_LIMIT = 300;
+const SHORT_SHA_LENGTH = 12;
+const OUTPUT_TAIL_LINES = 60;
+const JSON_INDENT_SPACES = 2;
+function buildPrBody(plan, steps, diffStat) {
+  const { entry, head, pin } = plan.status;
+  const source = isGitUpstream(entry) ? `\`${entry.repo}@${entry.ref}\`` : `npm \`${entry.npm}@${entry.tag ?? "latest"}\``;
+  const lines = [
+    `Upstream \`${entry.name}\` moved: ${source} from \`${pin}\` to \`${head}\`.`,
+    "",
+    `Compare: ${plan.status.compareUrl}`,
+    ""
+  ];
+  if (isGitUpstream(entry)) {
+    lines.push("### Changed upstream files", "", ...plan.status.changedPaths.map((path) => `- \`${path}\``));
+    if (plan.status.truncated) {
+      lines.push(`- GitHub lists at most ${String(COMPARE_FILE_LIMIT)} files: open the compare link for the rest.`);
+    }
+    lines.push("");
+  }
+  if (steps === null) {
+    lines.push("### Handler", "", `\`${entry.handler}\`: not run (dry run).`, "");
+  } else {
+    lines.push(...describeStep("Handler", steps.handler));
+    if (steps.verify !== null) {
+      lines.push(...describeStep("Verify", steps.verify));
+    }
+  }
+  if (diffStat !== null) {
+    lines.push("### Generated changes", "", "```text", diffStat.trimEnd(), "```", "");
+  }
+  lines.push("This PR was opened by the upstream-sync job and is never merged automatically.");
+  return `${lines.join("\n")}
+`;
+}
+async function compareWithUpstream(entry, dependencies) {
+  if (!isGitUpstream(entry)) {
+    const tag = entry.tag ?? "latest";
+    const packument = await dependencies.fetchJson(`https://registry.npmjs.org/${entry.npm.replace("/", "%2f")}`);
+    const head2 = packument["dist-tags"][tag];
+    if (head2 === void 0) {
+      throw new Error(`npm package ${entry.npm} has no dist-tag "${tag}".`);
+    }
+    return {
+      changedPaths: [],
+      compareUrl: `https://www.npmjs.com/package/${entry.npm}/v/${head2}`,
+      entry,
+      head: head2,
+      pin: entry.version,
+      state: head2 === entry.version ? "current" : "moved",
+      truncated: false
+    };
+  }
+  const commit = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/commits/${encodeURIComponent(entry.ref)}`);
+  const head = commit.sha;
+  const compareUrl = `https://github.com/${entry.repo}/compare/${entry.commit}...${head}`;
+  if (head === entry.commit) {
+    return { changedPaths: [], compareUrl, entry, head, pin: entry.commit, state: "current", truncated: false };
+  }
+  const compare = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/compare/${entry.commit}...${head}`);
+  const files = compare.files ?? [];
+  const touched = new Set(files.flatMap((file) => file.previous_filename === void 0 ? [file.filename] : [file.filename, file.previous_filename]));
+  const changedPaths = [...touched].filter((path) => entry.paths.some((glob) => matchesGlob(path, glob))).sort();
+  const isTruncated = files.length >= COMPARE_FILE_LIMIT;
+  return {
+    changedPaths,
+    compareUrl,
+    entry,
+    head,
+    pin: entry.commit,
+    state: changedPaths.length > 0 || isTruncated ? "moved" : "unwatched",
+    truncated: isTruncated
+  };
+}
+function parseUpstreamsConfig(text) {
+  const config = JSON.parse(text);
+  if (!Array.isArray(config.upstreams)) {
+    throw new TypeError('upstreams.json has no "upstreams" array.');
+  }
+  const entries = config.upstreams;
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const name = Reflect.get(entry, "name");
+    const label = typeof name === "string" ? `"${name}"` : "with no name";
+    const isGit = "repo" in entry;
+    const required = isGit ? ["name", "repo", "ref", "commit", "handler"] : ["name", "npm", "version", "handler"];
+    for (const key of required) {
+      if (typeof Reflect.get(entry, key) !== "string") {
+        throw new TypeError(`upstreams.json: entry ${label} needs a string "${key}".`);
+      }
+    }
+    if (isGit && !Array.isArray(Reflect.get(entry, "paths"))) {
+      throw new Error(`upstreams.json: entry ${label} needs a "paths" array.`);
+    }
+    if (names.has(name)) {
+      throw new Error(`upstreams.json: the name ${label} is used twice.`);
+    }
+    names.add(name);
+  }
+  return config;
+}
+function planSync(status) {
+  return {
+    branch: `upstream/${status.entry.name}`,
+    status,
+    title: `chore(upstream): sync ${status.entry.name} to ${shorten(status.head)}`
+  };
+}
+async function syncUpstreams(options, dependencies) {
+  const config = parseUpstreamsConfig(readFileSync(options.configPath, "utf-8"));
+  const unknown = options.only.filter((name) => config.upstreams.every((entry) => entry.name !== name));
+  if (unknown.length > 0) {
+    throw new Error(`upstreams.json has no entry named ${unknown.map((name) => `"${name}"`).join(", ")}.`);
+  }
+  const results = [];
+  for (const entry of config.upstreams) {
+    if (options.only.length > 0 && !options.only.includes(entry.name)) {
+      continue;
+    }
+    try {
+      results.push(await syncEntry(entry, config, options, dependencies));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      dependencies.log(`${entry.name}: ERROR ${message}`);
+      results.push({ error: message, name: entry.name, outcome: "error" });
+    }
+  }
+  return results;
+}
+function writePin(configPath, status) {
+  const text = readFileSync(configPath, "utf-8");
+  const parsed = JSON.parse(text);
+  const key = isGitUpstream(status.entry) ? "commit" : "version";
+  const target = parsed.upstreams.find((entry) => entry["name"] === status.entry.name);
+  if (target?.[key] !== status.pin) {
+    return;
+  }
+  target[key] = status.head;
+  writeFileSync(configPath, `${JSON.stringify(parsed, null, JSON_INDENT_SPACES)}
+`);
+}
+function applyPlan(plan, config, options, dependencies) {
+  const { entry } = plan.status;
+  const env = { UPSTREAM_NAME: entry.name, UPSTREAM_TARGET: plan.status.head };
+  const handler = { command: entry.handler, result: dependencies.shell(entry.handler, env) };
+  writePin(options.configPath, plan.status);
+  const verifyCommand = entry.verify ?? config.verify;
+  const verify = verifyCommand === void 0 ? null : { command: verifyCommand, result: dependencies.shell(verifyCommand, env) };
+  const isFailed = handler.result.exitCode !== 0 || verify !== null && verify.result.exitCode !== 0;
+  execOrThrow(dependencies, "git", ["add", "--all"]);
+  execOrThrow(dependencies, "git", ["commit", "--no-verify", "--message", plan.title]);
+  const diffStat = execOrThrow(dependencies, "git", ["diff", "--stat", "HEAD~1", "HEAD"]);
+  const isRemoteBranch = dependencies.exec("git", ["ls-remote", "--exit-code", "--heads", "origin", plan.branch]).exitCode === 0;
+  if (isRemoteBranch) {
+    execOrThrow(dependencies, "git", ["fetch", "origin", plan.branch]);
+    if (dependencies.exec("git", ["diff", "--quiet", "FETCH_HEAD", "HEAD"]).exitCode === 0) {
+      dependencies.log(`${entry.name}: ${plan.branch} already holds this result; nothing pushed.`);
+      return { name: entry.name, outcome: "unchanged" };
+    }
+  }
+  execOrThrow(dependencies, "git", ["push", "--force", "origin", `HEAD:refs/heads/${plan.branch}`]);
+  const body = buildPrBody(plan, { handler, verify }, diffStat);
+  const existing = execOrThrow(dependencies, "gh", ["pr", "list", "--head", plan.branch, "--state", "open", "--json", "number", "--jq", ".[0].number"]).trim();
+  if (existing !== "" && existing !== "null") {
+    const prNumber2 = Number(existing);
+    execOrThrow(dependencies, "gh", ["pr", "edit", existing, "--title", plan.title, "--body", body]);
+    execOrThrow(dependencies, "gh", isFailed ? ["pr", "ready", existing, "--undo"] : ["pr", "ready", existing]);
+    dependencies.log(`${entry.name}: updated PR #${existing}${isFailed ? " (draft: a step failed)" : ""}.`);
+    return { name: entry.name, outcome: "updated", prNumber: prNumber2 };
+  }
+  const url = execOrThrow(dependencies, "gh", [
+    "pr",
+    "create",
+    "--base",
+    options.baseBranch,
+    "--head",
+    plan.branch,
+    "--title",
+    plan.title,
+    "--body",
+    body,
+    ...isFailed ? ["--draft"] : []
+  ]).trim();
+  dependencies.log(`${entry.name}: opened ${url}${isFailed ? " (draft: a step failed)" : ""}.`);
+  const prNumber = Number(/\/pull\/(?<Number>\d+)/.exec(url)?.groups?.["Number"] ?? NaN);
+  return Number.isNaN(prNumber) ? { name: entry.name, outcome: "opened" } : { name: entry.name, outcome: "opened", prNumber };
+}
+function describeStep(heading, step) {
+  const isPassed = step.result.exitCode === 0;
+  const tail = step.result.output.trimEnd().split(/\r?\n/).slice(-OUTPUT_TAIL_LINES).join("\n");
+  return [
+    `### ${heading}`,
+    "",
+    `\`${step.command}\`: ${isPassed ? "passed" : `**FAILED** (exit ${String(step.result.exitCode)})`}.`,
+    "",
+    isPassed ? "<details><summary>Output</summary>" : "<details open><summary>Output</summary>",
+    "",
+    "```text",
+    tail,
+    "```",
+    "",
+    "</details>",
+    ""
+  ];
+}
+function execOrThrow(dependencies, file, arguments_) {
+  const result = dependencies.exec(file, arguments_);
+  if (result.exitCode !== 0) {
+    throw new Error(`${file} ${arguments_.join(" ")} failed (exit ${String(result.exitCode)}): ${result.output.trim()}`);
+  }
+  return result.output;
+}
+function isGitUpstream(entry) {
+  return "repo" in entry;
+}
+function shorten(head) {
+  return /^[0-9a-f]{40}$/.test(head) ? head.slice(0, SHORT_SHA_LENGTH) : head;
+}
+async function syncEntry(entry, config, options, dependencies) {
+  const status = await compareWithUpstream(entry, dependencies);
+  if (status.state === "current") {
+    dependencies.log(`${entry.name}: current at ${shorten(status.head)}.`);
+    return { name: entry.name, outcome: "current" };
+  }
+  if (status.state === "unwatched") {
+    dependencies.log(`${entry.name}: moved to ${shorten(status.head)}, but no watched path changed since ${shorten(status.pin)}.`);
+    return { name: entry.name, outcome: "unwatched" };
+  }
+  const plan = planSync(status);
+  if (options.dryRun) {
+    dependencies.log(`${entry.name}: moved from ${shorten(status.pin)} to ${shorten(status.head)}. Would push ${plan.branch} and open:`);
+    dependencies.log(`  title: ${plan.title}`);
+    dependencies.log(buildPrBody(plan, null, null).replaceAll(/^/gm, "  | "));
+    return { name: entry.name, outcome: "planned" };
+  }
+  const dirty = execOrThrow(dependencies, "git", ["status", "--porcelain"]).trim();
+  if (dirty !== "") {
+    throw new Error(`the working tree is not clean, and the update commit would take these files with it:
+${dirty}`);
+  }
+  execOrThrow(dependencies, "git", ["fetch", "origin", options.baseBranch]);
+  execOrThrow(dependencies, "git", ["checkout", "-B", plan.branch, `origin/${options.baseBranch}`]);
+  try {
+    return applyPlan(plan, config, options, dependencies);
+  } finally {
+    dependencies.exec("git", ["checkout", "--force", options.baseBranch]);
+    dependencies.exec("git", ["branch", "--delete", "--force", plan.branch]);
+  }
+}
+export {
+  buildPrBody,
+  compareWithUpstream,
+  parseUpstreamsConfig,
+  planSync,
+  syncUpstreams,
+  writePin
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/upstream-sync.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Watches the upstreams a repository mirrors and opens one update PR per upstream that moved.\n *\n * Everything here is driven by `upstreams.json` and the handler commands it names, so any repository that vendors\n * upstream code can use it: through the `sync-upstreams` bin, or the reusable `sync-upstreams.yml` workflow.\n */\n\nimport {\n  readFileSync,\n  writeFileSync\n} from 'node:fs';\nimport { matchesGlob } from 'node:path';\n\n/**\n * What a command printed and how it exited.\n */\nexport interface CommandResult {\n  readonly exitCode: number;\n  readonly output: string;\n}\n\n/**\n * An upstream followed on a GitHub branch or tag, pinned to a commit.\n */\nexport interface GitUpstreamEntry {\n  /**\n   * The pinned commit: the last upstream state the handler was run against.\n   */\n  commit: string;\n  /**\n   * The shell command that turns a newer upstream state into changes in this repository.\n   */\n  handler: string;\n  name: string;\n  /**\n   * The paths watched upstream, as globs relative to the repository root. A move that touches none of them opens no PR.\n   */\n  paths: readonly string[];\n  /**\n   * The branch or tag followed.\n   */\n  ref: string;\n  /**\n   * `<owner>/<repo>` on GitHub.\n   */\n  repo: string;\n  /**\n   * The shell command that checks the handler's result. Overrides the file's top-level `verify`.\n   */\n  verify?: string;\n}\n\n/**\n * An upstream followed as an npm package's dist-tag, pinned to a version.\n */\nexport interface NpmUpstreamEntry {\n  handler: string;\n  name: string;\n  /**\n   * The package name.\n   */\n  npm: string;\n  /**\n   * The dist-tag followed. `latest` when absent.\n   */\n  tag?: string;\n  verify?: string;\n  /**\n   * The pinned version.\n   */\n  version: string;\n}\n\n/**\n * Everything the sync does to the outside world, so a test can stand a fixture in for it.\n */\nexport interface SyncDependencies {\n  /**\n   * Runs an executable with arguments and no shell.\n   */\n  exec: (file: string, arguments_: readonly string[], env?: Readonly<Record<string, string>>) => CommandResult;\n  /**\n   * GETs a URL and parses the JSON it returns, throwing on an HTTP error.\n   */\n  fetchJson: (url: string) => Promise<unknown>;\n  log: (text: string) => void;\n  /**\n   * Runs a command line through the shell: a handler or a verify command.\n   */\n  shell: (command: string, env?: Readonly<Record<string, string>>) => CommandResult;\n}\n\n/**\n * The PR an upstream move asks for.\n */\nexport interface SyncPlan {\n  branch: string;\n  status: UpstreamStatus;\n  title: string;\n}\n\n/**\n * What happened to one entry.\n */\nexport interface SyncResult {\n  /**\n   * Set when checking or applying threw: the job reports it and moves on to the next entry.\n   */\n  readonly error?: string;\n  readonly name: string;\n  /**\n   * `planned` in a dry run, `opened`/`updated` when a PR was pushed, `unchanged` when the branch already held this result.\n   */\n  readonly outcome: 'current' | 'error' | 'opened' | 'planned' | 'unchanged' | 'unwatched' | 'updated';\n  readonly prNumber?: number;\n}\n\n/**\n * What {@link syncUpstreams} syncs, and how.\n */\nexport interface SyncUpstreamsOptions {\n  /**\n   * The branch each PR targets and each update branch is cut from.\n   */\n  readonly baseBranch: string;\n  /**\n   * The path to `upstreams.json`, which the sync updates the pin in.\n   */\n  readonly configPath: string;\n  /**\n   * Plan and print every PR, and change nothing.\n   */\n  readonly dryRun: boolean;\n  /**\n   * Only the entries with these names, or every entry when empty.\n   */\n  readonly only: readonly string[];\n}\n\n/**\n * One upstream that `upstreams.json` lists: a git one or an npm one.\n */\nexport type UpstreamEntry = GitUpstreamEntry | NpmUpstreamEntry;\n\n/**\n * The content of `upstreams.json`.\n */\nexport interface UpstreamsConfig {\n  upstreams: readonly UpstreamEntry[];\n  /**\n   * The shell command that checks every handler's result, unless an entry names its own.\n   */\n  verify?: string;\n}\n\n/**\n * What one comparison of an entry with its upstream found.\n */\nexport interface UpstreamStatus {\n  /**\n   * The upstream paths that changed and are watched, sorted. Always empty for an npm upstream.\n   */\n  changedPaths: readonly string[];\n  /**\n   * A link that shows what changed between the pin and the head.\n   */\n  compareUrl: string;\n  entry: UpstreamEntry;\n  /**\n   * The commit or version the upstream is at now.\n   */\n  head: string;\n  /**\n   * The commit or version `upstreams.json` records.\n   */\n  pin: string;\n  /**\n   * `current`: nothing to do. `moved`: a PR is due. `unwatched`: upstream moved, but no watched path changed.\n   */\n  state: 'current' | 'moved' | 'unwatched';\n  /**\n   * Whether GitHub truncated the compare's file list, so a watched path may be missing from `changedPaths`.\n   */\n  truncated: boolean;\n}\n\ninterface GitHubCommit {\n  sha: string;\n}\n\ninterface GitHubCompare {\n  files?: readonly GitHubCompareFile[];\n}\n\n/**\n * One file of a GitHub compare, as the API spells it.\n */\ninterface GitHubCompareFile {\n  filename: string;\n\n  previous_filename?: string;\n}\n\ninterface NpmPackument {\n  'dist-tags': Record<string, string>;\n}\n\ninterface StepResult {\n  readonly command: string;\n  readonly result: CommandResult;\n}\n\n/**\n * The handler and verify runs a PR body reports.\n */\ninterface StepResults {\n  handler: StepResult;\n  verify: null | StepResult;\n}\n\n/**\n * `upstreams.json` read loosely, to write one value back without disturbing the rest.\n */\ninterface UpstreamsFileShape {\n  upstreams: Record<string, unknown>[];\n}\n\n/**\n * GitHub's compare API lists at most this many files, and says nothing when it stops.\n */\nconst COMPARE_FILE_LIMIT = 300;\n\nconst SHORT_SHA_LENGTH = 12;\n\n/**\n * The tail of a command's output a PR body quotes: enough to read a failure, short enough to stay under GitHub's body limit.\n */\nconst OUTPUT_TAIL_LINES = 60;\n\nconst JSON_INDENT_SPACES = 2;\n\n/**\n * Writes the PR body.\n *\n * @param plan - The plan.\n * @param steps - The handler and verify runs, or `null` in a dry run, where neither runs.\n * @param diffStat - `git diff --stat` of the update commit, or `null` in a dry run.\n * @returns The body, in Markdown.\n */\nexport function buildPrBody(plan: SyncPlan, steps: null | StepResults, diffStat: null | string): string {\n  const { entry, head, pin } = plan.status;\n  const source = isGitUpstream(entry) ? `\\`${entry.repo}@${entry.ref}\\`` : `npm \\`${entry.npm}@${entry.tag ?? 'latest'}\\``;\n  const lines = [\n    `Upstream \\`${entry.name}\\` moved: ${source} from \\`${pin}\\` to \\`${head}\\`.`,\n    '',\n    `Compare: ${plan.status.compareUrl}`,\n    ''\n  ];\n\n  if (isGitUpstream(entry)) {\n    lines.push('### Changed upstream files', '', ...plan.status.changedPaths.map((path) => `- \\`${path}\\``));\n    if (plan.status.truncated) {\n      lines.push(`- GitHub lists at most ${String(COMPARE_FILE_LIMIT)} files: open the compare link for the rest.`);\n    }\n    lines.push('');\n  }\n\n  if (steps === null) {\n    lines.push('### Handler', '', `\\`${entry.handler}\\`: not run (dry run).`, '');\n  } else {\n    lines.push(...describeStep('Handler', steps.handler));\n    if (steps.verify !== null) {\n      lines.push(...describeStep('Verify', steps.verify));\n    }\n  }\n\n  if (diffStat !== null) {\n    lines.push('### Generated changes', '', '```text', diffStat.trimEnd(), '```', '');\n  }\n\n  lines.push('This PR was opened by the upstream-sync job and is never merged automatically.');\n  return `${lines.join('\\n')}\\n`;\n}\n\n/**\n * Compares one entry with its upstream.\n *\n * @param entry - The entry.\n * @param dependencies - The outside world.\n * @returns What the comparison found.\n */\nexport async function compareWithUpstream(entry: UpstreamEntry, dependencies: Pick<SyncDependencies, 'fetchJson'>): Promise<UpstreamStatus> {\n  if (!isGitUpstream(entry)) {\n    const tag = entry.tag ?? 'latest';\n    const packument = await dependencies.fetchJson(`https://registry.npmjs.org/${entry.npm.replace('/', '%2f')}`) as NpmPackument;\n    const head = packument['dist-tags'][tag];\n    if (head === undefined) {\n      throw new Error(`npm package ${entry.npm} has no dist-tag \"${tag}\".`);\n    }\n    return {\n      changedPaths: [],\n      compareUrl: `https://www.npmjs.com/package/${entry.npm}/v/${head}`,\n      entry,\n      head,\n      pin: entry.version,\n      state: head === entry.version ? 'current' : 'moved',\n      truncated: false\n    };\n  }\n\n  const commit = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/commits/${encodeURIComponent(entry.ref)}`) as GitHubCommit;\n  const head = commit.sha;\n  const compareUrl = `https://github.com/${entry.repo}/compare/${entry.commit}...${head}`;\n  if (head === entry.commit) {\n    return { changedPaths: [], compareUrl, entry, head, pin: entry.commit, state: 'current', truncated: false };\n  }\n\n  const compare = await dependencies.fetchJson(`https://api.github.com/repos/${entry.repo}/compare/${entry.commit}...${head}`) as GitHubCompare;\n  const files = compare.files ?? [];\n  const touched = new Set(files.flatMap((file) => file.previous_filename === undefined ? [file.filename] : [file.filename, file.previous_filename]));\n  const changedPaths = [...touched].filter((path) => entry.paths.some((glob) => matchesGlob(path, glob))).sort();\n  const isTruncated = files.length >= COMPARE_FILE_LIMIT;\n  return {\n    changedPaths,\n    compareUrl,\n    entry,\n    head,\n    pin: entry.commit,\n    state: changedPaths.length > 0 || isTruncated ? 'moved' : 'unwatched',\n    truncated: isTruncated\n  };\n}\n\n/**\n * Parses and validates an `upstreams.json`.\n *\n * @param text - The file's content.\n * @returns The config.\n */\nexport function parseUpstreamsConfig(text: string): UpstreamsConfig {\n  const config = JSON.parse(text) as Partial<UpstreamsConfig>;\n  if (!Array.isArray(config.upstreams)) {\n    throw new TypeError('upstreams.json has no \"upstreams\" array.');\n  }\n  // Read through `Reflect.get`, because nothing about the parsed entries is known yet.\n  const entries: readonly object[] = config.upstreams;\n  const names = new Set<unknown>();\n  for (const entry of entries) {\n    const name: unknown = Reflect.get(entry, 'name');\n    const label = typeof name === 'string' ? `\"${name}\"` : 'with no name';\n    const isGit = 'repo' in entry;\n    const required = isGit ? ['name', 'repo', 'ref', 'commit', 'handler'] : ['name', 'npm', 'version', 'handler'];\n    for (const key of required) {\n      if (typeof Reflect.get(entry, key) !== 'string') {\n        throw new TypeError(`upstreams.json: entry ${label} needs a string \"${key}\".`);\n      }\n    }\n    if (isGit && !Array.isArray(Reflect.get(entry, 'paths'))) {\n      throw new Error(`upstreams.json: entry ${label} needs a \"paths\" array.`);\n    }\n    if (names.has(name)) {\n      throw new Error(`upstreams.json: the name ${label} is used twice.`);\n    }\n    names.add(name);\n  }\n  return config as UpstreamsConfig;\n}\n\n/**\n * Plans the PR a moved upstream asks for.\n *\n * @param status - The comparison of a moved entry.\n * @returns The branch and title.\n */\nexport function planSync(status: UpstreamStatus): SyncPlan {\n  return {\n    branch: `upstream/${status.entry.name}`,\n    status,\n    title: `chore(upstream): sync ${status.entry.name} to ${shorten(status.head)}`\n  };\n}\n\n/**\n * Checks every entry, and opens or updates one PR per moved upstream.\n *\n * A handler or verify failure still opens the PR, as a draft with the failure in its body, so a breaking upstream change\n * is seen rather than skipped. An error in the sync itself, such as a failed API call, is reported in the entry's result\n * and the next entry still runs.\n *\n * @param options - What to sync, and how.\n * @param dependencies - The outside world.\n * @returns One result per entry checked.\n */\nexport async function syncUpstreams(options: SyncUpstreamsOptions, dependencies: SyncDependencies): Promise<SyncResult[]> {\n  const config = parseUpstreamsConfig(readFileSync(options.configPath, 'utf-8'));\n  const unknown = options.only.filter((name) => config.upstreams.every((entry) => entry.name !== name));\n  if (unknown.length > 0) {\n    throw new Error(`upstreams.json has no entry named ${unknown.map((name) => `\"${name}\"`).join(', ')}.`);\n  }\n\n  const results: SyncResult[] = [];\n  for (const entry of config.upstreams) {\n    if (options.only.length > 0 && !options.only.includes(entry.name)) {\n      continue;\n    }\n    try {\n      results.push(await syncEntry(entry, config, options, dependencies));\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      dependencies.log(`${entry.name}: ERROR ${message}`);\n      results.push({ error: message, name: entry.name, outcome: 'error' });\n    }\n  }\n  return results;\n}\n\n/**\n * Records `head` as the entry's pin in `upstreams.json`, unless the handler already moved it, keeping the file's\n * key order and formatting.\n *\n * @param configPath - The path to `upstreams.json`.\n * @param status - The comparison.\n */\nexport function writePin(configPath: string, status: UpstreamStatus): void {\n  const text = readFileSync(configPath, 'utf-8');\n  const parsed = JSON.parse(text) as UpstreamsFileShape;\n  const key = isGitUpstream(status.entry) ? 'commit' : 'version';\n  const target = parsed.upstreams.find((entry) => entry['name'] === status.entry.name);\n  if (target?.[key] !== status.pin) {\n    return;\n  }\n  target[key] = status.head;\n  writeFileSync(configPath, `${JSON.stringify(parsed, null, JSON_INDENT_SPACES)}\\n`);\n}\n\nfunction applyPlan(plan: SyncPlan, config: UpstreamsConfig, options: SyncUpstreamsOptions, dependencies: SyncDependencies): SyncResult {\n  const { entry } = plan.status;\n  const env = { UPSTREAM_NAME: entry.name, UPSTREAM_TARGET: plan.status.head };\n  const handler: StepResult = { command: entry.handler, result: dependencies.shell(entry.handler, env) };\n  writePin(options.configPath, plan.status);\n  const verifyCommand = entry.verify ?? config.verify;\n  const verify: null | StepResult = verifyCommand === undefined ? null : { command: verifyCommand, result: dependencies.shell(verifyCommand, env) };\n  const isFailed = handler.result.exitCode !== 0 || (verify !== null && verify.result.exitCode !== 0);\n\n  execOrThrow(dependencies, 'git', ['add', '--all']);\n  execOrThrow(dependencies, 'git', ['commit', '--no-verify', '--message', plan.title]);\n  const diffStat = execOrThrow(dependencies, 'git', ['diff', '--stat', 'HEAD~1', 'HEAD']);\n\n  const isRemoteBranch = dependencies.exec('git', ['ls-remote', '--exit-code', '--heads', 'origin', plan.branch]).exitCode === 0;\n  if (isRemoteBranch) {\n    execOrThrow(dependencies, 'git', ['fetch', 'origin', plan.branch]);\n    if (dependencies.exec('git', ['diff', '--quiet', 'FETCH_HEAD', 'HEAD']).exitCode === 0) {\n      dependencies.log(`${entry.name}: ${plan.branch} already holds this result; nothing pushed.`);\n      return { name: entry.name, outcome: 'unchanged' };\n    }\n  }\n  execOrThrow(dependencies, 'git', ['push', '--force', 'origin', `HEAD:refs/heads/${plan.branch}`]);\n\n  const body = buildPrBody(plan, { handler, verify }, diffStat);\n  const existing = execOrThrow(dependencies, 'gh', ['pr', 'list', '--head', plan.branch, '--state', 'open', '--json', 'number', '--jq', '.[0].number']).trim();\n  if (existing !== '' && existing !== 'null') {\n    const prNumber = Number(existing);\n    execOrThrow(dependencies, 'gh', ['pr', 'edit', existing, '--title', plan.title, '--body', body]);\n    execOrThrow(dependencies, 'gh', isFailed ? ['pr', 'ready', existing, '--undo'] : ['pr', 'ready', existing]);\n    dependencies.log(`${entry.name}: updated PR #${existing}${isFailed ? ' (draft: a step failed)' : ''}.`);\n    return { name: entry.name, outcome: 'updated', prNumber };\n  }\n\n  const url = execOrThrow(dependencies, 'gh', [\n    'pr',\n    'create',\n    '--base',\n    options.baseBranch,\n    '--head',\n    plan.branch,\n    '--title',\n    plan.title,\n    '--body',\n    body,\n    ...(isFailed ? ['--draft'] : [])\n  ]).trim();\n  dependencies.log(`${entry.name}: opened ${url}${isFailed ? ' (draft: a step failed)' : ''}.`);\n  const prNumber = Number(/\\/pull\\/(?<Number>\\d+)/.exec(url)?.groups?.['Number'] ?? NaN);\n  return Number.isNaN(prNumber) ? { name: entry.name, outcome: 'opened' } : { name: entry.name, outcome: 'opened', prNumber };\n}\n\nfunction describeStep(heading: string, step: StepResult): string[] {\n  const isPassed = step.result.exitCode === 0;\n  const tail = step.result.output.trimEnd().split(/\\r?\\n/).slice(-OUTPUT_TAIL_LINES).join('\\n');\n  return [\n    `### ${heading}`,\n    '',\n    `\\`${step.command}\\`: ${isPassed ? 'passed' : `**FAILED** (exit ${String(step.result.exitCode)})`}.`,\n    '',\n    isPassed ? '<details><summary>Output</summary>' : '<details open><summary>Output</summary>',\n    '',\n    '```text',\n    tail,\n    '```',\n    '',\n    '</details>',\n    ''\n  ];\n}\n\nfunction execOrThrow(dependencies: SyncDependencies, file: string, arguments_: readonly string[]): string {\n  const result = dependencies.exec(file, arguments_);\n  if (result.exitCode !== 0) {\n    throw new Error(`${file} ${arguments_.join(' ')} failed (exit ${String(result.exitCode)}): ${result.output.trim()}`);\n  }\n  return result.output;\n}\n\nfunction isGitUpstream(entry: UpstreamEntry): entry is GitUpstreamEntry {\n  return 'repo' in entry;\n}\n\nfunction shorten(head: string): string {\n  return /^[0-9a-f]{40}$/.test(head) ? head.slice(0, SHORT_SHA_LENGTH) : head;\n}\n\nasync function syncEntry(entry: UpstreamEntry, config: UpstreamsConfig, options: SyncUpstreamsOptions, dependencies: SyncDependencies): Promise<SyncResult> {\n  const status = await compareWithUpstream(entry, dependencies);\n  if (status.state === 'current') {\n    dependencies.log(`${entry.name}: current at ${shorten(status.head)}.`);\n    return { name: entry.name, outcome: 'current' };\n  }\n  if (status.state === 'unwatched') {\n    dependencies.log(`${entry.name}: moved to ${shorten(status.head)}, but no watched path changed since ${shorten(status.pin)}.`);\n    return { name: entry.name, outcome: 'unwatched' };\n  }\n\n  const plan = planSync(status);\n  if (options.dryRun) {\n    dependencies.log(`${entry.name}: moved from ${shorten(status.pin)} to ${shorten(status.head)}. Would push ${plan.branch} and open:`);\n    dependencies.log(`  title: ${plan.title}`);\n    dependencies.log(buildPrBody(plan, null, null).replaceAll(/^/gm, '  | '));\n    return { name: entry.name, outcome: 'planned' };\n  }\n\n  // The update commit takes every file in the tree, so a file left lying around would be pushed with it.\n  const dirty = execOrThrow(dependencies, 'git', ['status', '--porcelain']).trim();\n  if (dirty !== '') {\n    throw new Error(`the working tree is not clean, and the update commit would take these files with it:\\n${dirty}`);\n  }\n  execOrThrow(dependencies, 'git', ['fetch', 'origin', options.baseBranch]);\n  execOrThrow(dependencies, 'git', ['checkout', '-B', plan.branch, `origin/${options.baseBranch}`]);\n  try {\n    return applyPlan(plan, config, options, dependencies);\n  } finally {\n    dependencies.exec('git', ['checkout', '--force', options.baseBranch]);\n    dependencies.exec('git', ['branch', '--delete', '--force', plan.branch]);\n  }\n}\n"],
  "mappings": ";;;;;AASA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,mBAAmB;AA2N5B,MAAM,qBAAqB;AAE3B,MAAM,mBAAmB;AAKzB,MAAM,oBAAoB;AAE1B,MAAM,qBAAqB;AAUpB,SAAS,YAAY,MAAgB,OAA2B,UAAiC;AACtG,QAAM,EAAE,OAAO,MAAM,IAAI,IAAI,KAAK;AAClC,QAAM,SAAS,cAAc,KAAK,IAAI,KAAK,MAAM,IAAI,IAAI,MAAM,GAAG,OAAO,SAAS,MAAM,GAAG,IAAI,MAAM,OAAO,QAAQ;AACpH,QAAM,QAAQ;AAAA,IACZ,cAAc,MAAM,IAAI,aAAa,MAAM,WAAW,GAAG,WAAW,IAAI;AAAA,IACxE;AAAA,IACA,YAAY,KAAK,OAAO,UAAU;AAAA,IAClC;AAAA,EACF;AAEA,MAAI,cAAc,KAAK,GAAG;AACxB,UAAM,KAAK,8BAA8B,IAAI,GAAG,KAAK,OAAO,aAAa,IAAI,CAAC,SAAS,OAAO,IAAI,IAAI,CAAC;AACvG,QAAI,KAAK,OAAO,WAAW;AACzB,YAAM,KAAK,0BAA0B,OAAO,kBAAkB,CAAC,6CAA6C;AAAA,IAC9G;AACA,UAAM,KAAK,EAAE;AAAA,EACf;AAEA,MAAI,UAAU,MAAM;AAClB,UAAM,KAAK,eAAe,IAAI,KAAK,MAAM,OAAO,0BAA0B,EAAE;AAAA,EAC9E,OAAO;AACL,UAAM,KAAK,GAAG,aAAa,WAAW,MAAM,OAAO,CAAC;AACpD,QAAI,MAAM,WAAW,MAAM;AACzB,YAAM,KAAK,GAAG,aAAa,UAAU,MAAM,MAAM,CAAC;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,aAAa,MAAM;AACrB,UAAM,KAAK,yBAAyB,IAAI,WAAW,SAAS,QAAQ,GAAG,OAAO,EAAE;AAAA,EAClF;AAEA,QAAM,KAAK,gFAAgF;AAC3F,SAAO,GAAG,MAAM,KAAK,IAAI,CAAC;AAAA;AAC5B;AASA,eAAsB,oBAAoB,OAAsB,cAA4E;AAC1I,MAAI,CAAC,cAAc,KAAK,GAAG;AACzB,UAAM,MAAM,MAAM,OAAO;AACzB,UAAM,YAAY,MAAM,aAAa,UAAU,8BAA8B,MAAM,IAAI,QAAQ,KAAK,KAAK,CAAC,EAAE;AAC5G,UAAMA,QAAO,UAAU,WAAW,EAAE,GAAG;AACvC,QAAIA,UAAS,QAAW;AACtB,YAAM,IAAI,MAAM,eAAe,MAAM,GAAG,qBAAqB,GAAG,IAAI;AAAA,IACtE;AACA,WAAO;AAAA,MACL,cAAc,CAAC;AAAA,MACf,YAAY,iCAAiC,MAAM,GAAG,MAAMA,KAAI;AAAA,MAChE;AAAA,MACA,MAAAA;AAAA,MACA,KAAK,MAAM;AAAA,MACX,OAAOA,UAAS,MAAM,UAAU,YAAY;AAAA,MAC5C,WAAW;AAAA,IACb;AAAA,EACF;AAEA,QAAM,SAAS,MAAM,aAAa,UAAU,gCAAgC,MAAM,IAAI,YAAY,mBAAmB,MAAM,GAAG,CAAC,EAAE;AACjI,QAAM,OAAO,OAAO;AACpB,QAAM,aAAa,sBAAsB,MAAM,IAAI,YAAY,MAAM,MAAM,MAAM,IAAI;AACrF,MAAI,SAAS,MAAM,QAAQ;AACzB,WAAO,EAAE,cAAc,CAAC,GAAG,YAAY,OAAO,MAAM,KAAK,MAAM,QAAQ,OAAO,WAAW,WAAW,MAAM;AAAA,EAC5G;AAEA,QAAM,UAAU,MAAM,aAAa,UAAU,gCAAgC,MAAM,IAAI,YAAY,MAAM,MAAM,MAAM,IAAI,EAAE;AAC3H,QAAM,QAAQ,QAAQ,SAAS,CAAC;AAChC,QAAM,UAAU,IAAI,IAAI,MAAM,QAAQ,CAAC,SAAS,KAAK,sBAAsB,SAAY,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,UAAU,KAAK,iBAAiB,CAAC,CAAC;AACjJ,QAAM,eAAe,CAAC,GAAG,OAAO,EAAE,OAAO,CAAC,SAAS,MAAM,MAAM,KAAK,CAAC,SAAS,YAAY,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK;AAC7G,QAAM,cAAc,MAAM,UAAU;AACpC,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,KAAK,MAAM;AAAA,IACX,OAAO,aAAa,SAAS,KAAK,cAAc,UAAU;AAAA,IAC1D,WAAW;AAAA,EACb;AACF;AAQO,SAAS,qBAAqB,MAA+B;AAClE,QAAM,SAAS,KAAK,MAAM,IAAI;AAC9B,MAAI,CAAC,MAAM,QAAQ,OAAO,SAAS,GAAG;AACpC,UAAM,IAAI,UAAU,0CAA0C;AAAA,EAChE;AAEA,QAAM,UAA6B,OAAO;AAC1C,QAAM,QAAQ,oBAAI,IAAa;AAC/B,aAAW,SAAS,SAAS;AAC3B,UAAM,OAAgB,QAAQ,IAAI,OAAO,MAAM;AAC/C,UAAM,QAAQ,OAAO,SAAS,WAAW,IAAI,IAAI,MAAM;AACvD,UAAM,QAAQ,UAAU;AACxB,UAAM,WAAW,QAAQ,CAAC,QAAQ,QAAQ,OAAO,UAAU,SAAS,IAAI,CAAC,QAAQ,OAAO,WAAW,SAAS;AAC5G,eAAW,OAAO,UAAU;AAC1B,UAAI,OAAO,QAAQ,IAAI,OAAO,GAAG,MAAM,UAAU;AAC/C,cAAM,IAAI,UAAU,yBAAyB,KAAK,oBAAoB,GAAG,IAAI;AAAA,MAC/E;AAAA,IACF;AACA,QAAI,SAAS,CAAC,MAAM,QAAQ,QAAQ,IAAI,OAAO,OAAO,CAAC,GAAG;AACxD,YAAM,IAAI,MAAM,yBAAyB,KAAK,yBAAyB;AAAA,IACzE;AACA,QAAI,MAAM,IAAI,IAAI,GAAG;AACnB,YAAM,IAAI,MAAM,4BAA4B,KAAK,iBAAiB;AAAA,IACpE;AACA,UAAM,IAAI,IAAI;AAAA,EAChB;AACA,SAAO;AACT;AAQO,SAAS,SAAS,QAAkC;AACzD,SAAO;AAAA,IACL,QAAQ,YAAY,OAAO,MAAM,IAAI;AAAA,IACrC;AAAA,IACA,OAAO,yBAAyB,OAAO,MAAM,IAAI,OAAO,QAAQ,OAAO,IAAI,CAAC;AAAA,EAC9E;AACF;AAaA,eAAsB,cAAc,SAA+B,cAAuD;AACxH,QAAM,SAAS,qBAAqB,aAAa,QAAQ,YAAY,OAAO,CAAC;AAC7E,QAAM,UAAU,QAAQ,KAAK,OAAO,CAAC,SAAS,OAAO,UAAU,MAAM,CAAC,UAAU,MAAM,SAAS,IAAI,CAAC;AACpG,MAAI,QAAQ,SAAS,GAAG;AACtB,UAAM,IAAI,MAAM,qCAAqC,QAAQ,IAAI,CAAC,SAAS,IAAI,IAAI,GAAG,EAAE,KAAK,IAAI,CAAC,GAAG;AAAA,EACvG;AAEA,QAAM,UAAwB,CAAC;AAC/B,aAAW,SAAS,OAAO,WAAW;AACpC,QAAI,QAAQ,KAAK,SAAS,KAAK,CAAC,QAAQ,KAAK,SAAS,MAAM,IAAI,GAAG;AACjE;AAAA,IACF;AACA,QAAI;AACF,cAAQ,KAAK,MAAM,UAAU,OAAO,QAAQ,SAAS,YAAY,CAAC;AAAA,IACpE,SAAS,OAAO;AACd,YAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,mBAAa,IAAI,GAAG,MAAM,IAAI,WAAW,OAAO,EAAE;AAClD,cAAQ,KAAK,EAAE,OAAO,SAAS,MAAM,MAAM,MAAM,SAAS,QAAQ,CAAC;AAAA,IACrE;AAAA,EACF;AACA,SAAO;AACT;AASO,SAAS,SAAS,YAAoB,QAA8B;AACzE,QAAM,OAAO,aAAa,YAAY,OAAO;AAC7C,QAAM,SAAS,KAAK,MAAM,IAAI;AAC9B,QAAM,MAAM,cAAc,OAAO,KAAK,IAAI,WAAW;AACrD,QAAM,SAAS,OAAO,UAAU,KAAK,CAAC,UAAU,MAAM,MAAM,MAAM,OAAO,MAAM,IAAI;AACnF,MAAI,SAAS,GAAG,MAAM,OAAO,KAAK;AAChC;AAAA,EACF;AACA,SAAO,GAAG,IAAI,OAAO;AACrB,gBAAc,YAAY,GAAG,KAAK,UAAU,QAAQ,MAAM,kBAAkB,CAAC;AAAA,CAAI;AACnF;AAEA,SAAS,UAAU,MAAgB,QAAyB,SAA+B,cAA4C;AACrI,QAAM,EAAE,MAAM,IAAI,KAAK;AACvB,QAAM,MAAM,EAAE,eAAe,MAAM,MAAM,iBAAiB,KAAK,OAAO,KAAK;AAC3E,QAAM,UAAsB,EAAE,SAAS,MAAM,SAAS,QAAQ,aAAa,MAAM,MAAM,SAAS,GAAG,EAAE;AACrG,WAAS,QAAQ,YAAY,KAAK,MAAM;AACxC,QAAM,gBAAgB,MAAM,UAAU,OAAO;AAC7C,QAAM,SAA4B,kBAAkB,SAAY,OAAO,EAAE,SAAS,eAAe,QAAQ,aAAa,MAAM,eAAe,GAAG,EAAE;AAChJ,QAAM,WAAW,QAAQ,OAAO,aAAa,KAAM,WAAW,QAAQ,OAAO,OAAO,aAAa;AAEjG,cAAY,cAAc,OAAO,CAAC,OAAO,OAAO,CAAC;AACjD,cAAY,cAAc,OAAO,CAAC,UAAU,eAAe,aAAa,KAAK,KAAK,CAAC;AACnF,QAAM,WAAW,YAAY,cAAc,OAAO,CAAC,QAAQ,UAAU,UAAU,MAAM,CAAC;AAEtF,QAAM,iBAAiB,aAAa,KAAK,OAAO,CAAC,aAAa,eAAe,WAAW,UAAU,KAAK,MAAM,CAAC,EAAE,aAAa;AAC7H,MAAI,gBAAgB;AAClB,gBAAY,cAAc,OAAO,CAAC,SAAS,UAAU,KAAK,MAAM,CAAC;AACjE,QAAI,aAAa,KAAK,OAAO,CAAC,QAAQ,WAAW,cAAc,MAAM,CAAC,EAAE,aAAa,GAAG;AACtF,mBAAa,IAAI,GAAG,MAAM,IAAI,KAAK,KAAK,MAAM,6CAA6C;AAC3F,aAAO,EAAE,MAAM,MAAM,MAAM,SAAS,YAAY;AAAA,IAClD;AAAA,EACF;AACA,cAAY,cAAc,OAAO,CAAC,QAAQ,WAAW,UAAU,mBAAmB,KAAK,MAAM,EAAE,CAAC;AAEhG,QAAM,OAAO,YAAY,MAAM,EAAE,SAAS,OAAO,GAAG,QAAQ;AAC5D,QAAM,WAAW,YAAY,cAAc,MAAM,CAAC,MAAM,QAAQ,UAAU,KAAK,QAAQ,WAAW,QAAQ,UAAU,UAAU,QAAQ,aAAa,CAAC,EAAE,KAAK;AAC3J,MAAI,aAAa,MAAM,aAAa,QAAQ;AAC1C,UAAMC,YAAW,OAAO,QAAQ;AAChC,gBAAY,cAAc,MAAM,CAAC,MAAM,QAAQ,UAAU,WAAW,KAAK,OAAO,UAAU,IAAI,CAAC;AAC/F,gBAAY,cAAc,MAAM,WAAW,CAAC,MAAM,SAAS,UAAU,QAAQ,IAAI,CAAC,MAAM,SAAS,QAAQ,CAAC;AAC1G,iBAAa,IAAI,GAAG,MAAM,IAAI,iBAAiB,QAAQ,GAAG,WAAW,4BAA4B,EAAE,GAAG;AACtG,WAAO,EAAE,MAAM,MAAM,MAAM,SAAS,WAAW,UAAAA,UAAS;AAAA,EAC1D;AAEA,QAAM,MAAM,YAAY,cAAc,MAAM;AAAA,IAC1C;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,IACR;AAAA,IACA,KAAK;AAAA,IACL;AAAA,IACA,KAAK;AAAA,IACL;AAAA,IACA;AAAA,IACA,GAAI,WAAW,CAAC,SAAS,IAAI,CAAC;AAAA,EAChC,CAAC,EAAE,KAAK;AACR,eAAa,IAAI,GAAG,MAAM,IAAI,YAAY,GAAG,GAAG,WAAW,4BAA4B,EAAE,GAAG;AAC5F,QAAM,WAAW,OAAO,yBAAyB,KAAK,GAAG,GAAG,SAAS,QAAQ,KAAK,GAAG;AACrF,SAAO,OAAO,MAAM,QAAQ,IAAI,EAAE,MAAM,MAAM,MAAM,SAAS,SAAS,IAAI,EAAE,MAAM,MAAM,MAAM,SAAS,UAAU,SAAS;AAC5H;AAEA,SAAS,aAAa,SAAiB,MAA4B;AACjE,QAAM,WAAW,KAAK,OAAO,aAAa;AAC1C,QAAM,OAAO,KAAK,OAAO,OAAO,QAAQ,EAAE,MAAM,OAAO,EAAE,MAAM,CAAC,iBAAiB,EAAE,KAAK,IAAI;AAC5F,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd;AAAA,IACA,KAAK,KAAK,OAAO,OAAO,WAAW,WAAW,oBAAoB,OAAO,KAAK,OAAO,QAAQ,CAAC,GAAG;AAAA,IACjG;AAAA,IACA,WAAW,uCAAuC;AAAA,IAClD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,YAAY,cAAgC,MAAc,YAAuC;AACxG,QAAM,SAAS,aAAa,KAAK,MAAM,UAAU;AACjD,MAAI,OAAO,aAAa,GAAG;AACzB,UAAM,IAAI,MAAM,GAAG,IAAI,IAAI,WAAW,KAAK,GAAG,CAAC,iBAAiB,OAAO,OAAO,QAAQ,CAAC,MAAM,OAAO,OAAO,KAAK,CAAC,EAAE;AAAA,EACrH;AACA,SAAO,OAAO;AAChB;AAEA,SAAS,cAAc,OAAiD;AACtE,SAAO,UAAU;AACnB;AAEA,SAAS,QAAQ,MAAsB;AACrC,SAAO,iBAAiB,KAAK,IAAI,IAAI,KAAK,MAAM,GAAG,gBAAgB,IAAI;AACzE;AAEA,eAAe,UAAU,OAAsB,QAAyB,SAA+B,cAAqD;AAC1J,QAAM,SAAS,MAAM,oBAAoB,OAAO,YAAY;AAC5D,MAAI,OAAO,UAAU,WAAW;AAC9B,iBAAa,IAAI,GAAG,MAAM,IAAI,gBAAgB,QAAQ,OAAO,IAAI,CAAC,GAAG;AACrE,WAAO,EAAE,MAAM,MAAM,MAAM,SAAS,UAAU;AAAA,EAChD;AACA,MAAI,OAAO,UAAU,aAAa;AAChC,iBAAa,IAAI,GAAG,MAAM,IAAI,cAAc,QAAQ,OAAO,IAAI,CAAC,uCAAuC,QAAQ,OAAO,GAAG,CAAC,GAAG;AAC7H,WAAO,EAAE,MAAM,MAAM,MAAM,SAAS,YAAY;AAAA,EAClD;AAEA,QAAM,OAAO,SAAS,MAAM;AAC5B,MAAI,QAAQ,QAAQ;AAClB,iBAAa,IAAI,GAAG,MAAM,IAAI,gBAAgB,QAAQ,OAAO,GAAG,CAAC,OAAO,QAAQ,OAAO,IAAI,CAAC,gBAAgB,KAAK,MAAM,YAAY;AACnI,iBAAa,IAAI,YAAY,KAAK,KAAK,EAAE;AACzC,iBAAa,IAAI,YAAY,MAAM,MAAM,IAAI,EAAE,WAAW,OAAO,MAAM,CAAC;AACxE,WAAO,EAAE,MAAM,MAAM,MAAM,SAAS,UAAU;AAAA,EAChD;AAGA,QAAM,QAAQ,YAAY,cAAc,OAAO,CAAC,UAAU,aAAa,CAAC,EAAE,KAAK;AAC/E,MAAI,UAAU,IAAI;AAChB,UAAM,IAAI,MAAM;AAAA,EAAyF,KAAK,EAAE;AAAA,EAClH;AACA,cAAY,cAAc,OAAO,CAAC,SAAS,UAAU,QAAQ,UAAU,CAAC;AACxE,cAAY,cAAc,OAAO,CAAC,YAAY,MAAM,KAAK,QAAQ,UAAU,QAAQ,UAAU,EAAE,CAAC;AAChG,MAAI;AACF,WAAO,UAAU,MAAM,QAAQ,SAAS,YAAY;AAAA,EACtD,UAAE;AACA,iBAAa,KAAK,OAAO,CAAC,YAAY,WAAW,QAAQ,UAAU,CAAC;AACpE,iBAAa,KAAK,OAAO,CAAC,UAAU,YAAY,WAAW,KAAK,MAAM,CAAC;AAAA,EACzE;AACF;",
  "names": ["head", "prNumber"]
}


package/dist/lib/esm/validate-dependencies.d.mts

@@ -0,0 +1,36 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * Fails the build when the published output imports a package that `package.json` does not install for a consumer.
+ *
+ * Every bare specifier in the scanned folders (`dist/lib` and `bin` by default, code and declarations, ESM and
+ * CommonJS) must name a package in `dependencies`, `optionalDependencies` or `peerDependencies`, the package itself,
+ * or a Node builtin; a declaration file's import may also be served by the package's `@types` one. A package in
+ * `devDependencies` only is present in the package's own repository and absent from a
+ * consumer's install, so nothing there fails, and the consumer gets `Cannot find module`.
+ */
+/**
+ * The folders {@link validateDependencies} scans when none are given.
+ */
+export declare const DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS: readonly string[];
+/**
+ * Options for {@link validateDependencies}.
+ */
+export interface ValidateDependenciesOptions {
+    /**
+     * The folders to scan, relative to the current working folder. A folder that does not exist is skipped.
+     *
+     * @default {@link DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS}
+     */
+    readonly folders?: readonly string[];
+}
+/**
+ * Checks that every bare import in the published output names a package a consumer installs.
+ *
+ * @param options - The options controlling which folders are scanned.
+ * @returns A {@link Promise} that resolves when every import is declared.
+ * @throws If any import names a package that is not in `dependencies`, `optionalDependencies` or `peerDependencies`,
+ * the package itself, or a Node builtin. The error lists each offending file and specifier.
+ */
+export declare function validateDependencies(options?: ValidateDependenciesOptions): Promise<void>;

package/dist/lib/esm/validate-dependencies.mjs

@@ -0,0 +1,118 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { existsSync } from "node:fs";
+import {
+  readdir,
+  readFile
+} from "node:fs/promises";
+import { isBuiltin } from "node:module";
+import {
+  join,
+  relative
+} from "node:path";
+import process from "node:process";
+import { preProcessFile } from "typescript";
+import { readPackageJson } from "./npm.mjs";
+import { RepoPaths } from "./repo-paths.mjs";
+const DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS = [RepoPaths.DistLib, "bin"];
+const DECLARATION_FILE_PATTERN = /\.d\.(?:cts|mts|ts)$/u;
+const SCANNED_FILE_PATTERN = /\.(?:cjs|cts|js|mjs|mts|ts)$/u;
+const TYPES_SCOPE = "@types/";
+const SCOPED_PACKAGE_NAME_SEGMENT_COUNT = 2;
+async function validateDependencies(options = {}) {
+  const root = process.cwd();
+  const packageJson = await readPackageJson(root);
+  const installedPackageNames = /* @__PURE__ */ new Set([
+    ...Object.keys(packageJson.dependencies ?? {}),
+    ...Object.keys(packageJson.optionalDependencies ?? {}),
+    ...Object.keys(packageJson.peerDependencies ?? {})
+  ]);
+  if (packageJson.name) {
+    installedPackageNames.add(packageJson.name);
+  }
+  const undeclaredImports = [];
+  for (const folder of options.folders ?? DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS) {
+    for (const filePath of await getFilePaths(join(root, folder))) {
+      const isDeclarationFile = DECLARATION_FILE_PATTERN.test(filePath);
+      for (const specifier of getImportSpecifiers(await readFile(filePath, "utf-8"))) {
+        const packageName = getPackageName(specifier);
+        if (packageName === null || installedPackageNames.has(packageName)) {
+          continue;
+        }
+        if (isDeclarationFile && installedPackageNames.has(getTypesPackageName(packageName))) {
+          continue;
+        }
+        undeclaredImports.push(`${relative(root, filePath).replaceAll("\\", "/")}: ${specifier}`);
+      }
+    }
+  }
+  if (undeclaredImports.length > 0) {
+    throw new Error(
+      `The published output imports packages that are not in dependencies, optionalDependencies or peerDependencies:
+${undeclaredImports.join("\n")}`
+    );
+  }
+}
+async function getFilePaths(folder) {
+  if (!existsSync(folder)) {
+    return [];
+  }
+  const entries = await readdir(folder, { recursive: true, withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && SCANNED_FILE_PATTERN.test(entry.name)).map((entry) => join(entry.parentPath, entry.name)).sort();
+}
+function getImportSpecifiers(sourceText) {
+  const { importedFiles } = preProcessFile(sourceText, true, true);
+  return importedFiles.map((importedFile) => importedFile.fileName);
+}
+function getPackageName(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || isBuiltin(specifier)) {
+    return null;
+  }
+  const segments = specifier.split("/");
+  const segmentCount = specifier.startsWith("@") ? SCOPED_PACKAGE_NAME_SEGMENT_COUNT : 1;
+  return segments.slice(0, segmentCount).join("/");
+}
+function getTypesPackageName(packageName) {
+  return TYPES_SCOPE + packageName.replace(/^@/u, "").replace("/", "__");
+}
+export {
+  DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS,
+  validateDependencies
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/validate-dependencies.ts"],"sourcesContent":["/**\n * @file\n *\n * Fails the build when the published output imports a package that `package.json` does not install for a consumer.\n *\n * Every bare specifier in the scanned folders (`dist/lib` and `bin` by default, code and declarations, ESM and\n * CommonJS) must name a package in `dependencies`, `optionalDependencies` or `peerDependencies`, the package itself,\n * or a Node builtin; a declaration file's import may also be served by the package's `@types` one. A package in\n * `devDependencies` only is present in the package's own repository and absent from a\n * consumer's install, so nothing there fails, and the consumer gets `Cannot find module`.\n */\n\nimport { existsSync } from 'node:fs';\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport { isBuiltin } from 'node:module';\nimport {\n  join,\n  relative\n} from 'node:path';\nimport process from 'node:process';\nimport { preProcessFile } from 'typescript';\n\nimport { readPackageJson } from './npm.ts';\nimport { RepoPaths } from './repo-paths.ts';\n\n/**\n * The folders {@link validateDependencies} scans when none are given.\n */\nexport const DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS: readonly string[] = [RepoPaths.DistLib, 'bin'];\n\nconst DECLARATION_FILE_PATTERN = /\\.d\\.(?:cts|mts|ts)$/u;\nconst SCANNED_FILE_PATTERN = /\\.(?:cjs|cts|js|mjs|mts|ts)$/u;\nconst TYPES_SCOPE = '@types/';\nconst SCOPED_PACKAGE_NAME_SEGMENT_COUNT = 2;\n\n/**\n * Options for {@link validateDependencies}.\n */\nexport interface ValidateDependenciesOptions {\n  /**\n   * The folders to scan, relative to the current working folder. A folder that does not exist is skipped.\n   *\n   * @default {@link DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS}\n   */\n  readonly folders?: readonly string[];\n}\n\n/**\n * Checks that every bare import in the published output names a package a consumer installs.\n *\n * @param options - The options controlling which folders are scanned.\n * @returns A {@link Promise} that resolves when every import is declared.\n * @throws If any import names a package that is not in `dependencies`, `optionalDependencies` or `peerDependencies`,\n * the package itself, or a Node builtin. The error lists each offending file and specifier.\n */\nexport async function validateDependencies(options: ValidateDependenciesOptions = {}): Promise<void> {\n  const root = process.cwd();\n  const packageJson = await readPackageJson(root);\n  const installedPackageNames = new Set([\n    ...Object.keys(packageJson.dependencies ?? {}),\n    ...Object.keys(packageJson.optionalDependencies ?? {}),\n    ...Object.keys(packageJson.peerDependencies ?? {})\n  ]);\n  if (packageJson.name) {\n    installedPackageNames.add(packageJson.name);\n  }\n\n  const undeclaredImports: string[] = [];\n  for (const folder of options.folders ?? DEFAULT_VALIDATE_DEPENDENCIES_FOLDERS) {\n    for (const filePath of await getFilePaths(join(root, folder))) {\n      const isDeclarationFile = DECLARATION_FILE_PATTERN.test(filePath);\n      for (const specifier of getImportSpecifiers(await readFile(filePath, 'utf-8'))) {\n        const packageName = getPackageName(specifier);\n        if (packageName === null || installedPackageNames.has(packageName)) {\n          continue;\n        }\n        if (isDeclarationFile && installedPackageNames.has(getTypesPackageName(packageName))) {\n          continue;\n        }\n        undeclaredImports.push(`${relative(root, filePath).replaceAll('\\\\', '/')}: ${specifier}`);\n      }\n    }\n  }\n\n  if (undeclaredImports.length > 0) {\n    throw new Error(\n      `The published output imports packages that are not in dependencies, optionalDependencies or peerDependencies:\\n${undeclaredImports.join('\\n')}`\n    );\n  }\n}\n\n/**\n * Lists the scanned files under a folder, recursively.\n *\n * @param folder - The absolute folder path.\n * @returns The absolute paths of the scanned files, or none when the folder does not exist.\n */\nasync function getFilePaths(folder: string): Promise<string[]> {\n  if (!existsSync(folder)) {\n    return [];\n  }\n\n  const entries = await readdir(folder, { recursive: true, withFileTypes: true });\n  return entries\n    .filter((entry) => entry.isFile() && SCANNED_FILE_PATTERN.test(entry.name))\n    .map((entry) => join(entry.parentPath, entry.name))\n    .sort();\n}\n\n/**\n * Collects the module specifiers a source file imports, requires or references, ignoring strings and comments.\n *\n * @param sourceText - The source text.\n * @returns The module specifiers.\n */\nfunction getImportSpecifiers(sourceText: string): string[] {\n  const { importedFiles } = preProcessFile(sourceText, true, true);\n  return importedFiles.map((importedFile) => importedFile.fileName);\n}\n\n/**\n * Gets the package a bare specifier names.\n *\n * @param specifier - The module specifier.\n * @returns The package name, or `null` for a relative or absolute path or a Node builtin.\n */\nfunction getPackageName(specifier: string): null | string {\n  if (specifier.startsWith('.') || specifier.startsWith('/') || isBuiltin(specifier)) {\n    return null;\n  }\n\n  const segments = specifier.split('/');\n  const segmentCount = specifier.startsWith('@') ? SCOPED_PACKAGE_NAME_SEGMENT_COUNT : 1;\n  return segments.slice(0, segmentCount).join('/');\n}\n\n/**\n * Gets the DefinitelyTyped package that declares a package's types, which is what a declaration file's import of\n * that package resolves to when the package ships no types of its own (`estree` → `@types/estree`,\n * `@scope/name` → `@types/scope__name`).\n *\n * @param packageName - The package name.\n * @returns The `@types` package name.\n */\nfunction getTypesPackageName(packageName: string): string {\n  return TYPES_SCOPE + packageName.replace(/^@/u, '').replace('/', '__');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,OAAO,aAAa;AACpB,SAAS,sBAAsB;AAE/B,SAAS,uBAAuB;AAChC,SAAS,iBAAiB;AAKnB,MAAM,wCAA2D,CAAC,UAAU,SAAS,KAAK;AAEjG,MAAM,2BAA2B;AACjC,MAAM,uBAAuB;AAC7B,MAAM,cAAc;AACpB,MAAM,oCAAoC;AAsB1C,eAAsB,qBAAqB,UAAuC,CAAC,GAAkB;AACnG,QAAM,OAAO,QAAQ,IAAI;AACzB,QAAM,cAAc,MAAM,gBAAgB,IAAI;AAC9C,QAAM,wBAAwB,oBAAI,IAAI;AAAA,IACpC,GAAG,OAAO,KAAK,YAAY,gBAAgB,CAAC,CAAC;AAAA,IAC7C,GAAG,OAAO,KAAK,YAAY,wBAAwB,CAAC,CAAC;AAAA,IACrD,GAAG,OAAO,KAAK,YAAY,oBAAoB,CAAC,CAAC;AAAA,EACnD,CAAC;AACD,MAAI,YAAY,MAAM;AACpB,0BAAsB,IAAI,YAAY,IAAI;AAAA,EAC5C;AAEA,QAAM,oBAA8B,CAAC;AACrC,aAAW,UAAU,QAAQ,WAAW,uCAAuC;AAC7E,eAAW,YAAY,MAAM,aAAa,KAAK,MAAM,MAAM,CAAC,GAAG;AAC7D,YAAM,oBAAoB,yBAAyB,KAAK,QAAQ;AAChE,iBAAW,aAAa,oBAAoB,MAAM,SAAS,UAAU,OAAO,CAAC,GAAG;AAC9E,cAAM,cAAc,eAAe,SAAS;AAC5C,YAAI,gBAAgB,QAAQ,sBAAsB,IAAI,WAAW,GAAG;AAClE;AAAA,QACF;AACA,YAAI,qBAAqB,sBAAsB,IAAI,oBAAoB,WAAW,CAAC,GAAG;AACpF;AAAA,QACF;AACA,0BAAkB,KAAK,GAAG,SAAS,MAAM,QAAQ,EAAE,WAAW,MAAM,GAAG,CAAC,KAAK,SAAS,EAAE;AAAA,MAC1F;AAAA,IACF;AAAA,EACF;AAEA,MAAI,kBAAkB,SAAS,GAAG;AAChC,UAAM,IAAI;AAAA,MACR;AAAA,EAAkH,kBAAkB,KAAK,IAAI,CAAC;AAAA,IAChJ;AAAA,EACF;AACF;AAQA,eAAe,aAAa,QAAmC;AAC7D,MAAI,CAAC,WAAW,MAAM,GAAG;AACvB,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,UAAU,MAAM,QAAQ,QAAQ,EAAE,WAAW,MAAM,eAAe,KAAK,CAAC;AAC9E,SAAO,QACJ,OAAO,CAAC,UAAU,MAAM,OAAO,KAAK,qBAAqB,KAAK,MAAM,IAAI,CAAC,EACzE,IAAI,CAAC,UAAU,KAAK,MAAM,YAAY,MAAM,IAAI,CAAC,EACjD,KAAK;AACV;AAQA,SAAS,oBAAoB,YAA8B;AACzD,QAAM,EAAE,cAAc,IAAI,eAAe,YAAY,MAAM,IAAI;AAC/D,SAAO,cAAc,IAAI,CAAC,iBAAiB,aAAa,QAAQ;AAClE;AAQA,SAAS,eAAe,WAAkC;AACxD,MAAI,UAAU,WAAW,GAAG,KAAK,UAAU,WAAW,GAAG,KAAK,UAAU,SAAS,GAAG;AAClF,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,UAAU,MAAM,GAAG;AACpC,QAAM,eAAe,UAAU,WAAW,GAAG,IAAI,oCAAoC;AACrF,SAAO,SAAS,MAAM,GAAG,YAAY,EAAE,KAAK,GAAG;AACjD;AAUA,SAAS,oBAAoB,aAA6B;AACxD,SAAO,cAAc,YAAY,QAAQ,OAAO,EAAE,EAAE,QAAQ,KAAK,IAAI;AACvE;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/typescript-dev-toolkit",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Generic TypeScript project tooling: build, lint, format, spellcheck, test, gate and release scripts.",
   "keywords": [
     "typescript",
@@ -19,6 +19,9 @@
   "license": "MIT",
   "author": "Michael Naumov",
   "type": "module",
+  "bin": {
+    "sync-upstreams": "bin/sync-upstreams.mjs"
+  },
   "exports": {
     ".": {
       "import": {
@@ -240,6 +243,7 @@
   "files": [
     "**/package.json",
     "assets/",
+    "bin/",
     "dist/",
     "!dist/*.tgz",
     "README.md",
@@ -255,6 +259,7 @@
     "build:lib": "jiti scripts/build-lib.ts",
     "build:types": "jiti scripts/build-types.ts",
     "build:validate-declarations": "jiti scripts/build-validate-declarations.ts",
+    "build:validate-dependencies": "jiti scripts/build-validate-dependencies.ts",
     "commit": "jiti scripts/commit.ts",
     "docs:build": "jiti scripts/docs-build.ts",
     "docs:dev": "jiti scripts/docs-dev.ts",
@@ -286,6 +291,7 @@
     "@mnaoumov/typescript-lib": "^1.0.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@tsconfig/strictest": "^2.0.8",
+    "@types/estree": "^1.0.9",
     "@types/node": "^26.6.2",
     "@types/semver": "^7.8.0",
     "@typescript-eslint/rule-tester": "^8.71.2",