@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-NRULNBYI.js

@@ -1,1153 +0,0 @@
-import {
-  git_gh_pr_rollup
-} from "./chunk-OBYLXHCH.js";
-import {
-  git_gh_repo
-} from "./chunk-CTXJVMHW.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-5IHEBIPD.js";
-import {
-  FIRST_PAGE,
-  git_gh_issue_list
-} from "./chunk-TEXUEBGE.js";
-import {
-  pr_classification
-} from "./chunk-RS5HBJY6.js";
-import {
-  git_gh_issue_write
-} from "./chunk-4F4KARQN.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-TFYYXETQ.js";
-import {
-  GRAPHQL_PATH,
-  git_gh_transport
-} from "./chunk-LX2ENXHZ.js";
-import {
-  git_gh_helpers,
-  to_gh_state
-} from "./chunk-IAGENI2U.js";
-import {
-  gh_author_association
-} from "./chunk-5YTEMF4O.js";
-import {
-  git_gh_conditional,
-  git_gh_etag_read
-} from "./chunk-IPS7EBE5.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-43DU7DYZ.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.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
-};