@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-VWNVKWLV.js

@@ -0,0 +1,298 @@
+import {
+  git_gh_issue_batch_read
+} from "./chunk-WHYYBPIC.js";
+import {
+  cutoff_cause,
+  cutoff_of
+} from "./chunk-SK3GDQOI.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  epic_child_schema,
+  epic_issue_schema,
+  rest_comment_schema
+} from "./chunk-34DND4BA.js";
+import {
+  EPIC_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  parse_json_array_or_undefined,
+  parse_json_object_or_undefined,
+  read_json_listing
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/epic/epic-close-comment.ts
+var CLOSE_ANNOUNCEMENT = "Closing this epic automatically.";
+var MARKER_OPEN = "<!-- josh:epic-auto-close children=";
+var MARKER_CLOSE = " -->";
+function child_references(epic) {
+  return [
+    ...epic.children.map((child) => issue_cite.plain_for("github", child)),
+    ...epic.external_children.map(
+      (child) => issue_cite.plain_for("github", child.number, child.repo)
+    )
+  ];
+}
+function build_marker(epic) {
+  return `${MARKER_OPEN}${child_references(epic).join(",")}${MARKER_CLOSE}`;
+}
+var INDENTED_CODE_SPACES = 4;
+function indent_of(line) {
+  return line.length - line.trimStart().length;
+}
+function marker_children(line) {
+  if (indent_of(line) >= INDENTED_CODE_SPACES) return void 0;
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(MARKER_OPEN) || !trimmed.endsWith(MARKER_CLOSE)) return void 0;
+  const listed = trimmed.slice(MARKER_OPEN.length, -MARKER_CLOSE.length);
+  return listed.split(",").filter((reference) => reference.length > 0);
+}
+function is_same_children(left, right) {
+  const left_set = new Set(left);
+  const right_set = new Set(right);
+  return left_set.size === right_set.size && [...left_set].every((one) => right_set.has(one));
+}
+function build_close_comment(epic) {
+  return `All child issues are closed (${child_references(epic).join(", ")}). ${CLOSE_ANNOUNCEMENT}
+
+${build_marker(epic)}`;
+}
+var LEGACY_ANNOUNCEMENT_PATTERN = /^All child issues are closed \([^)]*\)\. Closing this epic automatically\.$/u;
+function is_legacy_announcement(body) {
+  return LEGACY_ANNOUNCEMENT_PATTERN.test(body.trim());
+}
+function has_marker(body, children) {
+  const mask = epic_parse.fence_mask(body);
+  return body.split("\n").some((line, index) => {
+    if (mask[index] !== true) return false;
+    const announced = marker_children(line);
+    return announced !== void 0 && is_same_children(announced, children);
+  });
+}
+function has_announcement(comments, children) {
+  return comments.some((comment) => {
+    const body = comment.body ?? "";
+    return has_marker(body, children) || is_legacy_announcement(body);
+  });
+}
+async function read_close_comment_state(epic_number, epic) {
+  const raw_json = await git_gh_command.issue_list_comments(epic_number);
+  if (raw_json === void 0) return "unreadable";
+  const listing = read_json_listing(raw_json, rest_comment_schema);
+  if (listing.kind !== "read") return "unreadable";
+  return has_announcement(listing.rows, child_references(epic)) ? "present" : "absent";
+}
+var epic_close_comment = {
+  build_close_comment,
+  read_close_comment_state
+};
+
+// scripts/epic/epic-close.ts
+var EPIC_LIST_LIMIT = 100;
+function truncated_epic_list_note(cutoff) {
+  const cause = cutoff_cause(cutoff, `hit its ${String(EPIC_LIST_LIMIT)}-epic cap`);
+  if (cause === void 0) return void 0;
+  return `\u26A0\uFE0F  The open epic listing ${cause}; an epic past it was not checked for completion.`;
+}
+var REOPENED = "reopened";
+function to_epic_issue(raw) {
+  return {
+    is_reopened: raw.stateReason === REOPENED,
+    number: raw.number,
+    children: epic_parse.parse_task_list_issue_numbers(raw.body),
+    external_children: epic_parse.parse_external_task_list_children(raw.body),
+    has_declared_order: epic_parse.has_declared_dependency_chain(raw.body)
+  };
+}
+async function fetch_open_epics() {
+  const { json, is_capped } = await git_gh_command.issue_list_by_label(EPIC_LABEL, EPIC_LIST_LIMIT);
+  if (json === void 0) return void 0;
+  const rows = parse_json_array_or_undefined(json, epic_issue_schema);
+  if (rows === void 0) return void 0;
+  const note = truncated_epic_list_note(cutoff_of(rows.length, EPIC_LIST_LIMIT, is_capped));
+  if (note !== void 0) console.info(note);
+  return rows.map((raw) => to_epic_issue(raw));
+}
+function parse_child(raw_json) {
+  if (raw_json === void 0) return void 0;
+  return parse_json_object_or_undefined(raw_json, epic_child_schema);
+}
+function has_blocked_by(child) {
+  const blocked_by = child?.blockedBy;
+  return (blocked_by?.totalCount ?? 0) > 0;
+}
+function to_sibling_state(raw_json) {
+  const child = parse_child(raw_json);
+  return {
+    is_closed: epic_parse.is_state_closed(child?.state),
+    has_blocked_by: has_blocked_by(child)
+  };
+}
+function state_reader(repo) {
+  return {
+    repo,
+    from_json: (json) => json,
+    read_rest: async (issue_number) => await git_gh_command.issue_get_state_and_relations(String(issue_number), repo)
+  };
+}
+function to_child_read(raw) {
+  return { ...to_sibling_state(raw), is_readable: parse_child(raw)?.state !== void 0 };
+}
+async function inspect_children(epic, merged_number) {
+  const siblings = epic.children.filter((child) => child !== merged_number).map((number) => ({ number }));
+  const reads = await git_gh_issue_batch_read.read_across(
+    [...siblings, ...epic.external_children],
+    state_reader
+  );
+  return reads.map((raw) => to_child_read(raw));
+}
+function warn_when_order_unrecorded(epic, states) {
+  if (states.length === 0 || !epic.has_declared_order || states.some((state) => state.has_blocked_by)) {
+    return;
+  }
+  console.info(
+    `\u2139\uFE0F  Epic ${session_cite.issue(epic.number)} has no blocked-by relation on any child; the batch order was never recorded natively (see the epic creation procedure).`
+  );
+}
+var CLOSE_MANUALLY = "close it manually.";
+var MAX_CASCADE_DEPTH = 10;
+var CASCADE_DEPTH_NOTE = `\u26A0\uFE0F  Epic auto-close cascade reached its ${String(
+  MAX_CASCADE_DEPTH
+)}-level cap; ${CLOSE_MANUALLY}`;
+var UNREADABLE_COMMENTS_NOTE = "'s comments could not be read; announcing again rather than leaving it open.";
+async function close_epic_with(epic_number, comment) {
+  const is_closed = await git_gh_command.issue_close(epic_number, comment);
+  console.info(
+    is_closed ? `\u{1F3C1} Closed epic ${session_cite.issue(epic_number)} \u2014 every child issue is complete.` : `\u26A0\uFE0F  Could not close epic ${session_cite.issue(epic_number)}; ${CLOSE_MANUALLY}`
+  );
+  return is_closed;
+}
+async function close_epic(epic) {
+  const epic_number = String(epic.number);
+  const state = await epic_close_comment.read_close_comment_state(epic_number, epic);
+  const note = `\u2139\uFE0F  Epic ${session_cite.issue(epic_number)}${UNREADABLE_COMMENTS_NOTE}`;
+  if (state === "unreadable") console.info(note);
+  const comment = state === "present" ? void 0 : epic_close_comment.build_close_comment(epic);
+  return await close_epic_with(epic_number, comment);
+}
+function warn_when_unread_blocks_close(epic, states) {
+  if (states.some((state) => state.is_readable && !state.is_closed)) return;
+  console.info(
+    `\u26A0\uFE0F  Epic ${session_cite.issue(epic.number)} has a child whose state could not be read; ${CLOSE_MANUALLY}`
+  );
+}
+async function close_epic_when_complete(epic, merged_number) {
+  const states = await inspect_children(epic, merged_number);
+  if (states.some((state) => !state.is_readable)) {
+    warn_when_unread_blocks_close(epic, states);
+    return false;
+  }
+  warn_when_order_unrecorded(epic, states);
+  if (states.some((state) => !state.is_closed)) return false;
+  return await close_epic(epic);
+}
+async function close_epic_isolated(epic, merged_number) {
+  try {
+    return await close_epic_when_complete(epic, merged_number);
+  } catch (error) {
+    const message = error_text.message_of(error);
+    console.info(`\u26A0\uFE0F  Skipped epic ${session_cite.issue(epic.number)}: ${message}`);
+    return false;
+  }
+}
+function parents_of(open_epics, child_number) {
+  return open_epics.filter((epic) => epic_parse.has_child(epic.children, child_number));
+}
+async function close_if_unseen(epic, child_number, evaluated) {
+  if (evaluated.has(epic.number)) return void 0;
+  evaluated.add(epic.number);
+  return await close_epic_isolated(epic, child_number) ? epic.number : void 0;
+}
+async function close_parents_of(open_epics, child_number, evaluated) {
+  const closed = [];
+  for (const epic of parents_of(open_epics, child_number)) {
+    const number = await close_if_unseen(epic, child_number, evaluated);
+    if (number !== void 0) closed.push(number);
+  }
+  return closed;
+}
+async function close_next_level(open_epics, frontier, evaluated) {
+  const next = [];
+  for (const child_number of frontier) {
+    next.push(...await close_parents_of(open_epics, child_number, evaluated));
+  }
+  return next;
+}
+async function cascade_from(open_epics, start, evaluated) {
+  let frontier = start;
+  for (let depth = 0; depth < MAX_CASCADE_DEPTH; depth++) {
+    if (frontier.length === 0) return true;
+    frontier = await close_next_level(open_epics, frontier, evaluated);
+  }
+  if (frontier.length > 0) console.info(CASCADE_DEPTH_NOTE);
+  return frontier.length === 0;
+}
+function tracks_children(epic) {
+  return epic.children.length + epic.external_children.length > 0;
+}
+function is_sweep_target(epic, evaluated) {
+  return !evaluated.has(epic.number) && !epic.is_reopened && tracks_children(epic);
+}
+async function sweep_unreached(open_epics, merged_number, evaluated) {
+  const closed = [];
+  const unreached = open_epics.filter((epic) => is_sweep_target(epic, evaluated));
+  for (const epic of unreached) {
+    if (await close_epic_isolated(epic, merged_number)) closed.push(epic.number);
+  }
+  for (const number of closed) evaluated.add(number);
+  return closed;
+}
+async function cascade_close(open_epics, merged_number) {
+  const evaluated = /* @__PURE__ */ new Set();
+  if (!await cascade_from(open_epics, [merged_number], evaluated)) return;
+  const swept = await sweep_unreached(open_epics, merged_number, evaluated);
+  await cascade_from(open_epics, swept, evaluated);
+}
+var UNREADABLE_EPIC_LIST_MESSAGE = "\u26A0\uFE0F  Could not read the open epic listing; skipped the epic auto-close check.";
+async function resolve_and_close(merged_number) {
+  const open_epics = await fetch_open_epics();
+  if (open_epics === void 0) {
+    console.info(UNREADABLE_EPIC_LIST_MESSAGE);
+    return;
+  }
+  await cascade_close(open_epics, merged_number);
+}
+async function resolve_and_close_safely(merged_number) {
+  try {
+    await resolve_and_close(merged_number);
+  } catch (error) {
+    const message = error_text.message_of(error);
+    console.info(`\u26A0\uFE0F  Skipped the epic auto-close check: ${message}`);
+  }
+}
+async function close_completed_epics(input) {
+  if (!input.is_merged) return;
+  const merged_number = Number(input.issue_number);
+  if (!Number.isSafeInteger(merged_number)) return;
+  await resolve_and_close_safely(merged_number);
+}
+var epic_close = {
+  close_completed_epics
+};
+
+export {
+  epic_close
+};

