@mnaoumov/typescript-dev-toolkit 3.1.0 → 3.3.0

package/dist/lib/cjs/upstream-sync-cli.cjs

@@ -0,0 +1,113 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upstream_sync_cli_exports = {};
+__export(upstream_sync_cli_exports, {
+  createNodeSyncDependencies: () => createNodeSyncDependencies,
+  parseSyncUpstreamsArguments: () => parseSyncUpstreamsArguments,
+  runSyncUpstreamsCli: () => runSyncUpstreamsCli
+});
+module.exports = __toCommonJS(upstream_sync_cli_exports);
+var import_node_child_process = require('node:child_process');
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+var import_upstream_sync = require('./upstream-sync.cjs');
+const DEFAULT_BASE_BRANCH = "main";
+const DEFAULT_CONFIG_PATH = "upstreams.json";
+function createNodeSyncDependencies() {
+  return {
+    exec(file, arguments_, env) {
+      return toResult((0, import_node_child_process.spawnSync)(file, arguments_, { encoding: "utf-8", env: { ...import_node_process.default.env, ...env } }));
+    },
+    async fetchJson(url) {
+      const headers = { Accept: "application/vnd.github+json" };
+      const token = import_node_process.default.env["GITHUB_TOKEN"];
+      if (token && url.startsWith("https://api.github.com/")) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+      const response = await fetch(url, { headers });
+      if (!response.ok) {
+        throw new Error(`GET ${url} failed: HTTP ${String(response.status)}.`);
+      }
+      return await response.json();
+    },
+    log(text) {
+      import_node_process.default.stdout.write(`${text}
+`);
+    },
+    shell(command, env) {
+      import_node_process.default.stdout.write(`> ${command}
+`);
+      const result = toResult((0, import_node_child_process.spawnSync)(command, { encoding: "utf-8", env: { ...import_node_process.default.env, ...env }, shell: true }));
+      import_node_process.default.stdout.write(result.output);
+      return result;
+    }
+  };
+}
+function parseSyncUpstreamsArguments(cliArguments) {
+  const known = ["--dry-run", "--only=", "--base=", "--config="];
+  const unknown = cliArguments.filter((argument) => known.every((prefix) => !(prefix.endsWith("=") ? argument.startsWith(prefix) : argument === prefix)));
+  if (unknown.length > 0) {
+    throw new Error(`sync-upstreams: unknown argument ${unknown.map((argument) => `"${argument}"`).join(", ")}. Known: --dry-run, --only=, --base=, --config=.`);
+  }
+  return {
+    baseBranch: readOption(cliArguments, "base") ?? DEFAULT_BASE_BRANCH,
+    configPath: readOption(cliArguments, "config") ?? DEFAULT_CONFIG_PATH,
+    dryRun: cliArguments.includes("--dry-run"),
+    only: readOption(cliArguments, "only")?.split(",").filter((name) => name !== "") ?? []
+  };
+}
+async function runSyncUpstreamsCli(cliArguments, dependencies = createNodeSyncDependencies()) {
+  try {
+    const results = await (0, import_upstream_sync.syncUpstreams)(parseSyncUpstreamsArguments(cliArguments), dependencies);
+    return results.some((result) => result.outcome === "error") ? 1 : 0;
+  } catch (error) {
+    import_node_process.default.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+function readOption(cliArguments, name) {
+  const prefix = `--${name}=`;
+  const value = cliArguments.find((argument) => argument.startsWith(prefix))?.slice(prefix.length);
+  return value === "" ? void 0 : value;
+}
+function toResult(result) {
+  return result.error ? { exitCode: 1, output: result.error.message } : { exitCode: result.status ?? 1, output: `${result.stdout}${result.stderr}` };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeSyncDependencies,
+  parseSyncUpstreamsArguments,
+  runSyncUpstreamsCli
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/upstream-sync-cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The `sync-upstreams` command: reads its arguments, wires {@link syncUpstreams} to the real git, `gh`, GitHub API and\n * npm registry, and turns the results into an exit code.\n */\n\nimport type { SpawnSyncReturns } from 'node:child_process';\n\nimport { spawnSync } from 'node:child_process';\nimport process from 'node:process';\n\nimport type {\n  CommandResult,\n  SyncDependencies,\n  SyncUpstreamsOptions\n} from './upstream-sync.ts';\n\nimport { syncUpstreams } from './upstream-sync.ts';\n\nconst DEFAULT_BASE_BRANCH = 'main';\nconst DEFAULT_CONFIG_PATH = 'upstreams.json';\n\n/**\n * Creates the sync's outside world: commands run with `spawnSync`, JSON fetched with `fetch`, output to stdout.\n * `GITHUB_TOKEN`, when set, is sent to the GitHub API and nowhere else.\n *\n * @returns The dependencies.\n */\nexport function createNodeSyncDependencies(): SyncDependencies {\n  return {\n    exec(file, arguments_, env): CommandResult {\n      return toResult(spawnSync(file, arguments_, { encoding: 'utf-8', env: { ...process.env, ...env } }));\n    },\n    async fetchJson(url): Promise<unknown> {\n      const headers: Record<string, string> = { Accept: 'application/vnd.github+json' };\n      const token = process.env['GITHUB_TOKEN'];\n      if (token && url.startsWith('https://api.github.com/')) {\n        headers['Authorization'] = `Bearer ${token}`;\n      }\n      const response = await fetch(url, { headers });\n      if (!response.ok) {\n        throw new Error(`GET ${url} failed: HTTP ${String(response.status)}.`);\n      }\n      return await response.json();\n    },\n    log(text): void {\n      process.stdout.write(`${text}\\n`);\n    },\n    shell(command, env): CommandResult {\n      process.stdout.write(`> ${command}\\n`);\n      const result = toResult(spawnSync(command, { encoding: 'utf-8', env: { ...process.env, ...env }, shell: true }));\n      process.stdout.write(result.output);\n      return result;\n    }\n  };\n}\n\n/**\n * Builds the sync options from the command line.\n *\n * `--dry-run` prints each PR it would open and changes nothing. `--only=<name>[,<name>]` limits the sync to those\n * entries, `--base=<branch>` names the branch the PRs target (`main` by default), and `--config=<path>` names the\n * `upstreams.json` (the one in the working directory by default).\n *\n * @param cliArguments - The arguments after the command name.\n * @returns The options.\n */\nexport function parseSyncUpstreamsArguments(cliArguments: readonly string[]): SyncUpstreamsOptions {\n  const known = ['--dry-run', '--only=', '--base=', '--config='];\n  const unknown = cliArguments.filter((argument) => known.every((prefix) => !(prefix.endsWith('=') ? argument.startsWith(prefix) : argument === prefix)));\n  if (unknown.length > 0) {\n    throw new Error(`sync-upstreams: unknown argument ${unknown.map((argument) => `\"${argument}\"`).join(', ')}. Known: --dry-run, --only=, --base=, --config=.`);\n  }\n  return {\n    baseBranch: readOption(cliArguments, 'base') ?? DEFAULT_BASE_BRANCH,\n    configPath: readOption(cliArguments, 'config') ?? DEFAULT_CONFIG_PATH,\n    dryRun: cliArguments.includes('--dry-run'),\n    only: readOption(cliArguments, 'only')?.split(',').filter((name) => name !== '') ?? []\n  };\n}\n\n/**\n * Runs the `sync-upstreams` command.\n *\n * @param cliArguments - The arguments after the command name.\n * @param dependencies - The outside world. The real one when omitted.\n * @returns The exit code: `1` when the arguments or `upstreams.json` are wrong or any entry failed, `0` otherwise.\n */\nexport async function runSyncUpstreamsCli(cliArguments: readonly string[], dependencies: SyncDependencies = createNodeSyncDependencies()): Promise<number> {\n  try {\n    const results = await syncUpstreams(parseSyncUpstreamsArguments(cliArguments), dependencies);\n    return results.some((result) => result.outcome === 'error') ? 1 : 0;\n  } catch (error) {\n    // A wrong argument or config is the user's to fix, so it gets its message rather than a stack trace.\n    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\\n`);\n    return 1;\n  }\n}\n\n// An empty value counts as absent, because a workflow passes an unset input as one.\nfunction readOption(cliArguments: readonly string[], name: string): string | undefined {\n  const prefix = `--${name}=`;\n  const value = cliArguments.find((argument) => argument.startsWith(prefix))?.slice(prefix.length);\n  return value === '' ? undefined : value;\n}\n\nfunction toResult(result: SpawnSyncReturns<string>): CommandResult {\n  return result.error ? { exitCode: 1, output: result.error.message } : { exitCode: result.status ?? 1, output: `${result.stdout}${result.stderr}` };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,gCAA0B;AAC1B,0BAAoB;AAQpB,2BAA8B;AAE9B,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;AAQrB,SAAS,6BAA+C;AAC7D,SAAO;AAAA,IACL,KAAK,MAAM,YAAY,KAAoB;AACzC,aAAO,aAAS,qCAAU,MAAM,YAAY,EAAE,UAAU,SAAS,KAAK,EAAE,GAAG,oBAAAA,QAAQ,KAAK,GAAG,IAAI,EAAE,CAAC,CAAC;AAAA,IACrG;AAAA,IACA,MAAM,UAAU,KAAuB;AACrC,YAAM,UAAkC,EAAE,QAAQ,8BAA8B;AAChF,YAAM,QAAQ,oBAAAA,QAAQ,IAAI,cAAc;AACxC,UAAI,SAAS,IAAI,WAAW,yBAAyB,GAAG;AACtD,gBAAQ,eAAe,IAAI,UAAU,KAAK;AAAA,MAC5C;AACA,YAAM,WAAW,MAAM,MAAM,KAAK,EAAE,QAAQ,CAAC;AAC7C,UAAI,CAAC,SAAS,IAAI;AAChB,cAAM,IAAI,MAAM,OAAO,GAAG,iBAAiB,OAAO,SAAS,MAAM,CAAC,GAAG;AAAA,MACvE;AACA,aAAO,MAAM,SAAS,KAAK;AAAA,IAC7B;AAAA,IACA,IAAI,MAAY;AACd,0BAAAA,QAAQ,OAAO,MAAM,GAAG,IAAI;AAAA,CAAI;AAAA,IAClC;AAAA,IACA,MAAM,SAAS,KAAoB;AACjC,0BAAAA,QAAQ,OAAO,MAAM,KAAK,OAAO;AAAA,CAAI;AACrC,YAAM,SAAS,aAAS,qCAAU,SAAS,EAAE,UAAU,SAAS,KAAK,EAAE,GAAG,oBAAAA,QAAQ,KAAK,GAAG,IAAI,GAAG,OAAO,KAAK,CAAC,CAAC;AAC/G,0BAAAA,QAAQ,OAAO,MAAM,OAAO,MAAM;AAClC,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAYO,SAAS,4BAA4B,cAAuD;AACjG,QAAM,QAAQ,CAAC,aAAa,WAAW,WAAW,WAAW;AAC7D,QAAM,UAAU,aAAa,OAAO,CAAC,aAAa,MAAM,MAAM,CAAC,WAAW,EAAE,OAAO,SAAS,GAAG,IAAI,SAAS,WAAW,MAAM,IAAI,aAAa,OAAO,CAAC;AACtJ,MAAI,QAAQ,SAAS,GAAG;AACtB,UAAM,IAAI,MAAM,oCAAoC,QAAQ,IAAI,CAAC,aAAa,IAAI,QAAQ,GAAG,EAAE,KAAK,IAAI,CAAC,kDAAkD;AAAA,EAC7J;AACA,SAAO;AAAA,IACL,YAAY,WAAW,cAAc,MAAM,KAAK;AAAA,IAChD,YAAY,WAAW,cAAc,QAAQ,KAAK;AAAA,IAClD,QAAQ,aAAa,SAAS,WAAW;AAAA,IACzC,MAAM,WAAW,cAAc,MAAM,GAAG,MAAM,GAAG,EAAE,OAAO,CAAC,SAAS,SAAS,EAAE,KAAK,CAAC;AAAA,EACvF;AACF;AASA,eAAsB,oBAAoB,cAAiC,eAAiC,2BAA2B,GAAoB;AACzJ,MAAI;AACF,UAAM,UAAU,UAAM,oCAAc,4BAA4B,YAAY,GAAG,YAAY;AAC3F,WAAO,QAAQ,KAAK,CAAC,WAAW,OAAO,YAAY,OAAO,IAAI,IAAI;AAAA,EACpE,SAAS,OAAO;AAEd,wBAAAA,QAAQ,OAAO,MAAM,GAAG,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,CAAI;AAClF,WAAO;AAAA,EACT;AACF;AAGA,SAAS,WAAW,cAAiC,MAAkC;AACrF,QAAM,SAAS,KAAK,IAAI;AACxB,QAAM,QAAQ,aAAa,KAAK,CAAC,aAAa,SAAS,WAAW,MAAM,CAAC,GAAG,MAAM,OAAO,MAAM;AAC/F,SAAO,UAAU,KAAK,SAAY;AACpC;AAEA,SAAS,SAAS,QAAiD;AACjE,SAAO,OAAO,QAAQ,EAAE,UAAU,GAAG,QAAQ,OAAO,MAAM,QAAQ,IAAI,EAAE,UAAU,OAAO,UAAU,GAAG,QAAQ,GAAG,OAAO,MAAM,GAAG,OAAO,MAAM,GAAG;AACnJ;",
  "names": ["process"]
}


package/dist/lib/cjs/upstream-sync-cli.d.cts

@@ -0,0 +1,34 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * The `sync-upstreams` command: reads its arguments, wires {@link syncUpstreams} to the real git, `gh`, GitHub API and
+ * npm registry, and turns the results into an exit code.
+ */
+import type { SyncDependencies, SyncUpstreamsOptions } from './upstream-sync.cjs';
+/**
+ * Creates the sync's outside world: commands run with `spawnSync`, JSON fetched with `fetch`, output to stdout.
+ * `GITHUB_TOKEN`, when set, is sent to the GitHub API and nowhere else.
+ *
+ * @returns The dependencies.
+ */
+export declare function createNodeSyncDependencies(): SyncDependencies;
+/**
+ * Builds the sync options from the command line.
+ *
+ * `--dry-run` prints each PR it would open and changes nothing. `--only=<name>[,<name>]` limits the sync to those
+ * entries, `--base=<branch>` names the branch the PRs target (`main` by default), and `--config=<path>` names the
+ * `upstreams.json` (the one in the working directory by default).
+ *
+ * @param cliArguments - The arguments after the command name.
+ * @returns The options.
+ */
+export declare function parseSyncUpstreamsArguments(cliArguments: readonly string[]): SyncUpstreamsOptions;
+/**
+ * Runs the `sync-upstreams` command.
+ *
+ * @param cliArguments - The arguments after the command name.
+ * @param dependencies - The outside world. The real one when omitted.
+ * @returns The exit code: `1` when the arguments or `upstreams.json` are wrong or any entry failed, `0` otherwise.
+ */
+export declare function runSyncUpstreamsCli(cliArguments: readonly string[], dependencies?: SyncDependencies): Promise<number>;

package/dist/lib/cjs/upstream-sync.cjs

@@ -0,0 +1,294 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var upstream_sync_exports = {};
+__export(upstream_sync_exports, {
+  buildPrBody: () => buildPrBody,
+  compareWithUpstream: () => compareWithUpstream,
+  parseUpstreamsConfig: () => parseUpstreamsConfig,
+  planSync: () => planSync,
+  syncUpstreams: () => syncUpstreams,
+  writePin: () => writePin
+});
+module.exports = __toCommonJS(upstream_sync_exports);
+var import_node_fs = require('node:fs');
+var import_node_path = require('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) => (0, import_node_path.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((0, import_node_fs.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 = (0, import_node_fs.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;
+  (0, import_node_fs.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]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": "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",
  "names": ["head", "prNumber"]
}
