@reviewflow/sdk 0.0.0-stage → 6.22.0

package/build/index-browser.es.js

@@ -0,0 +1,3328 @@
+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 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 directoryOf = (path) => {
+  const slash = path.lastIndexOf("/");
+  return slash === -1 ? "" : path.slice(0, slash);
+};
+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 diffThemes = [
+  "github",
+  "github-high-contrast",
+  "pierre",
+  "vscode",
+  "one",
+  "catppuccin",
+  "rose-pine",
+  "solarized",
+  "gruvbox",
+  "everforest",
+  "kanagawa",
+  "vitesse",
+  "ayu",
+  "material",
+  "night-owl",
+  "min"
+];
+const isDiffTheme = (value) => diffThemes.includes(value);
+const families = {
+  github: {
+    label: "GitHub",
+    themes: { light: "github-light-default", dark: "github-dark-default" }
+  },
+  "github-high-contrast": {
+    label: "GitHub high contrast",
+    themes: {
+      light: "github-light-high-contrast",
+      dark: "github-dark-high-contrast"
+    }
+  },
+  pierre: {
+    label: "Pierre",
+    themes: { light: "pierre-light", dark: "pierre-dark" }
+  },
+  vscode: {
+    label: "VS Code",
+    themes: { light: "light-plus", dark: "dark-plus" }
+  },
+  one: { label: "One", themes: { light: "one-light", dark: "one-dark-pro" } },
+  catppuccin: {
+    label: "Catppuccin",
+    themes: { light: "catppuccin-latte", dark: "catppuccin-mocha" }
+  },
+  "rose-pine": {
+    label: "Ros\xE9 Pine",
+    themes: { light: "rose-pine-dawn", dark: "rose-pine" }
+  },
+  solarized: {
+    label: "Solarized",
+    themes: { light: "solarized-light", dark: "solarized-dark" }
+  },
+  gruvbox: {
+    label: "Gruvbox",
+    themes: { light: "gruvbox-light-medium", dark: "gruvbox-dark-medium" }
+  },
+  everforest: {
+    label: "Everforest",
+    themes: { light: "everforest-light", dark: "everforest-dark" }
+  },
+  kanagawa: {
+    label: "Kanagawa",
+    themes: { light: "kanagawa-lotus", dark: "kanagawa-wave" }
+  },
+  vitesse: {
+    label: "Vitesse",
+    themes: { light: "vitesse-light", dark: "vitesse-dark" }
+  },
+  ayu: { label: "Ayu", themes: { light: "ayu-light", dark: "ayu-dark" } },
+  material: {
+    label: "Material",
+    themes: { light: "material-theme-lighter", dark: "material-theme" }
+  },
+  "night-owl": {
+    label: "Night Owl",
+    themes: { light: "night-owl-light", dark: "night-owl" }
+  },
+  min: { label: "Min", themes: { light: "min-light", dark: "min-dark" } }
+};
+const diffThemeNames = (theme) => families[theme].themes;
+const diffThemeOptions = diffThemes.map((theme) => ({
+  value: theme,
+  label: families[theme].label
+}));
+
+const isDiffWhitespace = (value) => value === "hide" || value === "show";
+
+const fenceOpen = /^( {0,3})(`{3,}(?!`)|~{3,}(?!~))(.*)$/;
+const withoutIndent = (line, indent) => {
+  let index = 0;
+  while (index < indent && line[index] === " ") index += 1;
+  return line.slice(index);
+};
+const parseSuggestions = (body) => {
+  const lines = body.replaceAll("\r\n", "\n").split("\n");
+  const suggestions = [];
+  let index = 0;
+  while (index < lines.length) {
+    const open = fenceOpen.exec(lines[index] ?? "");
+    index += 1;
+    if (open === null) continue;
+    const [, indent = "", fence = "", info = ""] = open;
+    if (fence.startsWith("`") && info.includes("`")) continue;
+    const close = new RegExp(
+      `^ {0,3}${fence[0] ?? ""}{${String(fence.length)},}[ \\t]*$`
+    );
+    const content = [];
+    while (index < lines.length && !close.test(lines[index] ?? "")) {
+      content.push(withoutIndent(lines[index] ?? "", indent.length));
+      index += 1;
+    }
+    index += 1;
+    if (info.trim().split(/\s/)[0] === "suggestion") suggestions.push(content);
+  }
+  return suggestions;
+};
+const rangeLength = (start, end) => {
+  if (end === null) return null;
+  return end - (start ?? end) + 1;
+};
+const suggestionOriginalLines = (thread) => {
+  const count = thread.line === null ? rangeLength(thread.originalStartLine, thread.originalLine) : rangeLength(thread.startLine, thread.line);
+  if (count === null || count < 1) return null;
+  const dropped = thread.side === "RIGHT" ? "-" : "+";
+  const sideLines = thread.diffHunk.replaceAll("\r\n", "\n").split("\n").filter(
+    (line) => !line.startsWith("@@") && !line.startsWith("\\") && !line.startsWith(dropped)
+  );
+  if (sideLines.length < count) return null;
+  return sideLines.slice(-count).map((line) => line.slice(1));
+};
+const suggestionCommitRefusal = ({
+  state,
+  viewerCanApplySuggestion,
+  suggestionCount,
+  outdated,
+  line,
+  side,
+  startSide
+}) => {
+  if (state === "closed" || state === "merged") {
+    return `The pull request is ${state}`;
+  }
+  if (!viewerCanApplySuggestion) {
+    return "GitHub does not let you commit to this pull request's branch";
+  }
+  if (suggestionCount === 0) return "The comment holds no suggestion";
+  if (suggestionCount > 1) {
+    return "The comment holds more than one suggestion: GitHub commits one per comment";
+  }
+  if (outdated || line === null) {
+    return "Outdated: the lines it replaces changed since";
+  }
+  if (side === "LEFT" || startSide === "LEFT") {
+    return "It is on removed lines, which the branch no longer has";
+  }
+  return null;
+};
+const suggestionRangesOverlap = (a, b) => a.path === b.path && (a.startLine ?? a.line) <= b.line && (b.startLine ?? b.line) <= a.line;
+
+const prFields = `fragment prFields on PullRequest {
+  number
+  state
+  isDraft
+  reviewDecision
+  mergedAt
+  mergeable
+  headRefOid
+  baseRefName
+  commits(last: 1) {
+    nodes {
+      commit {
+        statusCheckRollup {
+          contexts(first: 1) {
+            checkRunCountsByState { count state }
+            statusContextCountsByState { count state }
+          }
+        }
+      }
+    }
+  }
+}`;
+const splitOwnerRepo = (ownerRepo) => {
+  const segments = ownerRepo.split("/");
+  const [owner, name] = segments;
+  if (segments.length !== 2 || !owner || !name) return null;
+  return { owner, name };
+};
+const buildPrQuery = (targets) => {
+  const byRepo = /* @__PURE__ */ new Map();
+  const targetsByAlias = /* @__PURE__ */ new Map();
+  targets.forEach((target, index) => {
+    if (target.branch === "" || splitOwnerRepo(target.ownerRepo) === null) {
+      return;
+    }
+    const alias = `t${String(index)}`;
+    targetsByAlias.set(alias, target);
+    const existing = byRepo.get(target.ownerRepo);
+    const entry = { alias, branch: target.branch };
+    if (existing) existing.push(entry);
+    else byRepo.set(target.ownerRepo, [entry]);
+  });
+  if (targetsByAlias.size === 0) return null;
+  const repoBlocks = [...byRepo].map(([ownerRepo, branches], repoIndex) => {
+    const { owner, name } = splitOwnerRepo(ownerRepo);
+    const branchFields = branches.map(
+      ({ alias, branch }) => (
+        // Newest first: a branch that had a closed PR and then a new one is
+        // described by the new one, and `first: 1` is what keeps the cost flat.
+        `    ${alias}: pullRequests(headRefName: ${JSON.stringify(branch)}, first: 1, orderBy: { field: CREATED_AT, direction: DESC }) { nodes { ...prFields } }`
+      )
+    );
+    return [
+      `  r${String(repoIndex)}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {`,
+      ...branchFields,
+      "  }"
+    ].join("\n");
+  });
+  return {
+    query: `query {
+${repoBlocks.join("\n")}
+}
+
+${prFields}`,
+    targetsByAlias
+  };
+};
+const checkOutcomes = /* @__PURE__ */ new Map([
+  ["ACTION_REQUIRED", "failed"],
+  ["ERROR", "failed"],
+  ["FAILURE", "failed"],
+  ["STARTUP_FAILURE", "failed"],
+  ["TIMED_OUT", "failed"],
+  ["COMPLETED", "passed"],
+  ["NEUTRAL", "passed"],
+  ["SKIPPED", "passed"],
+  ["SUCCESS", "passed"],
+  ["CANCELLED", "pending"],
+  ["EXPECTED", "pending"],
+  ["IN_PROGRESS", "pending"],
+  ["PENDING", "pending"],
+  ["QUEUED", "pending"],
+  ["STALE", "pending"],
+  ["WAITING", "pending"]
+]);
+const countChecks = (pullRequest) => {
+  const totals = { failed: 0, passed: 0, pending: 0 };
+  const contexts = pullRequest.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
+  for (const { count, state } of [
+    ...contexts?.checkRunCountsByState ?? [],
+    ...contexts?.statusContextCountsByState ?? []
+  ]) {
+    const outcome = checkOutcomes.get(state);
+    if (outcome !== void 0) totals[outcome] += count;
+  }
+  return {
+    checksPassed: totals.passed,
+    checksFailed: totals.failed,
+    checksPending: totals.pending
+  };
+};
+const prStates$1 = /* @__PURE__ */ new Map([
+  ["CLOSED", "closed"],
+  ["MERGED", "merged"]
+]);
+const toPrState$1 = (state, isDraft) => {
+  if (state === "OPEN") return isDraft ? "draft" : "open";
+  return prStates$1.get(state) ?? null;
+};
+const reviewDecisions$1 = /* @__PURE__ */ new Map([
+  ["APPROVED", "approved"],
+  ["CHANGES_REQUESTED", "changesRequested"],
+  ["REVIEW_REQUIRED", "reviewRequired"]
+]);
+const mergeables$2 = /* @__PURE__ */ new Map([
+  ["CONFLICTING", "conflicting"],
+  ["MERGEABLE", "mergeable"]
+]);
+const toFetchedPr = (target, pullRequest) => {
+  const state = toPrState$1(pullRequest.state, pullRequest.isDraft);
+  if (state === null) return null;
+  return {
+    target,
+    number: pullRequest.number,
+    state,
+    reviewDecision: pullRequest.reviewDecision === null ? null : reviewDecisions$1.get(pullRequest.reviewDecision) ?? null,
+    mergeable: mergeables$2.get(pullRequest.mergeable) ?? "unknown",
+    mergedAt: pullRequest.mergedAt,
+    headSha: pullRequest.headRefOid,
+    baseRef: pullRequest.baseRefName,
+    ...countChecks(pullRequest)
+  };
+};
+const parsePrQueryResponse = (data, targetsByAlias) => {
+  if (data === null) return [];
+  const found = [];
+  for (const repository of Object.values(data)) {
+    if (!repository) continue;
+    for (const [alias, connection] of Object.entries(repository)) {
+      const target = targetsByAlias.get(alias);
+      const pullRequest = connection?.nodes?.[0];
+      if (!target || !pullRequest) continue;
+      const fetched = toFetchedPr(target, pullRequest);
+      if (fetched !== null) found.push(fetched);
+    }
+  }
+  return found;
+};
+
+const suggestionsQuery = `query SuggestionsToApply($owner: String!, $name: String!, $number: Int!, $threadIds: [ID!]!, $commentIds: [ID!]!) {
+  viewer { login }
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      id state headRefOid headRefName viewerCanApplySuggestion
+      headRepository { nameWithOwner }
+    }
+  }
+  threads: nodes(ids: $threadIds) {
+    ... on PullRequestReviewThread {
+      id path line startLine diffSide startDiffSide isOutdated isResolved
+      pullRequest { id }
+      comments(first: 1) { nodes { id } }
+    }
+  }
+  comments: nodes(ids: $commentIds) {
+    ... on PullRequestReviewComment {
+      id body state
+      replyTo { id }
+      author { login ... on User { databaseId name } }
+    }
+  }
+}`;
+const toPrState = (state) => {
+  if (state === "MERGED") return "merged";
+  if (state === "CLOSED") return "closed";
+  return "open";
+};
+const toSide$1 = (side) => {
+  if (side === null) return null;
+  return side === "LEFT" ? "LEFT" : "RIGHT";
+};
+const planSuggestions = (answer, edit) => {
+  const pullRequest = answer.repository?.pullRequest;
+  if (pullRequest === null || pullRequest === void 0) {
+    throw new Error("the pull request is not found");
+  }
+  if (pullRequest.headRefOid !== edit.expectedHeadSha) {
+    throw new Error(
+      `the pull request moved on to ${pullRequest.headRefOid.slice(0, 7)} since ${edit.expectedHeadSha.slice(0, 7)}: read it again before committing`
+    );
+  }
+  if (pullRequest.headRepository === null) {
+    throw new Error("the head branch's repository no longer exists");
+  }
+  const suggestions = [];
+  edit.suggestions.forEach((ref, index) => {
+    const thread = answer.threads[index];
+    const comment = answer.comments[index];
+    if (thread?.id !== ref.threadId) {
+      throw new Error(`no review thread ${ref.threadId}`);
+    }
+    if (thread.pullRequest.id !== pullRequest.id) {
+      throw new Error(`thread ${ref.threadId} is not of this pull request`);
+    }
+    if (comment?.id !== ref.commentId) {
+      throw new Error(`no review comment ${ref.commentId}`);
+    }
+    const root = comment.replyTo?.id ?? comment.id;
+    if (root !== thread.comments.nodes?.[0]?.id) {
+      throw new Error(`comment ${ref.commentId} is not in that thread`);
+    }
+    if (comment.state === "PENDING") {
+      throw new Error("a suggestion in a pending review cannot be committed");
+    }
+    const parsed = parseSuggestions(comment.body);
+    const refusal = suggestionCommitRefusal({
+      state: toPrState(pullRequest.state),
+      viewerCanApplySuggestion: pullRequest.viewerCanApplySuggestion,
+      suggestionCount: parsed.length,
+      outdated: thread.isOutdated,
+      line: thread.line,
+      side: toSide$1(thread.diffSide) ?? "RIGHT",
+      startSide: toSide$1(thread.startDiffSide)
+    });
+    const [lines] = parsed;
+    if (refusal !== null || thread.line === null || lines === void 0) {
+      throw new Error(`${thread.path}: ${refusal ?? "nothing to commit"}`);
+    }
+    const planned = {
+      threadId: thread.id,
+      resolved: thread.isResolved,
+      path: thread.path,
+      startLine: thread.startLine,
+      line: thread.line,
+      lines,
+      author: comment.author
+    };
+    if (suggestions.some((other) => suggestionRangesOverlap(other, planned))) {
+      throw new Error(
+        `${planned.path}: two suggestions of the batch replace line ${String(planned.line)}`
+      );
+    }
+    suggestions.push(planned);
+  });
+  return {
+    repositoryNameWithOwner: pullRequest.headRepository.nameWithOwner,
+    branchName: pullRequest.headRefName,
+    viewerLogin: answer.viewer.login,
+    suggestions
+  };
+};
+const applySuggestionsToText = (text, suggestions) => {
+  const eol = text.includes("\r\n") ? "\r" : "";
+  const lines = text.split("\n");
+  const endsWithNewline = lines.at(-1) === "";
+  const lineCount = endsWithNewline ? lines.length - 1 : lines.length;
+  const bottomFirst = suggestions.toSorted((a, b) => b.line - a.line);
+  for (const { startLine, line, lines: replacement } of bottomFirst) {
+    if (line > lineCount) {
+      throw new Error(
+        `line ${String(line)} is past the end of the file, ${String(lineCount)} lines long`
+      );
+    }
+    const first = startLine ?? line;
+    const isLastLine = line === lineCount && !endsWithNewline;
+    const put = replacement.map(
+      (content, index) => isLastLine && index === replacement.length - 1 ? content : content + eol
+    );
+    lines.splice(first - 1, line - first + 1, ...put);
+  }
+  return lines.join("\n");
+};
+const coAuthorTrailers = (authors, viewerLogin) => {
+  const seen = /* @__PURE__ */ new Set([viewerLogin]);
+  const trailers = [];
+  for (const author of authors) {
+    if (author?.databaseId === void 0 || seen.has(author.login)) continue;
+    seen.add(author.login);
+    const name = author.name === null || author.name === void 0 || author.name === "" ? author.login : author.name;
+    trailers.push(
+      `Co-authored-by: ${name} <${String(author.databaseId)}+${author.login}@users.noreply.github.com>`
+    );
+  }
+  return trailers;
+};
+const fileQuery = (count) => {
+  const indexes = Array.from({ length: count }, (_, index) => index);
+  const variables = indexes.map((index) => `$e${String(index)}: String!`).join(", ");
+  const fields = indexes.map(
+    (index) => `f${String(index)}: object(expression: $e${String(index)}) { ... on Blob { text isBinary isTruncated } }`
+  ).join("\n    ");
+  return `query SuggestedFiles($owner: String!, $name: String!, ${variables}) {
+  repository(owner: $owner, name: $name) {
+    ${fields}
+  }
+}`;
+};
+const readFiles = async (transport, nameWithOwner, sha, paths) => {
+  const split = splitOwnerRepo(nameWithOwner);
+  if (split === null) throw new Error(`${nameWithOwner} is not owner/repo`);
+  const variables = Object.fromEntries(
+    paths.map((path, index) => [`e${String(index)}`, `${sha}:${path}`])
+  );
+  const { data, errors } = await transport.graphql(fileQuery(paths.length), { ...split, ...variables });
+  if (errors.length > 0) {
+    throw new Error(`GitHub refused reading the files: ${errors.join("; ")}`);
+  }
+  const files = /* @__PURE__ */ new Map();
+  paths.forEach((path, index) => {
+    const blob = data?.repository?.[`f${String(index)}`];
+    const text = blob?.text;
+    if (text === null || text === void 0 || blob?.isBinary === true || blob?.isTruncated === true) {
+      throw new Error(`${path} cannot be read as text at ${sha.slice(0, 7)}`);
+    }
+    files.set(path, text);
+  });
+  return files;
+};
+const createCommitMutation = `mutation CommitSuggestions($input: CreateCommitOnBranchInput!) {
+  createCommitOnBranch(input: $input) { commit { oid } }
+}`;
+const toBase64 = (text) => {
+  let binary = "";
+  for (const byte of new TextEncoder().encode(text)) {
+    binary += String.fromCodePoint(byte);
+  }
+  return btoa(binary);
+};
+const messageBody = (body, trailers) => [body.trim(), trailers.join("\n")].filter((part) => part !== "").join("\n\n");
+const commitSuggestions = async (transport, {
+  ownerRepo,
+  number,
+  edit
+}) => {
+  const split = splitOwnerRepo(ownerRepo);
+  if (split === null) throw new Error(`${ownerRepo} is not owner/repo`);
+  const lookup = await transport.graphql(suggestionsQuery, {
+    ...split,
+    number,
+    threadIds: edit.suggestions.map(({ threadId }) => threadId),
+    commentIds: edit.suggestions.map(({ commentId }) => commentId)
+  });
+  if (lookup.data === null) {
+    throw new Error(
+      `GitHub refused reading the suggestions: ${lookup.errors.join("; ") || "no answer"}`
+    );
+  }
+  const plan = planSuggestions(lookup.data, edit);
+  const paths = [...new Set(plan.suggestions.map(({ path }) => path))];
+  const files = await readFiles(
+    transport,
+    plan.repositoryNameWithOwner,
+    edit.expectedHeadSha,
+    paths
+  );
+  const additions = paths.map((path) => {
+    const text = applySuggestionsToText(
+      files.get(path) ?? "",
+      plan.suggestions.filter((suggestion) => suggestion.path === path)
+    );
+    return { path, contents: toBase64(text) };
+  });
+  const { errors } = await transport.graphql(createCommitMutation, {
+    input: {
+      branch: {
+        repositoryNameWithOwner: plan.repositoryNameWithOwner,
+        branchName: plan.branchName
+      },
+      expectedHeadOid: edit.expectedHeadSha,
+      message: {
+        headline: edit.headline,
+        body: messageBody(
+          edit.body,
+          coAuthorTrailers(
+            plan.suggestions.map(({ author }) => author),
+            plan.viewerLogin
+          )
+        )
+      },
+      fileChanges: { additions }
+    }
+  });
+  if (errors.length > 0) {
+    throw new Error(`GitHub refused the commit: ${errors.join("; ")}`);
+  }
+  return plan.suggestions.filter(({ resolved }) => !resolved).map(({ threadId }) => threadId);
+};
+
+const pullRequestReactionContents = [
+  "thumbsUp",
+  "thumbsDown",
+  "laugh",
+  "hooray",
+  "confused",
+  "heart",
+  "rocket",
+  "eyes"
+];
+const isPullRequestReactionContent = (value) => pullRequestReactionContents.includes(value);
+
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const isNonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
+const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+const isSha = (value) => typeof value === "string" && /^[\da-f]{40}$/i.test(value);
+const isSide = (value) => value === "LEFT" || value === "RIGHT";
+const mergeMethods = ["merge", "rebase", "squash"];
+const reviewEvents = [
+  "approve",
+  "comment",
+  "requestChanges"
+];
+const editCommentTargets = ["issueComment", "review", "reviewComment"];
+const parseMergeCommitMessage = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return "a commit message must be an object";
+  }
+  const message = value;
+  if (!isNonEmptyString(message.title)) return "a commit needs a title";
+  if (typeof message.body !== "string") return "a commit body must be a string";
+  return { title: message.title, body: message.body };
+};
+const parseDraftComment = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return "a comment must be an object";
+  }
+  const comment = value;
+  if (!isNonEmptyString(comment.path)) return "a comment needs a path";
+  if (!isNonEmptyString(comment.body)) return "a comment cannot be empty";
+  if (!isSide(comment.side)) return "a comment side must be LEFT or RIGHT";
+  if (!isPositiveInteger(comment.line)) {
+    return "a comment line must be a positive integer";
+  }
+  const startLine = comment.startLine ?? null;
+  const startSide = comment.startSide ?? null;
+  if (startLine === null) {
+    if (startSide !== null) return "startSide needs a startLine";
+  } else {
+    if (!isPositiveInteger(startLine)) {
+      return "startLine must be a positive integer";
+    }
+    if (startLine > comment.line) return "startLine cannot follow line";
+    if (!isSide(startSide)) return "a range needs startSide, LEFT or RIGHT";
+  }
+  return {
+    path: comment.path,
+    side: comment.side,
+    line: comment.line,
+    startLine,
+    startSide,
+    body: comment.body
+  };
+};
+const parseReview = (edit) => {
+  if (!reviewEvents.includes(edit.event)) {
+    return "a review event must be approve, comment or requestChanges";
+  }
+  const event = edit.event;
+  if (typeof edit.body !== "string") return "a review body must be a string";
+  if (!isSha(edit.commitId)) return "a review needs the head commit sha";
+  if (!Array.isArray(edit.comments)) return "a review takes a comments array";
+  const comments = [];
+  for (const raw of edit.comments) {
+    const parsed = parseDraftComment(raw);
+    if (typeof parsed === "string") return parsed;
+    comments.push(parsed);
+  }
+  if (event === "requestChanges" && edit.body.trim() === "") {
+    return "requesting changes needs a body";
+  }
+  if (event === "comment" && edit.body.trim() === "" && comments.length === 0) {
+    return "a comment review needs a body or a comment";
+  }
+  return {
+    kind: "review",
+    event,
+    body: edit.body,
+    commitId: edit.commitId,
+    comments
+  };
+};
+const parseSuggestionRef = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return "a suggestion must be an object";
+  }
+  const ref = value;
+  if (!isNonEmptyString(ref.threadId)) return "a suggestion needs its threadId";
+  if (!isNonEmptyString(ref.commentId)) {
+    return "a suggestion needs its commentId";
+  }
+  return { threadId: ref.threadId, commentId: ref.commentId };
+};
+const parseApplySuggestions = (edit) => {
+  if (!isSha(edit.expectedHeadSha)) {
+    return "committing suggestions needs the head sha the screen read";
+  }
+  if (!Array.isArray(edit.suggestions) || edit.suggestions.length === 0) {
+    return "suggestions must be a non-empty array";
+  }
+  const suggestions = [];
+  for (const raw of edit.suggestions) {
+    const parsed = parseSuggestionRef(raw);
+    if (typeof parsed === "string") return parsed;
+    suggestions.push(parsed);
+  }
+  if (!isNonEmptyString(edit.headline)) return "a commit needs a headline";
+  if (typeof edit.body !== "string") return "a commit body must be a string";
+  return {
+    kind: "applySuggestions",
+    expectedHeadSha: edit.expectedHeadSha,
+    suggestions,
+    headline: edit.headline.trim(),
+    body: edit.body
+  };
+};
+const parsePullRequestEdit = (value) => {
+  if (typeof value !== "object" || value === null) return "edit is required";
+  const edit = value;
+  switch (edit.kind) {
+    case "title": {
+      if (typeof edit.title !== "string" || edit.title.trim() === "") {
+        return "a title cannot be empty";
+      }
+      return { kind: "title", title: edit.title.trim() };
+    }
+    case "labels": {
+      if (!isStringArray(edit.add) || !isStringArray(edit.remove)) {
+        return "labels take add and remove, arrays of names";
+      }
+      return { kind: "labels", add: edit.add, remove: edit.remove };
+    }
+    case "reviewers": {
+      if (!isStringArray(edit.add) || !isStringArray(edit.remove) || !isStringArray(edit.addTeams) || !isStringArray(edit.removeTeams)) {
+        return "reviewers take add, remove, addTeams and removeTeams, arrays of logins and team slugs";
+      }
+      return {
+        kind: "reviewers",
+        add: edit.add,
+        remove: edit.remove,
+        addTeams: edit.addTeams,
+        removeTeams: edit.removeTeams
+      };
+    }
+    case "draft": {
+      if (typeof edit.draft !== "boolean") return "draft must be a boolean";
+      return { kind: "draft", draft: edit.draft };
+    }
+    case "assignees": {
+      if (!isStringArray(edit.add) || !isStringArray(edit.remove)) {
+        return "assignees take add and remove, arrays of logins";
+      }
+      return { kind: "assignees", add: edit.add, remove: edit.remove };
+    }
+    case "body": {
+      if (typeof edit.body !== "string") return "body must be a string";
+      return { kind: "body", body: edit.body };
+    }
+    case "state": {
+      if (edit.state !== "closed" && edit.state !== "open") {
+        return "state must be closed or open";
+      }
+      return { kind: "state", state: edit.state };
+    }
+    case "merge": {
+      if (!mergeMethods.includes(edit.method)) {
+        return "a merge method must be merge, rebase or squash";
+      }
+      if (!isSha(edit.expectedHeadSha)) {
+        return "a merge needs the head sha the screen read";
+      }
+      const merge = {
+        kind: "merge",
+        method: edit.method,
+        expectedHeadSha: edit.expectedHeadSha
+      };
+      if (edit.commitMessage === void 0) return merge;
+      if (merge.method === "rebase") return "a rebase writes no commit message";
+      const commitMessage = parseMergeCommitMessage(edit.commitMessage);
+      if (typeof commitMessage === "string") return commitMessage;
+      return { ...merge, commitMessage };
+    }
+    case "updateBranch": {
+      if (!isSha(edit.expectedHeadSha)) {
+        return "updating the branch needs the head sha the screen read";
+      }
+      return { kind: "updateBranch", expectedHeadSha: edit.expectedHeadSha };
+    }
+    case "comment": {
+      if (!isNonEmptyString(edit.body)) return "a comment cannot be empty";
+      return { kind: "comment", body: edit.body };
+    }
+    case "editComment": {
+      if (!editCommentTargets.includes(
+        edit.target
+      )) {
+        return "editComment target must be issueComment, review or reviewComment";
+      }
+      if (!isPositiveInteger(edit.databaseId)) {
+        return "editComment needs the comment's databaseId";
+      }
+      if (!isNonEmptyString(edit.body)) return "a comment cannot be empty";
+      return {
+        kind: "editComment",
+        target: edit.target,
+        databaseId: edit.databaseId,
+        body: edit.body
+      };
+    }
+    case "reply": {
+      if (!isPositiveInteger(edit.inReplyTo)) {
+        return "a reply needs the databaseId of a comment of the thread";
+      }
+      if (!isNonEmptyString(edit.body)) return "a reply cannot be empty";
+      return { kind: "reply", inReplyTo: edit.inReplyTo, body: edit.body };
+    }
+    case "reaction": {
+      if (!isNonEmptyString(edit.subjectId)) {
+        return "a reaction needs the id of what it reacts to";
+      }
+      if (!isPullRequestReactionContent(edit.content)) {
+        return "unknown reaction content";
+      }
+      if (typeof edit.reacted !== "boolean") return "reacted must be a boolean";
+      return {
+        kind: "reaction",
+        subjectId: edit.subjectId,
+        content: edit.content,
+        reacted: edit.reacted
+      };
+    }
+    case "resolveThread": {
+      if (!isNonEmptyString(edit.threadId)) return "a thread id is required";
+      if (typeof edit.resolved !== "boolean") {
+        return "resolved must be a boolean";
+      }
+      return {
+        kind: "resolveThread",
+        threadId: edit.threadId,
+        resolved: edit.resolved
+      };
+    }
+    case "viewed": {
+      if (!isNonEmptyString(edit.path)) return "a file path is required";
+      if (typeof edit.viewed !== "boolean") return "viewed must be a boolean";
+      return { kind: "viewed", path: edit.path, viewed: edit.viewed };
+    }
+    case "review": {
+      return parseReview(edit);
+    }
+    case "applySuggestions": {
+      return parseApplySuggestions(edit);
+    }
+    case "inlineComment": {
+      if (!isSha(edit.commitId)) return "a comment needs the head commit sha";
+      const comment = parseDraftComment(edit.comment);
+      if (typeof comment === "string") return comment;
+      return { kind: "inlineComment", commitId: edit.commitId, comment };
+    }
+    default: {
+      return "unknown edit kind";
+    }
+  }
+};
+const pullRequestIdQuery = `query PullRequestId($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) { pullRequest(number: $number) { id } }
+}`;
+const readyForReviewMutation = `mutation ReadyForReview($id: ID!) {
+  markPullRequestReadyForReview(input: { pullRequestId: $id }) { pullRequest { isDraft } }
+}`;
+const convertToDraftMutation = `mutation ConvertToDraft($id: ID!) {
+  convertPullRequestToDraft(input: { pullRequestId: $id }) { pullRequest { isDraft } }
+}`;
+const resolveThreadMutation = `mutation ResolveThread($threadId: ID!) {
+  resolveReviewThread(input: { threadId: $threadId }) { thread { isResolved } }
+}`;
+const unresolveThreadMutation = `mutation UnresolveThread($threadId: ID!) {
+  unresolveReviewThread(input: { threadId: $threadId }) { thread { isResolved } }
+}`;
+const addReactionMutation = `mutation AddReaction($subjectId: ID!, $content: ReactionContent!) {
+  addReaction(input: { subjectId: $subjectId, content: $content }) { reaction { content } }
+}`;
+const removeReactionMutation = `mutation RemoveReaction($subjectId: ID!, $content: ReactionContent!) {
+  removeReaction(input: { subjectId: $subjectId, content: $content }) { reaction { content } }
+}`;
+const reactionContentNames = {
+  confused: "CONFUSED",
+  eyes: "EYES",
+  heart: "HEART",
+  hooray: "HOORAY",
+  laugh: "LAUGH",
+  rocket: "ROCKET",
+  thumbsDown: "THUMBS_DOWN",
+  thumbsUp: "THUMBS_UP"
+};
+const markViewedMutation = `mutation MarkViewed($id: ID!, $path: String!) {
+  markFileAsViewed(input: { pullRequestId: $id, path: $path }) { clientMutationId }
+}`;
+const unmarkViewedMutation = `mutation UnmarkViewed($id: ID!, $path: String!) {
+  unmarkFileAsViewed(input: { pullRequestId: $id, path: $path }) { clientMutationId }
+}`;
+const lookupPullRequestId = async (transport, { owner, name, number }) => {
+  const lookup = await transport.graphql(pullRequestIdQuery, { owner, name, number });
+  const id = lookup.data?.repository?.pullRequest?.id;
+  if (id === void 0) {
+    throw new Error(
+      `no pull request #${String(number)} in ${owner}/${name}: ${lookup.errors.join("; ") || "not found"}`
+    );
+  }
+  return id;
+};
+const pullRequestHeadQuery$1 = `query PullRequestHead($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) { pullRequest(number: $number) { headRefOid } }
+}`;
+const assertVerdictOnHead = async (transport, {
+  owner,
+  name,
+  number,
+  commitId
+}) => {
+  const lookup = await transport.graphql(pullRequestHeadQuery$1, { owner, name, number });
+  const head = lookup.data?.repository?.pullRequest?.headRefOid;
+  if (head === void 0) {
+    throw new Error(
+      `no pull request #${String(number)} in ${owner}/${name}: ${lookup.errors.join("; ") || "not found"}`
+    );
+  }
+  if (head !== commitId) {
+    throw new Error(
+      `the pull request moved on to ${head.slice(0, 7)} since ${commitId.slice(0, 7)}, the commit reviewed: only a comment review can be sent on it`
+    );
+  }
+};
+const runMutation = async (transport, query, variables, what) => {
+  const { errors } = await transport.graphql(query, variables);
+  if (errors.length > 0) {
+    throw new Error(`GitHub refused ${what}: ${errors.join("; ")}`);
+  }
+};
+const setDraft = async (transport, { owner, name, number, draft }) => {
+  const id = await lookupPullRequestId(transport, { owner, name, number });
+  await runMutation(
+    transport,
+    draft ? convertToDraftMutation : readyForReviewMutation,
+    { id },
+    "the draft change"
+  );
+};
+const setViewed = async (transport, {
+  owner,
+  name,
+  number,
+  path,
+  viewed
+}) => {
+  const id = await lookupPullRequestId(transport, { owner, name, number });
+  await runMutation(
+    transport,
+    viewed ? markViewedMutation : unmarkViewedMutation,
+    { id, path },
+    "the viewed mark"
+  );
+};
+const restComment = (comment) => ({
+  path: comment.path,
+  body: comment.body,
+  line: comment.line,
+  side: comment.side,
+  ...comment.startLine === null || comment.startSide === null ? {} : {
+    start_line: comment.startLine,
+    start_side: comment.startSide
+  }
+});
+const reviewEventNames = {
+  approve: "APPROVE",
+  comment: "COMMENT",
+  requestChanges: "REQUEST_CHANGES"
+};
+const resolveCommittedThreads = async (transport, threadIds, logger) => {
+  const failures = [];
+  for (const threadId of threadIds) {
+    try {
+      await runMutation(
+        transport,
+        resolveThreadMutation,
+        { threadId },
+        "resolving the thread"
+      );
+    } catch (error) {
+      logger?.warn("thread of a committed suggestion left unresolved", {
+        threadId,
+        error
+      });
+      failures.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (failures.length === 0) return null;
+  return `The suggestions were committed, but ${String(failures.length)} thread${failures.length === 1 ? "" : "s"} stayed unresolved: ${failures.join("; ")}`;
+};
+const editPullRequest = async (transport, { ownerRepo, number, edit }, options = {}) => {
+  const split = splitOwnerRepo(ownerRepo);
+  if (split === null) throw new Error(`${ownerRepo} is not owner/repo`);
+  const repoPath = `repos/${encodeURIComponent(split.owner)}/${encodeURIComponent(split.name)}`;
+  const pullPath = `${repoPath}/pulls/${String(number)}`;
+  const issuePath = `${repoPath}/issues/${String(number)}`;
+  switch (edit.kind) {
+    case "title": {
+      await transport.rest({
+        method: "PATCH",
+        path: pullPath,
+        body: { title: edit.title }
+      });
+      return null;
+    }
+    case "labels": {
+      if (edit.add.length > 0) {
+        await transport.rest({
+          method: "POST",
+          path: `${issuePath}/labels`,
+          body: { labels: edit.add }
+        });
+      }
+      for (const label of edit.remove) {
+        await transport.rest({
+          method: "DELETE",
+          path: `${issuePath}/labels/${encodeURIComponent(label)}`
+        });
+      }
+      return null;
+    }
+    case "reviewers": {
+      if (edit.add.length > 0 || edit.addTeams.length > 0) {
+        await transport.rest({
+          method: "POST",
+          path: `${pullPath}/requested_reviewers`,
+          body: { reviewers: edit.add, team_reviewers: edit.addTeams }
+        });
+      }
+      if (edit.remove.length > 0 || edit.removeTeams.length > 0) {
+        await transport.rest({
+          method: "DELETE",
+          path: `${pullPath}/requested_reviewers`,
+          body: { reviewers: edit.remove, team_reviewers: edit.removeTeams }
+        });
+      }
+      return null;
+    }
+    case "draft": {
+      await setDraft(transport, { ...split, number, draft: edit.draft });
+      return null;
+    }
+    case "body": {
+      await transport.rest({
+        method: "PATCH",
+        path: pullPath,
+        body: { body: edit.body }
+      });
+      return null;
+    }
+    case "assignees": {
+      if (edit.add.length > 0) {
+        await transport.rest({
+          method: "POST",
+          path: `${issuePath}/assignees`,
+          body: { assignees: edit.add }
+        });
+      }
+      if (edit.remove.length > 0) {
+        await transport.rest({
+          method: "DELETE",
+          path: `${issuePath}/assignees`,
+          body: { assignees: edit.remove }
+        });
+      }
+      return null;
+    }
+    case "state": {
+      await transport.rest({
+        method: "PATCH",
+        path: pullPath,
+        body: { state: edit.state }
+      });
+      return null;
+    }
+    case "merge": {
+      await transport.rest({
+        method: "PUT",
+        path: `${pullPath}/merge`,
+        body: {
+          merge_method: edit.method,
+          sha: edit.expectedHeadSha,
+          ...edit.commitMessage === void 0 ? {} : {
+            commit_title: edit.commitMessage.title,
+            commit_message: edit.commitMessage.body
+          }
+        }
+      });
+      return null;
+    }
+    case "updateBranch": {
+      await transport.rest({
+        method: "PUT",
+        path: `${pullPath}/update-branch`,
+        body: { expected_head_sha: edit.expectedHeadSha }
+      });
+      return null;
+    }
+    case "comment": {
+      await transport.rest({
+        method: "POST",
+        path: `${issuePath}/comments`,
+        body: { body: edit.body }
+      });
+      return null;
+    }
+    case "editComment": {
+      const id = String(edit.databaseId);
+      if (edit.target === "review") {
+        await transport.rest({
+          method: "PUT",
+          path: `${pullPath}/reviews/${id}`,
+          body: { body: edit.body }
+        });
+        return null;
+      }
+      await transport.rest({
+        method: "PATCH",
+        path: edit.target === "issueComment" ? `${repoPath}/issues/comments/${id}` : `${repoPath}/pulls/comments/${id}`,
+        body: { body: edit.body }
+      });
+      return null;
+    }
+    case "reply": {
+      await transport.rest({
+        method: "POST",
+        path: `${pullPath}/comments/${String(edit.inReplyTo)}/replies`,
+        body: { body: edit.body }
+      });
+      return null;
+    }
+    case "reaction": {
+      await runMutation(
+        transport,
+        edit.reacted ? addReactionMutation : removeReactionMutation,
+        {
+          subjectId: edit.subjectId,
+          content: reactionContentNames[edit.content]
+        },
+        "the reaction"
+      );
+      return null;
+    }
+    case "resolveThread": {
+      await runMutation(
+        transport,
+        edit.resolved ? resolveThreadMutation : unresolveThreadMutation,
+        { threadId: edit.threadId },
+        "the thread change"
+      );
+      return null;
+    }
+    case "viewed": {
+      await setViewed(transport, {
+        ...split,
+        number,
+        path: edit.path,
+        viewed: edit.viewed
+      });
+      return null;
+    }
+    case "review": {
+      if (edit.event !== "comment") {
+        await assertVerdictOnHead(transport, {
+          ...split,
+          number,
+          commitId: edit.commitId
+        });
+      }
+      await transport.rest({
+        method: "POST",
+        path: `${pullPath}/reviews`,
+        body: {
+          commit_id: edit.commitId,
+          ...edit.body === "" ? {} : { body: edit.body },
+          event: reviewEventNames[edit.event],
+          comments: edit.comments.map(restComment)
+        }
+      });
+      return null;
+    }
+    case "applySuggestions": {
+      return resolveCommittedThreads(
+        transport,
+        await commitSuggestions(transport, { ownerRepo, number, edit }),
+        options.logger
+      );
+    }
+    case "inlineComment": {
+      await transport.rest({
+        method: "POST",
+        path: `${pullPath}/comments`,
+        body: { commit_id: edit.commitId, ...restComment(edit.comment) }
+      });
+      return null;
+    }
+    default: {
+      throw new Error("unknown edit");
+    }
+  }
+};
+const applyPullRequestEdit = async (transport, request, options = {}) => {
+  const followUpError = await editPullRequest(transport, request, options);
+  const { edit } = request;
+  if (edit.kind !== "viewed") return followUpError;
+  try {
+    options.onFileViewed?.(edit.path, edit.viewed);
+  } catch (error) {
+    options.logger?.error("viewed mark not applied to the last read", {
+      error
+    });
+  }
+  return followUpError;
+};
+
+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 maxDiffCells = 16e4;
+const toLines = (value) => {
+  if (value === "") return [];
+  const lines = value.split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+};
+const context = (text) => ({ kind: "context", text });
+const removed = (text) => ({ kind: "removed", text });
+const added = (text) => ({ kind: "added", text });
+const wholeSides = (before, after) => [
+  ...before.map(removed),
+  ...after.map(added)
+];
+const shortestEdit = (before, after) => {
+  const height = before.length;
+  const width = after.length + 1;
+  const common = new Uint32Array((height + 1) * width);
+  for (let row2 = height - 1; row2 >= 0; row2--) {
+    const beforeLine = before[row2];
+    for (let column2 = after.length - 1; column2 >= 0; column2--) {
+      common[row2 * width + column2] = beforeLine === after[column2] ? (common[(row2 + 1) * width + column2 + 1] ?? 0) + 1 : Math.max(
+        common[(row2 + 1) * width + column2] ?? 0,
+        common[row2 * width + column2 + 1] ?? 0
+      );
+    }
+  }
+  const lines = [];
+  let row = 0;
+  let column = 0;
+  while (row < height && column < after.length) {
+    if (before[row] === after[column]) {
+      lines.push(context(before[row] ?? ""));
+      row++;
+      column++;
+      continue;
+    }
+    if ((common[(row + 1) * width + column] ?? 0) >= (common[row * width + column + 1] ?? 0)) {
+      lines.push(removed(before[row] ?? ""));
+      row++;
+      continue;
+    }
+    lines.push(added(after[column] ?? ""));
+    column++;
+  }
+  return [
+    ...lines,
+    ...before.slice(row).map(removed),
+    ...after.slice(column).map(added)
+  ];
+};
+const diffLines = ({
+  before,
+  after
+}) => {
+  const beforeLines = toLines(before);
+  const afterLines = toLines(after);
+  let head = 0;
+  while (head < beforeLines.length && head < afterLines.length && beforeLines[head] === afterLines[head]) {
+    head++;
+  }
+  let tail = 0;
+  while (tail < beforeLines.length - head && tail < afterLines.length - head && beforeLines[beforeLines.length - 1 - tail] === afterLines[afterLines.length - 1 - tail]) {
+    tail++;
+  }
+  const beforeMiddle = beforeLines.slice(head, beforeLines.length - tail);
+  const afterMiddle = afterLines.slice(head, afterLines.length - tail);
+  return [
+    ...beforeLines.slice(0, head).map(context),
+    ...beforeMiddle.length * afterMiddle.length > maxDiffCells ? wholeSides(beforeMiddle, afterMiddle) : shortestEdit(beforeMiddle, afterMiddle),
+    ...beforeLines.slice(beforeLines.length - tail).map(context)
+  ];
+};
+
+const imgTag = /<img\b[^>]*>/gi;
+const decodeAttribute = (value) => value.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+const attribute = (tag, name) => {
+  const match = new RegExp(`\\s${name}="([^"]*)"`, "i").exec(tag);
+  return match?.[1] === void 0 ? null : decodeAttribute(match[1]);
+};
+const imageProxiesOf = (html) => {
+  const proxies = {};
+  for (const [tag] of (html ?? "").matchAll(imgTag)) {
+    const src = attribute(tag, "src");
+    const canonical = attribute(tag, "data-canonical-src");
+    if (src !== null && canonical !== null && src !== canonical) {
+      proxies[canonical] = src;
+    }
+  }
+  return proxies;
+};
+const mergeImageProxies = (htmls) => Object.assign({}, ...htmls.map(imageProxiesOf));
+
+const timelineItemTypes = [
+  "ISSUE_COMMENT",
+  "PULL_REQUEST_REVIEW",
+  "PULL_REQUEST_COMMIT",
+  "ASSIGNED_EVENT",
+  "UNASSIGNED_EVENT",
+  "LABELED_EVENT",
+  "UNLABELED_EVENT",
+  "REVIEW_REQUESTED_EVENT",
+  "REVIEW_REQUEST_REMOVED_EVENT",
+  "CLOSED_EVENT",
+  "REOPENED_EVENT",
+  "MERGED_EVENT",
+  "READY_FOR_REVIEW_EVENT",
+  "CONVERT_TO_DRAFT_EVENT",
+  "HEAD_REF_FORCE_PUSHED_EVENT",
+  "BASE_REF_CHANGED_EVENT",
+  "RENAMED_TITLE_EVENT",
+  "REVIEW_DISMISSED_EVENT",
+  "AUTO_MERGE_ENABLED_EVENT",
+  "AUTO_MERGE_DISABLED_EVENT"
+].join(", ");
+const assigneeFields = "__typename ... on User { login } ... on Bot { login } ... on Mannequin { login } ... on Organization { login }";
+const reviewerFields = "__typename ... on User { login } ... on Bot { login } ... on Mannequin { login } ... on Team { name }";
+const reactionFields = "viewerCanReact reactionGroups { content viewerHasReacted reactors { totalCount } }";
+const pullRequestQuery = ({
+  name,
+  viewer = false,
+  repositoryFields = "",
+  fields
+}) => `query ${name}($owner: String!, $name: String!, $number: Int!) {${viewer ? "\n  viewer { login }" : ""}
+  repository(owner: $owner, name: $name) {${repositoryFields}
+    pullRequest(number: $number) {${fields}
+    }
+  }
+}`;
+const pullRequestDetailQuery = pullRequestQuery({
+  name: "PullRequestDetail",
+  viewer: true,
+  repositoryFields: `
+    mergeCommitAllowed
+    squashMergeAllowed
+    rebaseMergeAllowed
+    viewerDefaultMergeMethod`,
+  fields: `
+      id
+      number
+      url
+      title
+      body
+      bodyHTML
+      state
+      isDraft
+      author { login avatarUrl }
+      headRefName
+      baseRefName
+      headRefOid
+      baseRefOid
+      createdAt
+      updatedAt
+      lastEditedAt
+      additions
+      deletions
+      changedFiles
+      mergeable
+      mergeStateStatus
+      viewerCanUpdate
+      viewerCanUpdateBranch
+      viewerCanApplySuggestion
+      mergeCommitHeadline: viewerMergeHeadlineText(mergeType: MERGE)
+      mergeCommitBody: viewerMergeBodyText(mergeType: MERGE)
+      squashCommitHeadline: viewerMergeHeadlineText(mergeType: SQUASH)
+      squashCommitBody: viewerMergeBodyText(mergeType: SQUASH)
+      ${reactionFields}
+      reviewDecision
+      labels(first: 50) { nodes { name color description } }
+      assignees(first: 20) { nodes { login avatarUrl } }
+      reviewRequests(first: 50) {
+        nodes {
+          requestedReviewer {
+            __typename
+            ... on User { login avatarUrl }
+            ... on Bot { login avatarUrl }
+            ... on Mannequin { login avatarUrl }
+            ... on Team { slug name }
+          }
+        }
+      }
+      latestReviews(first: 50) { nodes { author { login } state submittedAt } }
+      commits { totalCount }`
+});
+const pullRequestChecksQuery = pullRequestQuery({
+  name: "PullRequestChecks",
+  fields: `
+      headCommits: commits(last: 1) {
+        nodes {
+          commit {
+            statusCheckRollup {
+              contexts(first: 100) {
+                totalCount
+                nodes {
+                  __typename
+                  ... on CheckRun { name status conclusion title detailsUrl }
+                  ... on StatusContext { context state description targetUrl }
+                }
+              }
+            }
+          }
+        }
+      }`
+});
+const pullRequestTimelineQuery = pullRequestQuery({
+  name: "PullRequestTimeline",
+  fields: `
+      timelineItems(last: 100, itemTypes: [${timelineItemTypes}]) {
+        filteredCount
+        pageInfo { hasPreviousPage }
+        nodes {
+          __typename
+          ... on IssueComment {
+            id databaseId author { login avatarUrl } body bodyHTML createdAt lastEditedAt url viewerCanUpdate
+            ${reactionFields}
+          }
+          ... on PullRequestReview {
+            id databaseId author { login avatarUrl } state body bodyHTML submittedAt createdAt lastEditedAt url
+            viewerCanUpdate
+            ${reactionFields}
+            commit { oid }
+          }
+          ... on PullRequestCommit {
+            commit {
+              abbreviatedOid
+              messageHeadline
+              committedDate
+              author { name user { login avatarUrl } }
+            }
+          }
+          ... on AssignedEvent { createdAt actor { login avatarUrl } assignee { ${assigneeFields} } }
+          ... on UnassignedEvent { createdAt actor { login avatarUrl } assignee { ${assigneeFields} } }
+          ... on LabeledEvent { createdAt actor { login avatarUrl } label { name color description } }
+          ... on UnlabeledEvent { createdAt actor { login avatarUrl } label { name color description } }
+          ... on ReviewRequestedEvent { createdAt actor { login avatarUrl } requestedReviewer { ${reviewerFields} } }
+          ... on ReviewRequestRemovedEvent { createdAt actor { login avatarUrl } requestedReviewer { ${reviewerFields} } }
+          ... on ClosedEvent { createdAt actor { login avatarUrl } }
+          ... on ReopenedEvent { createdAt actor { login avatarUrl } }
+          ... on MergedEvent { createdAt actor { login avatarUrl } }
+          ... on ReadyForReviewEvent { createdAt actor { login avatarUrl } }
+          ... on ConvertToDraftEvent { createdAt actor { login avatarUrl } }
+          ... on AutoMergeEnabledEvent { createdAt actor { login avatarUrl } }
+          ... on AutoMergeDisabledEvent { createdAt actor { login avatarUrl } }
+          ... on HeadRefForcePushedEvent { createdAt actor { login avatarUrl } afterCommit { abbreviatedOid } }
+          ... on BaseRefChangedEvent { createdAt actor { login avatarUrl } currentRefName previousRefName }
+          ... on RenamedTitleEvent { createdAt actor { login avatarUrl } currentTitle previousTitle }
+          ... on ReviewDismissedEvent { createdAt actor { login avatarUrl } review { author { login } } }
+        }
+      }
+      reviewThreads(first: 100) {
+        totalCount
+        nodes {
+          id
+          isResolved
+          isOutdated
+          path
+          line
+          startLine
+          diffSide
+          startDiffSide
+          originalLine
+          originalStartLine
+          viewerCanResolve
+          viewerCanUnresolve
+          viewerCanReply
+          comments(first: 20) {
+            totalCount
+            nodes {
+              id databaseId author { login avatarUrl } body bodyHTML createdAt lastEditedAt url diffHunk viewerCanUpdate
+              ${reactionFields}
+            }
+          }
+        }
+      }`
+});
+const pullRequestCommitsQuery = pullRequestQuery({
+  name: "PullRequestCommits",
+  fields: `
+      commits(first: 100) {
+        totalCount
+        nodes {
+          commit {
+            oid
+            parents(first: 1) { totalCount nodes { oid } }
+            messageHeadline
+            messageBody
+            committedDate
+            author { name user { login avatarUrl } }
+          }
+        }
+      }`
+});
+const pullRequestFilesQuery = pullRequestQuery({
+  name: "PullRequestFiles",
+  fields: `
+      files(first: 100) {
+        nodes { path additions deletions changeType viewerViewedState }
+      }
+      latestReviews(first: 100) {
+        nodes { viewerDidAuthor submittedAt commit { oid } }
+      }`
+});
+const present = (items) => (items ?? []).filter((item) => item !== null);
+const toPerson = ({ login, avatarUrl }) => ({
+  login,
+  avatarUrl: avatarUrl ?? null
+});
+const toLabel = ({ name, color, description }) => ({
+  name,
+  color,
+  description: description === "" ? null : description
+});
+const toState = (state, isDraft) => {
+  if (state === "MERGED") return "merged";
+  if (state === "CLOSED") return "closed";
+  return isDraft ? "draft" : "open";
+};
+const reviewDecisions = /* @__PURE__ */ new Map([
+  ["APPROVED", "approved"],
+  ["CHANGES_REQUESTED", "changesRequested"],
+  ["REVIEW_REQUIRED", "reviewRequired"]
+]);
+const mergeables$1 = /* @__PURE__ */ new Map([
+  ["CONFLICTING", "conflicting"],
+  ["MERGEABLE", "mergeable"]
+]);
+const reviewStates$1 = /* @__PURE__ */ new Map([
+  ["APPROVED", "approved"],
+  ["CHANGES_REQUESTED", "changesRequested"],
+  ["COMMENTED", "commented"],
+  ["DISMISSED", "dismissed"],
+  ["PENDING", "pending"]
+]);
+const fileChanges = /* @__PURE__ */ new Map([
+  ["ADDED", "added"],
+  ["CHANGED", "changed"],
+  ["COPIED", "copied"],
+  ["DELETED", "deleted"],
+  ["MODIFIED", "modified"],
+  ["RENAMED", "renamed"]
+]);
+const viewedStates = /* @__PURE__ */ new Map([
+  ["DISMISSED", "dismissed"],
+  ["VIEWED", "viewed"]
+]);
+const toReviewer = (reviewer) => reviewer.__typename === "Team" ? { kind: "team", slug: reviewer.slug, name: reviewer.name } : {
+  kind: "user",
+  login: reviewer.login,
+  avatarUrl: reviewer.avatarUrl
+};
+const nonEmpty = (text) => text === null || text === "" ? null : text;
+const toCheck = (context) => {
+  if (context.__typename === "StatusContext") {
+    return {
+      name: context.context,
+      outcome: checkOutcomes.get(context.state) ?? "pending",
+      running: false,
+      description: nonEmpty(context.description),
+      url: context.targetUrl
+    };
+  }
+  return {
+    name: context.name,
+    outcome: context.status === "COMPLETED" && context.conclusion !== null ? checkOutcomes.get(context.conclusion) ?? "pending" : "pending",
+    running: context.status === "IN_PROGRESS",
+    description: nonEmpty(context.title),
+    url: context.detailsUrl
+  };
+};
+const checkOrder = {
+  failed: 0,
+  pending: 1,
+  passed: 2
+};
+const ghost = { login: "ghost", avatarUrl: null };
+const toAuthor = (actor) => actor === null ? ghost : toPerson(actor);
+const reactionContents = /* @__PURE__ */ new Map([
+  ["CONFUSED", "confused"],
+  ["EYES", "eyes"],
+  ["HEART", "heart"],
+  ["HOORAY", "hooray"],
+  ["LAUGH", "laugh"],
+  ["ROCKET", "rocket"],
+  ["THUMBS_DOWN", "thumbsDown"],
+  ["THUMBS_UP", "thumbsUp"]
+]);
+const toReactable = (subject) => ({
+  id: subject.id,
+  viewerCanReact: subject.viewerCanReact,
+  reactions: (subject.reactionGroups ?? []).flatMap((group) => {
+    const content = reactionContents.get(group.content);
+    if (content === void 0 || group.reactors.totalCount === 0) return [];
+    return [
+      {
+        content,
+        count: group.reactors.totalCount,
+        viewerHasReacted: group.viewerHasReacted
+      }
+    ];
+  })
+});
+const toComment = (comment) => ({
+  ...toReactable(comment),
+  databaseId: comment.databaseId,
+  author: toAuthor(comment.author),
+  body: comment.body,
+  createdAt: comment.createdAt,
+  lastEditedAt: comment.lastEditedAt,
+  url: comment.url,
+  viewerCanUpdate: comment.viewerCanUpdate
+});
+const toReviewItem = (review) => {
+  if (review.state === "PENDING") return null;
+  if (review.state === "COMMENTED" && review.body.trim() === "") return null;
+  return {
+    kind: "review",
+    ...toReactable(review),
+    databaseId: review.databaseId,
+    author: toAuthor(review.author),
+    state: reviewStates$1.get(review.state) ?? "commented",
+    body: review.body,
+    createdAt: review.submittedAt ?? review.createdAt,
+    lastEditedAt: review.lastEditedAt,
+    url: review.url,
+    viewerCanUpdate: review.viewerCanUpdate && review.body !== "",
+    commitOid: review.commit?.oid ?? null
+  };
+};
+const toSide = (side) => side === "LEFT" ? "LEFT" : "RIGHT";
+const toThreadItem = (thread) => {
+  const comments = present(thread.comments.nodes);
+  const [first] = comments;
+  if (first === void 0) return null;
+  return {
+    kind: "thread",
+    id: thread.id,
+    path: thread.path,
+    line: thread.line,
+    startLine: thread.startLine,
+    side: toSide(thread.diffSide),
+    startSide: thread.startDiffSide === null ? null : toSide(thread.startDiffSide),
+    originalLine: thread.originalLine,
+    originalStartLine: thread.originalStartLine,
+    resolved: thread.isResolved,
+    outdated: thread.isOutdated,
+    viewerCanResolve: thread.viewerCanResolve,
+    viewerCanUnresolve: thread.viewerCanUnresolve,
+    viewerCanReply: thread.viewerCanReply,
+    diffHunk: first.diffHunk,
+    comments: comments.map(toComment),
+    commentsTotal: thread.comments.totalCount,
+    createdAt: first.createdAt
+  };
+};
+const nameOf = (named) => {
+  if (named === null) return null;
+  return "login" in named ? named.login : named.name;
+};
+const commitAuthor = (commit) => {
+  const { author } = commit;
+  if (author === null) return null;
+  if (author.user !== null) return toPerson(author.user);
+  return author.name === null ? null : { login: author.name, avatarUrl: null };
+};
+const simpleActions = {
+  AutoMergeDisabledEvent: "autoMergeDisabled",
+  AutoMergeEnabledEvent: "autoMergeEnabled",
+  ClosedEvent: "closed",
+  ConvertToDraftEvent: "convertedToDraft",
+  MergedEvent: "merged",
+  ReadyForReviewEvent: "readyForReview",
+  ReopenedEvent: "reopened"
+};
+const event = (action, { actor, createdAt }, extra = {}) => ({
+  kind: "event",
+  action,
+  actor: actor === null ? null : toPerson(actor),
+  subject: null,
+  label: null,
+  detail: null,
+  createdAt,
+  ...extra
+});
+const toEvent = (node) => {
+  switch (node.__typename) {
+    case "PullRequestCommit": {
+      const { commit } = node;
+      return event(
+        "committed",
+        { actor: commitAuthor(commit), createdAt: commit.committedDate },
+        { subject: commit.messageHeadline, detail: commit.abbreviatedOid }
+      );
+    }
+    case "AssignedEvent":
+    case "UnassignedEvent": {
+      return event(
+        node.__typename === "AssignedEvent" ? "assigned" : "unassigned",
+        node,
+        { subject: nameOf(node.assignee) }
+      );
+    }
+    case "LabeledEvent":
+    case "UnlabeledEvent": {
+      return event(
+        node.__typename === "LabeledEvent" ? "labeled" : "unlabeled",
+        node,
+        {
+          subject: node.label?.name ?? null,
+          label: node.label === null ? null : toLabel(node.label)
+        }
+      );
+    }
+    case "ReviewRequestedEvent":
+    case "ReviewRequestRemovedEvent": {
+      return event(
+        node.__typename === "ReviewRequestedEvent" ? "reviewRequested" : "reviewRequestRemoved",
+        node,
+        { subject: nameOf(node.requestedReviewer) }
+      );
+    }
+    case "HeadRefForcePushedEvent": {
+      return event("headRefForcePushed", node, {
+        detail: node.afterCommit?.abbreviatedOid ?? null
+      });
+    }
+    case "BaseRefChangedEvent": {
+      return event("baseRefChanged", node, {
+        subject: node.currentRefName,
+        detail: node.previousRefName
+      });
+    }
+    case "RenamedTitleEvent": {
+      return event("renamed", node, {
+        subject: node.currentTitle,
+        detail: node.previousTitle
+      });
+    }
+    case "ReviewDismissedEvent": {
+      return event("reviewDismissed", node, {
+        subject: node.review?.author?.login ?? null
+      });
+    }
+    case "AutoMergeDisabledEvent":
+    case "AutoMergeEnabledEvent":
+    case "ClosedEvent":
+    case "ConvertToDraftEvent":
+    case "MergedEvent":
+    case "ReadyForReviewEvent":
+    case "ReopenedEvent": {
+      return event(simpleActions[node.__typename], node);
+    }
+    default: {
+      return node;
+    }
+  }
+};
+const toTimelineNode = (node) => {
+  if (node.__typename === "IssueComment") {
+    return { kind: "comment", ...toComment(node) };
+  }
+  if (node.__typename === "PullRequestReview") return toReviewItem(node);
+  return toEvent(node);
+};
+const isTruncated = (connection) => connection !== null && connection.totalCount > present(connection.nodes).length;
+const bodyHtmlsOf = (pullRequest) => [
+  ...present(pullRequest.timelineItems?.nodes).map(
+    (node) => "bodyHTML" in node ? node.bodyHTML : void 0
+  ),
+  ...present(pullRequest.reviewThreads?.nodes).flatMap(
+    (thread) => present(thread.comments.nodes).map((comment) => comment.bodyHTML)
+  )
+];
+const toTimeline = (pullRequest) => {
+  const items = [
+    ...present(pullRequest.timelineItems?.nodes).map(toTimelineNode),
+    ...present(pullRequest.reviewThreads?.nodes).map(toThreadItem)
+  ].filter((item) => item !== null);
+  return {
+    timeline: items.toSorted((a, b) => a.createdAt.localeCompare(b.createdAt)),
+    images: mergeImageProxies(bodyHtmlsOf(pullRequest)),
+    timelineTruncated: pullRequest.timelineItems?.pageInfo.hasPreviousPage === true || isTruncated(pullRequest.reviewThreads)
+  };
+};
+const toChecks = (contexts) => present(contexts?.nodes).map(toCheck).map((check, index) => ({ check, index })).toSorted(
+  (a, b) => checkOrder[a.check.outcome] - checkOrder[b.check.outcome] || a.index - b.index
+).map(({ check }) => check);
+const toFiles = (pullRequest) => present(pullRequest.files?.nodes).map((file) => ({
+  path: file.path,
+  additions: file.additions,
+  deletions: file.deletions,
+  change: fileChanges.get(file.changeType) ?? "changed",
+  viewed: viewedStates.get(file.viewerViewedState) ?? "unviewed"
+}));
+const toRequestedReviewers = (pullRequest) => present(pullRequest.reviewRequests?.nodes).map(({ requestedReviewer }) => requestedReviewer).filter((reviewer) => reviewer !== null).map(toReviewer);
+const toReviewDecision = (decision) => decision === null ? null : reviewDecisions.get(decision) ?? null;
+const mergeStates = /* @__PURE__ */ new Map([
+  ["BEHIND", "behind"],
+  ["BLOCKED", "blocked"],
+  ["CLEAN", "clean"],
+  ["DIRTY", "dirty"],
+  ["DRAFT", "draft"],
+  ["HAS_HOOKS", "hasHooks"],
+  ["UNSTABLE", "unstable"]
+]);
+const mergeMethodNames = /* @__PURE__ */ new Map([
+  ["MERGE", "merge"],
+  ["REBASE", "rebase"],
+  ["SQUASH", "squash"]
+]);
+const toMergeMethods = (repository) => {
+  const allowed = [];
+  if (repository.mergeCommitAllowed === true) allowed.push("merge");
+  if (repository.squashMergeAllowed === true) allowed.push("squash");
+  if (repository.rebaseMergeAllowed === true) allowed.push("rebase");
+  const preferred = mergeMethodNames.get(
+    repository.viewerDefaultMergeMethod ?? ""
+  );
+  return preferred !== void 0 && allowed.includes(preferred) ? [preferred, ...allowed.filter((method) => method !== preferred)] : allowed;
+};
+const toCommit = ({ commit }) => ({
+  oid: commit.oid,
+  parentOid: present(commit.parents.nodes)[0]?.oid ?? null,
+  merge: commit.parents.totalCount > 1,
+  headline: commit.messageHeadline,
+  body: commit.messageBody.trim(),
+  author: commitAuthor(commit),
+  committedAt: commit.committedDate
+});
+const viewerLastReview = (pullRequest) => {
+  const review = present(pullRequest.latestReviews?.nodes).find(
+    ({ viewerDidAuthor }) => viewerDidAuthor
+  );
+  const oid = review?.commit?.oid;
+  if (review === void 0 || oid === void 0) return null;
+  return { oid, submittedAt: review.submittedAt };
+};
+const toDetail = (pullRequest, repository, ownerRepo) => ({
+  ...toReactable(pullRequest),
+  ownerRepo,
+  number: pullRequest.number,
+  url: pullRequest.url,
+  title: pullRequest.title,
+  body: pullRequest.body,
+  state: toState(pullRequest.state, pullRequest.isDraft),
+  author: pullRequest.author === null ? null : toPerson(pullRequest.author),
+  headRef: pullRequest.headRefName,
+  baseRef: pullRequest.baseRefName,
+  headSha: pullRequest.headRefOid,
+  baseSha: pullRequest.baseRefOid,
+  createdAt: pullRequest.createdAt,
+  updatedAt: pullRequest.updatedAt,
+  lastEditedAt: pullRequest.lastEditedAt,
+  additions: pullRequest.additions,
+  deletions: pullRequest.deletions,
+  changedFiles: pullRequest.changedFiles,
+  mergeable: mergeables$1.get(pullRequest.mergeable) ?? "unknown",
+  mergeState: mergeStates.get(pullRequest.mergeStateStatus) ?? "unknown",
+  mergeMethods: toMergeMethods(repository),
+  mergeCommitMessages: {
+    merge: {
+      title: pullRequest.mergeCommitHeadline,
+      body: pullRequest.mergeCommitBody
+    },
+    squash: {
+      title: pullRequest.squashCommitHeadline,
+      body: pullRequest.squashCommitBody
+    }
+  },
+  viewerCanUpdate: pullRequest.viewerCanUpdate,
+  viewerCanUpdateBranch: pullRequest.viewerCanUpdateBranch,
+  viewerCanApplySuggestion: pullRequest.viewerCanApplySuggestion,
+  reviewDecision: toReviewDecision(pullRequest.reviewDecision),
+  labels: present(pullRequest.labels?.nodes).map(toLabel),
+  assignees: present(pullRequest.assignees?.nodes).map(toPerson),
+  requestedReviewers: toRequestedReviewers(pullRequest),
+  reviews: present(pullRequest.latestReviews?.nodes).map((review) => ({
+    author: review.author?.login ?? "ghost",
+    state: reviewStates$1.get(review.state) ?? "commented",
+    submittedAt: review.submittedAt
+  })),
+  commitsTotal: pullRequest.commits.totalCount
+});
+const toChecksPart = (pullRequest) => {
+  const contexts = pullRequest.headCommits.nodes?.[0]?.commit.statusCheckRollup?.contexts ?? null;
+  return { checks: toChecks(contexts), checksTotal: contexts?.totalCount ?? 0 };
+};
+const pullRequestCandidatesQuery = `query PullRequestCandidates($owner: String!, $name: String!, $number: Int!) {
+  repositoryOwner(login: $owner) {
+    ... on Organization {
+      teams(first: 100, orderBy: { field: NAME, direction: ASC }) {
+        nodes { slug name }
+      }
+    }
+  }
+  repository(owner: $owner, name: $name) {
+    labels(first: 100, orderBy: { field: NAME, direction: ASC }) {
+      nodes { name color description }
+    }
+    assignableUsers(first: 100) { nodes { login avatarUrl } }
+    pullRequest(number: $number) {
+      author { login }
+      suggestedReviewers { reviewer { login avatarUrl } }
+    }
+  }
+}`;
+const reviewerCandidates = (pullRequest, assignable) => {
+  const author = pullRequest.author?.login;
+  const seen = /* @__PURE__ */ new Set();
+  const unseen = (actors) => actors.flatMap((actor) => {
+    if (actor.login === author || seen.has(actor.login)) return [];
+    seen.add(actor.login);
+    return [toPerson(actor)];
+  });
+  const suggested = unseen(
+    present(pullRequest.suggestedReviewers).map(({ reviewer }) => reviewer).filter((reviewer) => reviewer !== null)
+  );
+  const others = unseen(
+    assignable.toSorted((a, b) => a.login.localeCompare(b.login))
+  );
+  return { suggested, others };
+};
+const gitHubRead = ({
+  fetchedAt,
+  errors
+}) => ({
+  fetchedAt,
+  checkedAt: fetchedAt,
+  source: "github",
+  errors
+});
+const readPart = ({
+  data,
+  errors,
+  ownerRepo,
+  number
+}) => {
+  const repository = data?.repository ?? null;
+  const pullRequest = repository?.pullRequest ?? null;
+  if (repository === null || pullRequest === null) {
+    const reason = errors.length > 0 ? errors.join("; ") : "not found";
+    throw new Error(
+      `no pull request #${String(number)} in ${ownerRepo}: ${reason}`
+    );
+  }
+  return { pullRequest, repository };
+};
+const parsePullRequestDetail = (params) => {
+  const { pullRequest, repository } = readPart(params);
+  return {
+    pullRequest: toDetail(pullRequest, repository, params.ownerRepo),
+    viewer: params.data?.viewer?.login ?? "",
+    images: imageProxiesOf(pullRequest.bodyHTML),
+    ...gitHubRead(params)
+  };
+};
+const parsePullRequestChecks = (params) => ({
+  ...toChecksPart(readPart(params).pullRequest),
+  ...gitHubRead(params)
+});
+const parsePullRequestTimeline = (params) => ({
+  ...toTimeline(readPart(params).pullRequest),
+  ...gitHubRead(params)
+});
+const parsePullRequestCommits = (params) => ({
+  commits: present(readPart(params).pullRequest.commits.nodes).map(toCommit),
+  ...gitHubRead(params)
+});
+const parsePullRequestFiles = (params) => {
+  const { pullRequest } = readPart(params);
+  return {
+    files: toFiles(pullRequest),
+    viewerLastReview: viewerLastReview(pullRequest),
+    ...gitHubRead(params)
+  };
+};
+const readGitHub = async (transport, { ownerRepo, number }, query, parse) => {
+  const split = splitOwnerRepo(ownerRepo);
+  if (split === null) throw new Error(`${ownerRepo} is not owner/repo`);
+  const { data, errors } = await transport.graphql(
+    query,
+    {
+      owner: split.owner,
+      name: split.name,
+      number
+    }
+  );
+  return parse({
+    data,
+    errors,
+    ownerRepo,
+    number,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+const partReaders = {
+  detail: (transport, ref) => readGitHub(transport, ref, pullRequestDetailQuery, parsePullRequestDetail),
+  checks: (transport, ref) => readGitHub(transport, ref, pullRequestChecksQuery, parsePullRequestChecks),
+  timeline: (transport, ref) => readGitHub(
+    transport,
+    ref,
+    pullRequestTimelineQuery,
+    parsePullRequestTimeline
+  ),
+  commits: (transport, ref) => readGitHub(
+    transport,
+    ref,
+    pullRequestCommitsQuery,
+    parsePullRequestCommits
+  ),
+  files: (transport, ref) => readGitHub(transport, ref, pullRequestFilesQuery, parsePullRequestFiles)
+};
+const fetchPullRequestPart = (transport, ref, part) => partReaders[part](transport, ref);
+const parsePullRequestCandidates = ({
+  data,
+  errors
+}) => {
+  const repository = data?.repository ?? null;
+  if (repository === null) {
+    throw new Error(errors.length > 0 ? errors.join("; ") : "not found");
+  }
+  const assignable = present(repository.assignableUsers?.nodes);
+  const reviewers = reviewerCandidates(
+    repository.pullRequest ?? { author: null, suggestedReviewers: null },
+    assignable
+  );
+  return {
+    repoLabels: present(repository.labels?.nodes).map(toLabel),
+    suggestedReviewers: reviewers.suggested,
+    reviewerCandidates: reviewers.others,
+    teamCandidates: present(data?.repositoryOwner?.teams?.nodes).map(
+      ({ slug, name }) => ({ slug, name })
+    ),
+    assigneeCandidates: assignable.toSorted((a, b) => a.login.localeCompare(b.login)).map(toPerson),
+    errors
+  };
+};
+const fetchPullRequestCandidates = async (transport, {
+  ownerRepo,
+  number
+}) => {
+  const split = splitOwnerRepo(ownerRepo);
+  if (split === null) throw new Error(`${ownerRepo} is not owner/repo`);
+  const { data, errors } = await transport.graphql(
+    pullRequestCandidatesQuery,
+    { owner: split.owner, name: split.name, number }
+  );
+  return parsePullRequestCandidates({ data, errors });
+};
+
+const pullRequestHeadQuery = `query PullRequestHead($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      state
+      headRefName
+      isCrossRepository
+      headRepositoryOwner { login }
+    }
+  }
+}`;
+const headStates = {
+  CLOSED: "closed",
+  MERGED: "merged",
+  OPEN: "open"
+};
+const fetchPullRequestHead = async (transport, { ownerRepo, number }) => {
+  const [owner = "", name = ""] = ownerRepo.split("/");
+  const { data, errors } = await transport.graphql(
+    pullRequestHeadQuery,
+    { owner, name, number }
+  );
+  const pullRequest = data?.repository?.pullRequest ?? null;
+  if (pullRequest === null) {
+    const reason = errors.length > 0 ? errors.join("; ") : "not found";
+    throw new Error(`${ownerRepo}#${String(number)}: ${reason}`);
+  }
+  return {
+    state: headStates[pullRequest.state],
+    branch: pullRequest.headRefName,
+    fork: pullRequest.isCrossRepository ? pullRequest.headRepositoryOwner?.login ?? "a deleted fork" : null
+  };
+};
+
+const revisionsPage = 50;
+const pullRequestRevisionsQuery = `query PullRequestRevisions($id: ID!) {
+  node(id: $id) {
+    ... on Comment {
+      includesCreatedEdit
+      userContentEdits(first: ${String(revisionsPage)}) {
+        totalCount
+        nodes {
+          editedAt
+          deletedAt
+          editor { login avatarUrl }
+          deletedBy { login }
+          diff
+        }
+      }
+    }
+  }
+}`;
+const normalizeNewlines = (text) => text?.replaceAll("\r\n", "\n") ?? null;
+const parsePullRequestRevisions = ({
+  data,
+  errors,
+  subjectId
+}) => {
+  const edits = data?.node?.userContentEdits ?? null;
+  if (edits === null) {
+    const reason = errors.length > 0 ? errors.join("; ") : "not found";
+    throw new Error(`no edit history for ${subjectId}: ${reason}`);
+  }
+  const nodes = (edits.nodes ?? []).flatMap(
+    (node, rawIndex) => node === null ? [] : [{ ...node, rawIndex }]
+  );
+  const bodies = nodes.map(
+    (node) => node.deletedAt === null ? normalizeNewlines(node.diff) : null
+  );
+  const lastIndex = edits.totalCount - 1;
+  const revisions = nodes.map((node, index) => {
+    const body = bodies[index] ?? null;
+    const before = bodies.slice(index + 1).find((older) => older !== null);
+    return {
+      editedAt: node.editedAt,
+      editor: node.editor === null ? null : {
+        login: node.editor.login,
+        avatarUrl: node.editor.avatarUrl ?? null
+      },
+      original: data?.node?.includesCreatedEdit === true && node.rawIndex === lastIndex,
+      body,
+      deletedBy: node.deletedBy?.login ?? null,
+      changes: body === null || before === void 0 ? null : diffLines({ before, after: body })
+    };
+  });
+  return { revisions, revisionsTotal: edits.totalCount };
+};
+const fetchPullRequestRevisions = async (transport, subjectId) => {
+  const { data, errors } = await transport.graphql(
+    pullRequestRevisionsQuery,
+    { id: subjectId }
+  );
+  return parsePullRequestRevisions({ data, errors, subjectId });
+};
+
+const firstLine = (text) => text.split("\n", 1)[0]?.trim() ?? "";
+const isSuccess = (status) => status >= 200 && status < 300;
+const parseJson = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+const interpretGraphql = ({
+  status,
+  body
+}) => {
+  const parsed = parseJson(body);
+  if (parsed === null || !isSuccess(status) && parsed.data == null) {
+    const detail = parsed?.message ?? firstLine(body);
+    throw new Error(
+      `GitHub graphql failed (HTTP ${String(status)})${detail === "" ? "" : `: ${detail}`}`
+    );
+  }
+  return {
+    data: parsed.data ?? null,
+    errors: (parsed.errors ?? []).map(
+      ({ message }) => message ?? "github returned an unnamed error"
+    )
+  };
+};
+const restErrorMessage = ({ status, body }) => {
+  const parsed = parseJson(body);
+  const details = (parsed?.errors ?? []).map(
+    (error) => typeof error === "string" ? error : error.message ?? [error.field, error.code].filter(Boolean).join(" ")
+  ).filter((detail) => detail !== "");
+  const headline = parsed?.message ?? (firstLine(body) || `HTTP ${String(status)}`);
+  return [headline, ...details].filter((part) => part !== "").join(": ");
+};
+const createGitHubTransport = (send) => ({
+  graphql: async (query, variables) => interpretGraphql(
+    await send({
+      method: "POST",
+      path: "graphql",
+      accept: "application/json",
+      body: JSON.stringify(
+        variables === void 0 ? { query } : { query, variables }
+      )
+    })
+  ),
+  rest: async ({
+    method,
+    path,
+    body
+  }) => {
+    const answer = await send({
+      method,
+      path,
+      accept: "application/vnd.github+json",
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!isSuccess(answer.status)) {
+      throw new Error(
+        `GitHub refused ${method} ${path}: ${restErrorMessage(answer)}`
+      );
+    }
+    return parseJson(answer.body);
+  },
+  text: async ({ path, accept }) => {
+    const answer = await send({ method: "GET", path, accept, body: void 0 });
+    if (!isSuccess(answer.status)) {
+      throw new Error(
+        `GitHub refused GET ${path}: ${restErrorMessage(answer)}`
+      );
+    }
+    return answer.body;
+  }
+});
+
+const pullRequestParts = [
+  "detail",
+  "checks",
+  "timeline",
+  "commits",
+  "files"
+];
+const isPullRequestPart = (value) => pullRequestParts.includes(value);
+
+const pullRequestPartsStaleAfter = (edit, pullRequestId) => {
+  switch (edit.kind) {
+    case "applySuggestions":
+    case "updateBranch": {
+      return pullRequestParts;
+    }
+    case "body": {
+      return ["detail"];
+    }
+    case "reaction": {
+      return edit.subjectId === pullRequestId ? ["detail"] : ["timeline"];
+    }
+    case "viewed": {
+      return [];
+    }
+    case "comment":
+    case "editComment":
+    case "inlineComment":
+    case "reply":
+    case "resolveThread": {
+      return ["timeline"];
+    }
+    case "review": {
+      return ["detail", "timeline", "files"];
+    }
+    case "assignees":
+    case "draft":
+    case "labels":
+    case "merge":
+    case "reviewers":
+    case "state":
+    case "title": {
+      return ["detail", "timeline"];
+    }
+    default: {
+      return edit;
+    }
+  }
+};
+const withFileViewed = (files, path, viewed) => ({
+  ...files,
+  files: files.files.map(
+    (file) => file.path === path ? { ...file, viewed: viewed ? "viewed" : "unviewed" } : file
+  )
+});
+const pullRequestEditMovesBoard = (edit) => {
+  switch (edit.kind) {
+    case "applySuggestions":
+    case "draft":
+    case "merge":
+    case "review":
+    case "reviewers":
+    case "state":
+    case "updateBranch": {
+      return true;
+    }
+    case "assignees":
+    case "body":
+    case "comment":
+    case "editComment":
+    case "inlineComment":
+    case "labels":
+    case "reaction":
+    case "reply":
+    case "resolveThread":
+    case "title":
+    case "viewed": {
+      return false;
+    }
+    default: {
+      return edit;
+    }
+  }
+};
+
+const partFields = {
+  detail: (pr) => [
+    pr.title,
+    pr.headRef,
+    pr.baseRef,
+    pr.headSha,
+    pr.baseSha,
+    pr.state,
+    pr.reviewState,
+    pr.author,
+    pr.checks.conclusion,
+    pr.approvedBy,
+    pr.changesRequestedBy,
+    pr.requestedReviewers,
+    pr.reRequestedReviewers,
+    pr.requestedTeams,
+    pr.assignees,
+    pr.labels,
+    pr.mergeable,
+    pr.unresolvedThreads === 0,
+    pr.reviewActivityAt,
+    pr.bodyEditedAt,
+    pr.closedAt
+  ],
+  checks: (pr) => [pr.headSha, pr.checks],
+  timeline: (pr) => [
+    pr.headSha,
+    pr.baseSha,
+    pr.baseRef,
+    pr.title,
+    pr.state,
+    pr.labels,
+    pr.assignees,
+    pr.requestedReviewers,
+    pr.reRequestedReviewers,
+    pr.requestedTeams,
+    pr.approvedBy,
+    pr.changesRequestedBy,
+    pr.reviewActivityAt,
+    pr.commentActivityAt,
+    pr.reviewCommentActivityAt,
+    pr.unresolvedThreads
+  ],
+  commits: (pr) => [pr.headSha, pr.baseSha],
+  files: (pr) => [pr.headSha, pr.baseSha]
+};
+const partFingerprint = (pr, part) => JSON.stringify(partFields[part](pr));
+const changedPullRequestParts = (previous, next) => pullRequestParts.filter(
+  (part) => partFingerprint(previous, part) !== partFingerprint(next, part)
+);
+
+const upperOrNull = (value) => value === null ? null : value.toUpperCase();
+const checksFromReviewflow = ({
+  checkRuns,
+  statuses
+}, at) => {
+  const nodes = [
+    ...checkRuns.map((run) => ({
+      __typename: "CheckRun",
+      name: run.name,
+      status: upperOrNull(run.status) ?? (run.conclusion === null ? "QUEUED" : "COMPLETED"),
+      conclusion: upperOrNull(run.conclusion),
+      title: run.title,
+      detailsUrl: run.detailsUrl
+    })),
+    ...statuses.map((status) => ({
+      __typename: "StatusContext",
+      context: status.context,
+      state: status.state.toUpperCase(),
+      description: status.description,
+      targetUrl: status.targetUrl
+    }))
+  ];
+  const parsed = parsePullRequestChecks({
+    data: {
+      repository: {
+        pullRequest: {
+          headCommits: {
+            nodes: [
+              {
+                commit: {
+                  statusCheckRollup: {
+                    contexts: { totalCount: nodes.length, nodes }
+                  }
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    errors: [],
+    ownerRepo: "",
+    number: 0,
+    fetchedAt: at
+  });
+  return { ...parsed, source: "reviewflow" };
+};
+
+const reviewflowErrorCode = "ERR_REVIEWFLOW";
+const timeoutMs = 15e3;
+const maxLookupTargets = 200;
+const maxExtraPagesPerBucket = 5;
+const fail = (message, { status, retryAfterMs } = {}) => Object.assign(new Error(message), {
+  code: reviewflowErrorCode,
+  status,
+  retryAfterMs
+});
+const isReviewflowFailure = (error) => error instanceof Error && error.code === reviewflowErrorCode;
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stringOrNull = (value) => typeof value === "string" ? value : null;
+const numberOr = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+const prStates = /* @__PURE__ */ new Set(["closed", "draft", "merged", "open"]);
+const reviewStates = /* @__PURE__ */ new Set([
+  "approved",
+  "changesRequested",
+  "none",
+  "requested"
+]);
+const mergeables = /* @__PURE__ */ new Set(["conflicting", "mergeable", "unknown"]);
+const checksConclusions = {
+  failed: "failed",
+  "in-progress": "inProgress",
+  passed: "passed"
+};
+const enumOrNull = (value, allowed) => typeof value === "string" && allowed.has(value) ? value : null;
+const strings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const logins = (value) => Array.isArray(value) ? value.flatMap(
+  (person) => isRecord$1(person) && typeof person.login === "string" ? [person.login] : []
+) : [];
+const readCheckRuns = (value) => Array.isArray(value) ? value.flatMap(
+  (run) => isRecord$1(run) && typeof run.name === "string" ? [
+    {
+      name: run.name,
+      status: stringOrNull(run.status),
+      conclusion: stringOrNull(run.conclusion),
+      title: stringOrNull(run.title),
+      detailsUrl: stringOrNull(run.detailsUrl)
+    }
+  ] : []
+) : null;
+const readCommitStatuses = (value) => Array.isArray(value) ? value.flatMap(
+  (status) => isRecord$1(status) && typeof status.context === "string" && typeof status.state === "string" ? [
+    {
+      context: status.context,
+      state: status.state,
+      description: stringOrNull(status.description),
+      targetUrl: stringOrNull(status.targetUrl)
+    }
+  ] : []
+) : null;
+const readStatusLinks = (value) => Array.isArray(value) ? value.flatMap(
+  (link) => isRecord$1(link) && link.type === "success" && typeof link.name === "string" && typeof link.label === "string" && typeof link.url === "string" ? [{ name: link.name, label: link.label, url: link.url }] : []
+) : [];
+const readLabels = (value) => Array.isArray(value) ? value.flatMap(
+  (label) => isRecord$1(label) && typeof label.name === "string" ? [label.name] : []
+) : [];
+const readChanges = (value) => isRecord$1(value) && typeof value.changedFiles === "number" && typeof value.additions === "number" && typeof value.deletions === "number" ? {
+  changedFiles: value.changedFiles,
+  additions: value.additions,
+  deletions: value.deletions
+} : null;
+const readPrDetail = (value) => {
+  if (!isRecord$1(value) || typeof value._id !== "string" || typeof value.ownerRepo !== "string" || typeof value.number !== "number" || typeof value.url !== "string" || !isRecord$1(value.checks)) {
+    throw fail("reviewflow returned a pull request the client cannot read");
+  }
+  const { checks } = value;
+  const creator = isRecord$1(value.creator) ? value.creator : null;
+  const flowDates = isRecord$1(value.flowDates) ? value.flowDates : {};
+  return {
+    id: value._id,
+    ownerRepo: value.ownerRepo,
+    number: value.number,
+    title: typeof value.title === "string" ? value.title : "",
+    url: value.url,
+    headRef: stringOrNull(value.headRef),
+    baseRef: stringOrNull(value.baseRef),
+    headSha: stringOrNull(value.headSha),
+    baseSha: stringOrNull(value.baseSha),
+    state: enumOrNull(value.state, prStates),
+    reviewState: enumOrNull(
+      value.reviewState,
+      reviewStates
+    ),
+    author: stringOrNull(creator?.login),
+    checks: {
+      conclusion: typeof checks.conclusion === "string" ? checksConclusions[checks.conclusion] ?? "unknown" : "unknown",
+      passed: numberOr(checks.passed, 0),
+      failed: numberOr(checks.failed, 0),
+      pending: numberOr(checks.pending, 0),
+      running: numberOr(checks.runningCount, 0),
+      failedNames: strings(checks.failedNames),
+      checkRuns: readCheckRuns(checks.checkRuns),
+      statuses: readCommitStatuses(checks.statuses)
+    },
+    lintFailed: value.lintFailed === true,
+    approvedBy: logins(value.approvedBy),
+    changesRequestedBy: logins(value.changesRequestedBy),
+    requestedReviewers: logins(value.requestedReviewers),
+    reRequestedReviewers: logins(value.reRequestedReviewers),
+    requestedTeams: strings(value.requestedTeams),
+    assignees: logins(value.assignees),
+    labels: readLabels(value.labels),
+    statusLinks: readStatusLinks(value.statusLinks),
+    openedAt: stringOrNull(flowDates.openedAt),
+    approvedAt: stringOrNull(flowDates.approvedAt),
+    changes: readChanges(value.changes),
+    unresolvedThreads: typeof value.unresolvedThreads === "number" ? value.unresolvedThreads : null,
+    mergeable: enumOrNull(value.mergeable, mergeables) ?? "unknown",
+    closedAt: stringOrNull(flowDates.closedAt),
+    commentActivityAt: stringOrNull(flowDates.lastCommentActivityAt),
+    reviewActivityAt: stringOrNull(flowDates.lastReviewSubmittedAt),
+    reviewCommentActivityAt: stringOrNull(
+      flowDates.lastReviewCommentActivityAt
+    ),
+    bodyEditedAt: stringOrNull(flowDates.lastBodyEditedAt),
+    updatedAt: typeof value.updatedAt === "string" ? value.updatedAt : ""
+  };
+};
+const lookupReasons = /* @__PURE__ */ new Set(["forbidden", "noPr", "notTracked"]);
+const readLookupResult = (value) => {
+  if (isRecord$1(value) && value.found === true) {
+    return { found: true, pr: readPrDetail(value.pr) };
+  }
+  if (isRecord$1(value) && value.found === false && typeof value.reason === "string" && lookupReasons.has(value.reason)) {
+    return {
+      found: false,
+      reason: value.reason
+    };
+  }
+  return { found: false, reason: "notTracked" };
+};
+const readBucketPage = (value) => {
+  if (!isRecord$1(value) || typeof value.key !== "string" || !Array.isArray(value.prs)) {
+    throw fail("reviewflow returned a board bucket the client cannot read");
+  }
+  return {
+    key: value.key,
+    title: typeof value.title === "string" ? value.title : value.key,
+    total: numberOr(value.total, value.prs.length),
+    prs: value.prs.map(readPrDetail),
+    nextPage: stringOrNull(value.nextPage)
+  };
+};
+const readMe = (value) => {
+  if (!isRecord$1(value) || !isRecord$1(value.user) || typeof value.user.login !== "string" || !Array.isArray(value.accounts)) {
+    throw fail("reviewflow returned a /me the client cannot read");
+  }
+  return {
+    login: value.user.login,
+    accounts: value.accounts.filter(isRecord$1).map((account) => ({
+      login: String(account.login),
+      type: account.type === "Organization" ? "Organization" : "User"
+    }))
+  };
+};
+const readRetryAfterMs = (response) => {
+  const seconds = Number(response.headers.get("retry-after") ?? Number.NaN);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+};
+const responseFailure = async (response) => {
+  const body = await response.json().catch(() => null);
+  const error = isRecord$1(body) && isRecord$1(body.error) ? body.error : null;
+  const detail = error === null ? "" : ` ${String(error.code)}: ${typeof error.message === "string" ? error.message : ""}`;
+  const retryAfter = response.headers.get("retry-after");
+  const retry = retryAfter === null ? "" : ` (retry after ${retryAfter}s)`;
+  return fail(
+    `reviewflow answered ${String(response.status)}${detail}${retry}`,
+    { status: response.status, retryAfterMs: readRetryAfterMs(response) }
+  );
+};
+const chunk = (items, size) => Array.from(
+  { length: Math.ceil(items.length / size) },
+  (_, index) => items.slice(index * size, (index + 1) * size)
+);
+const createReviewflowClient = ({
+  url,
+  token,
+  fetch = globalThis.fetch
+}) => {
+  const request = async (path, init = {}) => {
+    const response = await fetch(`${url}/api${path}`, {
+      method: init.method ?? "GET",
+      headers: {
+        authorization: `Bearer ${token}`,
+        accept: "application/json",
+        ...init.body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
+      signal: AbortSignal.timeout(timeoutMs)
+    }).catch((error) => {
+      const cause = error instanceof Error ? error.message : String(error);
+      throw fail(`reviewflow could not be reached at ${url}: ${cause}`);
+    });
+    if (!response.ok) throw await responseFailure(response);
+    return response.json().catch(() => {
+      throw fail("reviewflow answered with a body that is not json");
+    });
+  };
+  const readBucket = async (account, first) => {
+    const prs = [...first.prs];
+    let { nextPage } = first;
+    for (let page = 0; nextPage !== null && page < maxExtraPagesPerBucket; page++) {
+      const query = new URLSearchParams({
+        bucket: first.key,
+        account,
+        page: nextPage
+      });
+      const next = readBucketPage(
+        await request(`/board-bucket/v1?${query.toString()}`)
+      );
+      prs.push(...next.prs);
+      ({ nextPage } = next);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return {
+      key: first.key,
+      title: first.title,
+      total: first.total,
+      prs: prs.filter((pr) => !seen.has(pr.id) && seen.add(pr.id))
+    };
+  };
+  return {
+    me: async () => readMe(await request("/me/v1")),
+    lookup: async (targets) => {
+      const answers = await Promise.all(
+        chunk(targets, maxLookupTargets).map(async (part) => {
+          const body = await request("/prs-lookup/v1", {
+            method: "POST",
+            body: { targets: part }
+          });
+          if (!isRecord$1(body) || !Array.isArray(body.results) || body.results.length !== part.length) {
+            throw fail("reviewflow returned a lookup the client cannot read");
+          }
+          return body.results.map(readLookupResult);
+        })
+      );
+      return answers.flat();
+    },
+    pr: async (ownerRepo, number) => {
+      const path = ownerRepo.split("/").map((part) => encodeURIComponent(part)).join("/");
+      try {
+        return readPrDetail(await request(`/pr/v1/${path}/${String(number)}`));
+      } catch (error) {
+        if (isReviewflowFailure(error) && (error.status === 403 || error.status === 404)) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    board: async (account) => {
+      const body = await request(
+        `/board/v1?${new URLSearchParams({ account }).toString()}`
+      );
+      if (!isRecord$1(body) || !Array.isArray(body.groups)) {
+        throw fail("reviewflow returned a board the client cannot read");
+      }
+      return Promise.all(
+        body.groups.map(async (group) => {
+          if (!isRecord$1(group) || typeof group.key !== "string" || !Array.isArray(group.buckets)) {
+            throw fail(
+              "reviewflow returned a board group the client cannot read"
+            );
+          }
+          return {
+            key: group.key,
+            title: typeof group.title === "string" ? group.title : group.key,
+            buckets: await Promise.all(
+              group.buckets.map(
+                (bucket) => readBucket(account, readBucketPage(bucket))
+              )
+            )
+          };
+        })
+      );
+    }
+  };
+};
+
+const streamIdleTimeoutMs = 6e4;
+const streamClosedWithinDays = 7;
+const parseFrame = (block) => {
+  let event = "message";
+  const data = [];
+  for (const line of block.split("\n")) {
+    if (line.startsWith(":")) continue;
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    const value = separator === -1 ? "" : line.slice(separator + 1).replace(/^ /, "");
+    if (field === "event") event = value;
+    else if (field === "data") data.push(value);
+  }
+  return { event, data: data.join("\n") };
+};
+const parseData = (frame) => {
+  try {
+    return JSON.parse(frame.data);
+  } catch {
+    return null;
+  }
+};
+const toStreamEvent = (frame, logger) => {
+  switch (frame.event) {
+    case "pr": {
+      try {
+        return { type: "pr", pr: readPrDetail(parseData(frame)) };
+      } catch (error) {
+        logger?.warn(
+          "reviewflow streamed a pull request the client cannot read",
+          { error }
+        );
+        return null;
+      }
+    }
+    case "prRemoved": {
+      const data = parseData(frame);
+      return typeof data?._id === "string" ? { type: "prRemoved", id: data._id } : null;
+    }
+    case "ready":
+      return { type: "ready" };
+    case "scopeChanged":
+      return { type: "end", reason: "scopeChanged" };
+    case "reset": {
+      const data = parseData(frame);
+      return {
+        type: "end",
+        reason: `reset: ${typeof data?.reason === "string" ? data.reason : "unknown"}`
+      };
+    }
+    default:
+      return null;
+  }
+};
+async function* readReviewflowStream({
+  url,
+  token,
+  signal,
+  fetch = globalThis.fetch,
+  idleTimeoutMs = streamIdleTimeoutMs,
+  logger
+}) {
+  const controller = new AbortController();
+  let reader;
+  const cancel = () => {
+    controller.abort();
+    reader?.cancel().catch(() => void 0);
+  };
+  signal.addEventListener("abort", cancel, { once: true });
+  let silent = false;
+  let idle;
+  const armIdle = () => {
+    clearTimeout(idle);
+    idle = setTimeout(() => {
+      silent = true;
+      cancel();
+    }, idleTimeoutMs);
+  };
+  const silence = () => fail(
+    `reviewflow's stream went silent for ${String(idleTimeoutMs / 1e3)}s`
+  );
+  try {
+    armIdle();
+    const query = new URLSearchParams({
+      closedWithinDays: String(streamClosedWithinDays)
+    });
+    const response = await fetch(`${url}/api/stream/v1?${query.toString()}`, {
+      headers: {
+        authorization: `Bearer ${token}`,
+        accept: "text/event-stream"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) throw await responseFailure(response);
+    if (response.body === null) {
+      throw fail("reviewflow answered the stream with no body");
+    }
+    reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      armIdle();
+      buffer = (buffer + decoder.decode(value, { stream: true })).replaceAll(
+        "\r\n",
+        "\n"
+      );
+      let end = buffer.indexOf("\n\n");
+      while (end !== -1) {
+        const event = toStreamEvent(parseFrame(buffer.slice(0, end)), logger);
+        buffer = buffer.slice(end + 2);
+        if (event !== null) {
+          yield event;
+          if (event.type === "end") return;
+        }
+        end = buffer.indexOf("\n\n");
+      }
+    }
+    if (silent) throw silence();
+  } catch (error) {
+    if (signal.aborted) return;
+    if (silent) throw silence();
+    if (isReviewflowFailure(error)) throw error;
+    const cause = error instanceof Error ? error.message : String(error);
+    throw fail(`reviewflow's stream could not be read at ${url}: ${cause}`);
+  } finally {
+    clearTimeout(idle);
+    signal.removeEventListener("abort", cancel);
+    cancel();
+  }
+}
+
+const toBoardPr = (pr) => ({
+  id: pr.id,
+  ownerRepo: pr.ownerRepo,
+  number: pr.number,
+  title: pr.title,
+  url: pr.url,
+  headRef: pr.headRef,
+  state: pr.state,
+  reviewState: pr.reviewState,
+  author: pr.author,
+  checksFailed: pr.checks.failed,
+  checksConclusion: pr.checks.conclusion,
+  checksRunning: pr.checks.running,
+  failedChecks: pr.checks.failedNames,
+  lintFailed: pr.lintFailed,
+  approvedBy: pr.approvedBy,
+  changesRequestedBy: pr.changesRequestedBy,
+  requestedReviewers: pr.requestedReviewers,
+  reRequestedReviewers: pr.reRequestedReviewers,
+  requestedTeams: pr.requestedTeams,
+  assignees: pr.assignees,
+  statusLinks: pr.statusLinks,
+  changes: pr.changes,
+  openedAt: pr.openedAt,
+  approvedAt: pr.approvedAt,
+  unresolvedThreads: pr.unresolvedThreads,
+  mergeable: pr.mergeable,
+  updatedAt: pr.updatedAt
+});
+const accountOfOwnerRepo = (ownerRepo) => ownerRepo.slice(0, ownerRepo.indexOf("/")).toLowerCase();
+const isPullRequestOnBoard = (board, { ownerRepo, number }) => {
+  const wanted = ownerRepo.toLowerCase();
+  return board?.groups.some(
+    (group) => group.buckets.some(
+      (bucket) => bucket.prs.some(
+        (pr) => pr.number === number && pr.ownerRepo.toLowerCase() === wanted
+      )
+    )
+  ) ?? false;
+};
+const withAccountBoard = (snapshot, account, board) => ({ ...snapshot, [account]: board });
+const readAccountBoards = async (client, accounts) => {
+  const settled = await Promise.allSettled(
+    accounts.map(async (account) => ({
+      account,
+      groups: await client.board(account)
+    }))
+  );
+  const read = { boards: [], errors: [] };
+  settled.forEach((result, index) => {
+    if (result.status === "fulfilled") read.boards.push(result.value);
+    else {
+      const { reason } = result;
+      read.errors.push({
+        account: accounts[index],
+        message: reason instanceof Error ? reason.message : String(reason)
+      });
+    }
+  });
+  return read;
+};
+const assembleBoard = (snapshot, viewer, accounts = Object.keys(snapshot)) => {
+  const merged = /* @__PURE__ */ new Map();
+  const fetchedAts = [];
+  for (const account of accounts) {
+    const read = snapshot[account];
+    if (read === void 0) continue;
+    fetchedAts.push(read.fetchedAt);
+    let position = 0;
+    for (const group of read.groups) {
+      for (const bucket of group.buckets) {
+        const existing = merged.get(bucket.key);
+        const prs = bucket.prs.map((pr) => toBoardPr(pr));
+        if (existing === void 0) {
+          merged.set(bucket.key, {
+            key: bucket.key,
+            group: { key: group.key, title: group.title },
+            title: bucket.title,
+            total: bucket.total,
+            position,
+            prs,
+            fetchedAt: read.fetchedAt
+          });
+        } else {
+          existing.total += bucket.total;
+          existing.position = Math.min(existing.position, position);
+          const seen = new Set(existing.prs.map((pr) => pr.id));
+          existing.prs.push(...prs.filter((pr) => !seen.has(pr.id)));
+        }
+        position++;
+      }
+    }
+  }
+  if (merged.size === 0) return { board: null, viewer };
+  const groups = [];
+  for (const bucket of [...merged.values()].toSorted(
+    (a, b) => a.position - b.position
+  )) {
+    const entry = {
+      key: bucket.key,
+      title: bucket.title,
+      total: bucket.total,
+      prs: bucket.prs
+    };
+    const last = groups.at(-1);
+    if (last?.key === bucket.group.key) last.buckets.push(entry);
+    else {
+      groups.push({
+        key: bucket.group.key,
+        title: bucket.group.title,
+        buckets: [entry]
+      });
+    }
+  }
+  const [oldest] = fetchedAts.toSorted((a, b) => a.localeCompare(b));
+  return { board: { fetchedAt: oldest ?? "", groups }, viewer };
+};
+const applyStreamEvent = (snapshot, event) => {
+  if (event.type !== "pr" && event.type !== "prRemoved") {
+    return { snapshot, changed: false, readAccounts: [] };
+  }
+  const id = event.type === "pr" ? event.pr.id : event.id;
+  let changed = false;
+  const holding = /* @__PURE__ */ new Set();
+  const next = {};
+  for (const [account, read] of Object.entries(snapshot)) {
+    const groups = read.groups.map((group) => ({
+      ...group,
+      buckets: group.buckets.map((bucket) => {
+        if (!bucket.prs.some((pr) => pr.id === id)) return bucket;
+        holding.add(account);
+        changed = true;
+        if (event.type === "pr") {
+          return {
+            ...bucket,
+            prs: bucket.prs.map((pr) => pr.id === id ? event.pr : pr)
+          };
+        }
+        return {
+          ...bucket,
+          total: Math.max(0, bucket.total - 1),
+          prs: bucket.prs.filter((pr) => pr.id !== id)
+        };
+      })
+    }));
+    next[account] = { ...read, groups };
+  }
+  const readAccounts = new Set(holding);
+  if (event.type === "pr") {
+    const owner = accountOfOwnerRepo(event.pr.ownerRepo);
+    for (const account of Object.keys(snapshot)) {
+      if (account.toLowerCase() === owner) readAccounts.add(account);
+    }
+  }
+  return {
+    snapshot: changed ? next : snapshot,
+    changed,
+    readAccounts: [...readAccounts]
+  };
+};
+
+const lingerMs = 5 * 6e4;
+const boardReadDelayMs = 3e3;
+const reconnectDelayMs = 1e3;
+const minRetryMs = 2e3;
+const maxRetryMs = 5 * 6e4;
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+const retryDelayMs = (error, failures) => {
+  if (isReviewflowFailure(error)) {
+    if (error.retryAfterMs !== void 0) return error.retryAfterMs;
+    if (error.status === 401) return maxRetryMs;
+  }
+  return Math.min(minRetryMs * 2 ** (failures - 1), maxRetryMs);
+};
+const wait = async (ms, signal) => new Promise((resolve) => {
+  const done = () => {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", done);
+    resolve();
+  };
+  const timer = setTimeout(done, ms);
+  signal.addEventListener("abort", done, { once: true });
+});
+const createReviewflowFollower = ({
+  connect,
+  accounts,
+  onPr,
+  onPrRemoved,
+  onAccountBoard,
+  onBoardError,
+  onPullRequestChanged,
+  onStateChanged,
+  onLog
+}) => {
+  let watched = false;
+  let state = "off";
+  let controller = null;
+  let linger;
+  const boardReads = /* @__PURE__ */ new Map();
+  const accountOfPr = /* @__PURE__ */ new Map();
+  const lastSeen = /* @__PURE__ */ new Map();
+  const setState = (next, error) => {
+    if (state === next && error === void 0) return;
+    state = next;
+    onStateChanged?.(next, error ?? null);
+  };
+  const comparePr = (pr) => {
+    const previous = lastSeen.get(pr.id);
+    lastSeen.set(pr.id, pr);
+    if (previous === void 0 || onPullRequestChanged === void 0) return;
+    const parts = changedPullRequestParts(previous, pr);
+    if (parts.length === 0) return;
+    onPullRequestChanged({ ownerRepo: pr.ownerRepo, number: pr.number, parts });
+  };
+  const linked = (account) => accounts().find((owner) => owner.toLowerCase() === account.toLowerCase());
+  const readBoard = async (connection, account, signal) => {
+    const read = boardReads.get(account);
+    if (read === void 0 || signal.aborted) return false;
+    read.timer = void 0;
+    read.inFlight = true;
+    read.again = false;
+    try {
+      const groups = await connection.client.board(account);
+      if (signal.aborted) return false;
+      onAccountBoard(account, groups);
+    } catch (error) {
+      if (signal.aborted) return false;
+      onBoardError?.(account, messageOf(error));
+    } finally {
+      read.inFlight = false;
+    }
+    return read.again;
+  };
+  const scheduleBoard = (connection, account, signal) => {
+    const owner = linked(account);
+    if (owner === void 0) return;
+    const read = boardReads.get(owner) ?? { inFlight: false, again: false };
+    boardReads.set(owner, read);
+    if (read.inFlight) {
+      read.again = true;
+      return;
+    }
+    read.timer ??= setTimeout(() => {
+      readBoard(connection, owner, signal).then((again) => {
+        if (again) scheduleBoard(connection, owner, signal);
+      }).catch((error) => {
+        onLog?.({
+          level: "warn",
+          message: "reviewflow board read failed",
+          error
+        });
+      });
+    }, boardReadDelayMs);
+  };
+  const scheduleEveryBoard = (connection, signal) => {
+    for (const owner of accounts()) scheduleBoard(connection, owner, signal);
+  };
+  const follow = async (connection, signal, onReady) => {
+    const scope = [];
+    let ready = false;
+    for await (const event of connection.events(signal)) {
+      if (event.type === "end") {
+        onLog?.({
+          level: "info",
+          message: "reviewflow ended the stream",
+          fields: { reason: event.reason }
+        });
+        scheduleEveryBoard(connection, signal);
+        return ready;
+      }
+      if (event.type === "ready") {
+        ready = true;
+        onReady();
+        onLog?.({
+          level: "info",
+          message: "reviewflow stream ready",
+          fields: { prs: scope.length }
+        });
+        for (const pr of scope.splice(0)) onPr(pr, "scope");
+        setState("live");
+        scheduleEveryBoard(connection, signal);
+      } else if (event.type === "pr") {
+        accountOfPr.set(event.pr.id, accountOfOwnerRepo(event.pr.ownerRepo));
+        comparePr(event.pr);
+        if (ready) {
+          onPr(event.pr, "change");
+          scheduleBoard(
+            connection,
+            accountOfOwnerRepo(event.pr.ownerRepo),
+            signal
+          );
+        } else {
+          scope.push(event.pr);
+        }
+      } else if (ready) {
+        const account = accountOfPr.get(event.id);
+        accountOfPr.delete(event.id);
+        lastSeen.delete(event.id);
+        onPrRemoved(event.id);
+        if (account === void 0) scheduleEveryBoard(connection, signal);
+        else scheduleBoard(connection, account, signal);
+      }
+    }
+    return ready;
+  };
+  const run = async (signal) => {
+    let failures = 0;
+    const resetFailures = () => {
+      failures = 0;
+    };
+    while (!signal.aborted) {
+      const connection = connect();
+      if (connection === null) {
+        setState("off");
+        return;
+      }
+      let delayMs = reconnectDelayMs;
+      setState("connecting");
+      try {
+        const reachedReady = await follow(connection, signal, resetFailures);
+        if (!reachedReady && !signal.aborted) {
+          failures++;
+          delayMs = retryDelayMs(void 0, failures);
+          onLog?.({
+            level: "warn",
+            message: "reviewflow ended the stream before it was ready",
+            fields: { retryInMs: delayMs }
+          });
+        }
+      } catch (error) {
+        if (signal.aborted) return;
+        failures++;
+        delayMs = retryDelayMs(error, failures);
+        onLog?.({
+          level: "warn",
+          message: "reviewflow stream failed",
+          error,
+          fields: { retryInMs: delayMs }
+        });
+        setState("error", messageOf(error));
+      }
+      if (state === "live") setState("connecting");
+      await wait(delayMs, signal);
+    }
+  };
+  const stop = () => {
+    controller?.abort();
+    controller = null;
+    for (const read of boardReads.values()) clearTimeout(read.timer);
+    boardReads.clear();
+    accountOfPr.clear();
+    setState("off");
+  };
+  const start = () => {
+    if (controller !== null) return;
+    const current = new AbortController();
+    controller = current;
+    run(current.signal).catch((error) => {
+      onLog?.({
+        level: "error",
+        message: "reviewflow stream stopped",
+        error
+      });
+    }).finally(() => {
+      if (controller === current) controller = null;
+    });
+  };
+  return {
+    setWatched: (value) => {
+      watched = value;
+      clearTimeout(linger);
+      linger = void 0;
+      if (value) start();
+      else if (controller !== null) linger = setTimeout(stop, lingerMs);
+    },
+    restart: () => {
+      const wasOpen = controller !== null;
+      stop();
+      lastSeen.clear();
+      if (watched || wasOpen) start();
+    },
+    state: () => state,
+    close: () => {
+      watched = false;
+      clearTimeout(linger);
+      stop();
+    }
+  };
+};
+
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const insertCheckoutEntry = (source, ownerRepo) => {
+  let parsed;
+  if (source.trim() === "") {
+    parsed = {};
+  } else {
+    try {
+      parsed = JSON.parse(source);
+    } catch {
+      return null;
+    }
+  }
+  if (!isRecord(parsed)) return null;
+  const repos = parsed.repos ?? {};
+  if (!isRecord(repos)) return null;
+  const wanted = ownerRepo.toLowerCase();
+  const existing = Object.keys(repos).find(
+    (key2) => key2.toLowerCase() === wanted
+  );
+  const key = existing ?? ownerRepo;
+  const next = existing === void 0 ? { ...repos, [key]: "" } : repos;
+  const text = `${JSON.stringify({ ...parsed, repos: next }, null, 2)}
+`;
+  const marker = `${JSON.stringify(key)}: "`;
+  const reposAt = text.indexOf('\n  "repos": ');
+  const at = text.indexOf(marker, reposAt);
+  if (at === -1) return null;
+  const value = at + marker.length;
+  return { source: text, cursor: value };
+};
+
+export { accountOfOwnerRepo, applyPullRequestEdit, applyStreamEvent, applySuggestionsToText, assembleBoard, boardReadDelayMs, buildPrQuery, changedPullRequestParts, checkOutcomes, checksFromReviewflow, coAuthorTrailers, commitSuggestions, createGitHubTransport, createReviewflowClient, createReviewflowFollower, diffLines, diffPaths, diffThemeNames, diffThemeOptions, diffThemes, editPullRequest, fail, fetchCompareDiff, fetchPullRequestCandidates, fetchPullRequestHead, fetchPullRequestPart, fetchPullRequestRevisions, insertCheckoutEntry, interpretGraphql, isAttachablePath, isDiffTheme, isDiffWhitespace, isPullRequestOnBoard, isPullRequestPart, isPullRequestReactionContent, isReviewflowFailure, lingerMs, maxExtraPagesPerBucket, maxLookupTargets, maxRetryMs, parsePrQueryResponse, parsePullRequestCandidates, parsePullRequestChecks, parsePullRequestCommits, parsePullRequestDetail, parsePullRequestEdit, parsePullRequestFiles, parsePullRequestRevisions, parsePullRequestTimeline, parseSuggestions, partFingerprint, planSuggestions, prFields, pullRequestCandidatesQuery, pullRequestChecksQuery, pullRequestCommitsQuery, pullRequestDetailQuery, pullRequestEditMovesBoard, pullRequestFilesQuery, pullRequestHeadQuery, pullRequestParts, pullRequestPartsStaleAfter, pullRequestReactionContents, pullRequestRevisionsQuery, pullRequestTimelineQuery, readAccountBoards, readPrDetail, readReviewflowStream, reconnectDelayMs, responseFailure, restErrorMessage, reviewflowErrorCode, splitOwnerRepo, streamClosedWithinDays, streamIdleTimeoutMs, subjectsOf, suggestionCommitRefusal, suggestionOriginalLines, suggestionRangesOverlap, toBoardPr, toFetchedPr, withAccountBoard, withFileViewed };
+//# sourceMappingURL=index-browser.es.js.map