@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-VJNE7W7O.js

@@ -0,0 +1,1153 @@
+import {
+  git_gh_pr_rollup
+} from "./chunk-CKD2G35M.js";
+import {
+  git_gh_repo
+} from "./chunk-QRY55H5U.js";
+import {
+  forget_pr_numbers,
+  git_gh_pr_read,
+  git_gh_pr_rest,
+  read_listed_pull,
+  read_pull,
+  read_pull_or_listed,
+  require_pr_number
+} from "./chunk-3PGB2RKZ.js";
+import {
+  FIRST_PAGE,
+  git_gh_issue_list
+} from "./chunk-ZB25RO3U.js";
+import {
+  pr_classification
+} from "./chunk-CT773QBI.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  CHECK_STATUS_FAIL,
+  CHECK_STATUS_PENDING,
+  PrConflictError,
+  REQUIRED_CHECKS,
+  blocked_cause,
+  collect_blocking_failures,
+  describe_pr_failure,
+  evaluate_pr_state,
+  is_auto_merge_blocked,
+  is_coderabbit_check,
+  is_merge_conflict,
+  is_required_check,
+  is_review_decision_decisive,
+  missing_context_error,
+  parse_pr_state_snapshot,
+  read_string
+} from "./chunk-WVR4RUFP.js";
+import {
+  BLOCKED_BY_COUNT_FIELD,
+  PAGE,
+  git_gh_issue_graphql,
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  GRAPHQL_PATH,
+  git_gh_transport
+} from "./chunk-W4R6ZBLO.js";
+import {
+  git_gh_helpers,
+  to_gh_state
+} from "./chunk-2BNLPPP4.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  git_gh_conditional,
+  git_gh_etag_read
+} from "./chunk-V6WWW6HX.js";
+import {
+  PR_POLL_SCHEDULES,
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  FULL_PAGE_QUERY,
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  gh_failure,
+  gh_retry,
+  git_gh_exec,
+  parse_json_array_or_undefined
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue.ts
+var NUMBER_AND_BODY_FIELDS = "number,body";
+var LABELLED_FIELDS = "number,body,stateReason";
+var BACKLOG_SCAN_FIELDS = `number,title,body,labels,${BLOCKED_BY_COUNT_FIELD}`;
+var NUMBER_TITLE_AND_LABELS_FIELDS = "number,title,labels";
+var SUMMARY_FIELDS = "number,title,labels,createdAt";
+var PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy,body,${gh_author_association.AUTHOR_FIELDS}`;
+var { issue_list } = git_gh_issue_list;
+async function issue_list_recent(limit) {
+  return await issue_list({ json_fields: `${SUMMARY_FIELDS},body`, limit });
+}
+async function issue_list_open_bodies(limit) {
+  return await issue_list({ json_fields: BACKLOG_SCAN_FIELDS, limit });
+}
+async function issue_list_open_relations(limit) {
+  return await issue_list({ json_fields: `${BACKLOG_SCAN_FIELDS},blockedBy`, limit });
+}
+async function issue_list_recently_closed(limit) {
+  return await issue_list({
+    json_fields: NUMBER_TITLE_AND_LABELS_FIELDS,
+    limit,
+    state: "closed",
+    sort: "updated"
+  });
+}
+async function issue_search_body(term, limit) {
+  return await issue_list({
+    json_fields: NUMBER_AND_BODY_FIELDS,
+    limit,
+    body_term: term
+  });
+}
+async function issue_list_by_label(label, limit) {
+  return await issue_list({ json_fields: LABELLED_FIELDS, limit, label });
+}
+async function issue_list_by_label_summary(label, limit, options) {
+  return await issue_list({
+    json_fields: options?.json_fields ?? PICKUP_FIELDS,
+    limit,
+    label
+  });
+}
+async function issue_list_label_first_page(label) {
+  const path = git_gh_issue_list.listing_path({ label }, FIRST_PAGE);
+  return await git_gh_etag_read.read_detail(path);
+}
+async function issue_list_by_label_in_repo(label, limit, repo) {
+  return await issue_list({ json_fields: SUMMARY_FIELDS, limit, label, repo });
+}
+var JUDGEMENT_FIELDS = "number,title,body,labels,updatedAt,author_association,user";
+async function issue_list_open_for_judgement(limit) {
+  return await issue_list({ json_fields: JUDGEMENT_FIELDS, limit });
+}
+var git_gh_issue = {
+  ...git_gh_issue_read,
+  ...git_gh_issue_write,
+  issue_list_recent,
+  issue_list_by_label,
+  issue_list_by_label_in_repo,
+  issue_list_by_label_summary,
+  issue_list_label_first_page,
+  issue_search_body,
+  issue_list_open_bodies,
+  issue_list_open_relations,
+  issue_list_open_for_judgement,
+  issue_list_recently_closed
+};
+
+// scripts/gh/git-gh-branch-rules.ts
+import { z } from "zod";
+var REQUIRED_STATUS_CHECKS_RULE = "required_status_checks";
+var required_check_schema = z.looseObject({ context: z.string() });
+var rule_parameters_schema = z.looseObject({
+  required_status_checks: z.array(required_check_schema).optional()
+});
+var branch_rule_schema = z.looseObject({
+  type: z.string(),
+  parameters: rule_parameters_schema.nullish()
+});
+var required_contexts_by_branch = /* @__PURE__ */ new Map();
+function to_required_contexts(rules) {
+  return rules.filter((rule) => rule.type === REQUIRED_STATUS_CHECKS_RULE).flatMap((rule) => rule.parameters?.required_status_checks ?? []).map((check) => check.context);
+}
+async function fetch_required_contexts(branch_name) {
+  const raw_json = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.branch_rules_api_path(branch_name)}${FULL_PAGE_QUERY}`,
+    should_paginate: true
+  });
+  const rules = parse_json_array_or_undefined(raw_json, branch_rule_schema);
+  return rules === void 0 ? void 0 : to_required_contexts(rules);
+}
+async function read_required_contexts(branch_name) {
+  if (branch_name === void 0) return [];
+  const cached = required_contexts_by_branch.get(branch_name);
+  if (cached !== void 0) return cached;
+  try {
+    const contexts = await fetch_required_contexts(branch_name);
+    if (contexts === void 0) return [];
+    required_contexts_by_branch.set(branch_name, contexts);
+    return contexts;
+  } catch {
+    return [];
+  }
+}
+var git_gh_branch_rules = { read_required_contexts };
+
+// scripts/gh/git-gh-poll-read.ts
+import { z as z2 } from "zod";
+var UNREADABLE_POLL_MESSAGE = "gh api could not read a merge-gate poll";
+var PAGE_SIZE = 100;
+var kept_by_path = /* @__PURE__ */ new Map();
+var page_schema = z2.object({ total_count: z2.number() });
+function unreadable(path, answer) {
+  const cause = answer.kind === "unreadable" ? answer.cause : void 0;
+  const reason = cause === void 0 ? "" : `: ${error_text.message_of(cause)}`;
+  return new Error(`${UNREADABLE_POLL_MESSAGE}: ${path}${reason}`, { cause });
+}
+function settle_kept(path, answer) {
+  const settled = git_gh_etag_read.settle(kept_by_path.get(path), answer);
+  if (settled?.kept !== void 0) kept_by_path.set(path, settled.kept);
+  return settled?.body;
+}
+async function read_answer(path) {
+  return await git_gh_conditional.read_conditional(path, kept_by_path.get(path)?.etag);
+}
+async function read(path) {
+  const answer = await read_answer(path);
+  const body = settle_kept(path, answer);
+  if (body === void 0) throw unreadable(path, answer);
+  return body;
+}
+async function read_detail(path) {
+  const answer = await read_answer(path);
+  const body = settle_kept(path, answer);
+  return body === void 0 ? void 0 : { body, is_unchanged: answer.kind === "unchanged" };
+}
+function is_whole_listing(page) {
+  const total = json_value.parse_with(page, page_schema)?.total_count;
+  return total !== void 0 && total <= PAGE_SIZE;
+}
+async function read_object_pages(path) {
+  const full_path = `${path}${FULL_PAGE_QUERY}`;
+  const page = await read(full_path);
+  if (is_whole_listing(page)) return `[${page}]`;
+  return await git_gh_exec.exec_gh_api({
+    path: full_path,
+    should_paginate: true,
+    should_slurp: true
+  });
+}
+async function read_array_pages(path) {
+  return await git_gh_etag_read.read_listing(`${path}${FULL_PAGE_QUERY}`, PAGE_SIZE, read);
+}
+function forget_poll_reads() {
+  kept_by_path.clear();
+}
+var git_gh_poll_read = {
+  UNREADABLE_POLL_MESSAGE,
+  forget_poll_reads,
+  read,
+  read_array_pages,
+  read_detail,
+  read_object_pages
+};
+
+// scripts/gh/git-gh-pr-graphql-snapshot.ts
+import { z as z4 } from "zod";
+
+// scripts/gh/git-gh-pr-review.ts
+import { z as z3 } from "zod";
+var REVIEW_APPROVED = "APPROVED";
+var REVIEW_CHANGES_REQUESTED = "CHANGES_REQUESTED";
+var REVIEW_NONE = "";
+var STATE_CHANGING_REVIEWS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
+var rest_review_schema = z3.looseObject({
+  state: z3.string().optional(),
+  user: z3.looseObject({ login: z3.string().optional() }).nullish()
+});
+var NOT_A_REVIEW_LISTING = "gh api answered something other than a review listing";
+function parse_rest_reviews(reviews_json) {
+  const parsed = parse_json_array_or_undefined(reviews_json, rest_review_schema);
+  if (parsed === void 0) throw new Error(NOT_A_REVIEW_LISTING);
+  return parsed;
+}
+var UNATTRIBUTED_REVIEWER = "(no author)";
+function read_reviewer(review) {
+  const login = review.user?.login;
+  return typeof login === "string" && login.length > 0 ? login : UNATTRIBUTED_REVIEWER;
+}
+function read_state_changing(review) {
+  const state = review.state?.toUpperCase();
+  return state !== void 0 && STATE_CHANGING_REVIEWS.has(state) ? state : void 0;
+}
+function fold_latest_states(reviews) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const review of reviews) {
+    const state = read_state_changing(review);
+    if (state !== void 0) latest.set(read_reviewer(review), state);
+  }
+  return latest;
+}
+function to_review_decision(reviews_json) {
+  const latest = new Set(fold_latest_states(parse_rest_reviews(reviews_json)).values());
+  if (latest.has(REVIEW_CHANGES_REQUESTED)) return REVIEW_CHANGES_REQUESTED;
+  return latest.has(REVIEW_APPROVED) ? REVIEW_APPROVED : REVIEW_NONE;
+}
+var git_gh_pr_review = { to_review_decision };
+
+// scripts/gh/git-gh-pr-graphql-snapshot.ts
+var TYPE_NAME_KEY = "__typename";
+var CHECK_RUN = "CheckRun";
+var STATUS_CONTEXT = "StatusContext";
+var REQUIRED_STATUS_CHECKS = "REQUIRED_STATUS_CHECKS";
+var CONTEXTS = `contexts(${PAGE}, after: $after) {
+	pageInfo { hasNextPage endCursor }
+	nodes {
+		__typename
+		... on ${CHECK_RUN} {
+			databaseId name status conclusion checkSuite { databaseId app { databaseId slug } }
+		}
+		... on ${STATUS_CONTEXT} { context state description }
+	}
+}`;
+var REQUIRED_CHECKS2 = `rules(${PAGE}) {
+	nodes { type parameters { ... on RequiredStatusChecksParameters { requiredStatusChecks { context } } } }
+}`;
+var SNAPSHOT_QUERY = `query($owner: String!, $name: String!, $branch: String!, $after: String) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) {
+		pullRequests(headRefName: $branch, first: 1, orderBy: { field: CREATED_AT, direction: DESC }) {
+			nodes {
+				number isCrossRepository merged mergeStateStatus reviewDecision
+				baseRef { ${REQUIRED_CHECKS2} }
+				commits(last: 1) { nodes { commit { id oid statusCheckRollup { ${CONTEXTS} } } } }
+			}
+		}
+	}
+}`;
+var CONTEXTS_PAGE_QUERY = `query($id: ID!, $after: String) {
+	rateLimit { cost remaining }
+	node(id: $id) { ... on Commit { statusCheckRollup { ${CONTEXTS} } } }
+}`;
+var REVIEW_DECISION_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
+	repository(owner: $owner, name: $name) { pullRequest(number: $number) { reviewDecision } }
+}`;
+var rate_limit_schema = z4.object({ cost: z4.number(), remaining: z4.number() });
+var database_id_schema = z4.number().nullish();
+var app_schema = z4.looseObject({ databaseId: database_id_schema, slug: z4.string().nullish() }).nullish();
+var check_suite_schema = z4.looseObject({ databaseId: database_id_schema, app: app_schema });
+var check_run_schema = z4.looseObject({
+  [TYPE_NAME_KEY]: z4.literal(CHECK_RUN),
+  databaseId: database_id_schema,
+  name: z4.string(),
+  status: z4.string(),
+  conclusion: z4.string().nullable(),
+  checkSuite: check_suite_schema.nullish()
+});
+var status_context_schema = z4.looseObject({
+  [TYPE_NAME_KEY]: z4.literal(STATUS_CONTEXT),
+  context: z4.string(),
+  state: z4.string(),
+  description: z4.string().nullable()
+});
+var context_schema = z4.discriminatedUnion(TYPE_NAME_KEY, [
+  check_run_schema,
+  status_context_schema
+]);
+var page_info_schema = z4.looseObject({
+  hasNextPage: z4.boolean(),
+  endCursor: z4.string().nullish()
+});
+var contexts_page_schema = z4.looseObject({
+  pageInfo: page_info_schema,
+  nodes: z4.array(context_schema)
+});
+var rollup_schema = z4.looseObject({ contexts: contexts_page_schema }).nullable();
+var commit_schema = z4.looseObject({
+  id: z4.string(),
+  oid: z4.string(),
+  statusCheckRollup: rollup_schema
+});
+var commit_node_schema = z4.looseObject({ commit: commit_schema });
+var commits_schema = z4.looseObject({ nodes: z4.array(commit_node_schema) });
+var required_check_schema2 = z4.looseObject({ context: z4.string() });
+var rule_parameters_schema2 = z4.looseObject({
+  requiredStatusChecks: z4.array(required_check_schema2).optional()
+});
+var rule_schema = z4.looseObject({
+  type: z4.string(),
+  parameters: rule_parameters_schema2.nullable()
+});
+var rules_schema = z4.looseObject({ nodes: z4.array(rule_schema) });
+var base_reference_schema = z4.looseObject({ rules: rules_schema });
+var pull_schema = z4.looseObject({
+  number: z4.number(),
+  isCrossRepository: z4.boolean(),
+  merged: z4.boolean(),
+  mergeStateStatus: z4.string(),
+  reviewDecision: z4.string().nullable(),
+  baseRef: base_reference_schema.nullable(),
+  commits: commits_schema
+});
+var pull_requests_schema = z4.looseObject({ nodes: z4.array(pull_schema) });
+var snapshot_data_schema = z4.looseObject({
+  rateLimit: rate_limit_schema,
+  repository: z4.looseObject({ pullRequests: pull_requests_schema })
+});
+var page_data_schema = z4.looseObject({
+  rateLimit: rate_limit_schema,
+  node: z4.looseObject({ statusCheckRollup: rollup_schema })
+});
+var decision_pull_schema = z4.looseObject({ reviewDecision: z4.string().nullable() });
+var decision_data_schema = z4.looseObject({
+  repository: z4.looseObject({ pullRequest: decision_pull_schema })
+});
+var EMPTY_PAGE = { pageInfo: { hasNextPage: false }, nodes: [] };
+var DECISIONS = /* @__PURE__ */ new Set([REVIEW_APPROVED, REVIEW_CHANGES_REQUESTED]);
+async function query_data(query, variables, schema) {
+  const json = await git_gh_transport.query({ query, variables });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, z4.looseObject({ data: schema }))?.data;
+}
+function page_of(rollup) {
+  return rollup?.contexts ?? EMPTY_PAGE;
+}
+function spent_on(previous, next) {
+  return { cost: previous.cost + next.cost, remaining: next.remaining };
+}
+async function read_next_page(commit_id, after) {
+  const data = await query_data(CONTEXTS_PAGE_QUERY, { id: commit_id, after }, page_data_schema);
+  return data && { page: page_of(data.node.statusCheckRollup), rate_limit: data.rateLimit };
+}
+function joined(page, rest) {
+  return rest && { contexts: [...page.nodes, ...rest.contexts], rate_limit: rest.rate_limit };
+}
+async function read_pages_from(commit_id, read2) {
+  const { page, rate_limit } = read2;
+  if (!page.pageInfo.hasNextPage) return { contexts: page.nodes, rate_limit };
+  const next = await read_next_page(commit_id, page.pageInfo.endCursor);
+  if (next === void 0) return void 0;
+  const spent = spent_on(rate_limit, next.rate_limit);
+  return joined(page, await read_pages_from(commit_id, { page: next.page, rate_limit: spent }));
+}
+function lower_case_of(value) {
+  return value === null ? value : value.toLowerCase();
+}
+function to_rest_context(context) {
+  if (context.__typename === STATUS_CONTEXT) {
+    const { context: name2, state, description } = context;
+    return {
+      [TYPE_NAME_KEY]: STATUS_CONTEXT,
+      context: name2,
+      state: state.toLowerCase(),
+      description
+    };
+  }
+  const { name, status, conclusion } = context;
+  return { name, status: status.toLowerCase(), conclusion: lower_case_of(conclusion) };
+}
+function id_holder_of(database_id) {
+  return database_id === null || database_id === void 0 ? void 0 : { id: database_id };
+}
+function to_rest_app(app) {
+  if (app === null || app === void 0) return void 0;
+  const holder = id_holder_of(app.databaseId);
+  if (holder === void 0) return void 0;
+  return { ...holder, slug: app.slug ?? void 0 };
+}
+function to_rest_ids(context) {
+  if (context.__typename === STATUS_CONTEXT) return {};
+  const suite = context.checkSuite;
+  return {
+    ...id_holder_of(context.databaseId),
+    check_suite: id_holder_of(suite?.databaseId),
+    app: to_rest_app(suite?.app)
+  };
+}
+function to_rest_rollup(contexts) {
+  const check_runs = contexts.filter((context) => context.__typename === CHECK_RUN).map((context) => ({ ...to_rest_ids(context), ...to_rest_context(context) }));
+  const statuses = contexts.filter((context) => context.__typename === STATUS_CONTEXT).map((context) => to_rest_context(context));
+  return [...git_gh_pr_rollup.newest_check_runs(check_runs), ...statuses];
+}
+function to_required_contexts2(base_reference) {
+  return (base_reference?.rules.nodes ?? []).filter((rule) => rule.type === REQUIRED_STATUS_CHECKS).flatMap((rule) => rule.parameters?.requiredStatusChecks ?? []).map((check) => check.context);
+}
+function to_review_decision2(decision) {
+  if (decision === null) return void 0;
+  return DECISIONS.has(decision) ? decision : REVIEW_NONE;
+}
+function to_checks_fields(pull, head_sha, contexts) {
+  return {
+    statusCheckRollup: to_rest_rollup(contexts),
+    mergeStateStatus: pull.mergeStateStatus,
+    headRefOid: head_sha,
+    requiredContexts: to_required_contexts2(pull.baseRef),
+    ...pull.merged && { merged: true }
+  };
+}
+async function query_pull(variables) {
+  const data = await query_data(SNAPSHOT_QUERY, variables, snapshot_data_schema);
+  if (data === void 0) return void 0;
+  const [pull] = data.repository.pullRequests.nodes;
+  if (pull === void 0 || pull.isCrossRepository) return void 0;
+  return { pull, rate_limit: data.rateLimit };
+}
+async function read_pull2(branch_name) {
+  const repository = git_gh_issue_graphql.repository_variables_of();
+  if (repository === void 0) return void 0;
+  return await query_pull({ ...repository, branch: branch_name });
+}
+async function read_head_snapshot(answered) {
+  const { pull, rate_limit } = answered;
+  const [node] = pull.commits.nodes;
+  if (node === void 0) return void 0;
+  const { id, oid, statusCheckRollup: rollup } = node.commit;
+  const read2 = await read_pages_from(id, { page: page_of(rollup), rate_limit });
+  if (read2 === void 0) return void 0;
+  return {
+    pr_number: pull.number,
+    fields: to_checks_fields(pull, oid, read2.contexts),
+    review_decision: to_review_decision2(pull.reviewDecision),
+    rate_limit: read2.rate_limit
+  };
+}
+async function read_snapshot(branch_name) {
+  const answered = await read_pull2(branch_name);
+  return answered && await read_head_snapshot(answered);
+}
+async function read_review_decision(pr_number) {
+  const repository = git_gh_issue_graphql.repository_variables_of();
+  if (repository === void 0) return void 0;
+  const variables = { ...repository, number: pr_number };
+  const data = await query_data(REVIEW_DECISION_QUERY, variables, decision_data_schema);
+  return data && to_review_decision2(data.repository.pullRequest.reviewDecision);
+}
+var git_gh_pr_graphql_snapshot = { read_snapshot, read_review_decision };
+
+// scripts/gh/git-gh-pr-graphql-state.ts
+import { z as z5 } from "zod";
+var MERGE_STATE_QUERY = "query($id: ID!) { node(id: $id) { ... on PullRequest { mergeStateStatus } } }";
+var NO_MERGE_STATE_MESSAGE = "The merge state cannot be judged: GitHub refuses this pull request as too many files changed, and GraphQL did not answer its mergeStateStatus";
+var merge_state_node_schema = z5.looseObject({ mergeStateStatus: z5.string() });
+var merge_state_data_schema = z5.looseObject({ node: merge_state_node_schema });
+var merge_state_response_schema = z5.looseObject({ data: merge_state_data_schema });
+async function try_read_merge_state(node_id) {
+  if (node_id === void 0) return void 0;
+  const json = await git_gh_transport.query({
+    query: MERGE_STATE_QUERY,
+    variables: { id: node_id }
+  });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, merge_state_response_schema)?.data.node.mergeStateStatus;
+}
+async function read_merge_state_status(listed, detail_error) {
+  const state = await try_read_merge_state(listed.node_id);
+  if (state === void 0) throw new Error(NO_MERGE_STATE_MESSAGE, { cause: detail_error });
+  return state;
+}
+var git_gh_pr_graphql_state = { read_merge_state_status, try_read_merge_state };
+
+// scripts/gh/git-gh-pr-snapshot.ts
+var NO_HEAD_SHA_MESSAGE = "gh api answered a pull request with no head commit";
+function read_head_sha(pull) {
+  const sha = pull.head?.sha;
+  if (sha === void 0) throw new Error(NO_HEAD_SHA_MESSAGE);
+  return sha;
+}
+async function read_status_check_rollup(commit_sha) {
+  const [check_runs_json, status_json] = await Promise.all([
+    git_gh_poll_read.read_object_pages(git_gh_api_path.commit_check_runs_api_path(commit_sha)),
+    git_gh_poll_read.read_object_pages(git_gh_api_path.commit_status_api_path(commit_sha))
+  ]);
+  return git_gh_pr_rollup.to_status_check_rollup({ check_runs_json, status_json });
+}
+async function read_rest_review_decision(pr_number) {
+  const path = git_gh_api_path.pull_reviews_api_path(String(pr_number));
+  return git_gh_pr_review.to_review_decision(await git_gh_poll_read.read_array_pages(path));
+}
+async function pr_get_review_decision(pr_number) {
+  const graphql_decision = await git_gh_pr_graphql_snapshot.read_review_decision(pr_number);
+  return graphql_decision ?? await read_rest_review_decision(pr_number);
+}
+async function build_checks_fields(pull) {
+  const head_sha = read_head_sha(pull);
+  const [rollup, required_contexts] = await Promise.all([
+    read_status_check_rollup(head_sha),
+    git_gh_branch_rules.read_required_contexts(pull.base?.ref)
+  ]);
+  return {
+    statusCheckRollup: rollup,
+    mergeStateStatus: to_gh_state(pull.mergeable_state),
+    headRefOid: head_sha,
+    requiredContexts: required_contexts,
+    ...git_gh_pr_rest.is_merged(pull) && { merged: true }
+  };
+}
+async function read_polled_pull(pr_number) {
+  const polled = await git_gh_poll_read.read_detail(
+    git_gh_api_path.pull_api_path(String(pr_number))
+  );
+  if (polled === void 0) return await read_pull(pr_number);
+  const pull = git_gh_pr_rest.parse_rest_pull(polled.body);
+  if (!polled.is_unchanged) return pull;
+  const state = await git_gh_pr_graphql_state.try_read_merge_state(pull.node_id);
+  return state === void 0 ? await read_pull(pr_number) : { ...pull, mergeable_state: state };
+}
+async function read_detail_or_listed(branch_name, pr_number) {
+  try {
+    return await read_polled_pull(pr_number);
+  } catch (error) {
+    const listed = await read_listed_pull(error, branch_name, pr_number);
+    if (listed === void 0) throw error;
+    const state = await git_gh_pr_graphql_state.read_merge_state_status(listed, error);
+    return { ...listed, mergeable_state: state };
+  }
+}
+async function resolve_pull(branch_name) {
+  const pr_number = await require_pr_number(branch_name);
+  return { pr_number, pull: await read_detail_or_listed(branch_name, pr_number) };
+}
+async function pr_get_checks_snapshot(branch_name) {
+  const graphql = await git_gh_pr_graphql_snapshot.read_snapshot(branch_name);
+  if (graphql !== void 0) {
+    return {
+      pr_number: graphql.pr_number,
+      snapshot_json: JSON.stringify(graphql.fields),
+      graphql: { review_decision: graphql.review_decision }
+    };
+  }
+  const { pr_number, pull } = await resolve_pull(branch_name);
+  return { pr_number, snapshot_json: JSON.stringify(await build_checks_fields(pull)) };
+}
+async function graphql_or_rest_decision(decision, pr_number) {
+  return decision ?? await read_rest_review_decision(pr_number);
+}
+async function pr_read_review_decision(checks) {
+  if (checks.graphql === void 0) return await pr_get_review_decision(checks.pr_number);
+  return await graphql_or_rest_decision(checks.graphql.review_decision, checks.pr_number);
+}
+async function pr_get_state_snapshot(branch_name) {
+  const graphql = await git_gh_pr_graphql_snapshot.read_snapshot(branch_name);
+  if (graphql !== void 0) {
+    const review_decision2 = await graphql_or_rest_decision(
+      graphql.review_decision,
+      graphql.pr_number
+    );
+    return JSON.stringify({ ...graphql.fields, reviewDecision: review_decision2 });
+  }
+  const { pr_number, pull } = await resolve_pull(branch_name);
+  const [fields, review_decision] = await Promise.all([
+    build_checks_fields(pull),
+    pr_get_review_decision(pr_number)
+  ]);
+  return JSON.stringify({ ...fields, reviewDecision: review_decision });
+}
+var git_gh_pr_snapshot = {
+  pr_get_state_snapshot,
+  pr_get_checks_snapshot,
+  pr_get_review_decision,
+  pr_read_review_decision
+};
+
+// scripts/gh/git-gh-pr.ts
+var HTML_URL_FILTER = ".html_url";
+var PUT_METHOD = "PUT";
+var PATCH_METHOD = "PATCH";
+var MERGE_COMMIT_METHOD = "merge";
+var MERGE_REQUEST_TIMEOUT_MS = 18e4;
+var MERGE_UNCONFIRMED_MESSAGE = "gh api could not read the pull request back after the merge request failed";
+var MERGE_READ_BACK_ATTEMPTS = 3;
+var MERGE_READ_BACK_INTERVAL_MS = 1e3;
+var MERGE_IN_PROGRESS_MESSAGE = "Merge already in progress";
+var MERGE_IN_PROGRESS_ATTEMPTS = 30;
+var MERGE_IN_PROGRESS_INTERVAL_MS = 2e3;
+var HEAD_MOVED_STATUS = 409;
+var PR_NUMBER_PATTERN = /\/pull\/([1-9]\d*)$/u;
+async function add_pr_classification(number, label) {
+  const write = await git_gh_issue_write.issue_apply_label(number, label);
+  if (!write.is_applied) throw new Error(write.reason);
+}
+async function pr_get_classification(branch_name) {
+  const number = await require_pr_number(branch_name);
+  const labels = await git_gh_issue_write.read_label_names(String(number));
+  if (labels === void 0) throw new Error(`Unreadable labels on branch ${branch_name}`);
+  const names = labels.map((name) => name.toLowerCase());
+  const selected = names.filter((name) => pr_classification.is_classification(name));
+  if (selected.length === 0) return void 0;
+  const error = pr_classification.classification_error(names, "human");
+  if (error !== void 0) throw new Error(error);
+  return selected[0];
+}
+async function pr_ensure_classification(branch_name, label) {
+  if (await pr_get_classification(branch_name) !== void 0) return;
+  const number = await require_pr_number(branch_name);
+  await add_pr_classification(String(number), label);
+}
+async function post_pull_request(title, body) {
+  const base = await git_command.get_default_branch();
+  const head = await git_command.branch();
+  forget_pr_numbers();
+  try {
+    return await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.pulls_api_path(),
+      body: JSON.stringify({ title, body, head, base }),
+      jq_filter: HTML_URL_FILTER
+    });
+  } catch (error) {
+    return git_gh_helpers.handle_pr_create_error(error);
+  }
+}
+async function pr_create(title, body, label) {
+  const classification_error = pr_classification.classification_error([label], "human");
+  if (classification_error !== void 0) throw new Error(classification_error);
+  const url = await post_pull_request(title, body);
+  const number = PR_NUMBER_PATTERN.exec(url)?.[1];
+  if (number === void 0) throw new Error(`Could not identify the created pull request: ${url}`);
+  await add_pr_classification(number, label);
+  return url;
+}
+async function pr_comment(branch_name, body) {
+  const pr_number = await require_pr_number(branch_name);
+  return await git_gh_issue_write.issue_comment(String(pr_number), body);
+}
+async function pr_update_body(branch_name, body) {
+  const pr_number = await require_pr_number(branch_name);
+  forget_pr_numbers();
+  await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_api_path(String(pr_number)),
+    method: PATCH_METHOD,
+    body: JSON.stringify({ body })
+  });
+}
+async function put_merge(pr_number, head_sha) {
+  forget_pr_numbers();
+  await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_merge_api_path(String(pr_number)),
+    method: PUT_METHOD,
+    body: JSON.stringify({ merge_method: MERGE_COMMIT_METHOD, sha: head_sha }),
+    timeout_ms: MERGE_REQUEST_TIMEOUT_MS,
+    should_retry: false
+  });
+}
+function is_head_moved(error) {
+  return gh_failure.failure_of(error)?.status === HEAD_MOVED_STATUS;
+}
+async function read_merge_state(branch_name, pr_number) {
+  try {
+    return git_gh_pr_rest.is_merged(await read_pull_or_listed(branch_name, pr_number, read_pull));
+  } catch (error) {
+    console.warn(`Could not read the pull request back: ${String(error)}`);
+    return void 0;
+  }
+}
+function is_merge_in_progress(error) {
+  return error instanceof Error && error.message.includes(MERGE_IN_PROGRESS_MESSAGE);
+}
+async function has_in_progress_merge_landed(branch_name, pr_number) {
+  return await poll.poll_until(
+    async () => await read_merge_state(branch_name, pr_number) === true,
+    { attempts: MERGE_IN_PROGRESS_ATTEMPTS, interval_ms: MERGE_IN_PROGRESS_INTERVAL_MS }
+  );
+}
+async function has_merge_landed(branch_name, pr_number, merge_error) {
+  if (is_merge_in_progress(merge_error)) {
+    return await has_in_progress_merge_landed(branch_name, pr_number);
+  }
+  const is_merged = await poll.poll_for(
+    async () => await read_merge_state(branch_name, pr_number),
+    { attempts: MERGE_READ_BACK_ATTEMPTS, interval_ms: MERGE_READ_BACK_INTERVAL_MS }
+  );
+  if (is_merged !== void 0) return is_merged;
+  throw new Error(MERGE_UNCONFIRMED_MESSAGE, { cause: merge_error });
+}
+async function merge_with_confirmation(branch_name, pr_number, head_sha) {
+  try {
+    await put_merge(pr_number, head_sha);
+  } catch (error) {
+    if (!await has_merge_landed(branch_name, pr_number, error)) throw error;
+  }
+}
+async function pr_merge(branch_name, head_sha) {
+  const pr_number = await require_pr_number(branch_name);
+  await gh_retry.with_retry(async () => {
+    await merge_with_confirmation(branch_name, pr_number, head_sha);
+  });
+}
+var git_gh_pr = {
+  ...git_gh_pr_read,
+  ...git_gh_pr_snapshot,
+  pr_create,
+  pr_get_classification,
+  pr_ensure_classification,
+  pr_comment,
+  pr_merge,
+  pr_update_body,
+  is_head_moved
+};
+
+// scripts/gh/git-gh-pr-auto-merge.ts
+var OPEN_PULLS_QUERY = `${git_gh_api_path.FULL_PAGE_QUERY}&state=open`;
+var MISSING_NODE_ID_MESSAGE = "gh api answered a pull request without a node_id";
+var ENABLE_AUTO_MERGE_MUTATION = "mutation($id: ID!, $head: GitObjectID!) { enablePullRequestAutoMerge(input: { pullRequestId: $id, mergeMethod: MERGE, expectedHeadOid: $head }) { clientMutationId } }";
+async function read_branch_pull(branch_name) {
+  return await read_pull_or_listed(branch_name, await require_pr_number(branch_name), read_pull);
+}
+async function pr_enable_auto_merge(branch_name, head_sha) {
+  const pull = await read_branch_pull(branch_name);
+  if (pull.node_id === void 0) throw new Error(MISSING_NODE_ID_MESSAGE);
+  await git_gh_exec.exec_gh_api({
+    path: GRAPHQL_PATH,
+    body: JSON.stringify({
+      query: ENABLE_AUTO_MERGE_MUTATION,
+      variables: { id: pull.node_id, head: head_sha }
+    })
+  });
+}
+async function pr_is_merged(branch_name) {
+  try {
+    return git_gh_pr_rest.is_merged(await read_branch_pull(branch_name));
+  } catch (error) {
+    error_text.trace_swallowed("git_gh_pr_auto_merge.pr_is_merged", error);
+    return false;
+  }
+}
+function head_reference_of(pull) {
+  return pull.head?.ref ?? "";
+}
+function has_head_prefix(pull, prefix) {
+  return git_gh_pr_rest.is_same_repository_head(pull) && head_reference_of(pull).startsWith(prefix);
+}
+function to_open_pull(pull) {
+  return {
+    number: pull.number,
+    head_ref: head_reference_of(pull),
+    has_auto_merge: pull.auto_merge !== null && pull.auto_merge !== void 0
+  };
+}
+async function pr_list_open_with_head_prefix(prefix) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.pulls_api_path()}${OPEN_PULLS_QUERY}`,
+    should_paginate: true
+  });
+  return git_gh_pr_rest.parse_rest_pulls(json).filter((pull) => has_head_prefix(pull, prefix)).map((pull) => to_open_pull(pull));
+}
+var git_gh_pr_auto_merge = {
+  pr_enable_auto_merge,
+  pr_is_merged,
+  pr_list_open_with_head_prefix
+};
+
+// scripts/gh/git-pr-checks-gate.ts
+var MERGE_STATE_UNKNOWN = "UNKNOWN";
+function probe_paths(branch_name) {
+  const reference = encodeURIComponent(branch_name);
+  return [
+    `${git_gh_api_path.commit_check_runs_api_path(reference)}${FULL_PAGE_QUERY}`,
+    git_gh_api_path.commit_status_api_path(reference)
+  ];
+}
+function next_etag(read2, previous) {
+  if (read2.kind === "unchanged") return previous;
+  return read2.kind === "changed" ? read2.etag : void 0;
+}
+async function probe_head(branch_name, etags) {
+  const reads = await Promise.all(
+    probe_paths(branch_name).map(async (path) => ({
+      path,
+      read: await git_gh_conditional.read_conditional(path, etags.get(path))
+    }))
+  );
+  return {
+    is_unchanged: reads.every(({ read: read2 }) => read2.kind === "unchanged"),
+    etags: new Map(reads.map(({ path, read: read2 }) => [path, next_etag(read2, etags.get(path))]))
+  };
+}
+function is_merge_state_known(snapshot) {
+  const status = snapshot.merge_state_status;
+  return status !== void 0 && status.toUpperCase() !== MERGE_STATE_UNKNOWN;
+}
+function is_ci_running(snapshot) {
+  return snapshot.rollup.some((check) => check.status === CHECK_STATUS_PENDING);
+}
+function can_reuse(snapshot, should_read) {
+  return is_ci_running(snapshot) && is_merge_state_known(snapshot) && !should_read(snapshot);
+}
+function reusable(last, should_read) {
+  return last !== void 0 && can_reuse(last, should_read) ? last : void 0;
+}
+function gate_fetcher(inner) {
+  const state = { last: void 0, etags: /* @__PURE__ */ new Map() };
+  return async function fetch_gated(branch_name, should_read_review_decision) {
+    const probe = await probe_head(branch_name, state.etags);
+    const reused = probe.is_unchanged ? reusable(state.last, should_read_review_decision) : void 0;
+    if (reused !== void 0) return reused;
+    const snapshot = await inner(branch_name, should_read_review_decision);
+    Object.assign(state, { last: snapshot, etags: probe.etags });
+    return snapshot;
+  };
+}
+var git_pr_checks_gate = { gate_fetcher };
+
+// scripts/gh/git-pr-checks.ts
+var SECONDS_TO_MS = 1e3;
+var CHECK_WAIT_INTERVAL_MS = 2e4;
+var DEFAULT_TIMEOUT_SECONDS = 1920;
+function compute_max_attempts(timeout_seconds, interval_ms) {
+  return Math.ceil(timeout_seconds / (interval_ms / SECONDS_TO_MS)) + 1;
+}
+var DEFAULT_MAX_ATTEMPTS = compute_max_attempts(DEFAULT_TIMEOUT_SECONDS, CHECK_WAIT_INTERVAL_MS);
+function get_configured_max_attempts() {
+  const environment_seconds = Number(process.env["JOSH_CI_TIMEOUT_SECONDS"]);
+  return Number.isFinite(environment_seconds) && environment_seconds > 0 ? compute_max_attempts(environment_seconds, CHECK_WAIT_INTERVAL_MS) : DEFAULT_MAX_ATTEMPTS;
+}
+var CHECK_MAX_ATTEMPTS = get_configured_max_attempts();
+var DEFAULT_STABLE_READS = 2;
+var WATCH_CONFIRMED_STABLE_READS = 1;
+var MAX_CONSECUTIVE_READ_FAILURES = 3;
+var PR_CHECKS_TIMEOUT_MESSAGE = "Timed out while waiting for PR checks to complete.";
+function is_pr_checks_timeout(error) {
+  return error instanceof Error && error.message === PR_CHECKS_TIMEOUT_MESSAGE;
+}
+function should_always_read_review_decision() {
+  return true;
+}
+var MERGE_GATE_EVALUATOR = {
+  evaluate: evaluate_pr_state,
+  describe: describe_pr_failure,
+  should_read_review_decision: is_review_decision_decisive
+};
+function advance_stable_count(previous, state) {
+  return state === "success" ? previous + 1 : 0;
+}
+function failure_error(message, snapshot) {
+  if (is_merge_conflict(snapshot.merge_state_status)) return new PrConflictError(message);
+  return missing_context_error(message, snapshot) ?? new Error(message);
+}
+function classify_poll_result(input) {
+  const state = input.evaluator.evaluate(input.snapshot);
+  if (state === "failure") {
+    throw failure_error(input.evaluator.describe(input.snapshot), input.snapshot);
+  }
+  const next_stable_count = advance_stable_count(input.stable_count, state);
+  return {
+    is_done: next_stable_count >= input.required_stable_reads,
+    next_stable_count
+  };
+}
+async function read_pr_state(input, evaluator) {
+  try {
+    const snapshot = await input.options.fetcher(
+      input.options.branch_name,
+      evaluator.should_read_review_decision ?? should_always_read_review_decision
+    );
+    return { kind: "read", snapshot };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+function retry_after_unreadable(input, cause) {
+  const next_failure_count = input.failure_count + 1;
+  if (next_failure_count >= MAX_CONSECUTIVE_READ_FAILURES) throw cause;
+  console.warn(
+    `Could not read the PR state (${String(next_failure_count)}/${String(MAX_CONSECUTIVE_READ_FAILURES)}); asking again on the next poll: ${String(cause)}`
+  );
+  return { next_stable_count: 0, next_failure_count, read_failure: cause };
+}
+function timeout_error(last_snapshot) {
+  const cause = last_snapshot && blocked_cause(last_snapshot, REQUIRED_CHECKS);
+  return cause === void 0 ? new Error(PR_CHECKS_TIMEOUT_MESSAGE) : new Error(PR_CHECKS_TIMEOUT_MESSAGE, { cause });
+}
+function to_exhaustion_error(carried) {
+  return carried.read_failure ?? timeout_error(carried.last_snapshot);
+}
+async function attempt_pr_success_poll(input) {
+  const evaluator = input.options.evaluator ?? MERGE_GATE_EVALUATOR;
+  const read2 = await read_pr_state(input, evaluator);
+  if (read2.kind === "unreadable") return retry_after_unreadable(input, read2.cause);
+  const classification = classify_poll_result({
+    snapshot: read2.snapshot,
+    stable_count: input.stable_count,
+    required_stable_reads: input.options.required_stable_reads,
+    evaluator
+  });
+  if (classification.is_done) {
+    return { snapshot: read2.snapshot, next_stable_count: 0, next_failure_count: 0 };
+  }
+  return {
+    next_stable_count: classification.next_stable_count,
+    next_failure_count: 0,
+    last_snapshot: read2.snapshot
+  };
+}
+function pr_poll_options(options, progress) {
+  const cadence = { attempts: options.max_attempts, interval_ms: options.interval_ms };
+  if (options.backoff === void 0) return cadence;
+  function seen() {
+    return JSON.stringify({ last: progress.carried.last_snapshot });
+  }
+  return { ...cadence, backoff: { schedule: options.backoff, seen } };
+}
+async function wait_for_pr_success(options) {
+  const progress = {
+    carried: { next_stable_count: 0, next_failure_count: 0 }
+  };
+  let attempt = 0;
+  const snapshot = await poll.poll_for(
+    async () => {
+      attempt += 1;
+      console.info(`Checking PR status\u2026 (read ${String(attempt)})`);
+      await options.before_poll?.();
+      const carried = await attempt_pr_success_poll({
+        options,
+        stable_count: progress.carried.next_stable_count,
+        failure_count: progress.carried.next_failure_count
+      });
+      Object.assign(progress, { carried });
+      return carried.snapshot;
+    },
+    pr_poll_options(options, progress)
+  );
+  if (snapshot !== void 0) return snapshot;
+  throw to_exhaustion_error(progress.carried);
+}
+async function default_fetch_pr_state(branch_name, should_read_review_decision = should_always_read_review_decision) {
+  const checks = await git_gh_pr_snapshot.pr_get_checks_snapshot(branch_name);
+  const snapshot = parse_pr_state_snapshot(checks.snapshot_json);
+  if (!should_read_review_decision(snapshot)) return snapshot;
+  const decision = await git_gh_pr_snapshot.pr_read_review_decision(checks);
+  return { ...snapshot, review_decision: read_string(decision) };
+}
+function observed_fetcher(observe) {
+  const fetch_gated = git_pr_checks_gate.gate_fetcher(default_fetch_pr_state);
+  if (observe === void 0) return fetch_gated;
+  return async function fetch_observed(branch_name, should_read_review_decision) {
+    const snapshot = await fetch_gated(branch_name, should_read_review_decision);
+    await observe(snapshot);
+    return snapshot;
+  };
+}
+async function wait_for_pr_success_default(branch_name, required_stable_reads = DEFAULT_STABLE_READS, before_poll, observe) {
+  return await wait_for_pr_success({
+    branch_name,
+    fetcher: observed_fetcher(observe),
+    interval_ms: CHECK_WAIT_INTERVAL_MS,
+    max_attempts: CHECK_MAX_ATTEMPTS,
+    backoff: PR_POLL_SCHEDULES.checks_gated,
+    required_stable_reads,
+    before_poll
+  });
+}
+function to_merge_progress(snapshot) {
+  if (snapshot.is_merged === true) return "merged";
+  return is_auto_merge_blocked(snapshot) ? "failed" : "waiting";
+}
+async function read_merge_progress(branch_name) {
+  try {
+    return to_merge_progress(await default_fetch_pr_state(branch_name));
+  } catch {
+    return await git_gh_pr_auto_merge.pr_is_merged(branch_name) ? "merged" : "waiting";
+  }
+}
+async function wait_for_pr_merged(branch_name) {
+  let progress = "waiting";
+  await poll.poll_until(
+    async () => {
+      progress = await read_merge_progress(branch_name);
+      return progress !== "waiting";
+    },
+    {
+      attempts: CHECK_MAX_ATTEMPTS,
+      interval_ms: CHECK_WAIT_INTERVAL_MS,
+      backoff: { schedule: PR_POLL_SCHEDULES.merge }
+    }
+  );
+  return progress;
+}
+var git_pr_checks = {
+  read_merge_progress,
+  wait_for_pr_merged,
+  wait_for_pr_success: wait_for_pr_success_default
+};
+
+// scripts/gh/git-pr-checks-watch.ts
+var PR_CHECKS_WATCH_TIMEOUT_MS = 12e4;
+var WATCH_TIMED_OUT_NOTE = "\u23F1\uFE0F pr checks --watch timed out.";
+var NO_CHECKS_MESSAGE = "gh api reported no checks on the branch";
+var CHECKS_FAILED_MESSAGE = "gh api reported a failing check on the branch";
+function is_awaited_check(check) {
+  return !is_coderabbit_check(check.name) || is_required_check(check.name);
+}
+function evaluate_awaited_settled(snapshot) {
+  const awaited = snapshot.rollup.filter((check) => is_awaited_check(check));
+  const considered = awaited.length === 0 ? snapshot.rollup : awaited;
+  if (considered.length === 0 || considered.some((check) => check.status === CHECK_STATUS_PENDING)) {
+    return "pending";
+  }
+  return snapshot.rollup.some((check) => check.status === CHECK_STATUS_FAIL) ? "failure" : "success";
+}
+function evaluate_checks_settled(snapshot) {
+  if (collect_blocking_failures(snapshot).length > 0) return "failure";
+  return evaluate_awaited_settled(snapshot);
+}
+function describe_checks_failure(snapshot) {
+  const failed = snapshot.rollup.filter((check) => check.status === CHECK_STATUS_FAIL);
+  return `${CHECKS_FAILED_MESSAGE}: ${failed.map((check) => check.name).join(", ")}`;
+}
+function should_never_read_review_decision() {
+  return false;
+}
+var CHECKS_SETTLED_EVALUATOR = {
+  evaluate: evaluate_checks_settled,
+  describe: describe_checks_failure,
+  should_read_review_decision: should_never_read_review_decision
+};
+async function watch_until_settled(branch_name, observe) {
+  await wait_for_pr_success({
+    branch_name,
+    fetcher: observed_fetcher(observe),
+    interval_ms: CHECK_WAIT_INTERVAL_MS,
+    max_attempts: compute_max_attempts(
+      PR_CHECKS_WATCH_TIMEOUT_MS / SECONDS_TO_MS,
+      CHECK_WAIT_INTERVAL_MS
+    ),
+    backoff: PR_POLL_SCHEDULES.checks_gated,
+    required_stable_reads: DEFAULT_STABLE_READS,
+    evaluator: CHECKS_SETTLED_EVALUATOR
+  });
+}
+async function fail_when_no_checks(branch_name) {
+  const snapshot = await default_fetch_pr_state(branch_name, should_never_read_review_decision);
+  if (snapshot.rollup.length === 0) throw new Error(NO_CHECKS_MESSAGE);
+}
+async function pr_checks_watch(branch_name, observe) {
+  try {
+    await watch_until_settled(branch_name, observe);
+    return { timed_out: false };
+  } catch (error) {
+    if (!is_pr_checks_timeout(error)) throw error;
+    await fail_when_no_checks(branch_name);
+    console.info(WATCH_TIMED_OUT_NOTE);
+    return { timed_out: true };
+  }
+}
+var git_pr_checks_watch = { pr_checks_watch };
+
+// scripts/gh/git-gh-command.ts
+var git_gh_command = {
+  ...git_gh_pr,
+  ...git_gh_pr_auto_merge,
+  pr_checks_watch: git_pr_checks_watch.pr_checks_watch,
+  ...git_gh_issue,
+  ...git_gh_repo
+};
+
+export {
+  SUMMARY_FIELDS,
+  git_gh_issue,
+  git_gh_pr_snapshot,
+  DEFAULT_STABLE_READS,
+  WATCH_CONFIRMED_STABLE_READS,
+  PR_CHECKS_TIMEOUT_MESSAGE,
+  git_pr_checks,
+  NO_CHECKS_MESSAGE,
+  git_gh_command
+};