package/dist/commands/chunk-VXWGPQJX.js

@@ -0,0 +1,140 @@
+import {
+  lane_breakdown_laps
+} from "./chunk-E5CGA7FC.js";
+import {
+  lane_breakdown
+} from "./chunk-2MDLCJZ4.js";
+import {
+  lane_net_time
+} from "./chunk-LAUKNN57.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  MAX_SCANNED,
+  git_gh_issue_list
+} from "./chunk-ZB25RO3U.js";
+import {
+  run_ship_lap
+} from "./chunk-3W2TJZMD.js";
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-sinks-issues.ts
+import { z } from "zod";
+var NONE = "none";
+var UNREAD = "unread";
+var SEPARATOR = ", ";
+var open_issues_schema = z.array(z.object({ number: z.number(), title: z.string() }));
+async function read() {
+  const outcome = await git_gh_issue_list.issue_list({
+    json_fields: "number,title",
+    limit: MAX_SCANNED
+  });
+  return outcome.json === void 0 ? void 0 : json_value.parse_with(outcome.json, open_issues_schema);
+}
+function cell(stage, issues, also = []) {
+  if (issues === void 0) return UNREAD;
+  const needles = [stage, ...also].map((name) => name.toLowerCase());
+  const named = issues.filter(
+    (issue) => needles.some((needle) => issue.title.toLowerCase().includes(needle))
+  );
+  return named.length === 0 ? NONE : named.map((issue) => issue_cite.plain_for("linked", issue.number)).join(SEPARATOR);
+}
+var lane_sinks_issues = { NONE, UNREAD, read, cell };
+
+// scripts/lane/lane-sinks.ts
+import path from "node:path";
+var DEFAULT_MINUTES = 30;
+var NOTE_LEAD = " (";
+var COLUMNS = ["stage", "total min", "lanes", "median min", "open issues"];
+var { SCOPED_PAIR } = run_ship_lap.STEP;
+function over_issues(records, window, minutes) {
+  const merged = lane_stats.in_window(records.entries, window).filter((entry) => lane_stage_stats.is_merge(entry)).map((merge) => merge.issue);
+  return [...new Set(merged)].filter(
+    (issue) => (lane_net_time.net_ms(records.entries, records.events, issue) ?? 0) > minutes * MS_PER_MINUTE
+  );
+}
+function base_name(name) {
+  const note_at = name.indexOf(NOTE_LEAD);
+  return note_at === -1 ? name : name.slice(0, note_at);
+}
+function lane_parts(records, issue) {
+  const breakdown = lane_breakdown.of(records.entries, records.events, issue);
+  if (breakdown === void 0) return [];
+  const laps = lane_breakdown_laps.of(records.entries, issue, breakdown, []);
+  const parts = [
+    ...breakdown.stages,
+    ...breakdown.stages.flatMap((stage) => laps.get(stage.name) ?? [])
+  ];
+  return lane_breakdown.ranked(parts.map((part) => ({ name: base_name(part.name), ms: part.ms })));
+}
+function total_ms(sink) {
+  return sink.per_lane_ms.reduce((sum, ms) => sum + ms, 0);
+}
+function sinks_of(records, issues) {
+  const sinks = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    for (const { name, ms } of lane_parts(records, issue)) {
+      sinks.set(name, [...sinks.get(name) ?? [], ms]);
+    }
+  }
+  return [...sinks].map(([name, per_lane_ms]) => ({ name, per_lane_ms })).toSorted((left, right) => total_ms(right) - total_ms(left));
+}
+function is_test_related(entry) {
+  return entry.kind === lane_ledger.KIND.TEST_RELATED;
+}
+function hubs_of(entries, issues) {
+  const named = entries.filter((entry) => is_test_related(entry)).filter((entry) => entry.issue !== void 0 && issues.includes(entry.issue)).map((entry) => entry.over_cap_hub).filter((hub) => hub !== void 0);
+  return [...new Set(named)];
+}
+function issues_cell(name, issues, hubs) {
+  const also = name === SCOPED_PAIR ? hubs.map((hub) => path.basename(hub)) : [];
+  return lane_sinks_issues.cell(name, issues, also);
+}
+function sink_row(sink, issues, hubs) {
+  return lane_stats.to_row([
+    sink.name,
+    lane_stage_stats.cell(total_ms(sink)),
+    String(sink.per_lane_ms.length),
+    lane_stage_stats.cell(lane_stats.median(sink.per_lane_ms)),
+    issues_cell(sink.name, issues, hubs)
+  ]);
+}
+function table(records, window, minutes, issues) {
+  const lanes = over_issues(records, window, minutes);
+  const hubs = hubs_of(records.entries, lanes);
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...sinks_of(records, lanes).map((sink) => sink_row(sink, issues, hubs))
+  ].join("\n");
+}
+var lane_sinks = {
+  DEFAULT_MINUTES,
+  base_name,
+  hubs_of,
+  issues_cell,
+  over_issues,
+  sinks_of,
+  table,
+  total_ms
+};
+
+export {
+  lane_sinks_issues,
+  lane_sinks
+};

