@reviewflow/sdk 0.0.0-stage → 6.22.0

package/build/git-node.mjs

@@ -0,0 +1,1792 @@
+import { execFile, spawn } from 'node:child_process';
+import { env } from 'node:process';
+import { promisify } from 'node:util';
+import { lstat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { parseSync } from 'oxc-parser';
+import { builtinModules } from 'node:module';
+import { setImmediate } from 'node:timers/promises';
+
+const execFileAsync = promisify(execFile);
+const timeoutMs = 1e4;
+const networkTimeoutMs = 6e4;
+const defaultMaxBuffer = 4 * 1024 * 1024;
+const batchMaxBuffer = 256 * 1024 * 1024;
+const networkEnv = () => ({
+  ...env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_SSH_COMMAND: env.GIT_SSH_COMMAND ?? "ssh -o BatchMode=yes"
+});
+const gitFailedCode = "ERR_GIT_FAILED";
+const reasonLine = (stderr) => {
+  const lines = stderr.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  return lines.find((line) => line.startsWith("! ")) ?? lines.find((line) => /^(?:fatal|error):/.test(line)) ?? lines.find((line) => !line.startsWith("hint:")) ?? "";
+};
+const failureReason = (error, timeout) => {
+  if (typeof error !== "object" || error === null) return "";
+  if ("killed" in error && error.killed === true) {
+    return `killed after ${String(timeout / 1e3)}s without finishing`;
+  }
+  return "stderr" in error ? reasonLine(String(error.stderr)) : "";
+};
+const isExitOneAnswer = (error) => typeof error === "object" && error !== null && "code" in error && error.code === 1 && "stdout" in error && typeof error.stdout === "string" && error.stdout !== "";
+const git = async (cwd, args, options = {}) => {
+  const timeout = options.network ? networkTimeoutMs : timeoutMs;
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      timeout,
+      maxBuffer: options.maxBuffer ?? defaultMaxBuffer,
+      env: options.network ? networkEnv() : env,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    });
+    return stdout;
+  } catch (error) {
+    if (options.exitOneIsAnswer && isExitOneAnswer(error)) return error.stdout;
+    const reason = failureReason(error, timeout);
+    throw Object.assign(
+      new Error(
+        `git ${args.join(" ")} failed in ${cwd}${reason ? `: ${reason}` : ""}`,
+        { cause: error }
+      ),
+      { code: gitFailedCode }
+    );
+  }
+};
+const unansweredHeader = / (?:missing|ambiguous)$/;
+const parseBatchOutput = (output, paths) => {
+  const contents = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (const path of paths) {
+    const newline = output.indexOf("\n", offset);
+    if (newline === -1) break;
+    const header = output.toString("utf8", offset, newline);
+    offset = newline + 1;
+    if (unansweredHeader.test(header)) continue;
+    const [, type, sizeText] = header.split(" ");
+    const size = Number(sizeText);
+    if (!Number.isSafeInteger(size) || size < 0) break;
+    if (type === "blob") {
+      contents.set(path, output.toString("utf8", offset, offset + size));
+    }
+    offset += size + 1;
+  }
+  return contents;
+};
+const catFiles = async (cwd, sha, paths) => {
+  const asked = paths.filter((path) => !path.includes("\n"));
+  if (asked.length === 0) return /* @__PURE__ */ new Map();
+  const args = ["cat-file", "--batch"];
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", args, { cwd, env, timeout: timeoutMs });
+    const chunks = [];
+    let size = 0;
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > batchMaxBuffer) {
+        child.kill();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", reject);
+    child.stdin.on("error", () => {
+    });
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve(parseBatchOutput(Buffer.concat(chunks), asked));
+        return;
+      }
+      const reason = signal === null ? reasonLine(stderr) : `killed (${signal}) after reading ${String(size)} bytes`;
+      reject(
+        Object.assign(
+          new Error(
+            `git ${args.join(" ")} failed in ${cwd}${reason ? `: ${reason}` : ""}`
+          ),
+          { code: gitFailedCode }
+        )
+      );
+    });
+    child.stdin.end(asked.map((path) => `${sha}:${path}
+`).join(""));
+  });
+};
+const gitOrNull = async (cwd, args, options = {}) => {
+  try {
+    return await git(cwd, args, options);
+  } catch {
+    return null;
+  }
+};
+
+const defaultDiffLimits = {
+  maxLinesPerFile: 3e3,
+  maxTotalLines: 3e4,
+  maxFiles: 500,
+  maxUntrackedFiles: 100,
+  maxUntrackedBytes: 512 * 1024
+};
+const maxPatchBytes = 64 * 1024 * 1024;
+const neutralConfig = ["-c", "core.quotePath=false"];
+const diffFlags = [
+  "--no-color",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--src-prefix=a/",
+  "--dst-prefix=b/"
+];
+const parseNumstat = (output) => {
+  const records = output.split("\0");
+  const entries = [];
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index] ?? "";
+    if (record === "") continue;
+    const [added = "", deleted = "", ...rest] = record.split("	");
+    const lines = added === "-" || deleted === "-" ? null : Number(added) + Number(deleted);
+    const path = rest.join("	");
+    if (path !== "") {
+      entries.push({ path, paths: [path], lines });
+      continue;
+    }
+    const from = records[index + 1] ?? "";
+    const to = records[index + 2] ?? "";
+    index += 2;
+    entries.push({ path: to, paths: [from, to], lines });
+  }
+  return entries;
+};
+const omissionReason = (lines, budget, limits) => {
+  if (lines === null) return "binary";
+  if (lines > limits.maxLinesPerFile) return "tooLarge";
+  if (budget.files + 1 > limits.maxFiles || budget.lines + lines > limits.maxTotalLines) {
+    return "budget";
+  }
+  return null;
+};
+const pathspecs = (included, excluded) => {
+  if (excluded.length === 0) return [];
+  if (included.length < excluded.length) {
+    return ["--", ...included.map((path) => `:(literal)${path}`)];
+  }
+  return ["--", ...excluded.map((path) => `:(exclude,literal)${path}`)];
+};
+const readNumstat = async (cwd, range, whitespaceFlags) => parseNumstat(
+  await git(cwd, [
+    ...neutralConfig,
+    "diff",
+    "--no-relative",
+    "-M",
+    ...whitespaceFlags,
+    "--numstat",
+    "-z",
+    ...range
+  ])
+);
+const whitespaceOnlyFiles = async (cwd, range, shown) => {
+  const shownPaths = new Set(shown.map(({ path }) => path));
+  const all = await readNumstat(cwd, range, []);
+  return all.filter(({ path }) => !shownPaths.has(path)).map(({ path }) => ({ path, reason: "whitespace" }));
+};
+const readTrackedDiff = async ({
+  cwd,
+  range,
+  whitespace,
+  limits,
+  budget
+}) => {
+  const whitespaceFlags = whitespace === "hide" ? ["-w"] : [];
+  const entries = await readNumstat(cwd, range, whitespaceFlags);
+  const omitted = whitespace === "hide" ? await whitespaceOnlyFiles(cwd, range, entries) : [];
+  const excluded = [];
+  const included = [];
+  const paths = [];
+  for (const entry of entries) {
+    const reason = omissionReason(entry.lines, budget, limits);
+    if (reason === null) {
+      budget.files += 1;
+      budget.lines += entry.lines ?? 0;
+      paths.push(entry.path);
+      included.push(...entry.paths);
+      continue;
+    }
+    omitted.push({ path: entry.path, reason });
+    excluded.push(...entry.paths);
+  }
+  if (paths.length === 0) return { patch: "", paths, omitted };
+  const patch = await git(
+    cwd,
+    [
+      ...neutralConfig,
+      "diff",
+      ...diffFlags,
+      "--no-relative",
+      "-M",
+      ...whitespaceFlags,
+      ...range,
+      ...pathspecs(included, excluded)
+    ],
+    { maxBuffer: maxPatchBytes }
+  );
+  return { patch, paths, omitted };
+};
+const countAddedLines = (patch) => {
+  const lines = patch.split("\n");
+  const firstHunk = lines.findIndex((line) => line.startsWith("@@"));
+  if (firstHunk === -1) return 0;
+  return lines.slice(firstHunk).filter((line) => line.startsWith("+")).length;
+};
+const isBinaryPatch = (patch) => /^Binary files /m.test(patch);
+const readUntrackedDiff = async (cwd, limits, budget) => {
+  const listing = await git(cwd, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z"
+  ]);
+  const listed = listing.split("\0").filter((path) => path !== "");
+  const patches = [];
+  const paths = [];
+  const omitted = [];
+  for (const [index, path] of listed.entries()) {
+    if (index >= limits.maxUntrackedFiles) {
+      omitted.push({ path, reason: "budget" });
+      continue;
+    }
+    const entry = await lstat(join(cwd, path)).catch(() => null);
+    if (entry === null || entry.isDirectory()) continue;
+    if (entry.size > limits.maxUntrackedBytes) {
+      omitted.push({ path, reason: "tooLarge" });
+      continue;
+    }
+    const patch = await git(
+      cwd,
+      [
+        ...neutralConfig,
+        "diff",
+        ...diffFlags,
+        "--no-index",
+        "--",
+        "/dev/null",
+        path
+      ],
+      { exitOneIsAnswer: true, maxBuffer: maxPatchBytes }
+    );
+    const lines = isBinaryPatch(patch) ? null : countAddedLines(patch);
+    const reason = omissionReason(lines, budget, limits);
+    if (reason !== null) {
+      omitted.push({ path, reason });
+      continue;
+    }
+    budget.files += 1;
+    budget.lines += lines ?? 0;
+    patches.push(patch);
+    paths.push(path);
+  }
+  return { patches, paths, omitted };
+};
+const readBranchDiff = async ({
+  cwd,
+  mergeBase,
+  scope = "committed",
+  head = "HEAD",
+  whitespace = "show",
+  limits = defaultDiffLimits
+}) => {
+  if (mergeBase.startsWith("-") || head.startsWith("-")) {
+    throw new Error(
+      `not a revision: ${mergeBase.startsWith("-") ? mergeBase : head}`
+    );
+  }
+  const budget = { files: 0, lines: 0 };
+  const tracked = await readTrackedDiff({
+    cwd,
+    range: scope === "committed" ? [mergeBase, head] : [mergeBase],
+    whitespace,
+    limits,
+    budget
+  });
+  if (scope === "committed") {
+    return {
+      patch: tracked.patch,
+      paths: tracked.paths,
+      omitted: tracked.omitted,
+      untrackedCount: 0
+    };
+  }
+  const untracked = await readUntrackedDiff(cwd, limits, budget);
+  return {
+    patch: [tracked.patch, ...untracked.patches].join(""),
+    paths: [...tracked.paths, ...untracked.paths],
+    omitted: [...tracked.omitted, ...untracked.omitted],
+    untrackedCount: untracked.patches.length
+  };
+};
+
+const manifestNames = [
+  // javascript
+  "package.json",
+  // python
+  "pyproject.toml",
+  "setup.py",
+  // ruby
+  "Gemfile",
+  // rust
+  "Cargo.toml",
+  // go
+  "go.mod",
+  // php
+  "composer.json",
+  // jvm
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  // elixir
+  "mix.exs",
+  // dart
+  "pubspec.yaml",
+  // swift
+  "Package.swift"
+];
+const manifests = new Set(manifestNames);
+const isManifestPath = (path) => manifests.has(path.slice(path.lastIndexOf("/") + 1));
+const packageOf = (path, isPackage) => {
+  const directories = path.split("/").slice(0, -1);
+  for (let depth = directories.length; depth >= 1; depth--) {
+    const directory = directories.slice(0, depth).join("/");
+    if (isPackage(directory)) return directory;
+  }
+  return directories[0] ?? "";
+};
+const noPackages = () => false;
+const listTree = async (checkout, sha) => {
+  const listing = await git(
+    checkout,
+    ["ls-tree", "-r", "--name-only", "-z", sha],
+    {
+      maxBuffer: 256 * 1024 * 1024
+    }
+  );
+  return listing.split("\0").filter((path) => path !== "");
+};
+const packagesInListing = (paths) => {
+  const directories = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const slash = path.lastIndexOf("/");
+    if (slash === -1) continue;
+    if (isManifestPath(path)) directories.add(path.slice(0, slash));
+  }
+  return (directory) => directories.has(directory);
+};
+const packagesAtTree = async (checkout, sha) => packagesInListing(await listTree(checkout, sha));
+const packagesOnDisk = (worktree) => {
+  const known = /* @__PURE__ */ new Map();
+  return (directory) => {
+    const cached = known.get(directory);
+    if (cached !== void 0) return cached;
+    const found = manifestNames.some(
+      (manifest) => existsSync(join(worktree, directory, manifest))
+    );
+    known.set(directory, found);
+    return found;
+  };
+};
+const groupDiffPaths = (isPackage, paths) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    const name = packageOf(path, isPackage);
+    const group = groups.get(name);
+    if (group === void 0) groups.set(name, [path]);
+    else group.push(path);
+  }
+  return [...groups].toSorted(([left], [right]) => Number(left !== "") - Number(right !== "")).map(([name, groupPaths]) => ({ name, paths: groupPaths }));
+};
+
+const cEscapes = {
+  a: 7,
+  b: 8,
+  f: 12,
+  n: 10,
+  r: 13,
+  t: 9,
+  v: 11,
+  '"': 34,
+  "\\": 92
+};
+const unquoteGitPath = (quoted) => {
+  const bytes = [];
+  const encoder = new TextEncoder();
+  for (let index = 1; index < quoted.length - 1; index++) {
+    const char = quoted[index];
+    if (char !== "\\") {
+      bytes.push(...encoder.encode(char));
+      continue;
+    }
+    const next = quoted[index + 1] ?? "";
+    const octal = /^[0-7]{3}/.exec(quoted.slice(index + 1));
+    if (octal) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      index += 3;
+    } else {
+      bytes.push(cEscapes[next] ?? next.codePointAt(0) ?? 0);
+      index += 1;
+    }
+  }
+  return new TextDecoder().decode(new Uint8Array(bytes));
+};
+const unquoted = (name) => name.length > 1 && name.startsWith('"') && name.endsWith('"') ? unquoteGitPath(name) : name;
+const headerName = (raw, prefix) => {
+  const name = unquoted(raw.endsWith("	") ? raw.slice(0, -1) : raw);
+  return name.startsWith(prefix) ? name.slice(prefix.length) : null;
+};
+const pathOfBlock = (block) => {
+  const added = /^\+\+\+ (.*)$/m.exec(block)?.[1];
+  const addedName = added === void 0 ? null : headerName(added, "b/");
+  if (addedName !== null) return addedName;
+  const removed = /^--- (.*)$/m.exec(block)?.[1];
+  const removedName = removed === void 0 ? null : headerName(removed, "a/");
+  if (removedName !== null) return removedName;
+  const renamed = /^rename to (.*)$/m.exec(block)?.[1];
+  if (renamed !== void 0) return unquoted(renamed);
+  const header = block.split("\n", 1)[0] ?? "";
+  const quotedSeparator = header.lastIndexOf(' "b/');
+  if (quotedSeparator !== -1) {
+    return headerName(header.slice(quotedSeparator + 1), "b/");
+  }
+  const separator = header.lastIndexOf(" b/");
+  return separator === -1 ? null : header.slice(separator + 3);
+};
+const diffPaths = (patch) => patch.split(/^diff --git /m).slice(1).map(pathOfBlock).filter((path) => path !== null);
+
+const fetchCompareDiff = (transport, { ownerRepo, base, head }) => {
+  const [owner, name, ...rest] = ownerRepo.split("/");
+  if (owner === void 0 || name === void 0 || rest.length > 0) {
+    throw new Error(`${ownerRepo} is not owner/repo`);
+  }
+  return transport.text({
+    path: `repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/compare/${base}...${head}`,
+    accept: "application/vnd.github.diff"
+  });
+};
+
+const isSha = (value) => /^[\da-f]{40}$/i.test(value);
+const hasCommit = async (checkout, sha) => await gitOrNull(checkout, ["cat-file", "-e", `${sha}^{commit}`]) !== null;
+const ensureCommits = async (checkout, shas, onStep, signal) => {
+  const missing = [];
+  for (const sha of shas) {
+    if (!await hasCommit(checkout, sha)) missing.push(sha);
+  }
+  if (missing.length === 0) return;
+  onStep?.("fetching");
+  await git(
+    checkout,
+    ["fetch", "--no-write-fetch-head", "--no-tags", "origin", ...missing],
+    { network: true, ...signal === void 0 ? {} : { signal } }
+  );
+};
+const readFromGit = async (checkout, { head, base, whitespace = "show", onStep, signal }) => {
+  await ensureCommits(checkout, [head, base], onStep, signal);
+  onStep?.("diffing");
+  const mergeBaseOutput = await git(checkout, ["merge-base", base, head]);
+  const mergeBase = mergeBaseOutput.trim();
+  const { patch, paths, omitted } = await readBranchDiff({
+    cwd: checkout,
+    mergeBase,
+    scope: "committed",
+    head,
+    whitespace
+  });
+  return {
+    source: "git",
+    fallbackReason: null,
+    whitespace,
+    patch,
+    sides: { old: mergeBase, new: head },
+    omitted,
+    groups: groupDiffPaths(await packagesAtTree(checkout, head), paths)
+  };
+};
+const readFromGitHub = async ({ checkout, transport, ref, head, base }, fallbackReason) => {
+  const patch = await fetchCompareDiff(transport, {
+    ownerRepo: ref.ownerRepo,
+    base,
+    head
+  });
+  let isPackage = noPackages;
+  if (checkout !== null) {
+    isPackage = await packagesAtTree(checkout, head).catch(() => noPackages);
+  }
+  return {
+    source: "github",
+    fallbackReason,
+    whitespace: "show",
+    patch,
+    sides: null,
+    omitted: [],
+    groups: groupDiffPaths(isPackage, diffPaths(patch))
+  };
+};
+const readPullRequestDiff = async (request) => {
+  if (!isSha(request.head) || !isSha(request.base)) {
+    throw new Error("head and base must be commit shas");
+  }
+  if (request.checkout === null) return readFromGitHub(request, "no checkout");
+  try {
+    return await readFromGit(request.checkout, request);
+  } catch (error) {
+    if (request.signal?.aborted) throw error;
+    const reason = error instanceof Error ? error.message : String(error);
+    return readFromGitHub(request, reason);
+  }
+};
+const readFileAtSha = async (checkout, sha, path) => {
+  if (!isSha(sha)) throw new Error("sha must be a commit sha");
+  if (path === "") throw new Error("path is required");
+  return git(checkout, ["cat-file", "blob", `${sha}:${path}`], {
+    maxBuffer: 64 * 1024 * 1024
+  });
+};
+
+const typescriptExtensions = [".ts", ".tsx", ".mts", ".cts"];
+const extensionOf = (path) => {
+  const slash = path.lastIndexOf("/");
+  const dot = path.lastIndexOf(".");
+  return dot > slash ? path.slice(dot) : "";
+};
+const isTypescriptPath = (path) => typescriptExtensions.includes(extensionOf(path));
+const attachableSuffix = /\.(?:test|spec|stories)(?=\.[cm]?tsx?$)/;
+const testDirectories = /* @__PURE__ */ new Set([
+  "__fixtures__",
+  "__mocks__",
+  "__tests__",
+  "fixtures",
+  "test",
+  "tests"
+]);
+const isAttachablePath = (path) => isTypescriptPath(path) && (attachableSuffix.test(path) || path.split("/").slice(0, -1).some((directory) => testDirectories.has(directory)));
+const javascriptToTypescript = {
+  ".js": ".ts",
+  ".jsx": ".tsx",
+  ".mjs": ".mts",
+  ".cjs": ".cts"
+};
+const directoryOf = (path) => {
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? "" : path.slice(0, slash);
+};
+const normalize = (path) => {
+  const segments = [];
+  for (const segment of path.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      if (segments.length === 0) return null;
+      segments.pop();
+    } else {
+      segments.push(segment);
+    }
+  }
+  return segments.join("/");
+};
+const candidatesOf = (target) => {
+  const extension = extensionOf(target);
+  const rewritten = javascriptToTypescript[extension];
+  const declaration = rewritten === void 0 ? `${target}.d.ts` : `${target.slice(0, -extension.length)}.d.ts`;
+  return [
+    target,
+    ...rewritten === void 0 ? [] : [target.slice(0, -extension.length) + rewritten],
+    ...typescriptExtensions.map((typescript) => target + typescript),
+    declaration,
+    `${target}/index.ts`,
+    `${target}/index.tsx`
+  ];
+};
+const resolveTarget = (target, exists) => target === null ? null : candidatesOf(target).find(
+  (candidate) => isTypescriptPath(candidate) && exists(candidate)
+) ?? null;
+const resolveRelative = (from, specifier, exists) => {
+  if (!specifier.startsWith(".")) return null;
+  return resolveTarget(normalize(`${directoryOf(from)}/${specifier}`), exists);
+};
+const conditionOrder = ["types", "import", "default"];
+const targetOf = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value !== "object" || value === null) return null;
+  const conditions = value;
+  for (const condition of conditionOrder) {
+    const target = targetOf(conditions[condition]);
+    if (target !== null) return target;
+  }
+  return null;
+};
+const expand = (pattern, specifier) => {
+  const star = pattern.indexOf("*");
+  if (star === -1) return pattern === specifier ? "" : null;
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) return null;
+  return specifier.slice(prefix.length, specifier.length - suffix.length);
+};
+const specificity = (pattern) => pattern.includes("*") ? pattern.indexOf("*") : Number.MAX_SAFE_INTEGER;
+const resolveSubpathImport = (specifier, { directory, imports }, exists) => {
+  if (!specifier.startsWith("#")) return null;
+  if (typeof imports !== "object" || imports === null) return null;
+  const patterns = Object.entries(imports).toSorted(
+    ([left], [right]) => specificity(right) - specificity(left)
+  );
+  for (const [pattern, value] of patterns) {
+    const captured = expand(pattern, specifier);
+    const target = targetOf(value);
+    if (captured === null || target?.startsWith("./") !== true) continue;
+    return resolveTarget(
+      normalize(`${directory}/${target.replace("*", captured)}`),
+      exists
+    );
+  }
+  return null;
+};
+const joinPath = (directory, name) => directory === "" ? name : `${directory}/${name}`;
+const coveredDirectoriesOf = (path) => {
+  const directory = directoryOf(path);
+  return directory.split("/").at(-1) === "__tests__" ? [directory, directoryOf(directory)] : [directory];
+};
+const attachableKinds = /* @__PURE__ */ new Set(["spec", "stories", "test"]);
+const subjectsOf = (path) => {
+  const parts = path.slice(directoryOf(path).length).replace(/^\//, "").replace(/\.[cm]?tsx?$/, "").split(".");
+  const kind = parts.findIndex((part) => attachableKinds.has(part));
+  const stem = kind === -1 ? parts : parts.slice(0, kind);
+  const names = stem.map(
+    (_, dropped) => stem.slice(0, stem.length - dropped).join(".")
+  );
+  return coveredDirectoriesOf(path).flatMap(
+    (directory) => names.flatMap(
+      (name) => typescriptExtensions.map(
+        (extension) => joinPath(directory, name + extension)
+      )
+    )
+  );
+};
+const reachedFrom = (path, { code, changed, imports }) => {
+  const reached = [];
+  const visited = /* @__PURE__ */ new Set([path]);
+  const visit = (from) => {
+    for (const target of imports.get(from) ?? []) {
+      if (visited.has(target)) continue;
+      visited.add(target);
+      if (code.has(target)) reached.push(target);
+      else if (!changed.has(target)) visit(target);
+    }
+  };
+  visit(path);
+  return reached;
+};
+const countReachable = (entry, edges) => {
+  const seen = /* @__PURE__ */ new Set([entry]);
+  const stack = [entry];
+  while (stack.length > 0) {
+    for (const target of edges.get(stack.pop()) ?? []) {
+      if (seen.has(target)) continue;
+      seen.add(target);
+      stack.push(target);
+    }
+  }
+  return seen.size - 1;
+};
+const attachTo = (attachable, code, reached) => {
+  const covered = coveredDirectoriesOf(attachable);
+  return subjectsOf(attachable).find((subject) => code.has(subject)) ?? reached.find((target) => covered.includes(directoryOf(target))) ?? reached[0] ?? null;
+};
+const orderGroup = ({ name, paths }, changed, imports) => {
+  const code = new Set(
+    paths.filter((path) => isTypescriptPath(path) && !isAttachablePath(path))
+  );
+  const attachables = paths.filter(isAttachablePath);
+  const others = paths.filter((path) => !isTypescriptPath(path));
+  const reach = { code, changed, imports };
+  const edges = new Map(
+    [...code].map((path) => [path, reachedFrom(path, reach)])
+  );
+  const imported = new Set([...edges.values()].flat());
+  const attached = /* @__PURE__ */ new Map();
+  const standalone = [];
+  for (const attachable of attachables) {
+    const subject = attachTo(attachable, code, reachedFrom(attachable, reach));
+    if (subject === null) standalone.push(attachable);
+    else attached.set(subject, [...attached.get(subject) ?? [], attachable]);
+  }
+  const reachable = new Map(
+    [...code].map((path) => [path, countReachable(path, edges)])
+  );
+  const byPath = (left, right) => left.localeCompare(right);
+  const roots = [...code].filter((path) => !imported.has(path)).toSorted(
+    (left, right) => reachable.get(right) - reachable.get(left) || byPath(left, right)
+  );
+  const ordered = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (path) => {
+    if (visited.has(path)) return;
+    visited.add(path);
+    ordered.push(path);
+    for (const target of edges.get(path) ?? []) visit(target);
+  };
+  for (const root of roots) visit(root);
+  for (const path of [...code].toSorted(byPath)) visit(path);
+  const entries = new Set(
+    roots.filter((root) => (edges.get(root) ?? []).length > 0)
+  );
+  const rootPaths = new Set(roots);
+  const codeFile = (path) => ({
+    path,
+    entry: entries.has(path),
+    root: rootPaths.has(path),
+    attached: (attached.get(path) ?? []).toSorted(byPath)
+  });
+  const plainFile = (path) => ({
+    path,
+    entry: false,
+    root: false,
+    attached: []
+  });
+  return {
+    name,
+    files: [
+      ...ordered.map(codeFile),
+      ...others.map(plainFile),
+      ...standalone.map(plainFile)
+    ]
+  };
+};
+const transitiveDependencies = (name, dependsOn) => {
+  const found = /* @__PURE__ */ new Set();
+  const stack = [name];
+  while (stack.length > 0) {
+    for (const dependency of dependsOn.get(stack.pop()) ?? []) {
+      if (found.has(dependency) || dependency === name) continue;
+      found.add(dependency);
+      stack.push(dependency);
+    }
+  }
+  return found;
+};
+const orderPackages = (names, dependsOn) => {
+  const remaining = new Set(names.filter((name) => name !== ""));
+  const dependencies = new Map(
+    [...remaining].map((name) => [
+      name,
+      transitiveDependencies(name, dependsOn)
+    ])
+  );
+  const isDependedOnByRemaining = (name) => [...remaining].some(
+    (other) => other !== name && dependencies.get(other).has(name)
+  );
+  const ordered = names.includes("") ? [""] : [];
+  while (remaining.size > 0) {
+    const sorted = [...remaining].toSorted(
+      (left, right) => left.localeCompare(right)
+    );
+    const next = sorted.find((name) => !isDependedOnByRemaining(name)) ?? sorted[0];
+    ordered.push(next);
+    remaining.delete(next);
+  }
+  return ordered;
+};
+const orderForReading = ({
+  groups,
+  imports,
+  dependsOn
+}) => {
+  const byName = new Map(groups.map((group) => [group.name, group]));
+  const changed = new Set(groups.flatMap(({ paths }) => paths));
+  return orderPackages(
+    groups.map(({ name }) => name),
+    dependsOn
+  ).map((name) => orderGroup(byName.get(name), changed, imports));
+};
+
+const manifestDirectoryOf = (path, manifests) => {
+  const directories = path.split("/").slice(0, -1);
+  for (let depth = directories.length; depth >= 0; depth--) {
+    const directory = directories.slice(0, depth).join("/");
+    if (manifests.has(directory)) return directory;
+  }
+  return null;
+};
+const resolveLocalSpecifier = ({
+  from,
+  specifier,
+  exists,
+  manifests
+}) => {
+  if (!specifier.startsWith("#")) {
+    return resolveRelative(from, specifier, exists);
+  }
+  const directory = manifestDirectoryOf(from, manifests);
+  if (directory === null) return null;
+  return resolveSubpathImport(
+    specifier,
+    { directory, imports: manifests.get(directory)?.imports },
+    exists
+  );
+};
+const dependencyFields = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+];
+const dependencyNamesOf = (manifest) => dependencyFields.flatMap((field) => {
+  const dependencies = manifest[field];
+  return typeof dependencies === "object" && dependencies !== null ? Object.keys(dependencies) : [];
+});
+const parseManifest = (source) => {
+  try {
+    const parsed = JSON.parse(source);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+const directoryOfManifest = (path) => path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+const readManifests = async (checkout, head, tree) => {
+  const manifestPaths = tree.filter(
+    (path) => (path === "package.json" || path.endsWith("/package.json")) && !path.split("/").includes("node_modules")
+  );
+  const contents = await catFiles(checkout, head, manifestPaths);
+  const manifests = /* @__PURE__ */ new Map();
+  for (const [path, source] of contents) {
+    const manifest = parseManifest(source);
+    if (manifest !== null) manifests.set(directoryOfManifest(path), manifest);
+  }
+  return manifests;
+};
+
+const maxUnchangedHops = 2;
+const stringLiteral$1 = /^(["'`])(.*)\1$/s;
+const importSpecifiers = (path, source) => {
+  const { staticImports, staticExports, dynamicImports } = parseSync(
+    path,
+    source
+  ).module;
+  const found = [
+    ...staticImports.map(({ start, moduleRequest }) => ({
+      start,
+      specifier: moduleRequest.value
+    })),
+    ...staticExports.flatMap(
+      ({ start, entries }) => entries.flatMap(
+        ({ moduleRequest }) => moduleRequest === null ? [] : [{ start, specifier: moduleRequest.value }]
+      )
+    ),
+    ...dynamicImports.flatMap(({ start, moduleRequest }) => {
+      const literal = stringLiteral$1.exec(
+        source.slice(moduleRequest.start, moduleRequest.end)
+      );
+      const specifier = literal?.[2];
+      return specifier === void 0 || specifier.includes("${") ? [] : [{ start, specifier }];
+    })
+  ];
+  return [
+    ...new Set(
+      found.toSorted((left, right) => left.start - right.start).map(({ specifier }) => specifier)
+    )
+  ];
+};
+const readImports = async ({
+  checkout,
+  head,
+  changed,
+  exists,
+  isPackage,
+  manifests
+}) => {
+  const changedSet = new Set(changed);
+  const imports = /* @__PURE__ */ new Map();
+  let toRead = changed.filter((path) => isTypescriptPath(path) && exists(path));
+  for (let hop = 0; hop <= maxUnchangedHops && toRead.length > 0; hop++) {
+    const contents = await catFiles(checkout, head, toRead);
+    const next = /* @__PURE__ */ new Set();
+    for (const path of toRead) {
+      const source = contents.get(path);
+      const resolved = (source === void 0 ? [] : importSpecifiers(path, source)).map(
+        (specifier) => resolveLocalSpecifier({ from: path, specifier, exists, manifests })
+      ).filter((target) => target !== null);
+      imports.set(path, resolved);
+      const ownPackage = packageOf(path, isPackage);
+      for (const target of resolved) {
+        if (changedSet.has(target) || imports.has(target)) continue;
+        if (packageOf(target, isPackage) === ownPackage) next.add(target);
+      }
+    }
+    toRead = [...next];
+  }
+  return imports;
+};
+const packageDependencies = (manifests) => {
+  const directoryOfName = /* @__PURE__ */ new Map();
+  for (const [directory, { name }] of manifests) {
+    if (typeof name === "string") directoryOfName.set(name, directory);
+  }
+  return new Map(
+    [...manifests].map(([directory, manifest]) => [
+      directory,
+      new Set(
+        dependencyNamesOf(manifest).flatMap((name) => {
+          const dependency = directoryOfName.get(name);
+          return dependency === void 0 || dependency === directory ? [] : [dependency];
+        })
+      )
+    ])
+  );
+};
+const readReadingOrder = async ({
+  checkout,
+  head,
+  base
+}) => {
+  if (!isSha(head) || !isSha(base)) {
+    throw new Error("head and base must be commit shas");
+  }
+  await ensureCommits(checkout, [head, base], void 0);
+  const mergeBaseOutput = await git(checkout, ["merge-base", base, head]);
+  const mergeBase = mergeBaseOutput.trim();
+  const numstat = await readNumstat(checkout, [mergeBase, head], []);
+  const changed = numstat.map(({ path }) => path);
+  const tree = await listTree(checkout, head);
+  const inTree = new Set(tree);
+  const exists = (path) => inTree.has(path);
+  const isPackage = packagesInListing(tree);
+  const manifests = await readManifests(checkout, head, tree);
+  const imports = await readImports({
+    checkout,
+    head,
+    changed,
+    exists,
+    isPackage,
+    manifests
+  });
+  return {
+    groups: orderForReading({
+      groups: groupDiffPaths(isPackage, changed),
+      imports,
+      dependsOn: packageDependencies(manifests)
+    })
+  };
+};
+
+const stringLiteral = /^(["'`])(.*)\1$/s;
+const lineStartsOf = (source) => {
+  const starts = [0];
+  for (let index = source.indexOf("\n"); index !== -1; ) {
+    starts.push(index + 1);
+    index = source.indexOf("\n", index + 1);
+  }
+  return starts;
+};
+const lineOf = (starts, offset) => {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (starts[middle] <= offset) low = middle;
+    else high = middle - 1;
+  }
+  return low + 1;
+};
+const rangeOf = (starts, { start, end }) => ({
+  start: lineOf(starts, start),
+  end: lineOf(starts, Math.max(start, end - 1))
+});
+const overlaps = (left, right) => left.start <= right.end && right.start <= left.end;
+const kindOf = ({ kind }) => String(kind);
+const nameOf = (entry) => kindOf(entry) === "Default" ? "default" : entry.name;
+const parse = (path, source) => ({
+  result: parseSync(path, source),
+  starts: lineStartsOf(source)
+});
+const importedNames = ({ result }) => {
+  const names = /* @__PURE__ */ new Map();
+  for (const { moduleRequest, entries } of result.module.staticImports) {
+    for (const { importName, localName } of entries) {
+      names.set(localName.value, {
+        specifier: moduleRequest.value,
+        imported: kindOf(importName) === "NamespaceObject" ? "*" : nameOf(importName) ?? "*"
+      });
+    }
+  }
+  return names;
+};
+const matchImport = ({ result }, { importName, moduleRequest }) => {
+  const name = nameOf(importName) ?? "*";
+  const statement = result.module.staticImports.find(
+    ({ moduleRequest: request }) => request.start === moduleRequest?.start
+  );
+  const entries = statement?.entries ?? [];
+  const asDefault = entries.find(
+    (entry) => kindOf(entry.importName) === "Default" && entry.localName.value === name
+  );
+  if (asDefault !== void 0) {
+    return { name: "default", local: asDefault.localName.value };
+  }
+  const named = entries.find((entry) => entry.importName.name === name);
+  return { name, local: named?.localName.value ?? null };
+};
+const isNode = (value) => typeof value === "object" && value !== null && typeof value.type === "string";
+const isExportList = (node) => node.type === "ExportNamedDeclaration" && node.declaration === null;
+const labelKeys = {
+  MemberExpression: "property",
+  Property: "key",
+  PropertyDefinition: "key",
+  MethodDefinition: "key",
+  TSPropertySignature: "key",
+  TSMethodSignature: "key",
+  TSQualifiedName: "right",
+  JSXMemberExpression: "property",
+  JSXAttribute: "name"
+};
+const collectNames = (root, names) => {
+  const stack = [root];
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (Array.isArray(value)) {
+      stack.push(...value);
+      continue;
+    }
+    if (!isNode(value)) continue;
+    if (value.type === "Identifier" || value.type === "JSXIdentifier") {
+      if (typeof value.name === "string") names.add(value.name);
+      stack.push(value.typeAnnotation);
+      continue;
+    }
+    const labelKey = labelKeys[value.type];
+    for (const [key, child] of Object.entries(value)) {
+      if (key === labelKey && value.computed !== true) continue;
+      if (typeof child === "object" && child !== null) stack.push(child);
+    }
+  }
+};
+const namesUsedLocally = ({ result }) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const node of result.program.body) {
+    const isListing = node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || isExportList(node);
+    if (!isListing) collectNames(node, names);
+  }
+  return names;
+};
+const readBindings = (parsed) => {
+  const { result, starts } = parsed;
+  const imported = importedNames(parsed);
+  const bindings = [];
+  const reExports = [];
+  const passedOn = /* @__PURE__ */ new Set();
+  for (const { start, end, entries } of result.module.staticExports) {
+    for (const entry of entries) {
+      const exported = nameOf(entry.exportName);
+      const inStatement = entry.exportName.start === null || entry.exportName.start >= start && entry.exportName.start < end;
+      const isListed = !inStatement || entries.length > 1 && entry.end < end;
+      const lines = rangeOf(
+        starts,
+        isListed ? { start: entry.start, end: entry.end } : { start, end }
+      );
+      const importKind = kindOf(entry.importName);
+      if (entry.moduleRequest !== null && importKind !== "None") {
+        const { value: specifier } = entry.moduleRequest;
+        if (importKind === "AllButDefault") {
+          reExports.push({ specifier, local: "*", exported: "*", lines });
+        } else if (exported !== null) {
+          const matched = matchImport(parsed, entry);
+          if (matched.local !== null && !inStatement) {
+            passedOn.add(matched.local);
+          }
+          reExports.push({
+            specifier,
+            local: importKind === "All" ? "*" : matched.name,
+            exported,
+            lines
+          });
+        }
+        continue;
+      }
+      if (exported === null) continue;
+      const local = entry.localName.name;
+      const viaImport = local === null ? void 0 : imported.get(local);
+      if (viaImport === void 0) {
+        bindings.push({ name: exported, local, lines });
+      } else {
+        passedOn.add(local);
+        reExports.push({
+          specifier: viaImport.specifier,
+          local: viaImport.imported,
+          exported,
+          lines
+        });
+      }
+    }
+  }
+  return { bindings, reExports, passedOn };
+};
+const exportedBindings = (path, source) => {
+  const { bindings, reExports } = readBindings(parse(path, source));
+  return { bindings, reExports };
+};
+const starSpecifiers = (reExports) => reExports.filter(({ local, exported }) => local === "*" && exported === "*").map(({ specifier }) => specifier);
+const exportedNames = ({
+  bindings,
+  reExports
+}) => [
+  .../* @__PURE__ */ new Set([
+    ...bindings.map(({ name }) => name),
+    ...reExports.flatMap(
+      ({ exported }) => exported === "*" ? [] : [exported]
+    )
+  ])
+];
+const importsOf = (parsed, source, passedOn) => {
+  const { result } = parsed;
+  const { staticImports, dynamicImports } = result.module;
+  const usedLocally = namesUsedLocally(parsed);
+  const found = [
+    ...staticImports.flatMap(({ start, moduleRequest, entries }) => {
+      const used = entries.filter(
+        ({ localName }) => !passedOn.has(localName.value) || usedLocally.has(localName.value)
+      );
+      if (entries.length > 0 && used.length === 0) return [];
+      const names = entries.length === 0 ? ["*"] : used.map(
+        ({ importName }) => kindOf(importName) === "NamespaceObject" ? "*" : nameOf(importName) ?? "*"
+      );
+      return [{ start, specifier: moduleRequest.value, names }];
+    }),
+    ...dynamicImports.flatMap(({ start, moduleRequest }) => {
+      const literal = stringLiteral.exec(
+        source.slice(moduleRequest.start, moduleRequest.end)
+      );
+      const specifier = literal?.[2];
+      return specifier === void 0 || specifier.includes("${") ? [] : [{ start, specifier, names: ["*"] }];
+    })
+  ];
+  const bySpecifier = /* @__PURE__ */ new Map();
+  for (const { specifier, names } of found.toSorted(
+    (left, right) => left.start - right.start
+  )) {
+    const merged = bySpecifier.get(specifier) ?? /* @__PURE__ */ new Set();
+    for (const name of names) merged.add(name);
+    bySpecifier.set(specifier, merged);
+  }
+  return [...bySpecifier].map(([specifier, names]) => ({
+    specifier,
+    names: [...names]
+  }));
+};
+const moduleBindings = (path, source) => {
+  const parsed = parse(path, source);
+  const { bindings, reExports, passedOn } = readBindings(parsed);
+  return { bindings, reExports, imports: importsOf(parsed, source, passedOn) };
+};
+const patternNames = (pattern, names) => {
+  if (!isNode(pattern)) return;
+  switch (pattern.type) {
+    case "Identifier":
+      names.push(String(pattern.name));
+      break;
+    case "ObjectPattern":
+      for (const property of pattern.properties) {
+        if (isNode(property)) {
+          patternNames(property.value ?? property.argument, names);
+        }
+      }
+      break;
+    case "ArrayPattern":
+      for (const element of pattern.elements) {
+        patternNames(element, names);
+      }
+      break;
+    case "AssignmentPattern":
+      patternNames(pattern.left, names);
+      break;
+    case "RestElement":
+      patternNames(pattern.argument, names);
+      break;
+  }
+};
+const declaredNamesOf = (statement) => {
+  const names = [];
+  if (statement.type === "VariableDeclaration") {
+    for (const declarator of statement.declarations) {
+      if (isNode(declarator)) patternNames(declarator.id, names);
+    }
+  } else if (statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration" || statement.type.startsWith("TS")) {
+    patternNames(statement.id, names);
+  }
+  return names;
+};
+const statementsOf = ({ result, starts }) => result.program.body.map((node) => {
+  const mentioned = /* @__PURE__ */ new Set();
+  collectNames(node, mentioned);
+  return {
+    lines: rangeOf(starts, node),
+    isList: isExportList(node),
+    declared: declaredNamesOf(node),
+    mentioned
+  };
+});
+const touchedExports = ({
+  path,
+  source,
+  touchedLines,
+  baseExports,
+  baseStars = []
+}) => {
+  const parsed = parse(path, source);
+  const { bindings, reExports } = readBindings(parsed);
+  const statements = statementsOf(parsed);
+  const isTouched = (lines) => touchedLines.some((touched2) => overlaps(touched2, lines));
+  const exportedLocals = new Set(
+    bindings.flatMap(({ local }) => local === null ? [] : [local])
+  );
+  const helpers = statements.filter(
+    ({ declared }) => declared.length > 0 && !declared.some((name) => exportedLocals.has(name))
+  );
+  const touchedHelperNames = new Set(
+    helpers.filter(({ lines }) => isTouched(lines)).flatMap(({ declared }) => declared)
+  );
+  for (let grown = true; grown; ) {
+    grown = false;
+    for (const { declared, mentioned } of helpers) {
+      if (declared.every((name) => touchedHelperNames.has(name))) continue;
+      if (![...touchedHelperNames].some((name) => mentioned.has(name))) {
+        continue;
+      }
+      for (const name of declared) touchedHelperNames.add(name);
+      grown = true;
+    }
+  }
+  const isBindingTouched = ({ local, lines }) => {
+    const declaring = [
+      ...statements.filter(
+        (statement) => !statement.isList && overlaps(statement.lines, lines)
+      ),
+      ...local === null ? [] : statements.filter(({ declared }) => declared.includes(local))
+    ];
+    return isTouched(lines) || declaring.some(
+      ({ lines: declaringLines, mentioned }) => isTouched(declaringLines) || [...touchedHelperNames].some((name) => mentioned.has(name))
+    );
+  };
+  const touched = /* @__PURE__ */ new Set([
+    ...bindings.filter(isBindingTouched).map(({ name }) => name),
+    ...reExports.filter(({ exported, lines }) => exported !== "*" && isTouched(lines)).map(({ exported }) => exported)
+  ]);
+  const now = new Set(exportedNames({ bindings, reExports }));
+  const stars = starSpecifiers(reExports);
+  return {
+    touched: [...touched],
+    removed: baseExports.filter((name) => !now.has(name)),
+    touchedStars: starSpecifiers(
+      reExports.filter(({ lines }) => isTouched(lines))
+    ),
+    removedStars: baseStars.filter((specifier) => !stars.includes(specifier))
+  };
+};
+
+const maxTypescriptFiles = 2e4;
+const maxReadMs = 15e3;
+const batchSize = 250;
+const diffChunkSize = 200;
+const maxTreeBuffer = 256 * 1024 * 1024;
+const defaultCacheEntries = 2 * maxTypescriptFiles;
+const createBindingsCache = (maxEntries = defaultCacheEntries) => {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get: (oid) => {
+      const summary = entries.get(oid);
+      if (summary === void 0) return void 0;
+      entries.delete(oid);
+      entries.set(oid, summary);
+      return summary;
+    },
+    set: (oid, summary) => {
+      entries.delete(oid);
+      entries.set(oid, summary);
+      for (const oldest of entries.keys()) {
+        if (entries.size <= maxEntries) break;
+        entries.delete(oldest);
+      }
+    }
+  };
+};
+const listBlobs = async (checkout, sha) => {
+  const listing = await git(checkout, ["ls-tree", "-r", "-z", sha], {
+    maxBuffer: maxTreeBuffer
+  });
+  return listing.split("\0").flatMap((record) => {
+    const tab = record.indexOf("	");
+    if (tab === -1) return [];
+    const [, type, oid] = record.slice(0, tab).split(" ");
+    return type === "blob" && oid !== void 0 ? [{ path: record.slice(tab + 1), oid }] : [];
+  });
+};
+const isInNodeModules = (path) => path.split("/").includes("node_modules");
+const emptySummary = { exports: [], imports: [], reExports: [] };
+const summarize = (path, source) => {
+  const { bindings, reExports, imports } = moduleBindings(path, source);
+  return {
+    exports: exportedNames({ bindings, reExports }),
+    imports,
+    reExports
+  };
+};
+const chunksOf = (items, size) => Array.from(
+  { length: Math.ceil(items.length / size) },
+  (_, index) => items.slice(index * size, (index + 1) * size)
+);
+const readSummaries = async ({
+  checkout,
+  head,
+  blobs,
+  cache,
+  budgetMs
+}) => {
+  const summaries = /* @__PURE__ */ new Map();
+  const missing = /* @__PURE__ */ new Map();
+  for (const { oid, path } of blobs) {
+    const cached = cache.get(oid);
+    if (cached === void 0) missing.set(oid, path);
+    else summaries.set(oid, cached);
+  }
+  const deadline = Date.now() + budgetMs;
+  for (const batch of chunksOf([...missing], batchSize)) {
+    if (Date.now() > deadline) return null;
+    const contents = await catFiles(
+      checkout,
+      head,
+      batch.map(([, path]) => path)
+    );
+    for (const [oid, path] of batch) {
+      const source = contents.get(path);
+      const summary = source === void 0 ? emptySummary : summarize(path, source);
+      summaries.set(oid, summary);
+      cache.set(oid, summary);
+    }
+    await setImmediate();
+  }
+  return summaries;
+};
+const hunkHeader = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/;
+const parseTouchedLines = (diff) => {
+  const touched = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      current = null;
+    } else if (line.startsWith("+++ ")) {
+      const path = line.slice(4).split("	")[0];
+      if (path.startsWith("b/")) {
+        current = touched.get(path.slice(2)) ?? [];
+        touched.set(path.slice(2), current);
+      }
+    } else if (line.startsWith("@@")) {
+      const match = hunkHeader.exec(line);
+      if (current === null || match === null) continue;
+      const start = Number(match[1]);
+      const count = match[2] === void 0 ? 1 : Number(match[2]);
+      current.push(
+        count === 0 ? { start: start + 1, end: start + 1 } : { start, end: start + count - 1 }
+      );
+    }
+  }
+  return touched;
+};
+const readTouchedLines = async ({
+  checkout,
+  mergeBase,
+  head,
+  entries
+}) => {
+  const touched = /* @__PURE__ */ new Map();
+  for (const chunk of chunksOf(entries, diffChunkSize)) {
+    const diff = await git(
+      checkout,
+      [
+        "-c",
+        "core.quotePath=false",
+        "diff",
+        "-U0",
+        "-M",
+        "--no-color",
+        "--no-ext-diff",
+        "--no-textconv",
+        "--no-relative",
+        "--src-prefix=a/",
+        "--dst-prefix=b/",
+        mergeBase,
+        head,
+        "--",
+        ...chunk.flatMap(
+          ({ paths }) => paths.map((path) => `:(literal)${path}`)
+        )
+      ],
+      { maxBuffer: maxTreeBuffer }
+    );
+    for (const [path, ranges] of parseTouchedLines(diff)) {
+      touched.set(path, ranges);
+    }
+  }
+  return touched;
+};
+const splitPackageSpecifier = (specifier) => {
+  const segments = specifier.split("/");
+  const nameLength = specifier.startsWith("@") ? 2 : 1;
+  const rest = segments.slice(nameLength).join("/");
+  return {
+    name: segments.slice(0, nameLength).join("/"),
+    subpath: rest === "" ? "." : `./${rest}`
+  };
+};
+const builtins = new Set(builtinModules);
+const urlScheme = /^[a-z][a-z0-9+.-]*:/;
+const typesPackageOf = (name) => `@types/${name.startsWith("@") ? name.slice(1).replace("/", "__") : name}`;
+const isConventionalAlias = (specifier) => specifier.startsWith("@/") || specifier.startsWith("~");
+const isBuiltinOrUrl = (specifier, name) => urlScheme.test(specifier) || specifier.startsWith("/") || builtins.has(specifier) || builtins.has(name);
+const external = { kind: "external" };
+const createResolver = ({
+  exists,
+  manifests
+}) => {
+  const directoryOfName = /* @__PURE__ */ new Map();
+  for (const [directory, { name }] of manifests) {
+    if (typeof name === "string") directoryOfName.set(name, directory);
+  }
+  const dependenciesByDirectory = /* @__PURE__ */ new Map();
+  const dependenciesOf = (directory) => {
+    const known = dependenciesByDirectory.get(directory);
+    if (known !== void 0) return known;
+    const manifest = manifests.get(directory);
+    const names = new Set(
+      manifest === void 0 ? [] : dependencyNamesOf(manifest)
+    );
+    dependenciesByDirectory.set(directory, names);
+    return names;
+  };
+  const isDependencyOf = (from, name) => {
+    const nearest = manifestDirectoryOf(from, manifests);
+    const wanted = [name, typesPackageOf(name)];
+    return [nearest, ""].some(
+      (directory) => directory !== null && wanted.some((candidate) => dependenciesOf(directory).has(candidate))
+    );
+  };
+  const resolveTarget = (directory, target) => typeof target === "string" && target.startsWith("./") ? resolveRelative(`${directory}/package.json`, target, exists) : null;
+  const resolveInPackage = (directory, subpath) => {
+    const manifest = manifests.get(directory);
+    const { exports } = manifest;
+    if (exports === void 0) {
+      return subpath === "." ? resolveTarget(directory, targetOf(manifest.types) ?? manifest.main) : resolveRelative(`${directory}/package.json`, subpath, exists);
+    }
+    const isSubpathMap = typeof exports === "object" && exports !== null && Object.keys(exports).some((key) => key.startsWith("."));
+    if (!isSubpathMap) {
+      return subpath === "." ? resolveTarget(directory, targetOf(exports)) : null;
+    }
+    const patterns = Object.entries(exports).filter(([pattern]) => pattern.startsWith(".")).toSorted(([left], [right]) => specificity(right) - specificity(left));
+    for (const [pattern, value] of patterns) {
+      const captured = expand(pattern, subpath);
+      if (captured === null) continue;
+      const target = targetOf(value);
+      return resolveTarget(
+        directory,
+        typeof target === "string" ? target.replace("*", captured) : null
+      );
+    }
+    return null;
+  };
+  return (from, specifier) => {
+    if (specifier.startsWith(".") || specifier.startsWith("#")) {
+      const path = resolveLocalSpecifier({
+        from,
+        specifier,
+        exists,
+        manifests
+      });
+      return path === null ? external : { kind: "file", path };
+    }
+    if (isConventionalAlias(specifier)) return { kind: "alias" };
+    const { name, subpath } = splitPackageSpecifier(specifier);
+    const directory = directoryOfName.get(name);
+    if (directory !== void 0) {
+      const path = resolveInPackage(directory, subpath);
+      return path === null ? { kind: "workspaceMiss", directory } : { kind: "file", path };
+    }
+    if (isBuiltinOrUrl(specifier, name) || isDependencyOf(from, name)) {
+      return external;
+    }
+    return { kind: "alias" };
+  };
+};
+const maxStarHops = 4;
+const readSummariesAt = async ({
+  checkout,
+  ref,
+  roots,
+  resolveFile
+}) => {
+  const found = /* @__PURE__ */ new Map();
+  let toRead = [...new Set(roots)];
+  for (let hop = 0; hop < maxStarHops && toRead.length > 0; hop++) {
+    const contents = await catFiles(checkout, ref, toRead);
+    const next = /* @__PURE__ */ new Set();
+    for (const path of toRead) {
+      const source = contents.get(path);
+      if (source === void 0) continue;
+      const summary = summarize(path, source);
+      found.set(path, summary);
+      for (const specifier of starSpecifiers(summary.reExports)) {
+        const target = resolveFile(path, specifier);
+        if (target !== null && !found.has(target)) next.add(target);
+      }
+    }
+    toRead = [...next];
+  }
+  return found;
+};
+const starNames = ({
+  from,
+  specifier,
+  summaryOf,
+  resolveFile
+}) => {
+  const names = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (importer, request) => {
+    const target = resolveFile(importer, request);
+    if (target === null) return false;
+    if (visited.has(target)) return true;
+    visited.add(target);
+    const summary = summaryOf(target);
+    if (summary === void 0) return false;
+    for (const name of summary.exports) {
+      if (name !== "default") names.add(name);
+    }
+    return starSpecifiers(summary.reExports).every(
+      (next) => visit(target, next)
+    );
+  };
+  return visit(from, specifier) ? [...names] : null;
+};
+const buildGraph = ({
+  files,
+  resolve,
+  packageOfFile,
+  changedPackages
+}) => {
+  const importers = /* @__PURE__ */ new Map();
+  const reExporters = /* @__PURE__ */ new Map();
+  const unresolvedIn = /* @__PURE__ */ new Set();
+  const push = (map, key, item) => {
+    const items = map.get(key);
+    if (items === void 0) map.set(key, [item]);
+    else items.push(item);
+  };
+  for (const [path, { imports, reExports }] of files) {
+    const reach = (specifier) => {
+      const resolution = resolve(path, specifier);
+      const importerPackage = packageOfFile(path);
+      if (resolution.kind === "alias" && changedPackages.has(importerPackage) || resolution.kind === "workspaceMiss" && changedPackages.has(
+        resolution.directory === "" ? "." : resolution.directory
+      )) {
+        unresolvedIn.add(importerPackage);
+      }
+      return resolution.kind === "file" ? resolution.path : null;
+    };
+    for (const { specifier, names } of imports) {
+      const target = reach(specifier);
+      if (target !== null) push(importers, target, { from: path, names });
+    }
+    for (const { specifier, local, exported } of reExports) {
+      const target = reach(specifier);
+      if (target !== null) {
+        push(reExporters, target, { from: path, local, exported });
+      }
+    }
+  }
+  return { importers, reExporters, unresolvedIn };
+};
+const importersOf = ({ importers, reExporters }, file, name) => {
+  const found = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set([`${file}\0${name}`]);
+  const stack = [[file, name]];
+  while (stack.length > 0) {
+    const [current, currentName] = stack.pop();
+    for (const { from, names } of importers.get(current) ?? []) {
+      if (names.includes(currentName) || names.includes("*")) found.add(from);
+    }
+    for (const { from, local, exported } of reExporters.get(current) ?? []) {
+      const passesAll = local === "*" && exported === "*";
+      if (local !== "*" && local !== currentName) continue;
+      if (passesAll && currentName === "default") continue;
+      const next = [
+        from,
+        exported === "*" ? currentName : exported
+      ];
+      const key = `${next[0]}\0${next[1]}`;
+      if (visited.has(key)) continue;
+      visited.add(key);
+      stack.push(next);
+    }
+  }
+  found.delete(file);
+  return found;
+};
+const readImpacts = async ({
+  checkout,
+  head,
+  base,
+  cache,
+  maxFiles = maxTypescriptFiles,
+  maxReadMs: budgetMs = maxReadMs
+}) => {
+  if (!isSha(head) || !isSha(base)) {
+    throw new Error("head and base must be commit shas");
+  }
+  await ensureCommits(checkout, [head, base], void 0);
+  const mergeBaseOutput = await git(checkout, ["merge-base", base, head]);
+  const mergeBase = mergeBaseOutput.trim();
+  const numstat = await readNumstat(checkout, [mergeBase, head], []);
+  const blobs = await listBlobs(checkout, head);
+  const treePaths = blobs.map(({ path }) => path);
+  const inTree = new Set(treePaths);
+  const typescriptBlobs = blobs.filter(
+    ({ path }) => isTypescriptPath(path) && !isInNodeModules(path)
+  );
+  if (typescriptBlobs.length > maxFiles) {
+    return { tooLarge: true, reason: "files" };
+  }
+  const summaries = await readSummaries({
+    checkout,
+    head,
+    blobs: typescriptBlobs,
+    cache,
+    budgetMs
+  });
+  if (summaries === null) return { tooLarge: true, reason: "time" };
+  const manifests = await readManifests(checkout, head, treePaths);
+  const files = new Map(
+    typescriptBlobs.map(({ path, oid }) => [path, summaries.get(oid)])
+  );
+  const packageOfFile = (path) => manifestDirectoryOf(path, manifests) || ".";
+  const analyzed = numstat.filter(({ path }) => files.has(path));
+  const resolve = createResolver({
+    exists: (path) => inTree.has(path),
+    manifests
+  });
+  const resolveFile = (from, specifier) => {
+    const resolution = resolve(from, specifier);
+    return resolution.kind === "file" ? resolution.path : null;
+  };
+  const graph = buildGraph({
+    files,
+    resolve,
+    packageOfFile,
+    changedPackages: new Set(analyzed.map(({ path }) => packageOfFile(path)))
+  });
+  const changedSet = new Set(numstat.map(({ path }) => path));
+  const notAnalyzed = numstat.filter(({ path }) => !files.has(path)).map(({ path }) => path);
+  const touchedLines = await readTouchedLines({
+    checkout,
+    mergeBase,
+    head,
+    entries: analyzed
+  });
+  const sources = await catFiles(
+    checkout,
+    head,
+    analyzed.map(({ path }) => path)
+  );
+  const baseSources = await catFiles(
+    checkout,
+    mergeBase,
+    analyzed.map(({ paths }) => paths[0])
+  );
+  const impacts = [];
+  for (const { path, paths } of analyzed) {
+    const source = sources.get(path);
+    if (source === void 0) {
+      notAnalyzed.push(path);
+      continue;
+    }
+    const baseSource = baseSources.get(paths[0]);
+    const baseBindings = baseSource === void 0 ? void 0 : exportedBindings(path, baseSource);
+    const { touched, removed, touchedStars, removedStars } = touchedExports({
+      path,
+      source,
+      touchedLines: touchedLines.get(path) ?? [],
+      baseExports: baseBindings === void 0 ? [] : exportedNames(baseBindings),
+      baseStars: baseBindings === void 0 ? [] : starSpecifiers(baseBindings.reExports)
+    });
+    let starsUnknown = false;
+    const known = (names) => {
+      if (names === null) starsUnknown = true;
+      return names ?? [];
+    };
+    const starNamesAtHead = (specifier) => known(
+      starNames({
+        from: path,
+        specifier,
+        summaryOf: (target) => files.get(target),
+        resolveFile
+      })
+    );
+    const baseSummaries = removedStars.length === 0 ? /* @__PURE__ */ new Map() : await readSummariesAt({
+      checkout,
+      ref: mergeBase,
+      roots: removedStars.flatMap(
+        (specifier) => resolveFile(paths[0], specifier) ?? []
+      ),
+      resolveFile
+    });
+    const removedByStars = removedStars.flatMap(
+      (specifier) => known(
+        starNames({
+          from: paths[0],
+          specifier,
+          summaryOf: (target) => baseSummaries.get(target),
+          resolveFile
+        })
+      )
+    );
+    const headSummary = files.get(path);
+    const stillExported = /* @__PURE__ */ new Set([
+      ...headSummary.exports,
+      ...removed.length + removedByStars.length === 0 ? [] : starSpecifiers(headSummary.reExports).flatMap(starNamesAtHead)
+    ]);
+    const touchedNames = /* @__PURE__ */ new Set([
+      ...touched,
+      ...touchedStars.flatMap(starNamesAtHead)
+    ]);
+    const removedNames = new Set(
+      [...removed, ...removedByStars].filter(
+        (name) => !stillExported.has(name)
+      )
+    );
+    if (starsUnknown && !notAnalyzed.includes(path)) notAnalyzed.push(path);
+    const exports = [
+      ...[...touchedNames].map((name) => ({ name, removed: false })),
+      ...[...removedNames].map((name) => ({ name, removed: true }))
+    ].flatMap(({ name, removed: isRemoved }) => {
+      const importers = [...importersOf(graph, path, name)].filter((importer) => !changedSet.has(importer)).toSorted((left, right) => left.localeCompare(right)).map((importer) => ({
+        path: importer,
+        test: isAttachablePath(importer)
+      }));
+      return importers.length === 0 ? [] : [{ name, removed: isRemoved, importers }];
+    });
+    if (exports.length > 0) impacts.push({ path, exports });
+  }
+  return {
+    tooLarge: false,
+    files: impacts,
+    notAnalyzed,
+    unresolvedIn: [...graph.unresolvedIn].toSorted(
+      (left, right) => left.localeCompare(right)
+    )
+  };
+};
+
+export { createBindingsCache, defaultDiffLimits, git, gitFailedCode, gitOrNull, groupDiffPaths, maxTypescriptFiles, noPackages, packagesAtTree, packagesOnDisk, parseNumstat, readBranchDiff, readFileAtSha, readImpacts, readPullRequestDiff, readReadingOrder, reasonLine };
+//# sourceMappingURL=git-node.mjs.map