package/dist/commands/chunk-W4R6ZBLO.js

@@ -0,0 +1,197 @@
+import {
+  shared_cache
+} from "./chunk-RW7OILP7.js";
+import {
+  gh_failure,
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-transport.ts
+import { z } from "zod";
+
+// scripts/gh/git-gh-rate-limit.ts
+var FORBIDDEN_STATUS = 403;
+var TOO_MANY_REQUESTS_STATUS = 429;
+var RATE_LIMIT_STATUSES = /* @__PURE__ */ new Set([
+  FORBIDDEN_STATUS,
+  TOO_MANY_REQUESTS_STATUS
+]);
+var MILLISECONDS_PER_SECOND = 1e3;
+var RATE_LIMIT_MESSAGE = /rate limit (?:already )?exceeded|exceeded a secondary rate limit/iu;
+var EXHAUSTED_HEADER = /^x-ratelimit-remaining:\s*0\s*$/imu;
+var RESET_HEADER = /^x-ratelimit-reset:\s*(?<epoch>\d+)\s*$/imu;
+var STATUS_PATTERNS = [
+  /\(HTTP (?<status>\d{3})\)/u,
+  /^HTTP\/\S+ (?<status>\d{3})/mu,
+  /"status":\s*"?(?<status>\d{3})/u
+];
+var AUTH_HINT = "check `gh auth status` and the network";
+function status_of(text) {
+  const status = STATUS_PATTERNS.map((pattern) => pattern.exec(text)?.groups?.["status"]).find(
+    (found) => found !== void 0
+  );
+  return status === void 0 ? void 0 : Number(status);
+}
+function is_exhausted(text) {
+  if (RATE_LIMIT_MESSAGE.test(text)) return true;
+  const status = status_of(text);
+  return status !== void 0 && RATE_LIMIT_STATUSES.has(status) && EXHAUSTED_HEADER.test(text);
+}
+function epoch_to_date(epoch) {
+  const seconds = Number(epoch);
+  if (epoch === void 0 || !Number.isSafeInteger(seconds) || seconds <= 0) return void 0;
+  return new Date(seconds * MILLISECONDS_PER_SECOND);
+}
+async function read_reset() {
+  try {
+    const epoch = await git_gh_exec.exec_gh_api({
+      path: "rate_limit",
+      jq_filter: ".resources.core.reset",
+      should_retry: false
+    });
+    return epoch_to_date(epoch.trim());
+  } catch (error) {
+    error_text.trace_swallowed("gh_rate_limit.read_reset", error);
+    return void 0;
+  }
+}
+function exhausted_message(resets_at) {
+  const when = resets_at === void 0 ? "at an unread time" : `at ${resets_at.toISOString()}`;
+  return `GitHub rate limit exhausted, resets ${when} \u2014 wait for the reset; this is not an authentication failure, so do not refresh gh auth`;
+}
+async function failure_hint(text) {
+  if (!is_exhausted(text)) return AUTH_HINT;
+  const resets_at = epoch_to_date(RESET_HEADER.exec(text)?.groups?.["epoch"]) ?? await read_reset();
+  return exhausted_message(resets_at);
+}
+var gh_rate_limit = { AUTH_HINT, exhausted_message, failure_hint, is_exhausted };
+
+// scripts/gh/git-gh-transport.ts
+var TRANSPORT_ENV_VAR = "JOSH_GH_TRANSPORT";
+var GRAPHQL_PATH = "graphql";
+var FORBIDDEN_STATUS2 = 403;
+var MS_KEPT = 36e5;
+var DEFAULT_HOST = "github.com";
+var PROBE_QUERY = "query { viewer { login } }";
+var NOT_PROBED = "not probed";
+var TRANSPORT_CACHE = { prefix: "josh-gh-transport-", ttl_ms: MS_KEPT };
+var REFUSED_MESSAGE = `GitHub refused a GraphQL read, and ${TRANSPORT_ENV_VAR}=graphql forbids reading it through REST \u2014 set it to auto or rest to read where GraphQL is refused`;
+var partial_document_schema = z.looseObject({
+  data: z.looseObject({}),
+  errors: z.array(z.unknown()).nonempty()
+});
+var transport_schema = z.enum(["graphql", "rest"]);
+var setting_schema = z.enum(["auto", "graphql", "rest"]);
+var logins = /* @__PURE__ */ new Map();
+function parse_setting(raw) {
+  if (raw === void 0 || raw === "") return "auto";
+  return setting_schema.safeParse(raw).data;
+}
+function setting() {
+  const raw = process.env[TRANSPORT_ENV_VAR];
+  const parsed = parse_setting(raw);
+  if (parsed === void 0) {
+    throw new Error(`${TRANSPORT_ENV_VAR} must be auto, graphql or rest, not ${String(raw)}`);
+  }
+  return parsed;
+}
+async function read_login(host) {
+  try {
+    return await git_gh_exec.exec_gh_command(["config", "get", "user", "--host", host]);
+  } catch {
+    return "";
+  }
+}
+async function key_of() {
+  const host = process.env["GH_HOST"] ?? DEFAULT_HOST;
+  const login = logins.get(host) ?? read_login(host);
+  logins.set(host, login);
+  return `${host}/${await login}`;
+}
+function is_refused(error) {
+  if (gh_failure.failure_of(error)?.status !== FORBIDDEN_STATUS2) return false;
+  return !gh_rate_limit.is_exhausted(error_text.message_of(error));
+}
+async function send(body) {
+  return await git_gh_exec.exec_gh_api({ path: GRAPHQL_PATH, body: JSON.stringify(body) });
+}
+async function probe() {
+  try {
+    await send({ query: PROBE_QUERY });
+    return "graphql";
+  } catch (error) {
+    return is_refused(error) ? "rest" : void 0;
+  }
+}
+async function current(now_ms = Date.now()) {
+  const chosen = setting();
+  if (chosen !== "auto") return chosen;
+  const request = { slot: TRANSPORT_CACHE, key: await key_of(), schema: transport_schema };
+  return await shared_cache.remember(request, probe, now_ms) ?? "graphql";
+}
+async function on_failure(error, now_ms) {
+  if (!is_refused(error)) return;
+  if (setting() === "graphql") throw new Error(REFUSED_MESSAGE, { cause: error });
+  shared_cache.write(TRANSPORT_CACHE, await key_of(), "rest", now_ms);
+}
+function partial_answer(error) {
+  const body = gh_failure.body_of(error);
+  if (body === void 0) return void 0;
+  return json_value.parse_with(body, partial_document_schema) === void 0 ? void 0 : body;
+}
+async function sent_or_failed(body, now_ms, recovered) {
+  try {
+    return await send(body);
+  } catch (error) {
+    await on_failure(error, now_ms);
+    return recovered?.(error);
+  }
+}
+async function answer_of(body, now_ms, recovered) {
+  if (await current(now_ms) === "rest") return void 0;
+  return await sent_or_failed(body, now_ms, recovered);
+}
+async function query(body, now_ms = Date.now()) {
+  return await answer_of(body, now_ms);
+}
+async function query_partial(body, now_ms = Date.now()) {
+  return await answer_of(body, now_ms, partial_answer);
+}
+async function kept(now_ms) {
+  return shared_cache.read(TRANSPORT_CACHE, await key_of(), transport_schema, now_ms);
+}
+async function known(now_ms = Date.now()) {
+  const chosen = parse_setting(process.env[TRANSPORT_ENV_VAR]);
+  if (chosen === void 0) return void 0;
+  return chosen === "auto" ? await kept(now_ms) : chosen;
+}
+async function label(now_ms = Date.now()) {
+  const chosen = parse_setting(process.env[TRANSPORT_ENV_VAR]);
+  if (chosen === void 0) return `invalid ${TRANSPORT_ENV_VAR}`;
+  if (chosen !== "auto") return chosen;
+  return `${await kept(now_ms) ?? NOT_PROBED} (auto)`;
+}
+function forget_logins() {
+  logins.clear();
+}
+var git_gh_transport = {
+  current,
+  forget_logins,
+  known,
+  label,
+  query,
+  query_partial,
+  TRANSPORT_CACHE
+};
+
+export {
+  gh_rate_limit,
+  GRAPHQL_PATH,
+  git_gh_transport
+};

package/dist/commands/chunk-WE2UMZXX.js

@@ -0,0 +1,47 @@
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/issue/issue-body-or-comment.ts
+import { z } from "zod";
+var BODY_FIELDS = `body,${gh_author_association.AUTHOR_FIELDS}`;
+var body_schema = z.looseObject({
+  body: z.string().nullish(),
+  ...gh_author_association.author_fields_schema
+});
+function is_blank_body(body) {
+  return body?.trim().length === 0;
+}
+async function is_author_trusted(row, repo) {
+  const author = gh_author_association.author_of(row);
+  return await gh_author_association.is_trusted(
+    repo === void 0 ? author : { ...author, login: void 0 }
+  );
+}
+async function is_writable_body(issue_number, repo) {
+  const json = await git_gh_command.issue_view_json(issue_number, BODY_FIELDS, repo);
+  const parsed = json === void 0 ? void 0 : parse_json_object_or_undefined(json, body_schema);
+  if (parsed === void 0 || !is_blank_body(parsed.body ?? "")) return false;
+  return await is_author_trusted(parsed, repo);
+}
+async function post(issue_number, text, repo) {
+  if (await is_writable_body(issue_number, repo)) {
+    const url = await git_gh_command.issue_edit_body(issue_number, text, repo);
+    return { destination: "body", url };
+  }
+  return {
+    destination: "comment",
+    url: await git_gh_command.issue_comment(issue_number, text, repo)
+  };
+}
+var issue_body_or_comment = { is_author_trusted, post };
+
+export {
+  issue_body_or_comment
+};