@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-T6OUNP7E.js

@@ -0,0 +1,426 @@
+import {
+  review_round_reuse,
+  run_ship_probe
+} from "./chunk-374XGAWD.js";
+import {
+  review_reviewed_tree
+} from "./chunk-ZGBXUY7R.js";
+import {
+  review_record
+} from "./chunk-TROCFVCU.js";
+import {
+  review_comment_carry
+} from "./chunk-TRHWBUWE.js";
+import {
+  review_comment_round
+} from "./chunk-2OEXY4GM.js";
+import {
+  review_record_pinned
+} from "./chunk-Z6QLFPFB.js";
+import {
+  review_finding_text,
+  review_fix_round,
+  review_round
+} from "./chunk-GVDRRBHZ.js";
+import {
+  review_interaction
+} from "./chunk-IOKOHB7P.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  review_attest,
+  review_checkout
+} from "./chunk-URZ4RDC4.js";
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  review_stamps
+} from "./chunk-XSKJAG72.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  run_ship_detach
+} from "./chunk-FJM2HWKW.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-lane-handover.ts
+var SHIP_STEP = 'pnpm josh ship --detach --review "<title> #<N>"';
+var NEXT_STEP_LINE = `Next: hand over to \`${SHIP_STEP}\` \u2014 round 2 is the ship's; never reopen \`run:review\` (chain-rule.md step 0).`;
+var SHIP_REVIEWS_LINE = `Files moved since \u2014 a widened \`lane:plan\`'s included \u2014 are the ship's: hand over to \`${SHIP_STEP}\`, whose round 2 reads them, or whose own round 1 reviews again where it does not reuse this one; never reopen \`run:review\` (chain-rule.md step 0).`;
+var UNANSWERED_CAUSE = "git could not answer the reuse question";
+async function answer_here(issue) {
+  try {
+    return await review_round_reuse.answer_here(issue);
+  } catch (error) {
+    error_text.trace_swallowed("review_lane_handover.answer_here", error);
+    return { reuse: review_round_reuse.REUSE.AGAIN, cause: UNANSWERED_CAUSE };
+  }
+}
+async function is_reused_here(issue) {
+  const answer = await answer_here(issue);
+  return answer.reuse !== review_round_reuse.REUSE.AGAIN;
+}
+function is_lane_child_of(issue) {
+  if (lane_child_marker.marked_issue() !== String(issue)) return false;
+  return lane_child_marker.is_child_of(PROJECT_ROOT);
+}
+async function is_handed_over(issue) {
+  if (!is_lane_child_of(issue)) return false;
+  return await is_reused_here(issue);
+}
+async function is_round_attested(issue) {
+  const verdict = await review_record.check(issue);
+  if (verdict.status !== "ok") return false;
+  const checkout = await review_checkout.read_checkout();
+  return review_attest.is_attested_on(checkout, checkout.root);
+}
+async function is_reopen_refused(issue) {
+  if (!is_lane_child_of(issue)) return false;
+  return await is_round_attested(issue);
+}
+function refusal(issue) {
+  return `\u26D4 run:review: round 1 of ${session_cite.issue(issue)} is recorded and attested, and this is a dispatched lane child (\`${lane_child_marker.KEY}\`), so no brief is minted. ${SHIP_REVIEWS_LINE}`;
+}
+var review_lane_handover = {
+  NEXT_STEP_LINE,
+  SHIP_REVIEWS_LINE,
+  answer_here,
+  is_handed_over,
+  is_reopen_refused,
+  refusal
+};
+
+// scripts/review/review-final-record.ts
+function stamp(issue, root = PROJECT_ROOT) {
+  return file_map_stamp.create(
+    `josh-ship-final-review-${issue}-`,
+    root,
+    () => review_attest.read_pointer(root)?.nonce ?? ""
+  );
+}
+function is_attested_final(root) {
+  const pointer = review_attest.read_pointer(root);
+  if (pointer === void 0 || review_round.current(root) !== "2") return false;
+  const expected = review_attest.read_expectation(pointer.nonce);
+  return expected !== void 0 && review_attest.is_attested_on(expected, root);
+}
+function record(issue, findings, root) {
+  const completion = stamp(String(issue), root);
+  const tree = review_stamps.briefed_stamp.read();
+  completion.remove();
+  if (tree === void 0 || !is_attested_final(root) || !review_attest.is_briefed_since(tree.taken_at, root) || findings.some((finding) => finding.severity !== "low")) {
+    return;
+  }
+  completion.write(tree.files, void 0, tree.base);
+  completion.complete();
+}
+var review_final_record = { record, stamp };
+
+// scripts/review/review-record-interaction.ts
+var NOT_REQUIRED_LINE = "No interaction review is due: the change touches no run tooling, changes only comments in it, or this checkout keeps no ledger.";
+var DUE_HEAD = "Interaction review now due";
+function due_line(issue) {
+  return `${DUE_HEAD}: this round\u2019s change touches the run tooling and no interaction pass is recorded. Before \`josh ship\`, record it with \`pnpm josh review:record --from-slot --interaction --issue ${String(issue)} [<n>=<disposition> ...]\` \u2014 if no interaction reviewer ran beside this round, first open its brief with \`pnpm josh review:brief --interaction\` and run that \`reviewer\` \u2014 so a finding is fixed in this lane rather than stopping the ship.`;
+}
+async function report_due(issue, root) {
+  try {
+    if (await review_interaction.status(issue, root) === "missing") console.info(due_line(issue));
+  } catch (error) {
+    error_text.trace_swallowed("review_record_interaction.report_due", error);
+  }
+}
+var review_record_interaction = {
+  due_line,
+  NOT_REQUIRED_LINE,
+  report_due
+};
+
+// scripts/review/review-record-code-round.ts
+var HIGH_SEVERITY = "high";
+function unsettled_files(findings) {
+  return findings.filter((finding) => finding.severity === HIGH_SEVERITY).map((finding) => finding.file);
+}
+async function report_handover(issue) {
+  const is_handed_over2 = await review_lane_handover.is_handed_over(issue);
+  if (is_handed_over2) console.info(review_lane_handover.NEXT_STEP_LINE);
+  return is_handed_over2;
+}
+function is_restarted_here(is_handed_over2) {
+  return is_handed_over2 && !run_ship_detach.is_supervised();
+}
+async function follow(issue, root, findings) {
+  await review_reviewed_tree.record(unsettled_files(findings));
+  const is_handed_over2 = await report_handover(issue);
+  await review_record_interaction.report_due(issue, root);
+  if (!is_restarted_here(is_handed_over2)) return;
+  await review_record_pinned.read_skipped_join(root);
+  await review_record_pinned.restart_if_moved(root);
+}
+var review_record_code_round = { follow };
+
+// scripts/review/review-record-comment.ts
+var FAILURE_EXIT_CODE = 1;
+var AFTER_PUSH_LINE = "The branch is pushed and the tree is clean, so this round is recorded on the issue, not in the ledger \u2014 a ledger line would need a push of its own and restart CI.";
+async function post(issue, lines) {
+  try {
+    const url = await git_gh_issue_write.issue_comment(
+      String(issue),
+      review_comment_round.body_of(lines)
+    );
+    console.info(`Recorded ${String(lines.length)} review-finding line(s) in ${url.trim()}.`);
+    return 0;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return FAILURE_EXIT_CODE;
+  }
+}
+async function is_after_push() {
+  return await run_ship_probe.is_pushed_clean();
+}
+async function post_after_push(round) {
+  console.info(AFTER_PUSH_LINE);
+  const code = await post(round.issue, round.lines);
+  if (code === 0) await review_record_code_round.follow(round.issue, round.root, round.findings);
+  return code;
+}
+var review_record_comment = { is_after_push, post, post_after_push };
+
+// scripts/review/review-record-cli.ts
+var FAILURE_EXIT_CODE2 = 1;
+var USAGE = "Usage: josh review:record --issue <N> [--comment | --interaction] [[<disposition> ]<category>:<severity>:<file>[ \u2014 <reason>] ...] | josh review:record --check [--interaction] --issue <N>";
+var FILE_HINT = "  <file>: the cited path, optionally with :line";
+var DISPOSITION_HINT = "  <disposition>: optional \u2014 fixed | false-positive | filed:#<M> | deferred:#<M>; josh review:round2 skips only when every High/Medium is fixed or false-positive";
+var REASON_HINT = "  <reason>: optional, one sentence on what was wrong, kept for the lane\u2019s next review and fix \u2014 pass each finding with its reason as one single-quoted argument";
+var CHECK_USAGE = "Usage: josh review:record --check [--interaction] --issue <N>";
+var RECORDED_LINE = "Recorded: the review round for this issue is in the ledger.";
+var REUSED_LINE = "Reused: josh ship takes this round as its round 1 \u2014 the files this round covers hold still since the record. A default branch the ship\u2019s sync merges in moves them only where it changed a file this round covers, and the ship then reviews round 1 again itself.";
+var DELTA_LINE = "Reused, delta to round 2: josh ship takes this round as its round 1 and does not review it again \u2014 every moved path a round executes is one round 2 reads after the commit, or the ship\u2019s own round 1 stopped on it.";
+function review_again_line(cause = "the reuse question gave no reason", is_refused = false) {
+  const next = is_refused ? review_lane_handover.SHIP_REVIEWS_LINE : "Run `pnpm josh run:review` and the round-1 `/code-review` here (chain-rule.md step 0).";
+  return `Not reused: josh ship reviews round 1 again \u2014 ${cause}. ${next}`;
+}
+function reuse_line(answer, is_refused) {
+  if (answer.reuse === "again") return review_again_line(answer.cause, is_refused);
+  const line = answer.reuse === "delta" ? DELTA_LINE : REUSED_LINE;
+  return answer.note === void 0 ? line : `${line} \u2014 ${answer.note}`;
+}
+var NOT_REQUIRED_LINE2 = "No review-finding ledger is kept in this checkout, so there is nothing to check.";
+var OPTIONS = {
+  issue: { type: "string" },
+  check: { type: "boolean" },
+  comment: { type: "boolean" },
+  interaction: { type: "boolean" }
+};
+function to_finding(category, severity, file) {
+  if (!review_finding_ledger.is_category(category) || !review_finding_ledger.is_severity(severity)) {
+    return void 0;
+  }
+  return review_finding_ledger.is_valid_file(file) ? { category, severity, file } : void 0;
+}
+function parse_finding(spec) {
+  const first = spec.indexOf(":");
+  const second = spec.indexOf(":", first + 1);
+  if (first === -1 || second === -1) return void 0;
+  return to_finding(spec.slice(0, first), spec.slice(first + 1, second), spec.slice(second + 1));
+}
+function parse_positional(positional) {
+  const { spec: marked, description } = review_finding_text.split_description(positional);
+  const { disposition, spec } = review_finding_ledger.split_disposition(marked);
+  const finding = parse_finding(spec);
+  if (finding === void 0) return void 0;
+  return { finding: disposition === void 0 ? finding : { ...finding, disposition }, description };
+}
+function parse_findings(positionals) {
+  const findings = [];
+  for (const positional of positionals) {
+    const parsed = parse_positional(positional);
+    if (parsed === void 0) return void 0;
+    findings.push({ ...parsed.finding, description: parsed.description });
+  }
+  return findings;
+}
+function parse_argv(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  return {
+    check: parsed.values.check === true,
+    comment: parsed.values.comment === true,
+    interaction: parsed.values.interaction === true,
+    issue: parsed.values.issue,
+    positionals: parsed.positionals
+  };
+}
+function to_request(parsed) {
+  const { issue } = parsed;
+  if (issue === void 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
+  const findings = parse_findings(parsed.positionals);
+  return findings === void 0 ? void 0 : { issue: Number(issue), findings };
+}
+function accepted_values(placeholder, values) {
+  return `  ${placeholder}: ${values.join(" | ")}`;
+}
+function usage_text() {
+  return [
+    USAGE,
+    accepted_values("<category>", review_finding_ledger.CATEGORIES),
+    accepted_values("<severity>", review_finding_ledger.SEVERITIES),
+    FILE_HINT,
+    DISPOSITION_HINT,
+    REASON_HINT
+  ].join("\n");
+}
+function build_lines(request, date, kind = "code") {
+  if (request.findings.length === 0) {
+    return [review_finding_ledger.zero_round_line(date, request.issue, kind)];
+  }
+  return request.findings.map(
+    (finding) => review_finding_ledger.finding_line(finding, date, request.issue, kind)
+  );
+}
+function confirmation(count, ledger_path) {
+  return `Recorded ${String(count)} review-finding line(s) in ${ledger_path}.`;
+}
+async function code_recorded(issue) {
+  const answer = await review_lane_handover.answer_here(issue);
+  const is_refused = await review_lane_handover.is_reopen_refused(issue);
+  return [RECORDED_LINE, reuse_line(answer, is_refused)].join("\n");
+}
+async function interaction_recorded() {
+  return RECORDED_LINE;
+}
+async function code_status(issue, root) {
+  const verdict = await review_record.check(issue, root);
+  return verdict.status;
+}
+var CHECK_MODES = {
+  code: {
+    status: code_status,
+    recorded: code_recorded,
+    refusal: review_record.refusal_message,
+    not_required: NOT_REQUIRED_LINE2
+  },
+  interaction: {
+    status: review_interaction.status,
+    recorded: interaction_recorded,
+    refusal: review_interaction.refusal_message,
+    not_required: review_record_interaction.NOT_REQUIRED_LINE
+  }
+};
+function kind_of(parsed) {
+  return parsed.interaction ? "interaction" : "code";
+}
+async function report_check(issue, mode, root) {
+  const status = await mode.status(issue, root);
+  if (status === "missing") {
+    console.error(mode.refusal(issue));
+    return FAILURE_EXIT_CODE2;
+  }
+  console.info(status === "ok" ? await mode.recorded(issue) : mode.not_required);
+  return 0;
+}
+async function run_check(parsed, root) {
+  const { issue } = parsed;
+  if (issue === void 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) {
+    console.error(CHECK_USAGE);
+    return FAILURE_EXIT_CODE2;
+  }
+  return await report_check(Number(issue), CHECK_MODES[kind_of(parsed)], root);
+}
+function ledger_lines({ issue, lines, kind, date }) {
+  if (kind === "interaction") return lines;
+  return [review_finding_ledger.round_line(date, issue), ...lines];
+}
+async function append_round(round) {
+  const { issue, lines, root } = round;
+  const ledger_path = observation_ledger_home.issue_path(issue, root);
+  await observation_ledger_home.append(ledger_path, ledger_lines(round));
+  console.info(confirmation(lines.length, ledger_path));
+  await review_comment_carry.carry_from_record(root);
+  return 0;
+}
+async function write_round(parsed, request, now, root) {
+  const kind = kind_of(parsed);
+  const date = observation_ledger_home.ledger_date(now);
+  const lines = [
+    ...build_lines(request, date, kind),
+    ...review_fix_round.lines(request.round, root)
+  ];
+  const { issue, findings } = request;
+  if (parsed.comment) {
+    return { code: await review_record_comment.post(issue, lines), is_ledger: false };
+  }
+  if (kind === "code" && await review_record_comment.is_after_push()) {
+    const code = await review_record_comment.post_after_push({ issue, lines, root, findings });
+    return { code, is_ledger: false };
+  }
+  return { code: await append_round({ issue, lines, root, kind, date }), is_ledger: true };
+}
+function finish_record(request, is_interaction, root) {
+  if (!is_interaction) review_final_record.record(request.issue, request.findings, root);
+  review_fix_round.record_reasons(request.issue, request.findings);
+  if (request.round !== void 0) review_fix_round.save(request.round, root);
+}
+async function record_prepared(parsed, request, now, root) {
+  request.round = parsed.interaction ? void 0 : review_fix_round.prepare(request.issue, request.findings, root);
+  const { code, is_ledger } = await write_round(parsed, request, now, root);
+  if (code !== 0) return code;
+  finish_record(request, parsed.interaction, root);
+  if (is_ledger && !parsed.interaction) {
+    await review_record_code_round.follow(request.issue, root, request.findings);
+  }
+  return 0;
+}
+async function run_record(parsed, now, root) {
+  const request = parsed.comment && parsed.interaction ? void 0 : to_request(parsed);
+  if (request === void 0) {
+    console.error(usage_text());
+    return FAILURE_EXIT_CODE2;
+  }
+  return await record_prepared(parsed, request, now, root);
+}
+async function run(argv, now, root = observation_ledger_home.ledger_root()) {
+  const parsed = parse_argv(argv);
+  if (parsed === void 0) {
+    console.error(usage_text());
+    return FAILURE_EXIT_CODE2;
+  }
+  if (parsed.check) return await run_check(parsed, root);
+  return await run_record(parsed, now, root);
+}
+var review_record_cli = {
+  accepted_values,
+  build_lines,
+  parse_finding,
+  parse_positional,
+  run,
+  usage_text
+};
+
+export {
+  review_final_record,
+  review_lane_handover,
+  review_record_cli
+};

package/dist/commands/chunk-TEXUEBGE.js

@@ -0,0 +1,208 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-LS7P324N.js";
+import {
+  BLOCKED_BY_COUNT_FIELD,
+  BLOCKED_BY_FIELD,
+  ISSUE_FIELDS,
+  PAGE,
+  git_gh_issue_graphql,
+  git_gh_issue_rest,
+  issue_fields_schema,
+  read_blocked_by
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_gh_transport
+} from "./chunk-LX2ENXHZ.js";
+import {
+  git_gh_etag_read
+} from "./chunk-IPS7EBE5.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  GH_SPAWN_CONCURRENCY
+} from "./chunk-43DU7DYZ.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-list-graphql.ts
+import { z } from "zod";
+var LISTING_QUERY = `query($owner: String!, $name: String!, $labels: [String!]) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) {
+		issues(${PAGE}, labels: $labels, states: OPEN, orderBy: { field: CREATED_AT, direction: DESC }) {
+			pageInfo { hasNextPage }
+			nodes { ${ISSUE_FIELDS} }
+		}
+	}
+}`;
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+var page_info_schema = z.object({ hasNextPage: z.boolean() });
+var issues_schema = z.object({
+  pageInfo: page_info_schema,
+  nodes: z.array(issue_fields_schema)
+});
+var response_schema = z.looseObject({
+  data: z.looseObject({
+    rateLimit: rate_limit_schema,
+    repository: z.looseObject({ issues: issues_schema })
+  })
+});
+function labels_of(label) {
+  return label === void 0 ? void 0 : [label];
+}
+function to_page(data) {
+  const { issues } = data.repository;
+  return {
+    issues: issues.nodes.map((issue) => ({
+      rest: git_gh_issue_graphql.to_rest_issue(issue),
+      blocked_by: git_gh_issue_graphql.to_blocked_by(issue)
+    })),
+    has_next_page: issues.pageInfo.hasNextPage,
+    cost: data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+async function read_open_page(label, repo) {
+  const repository = git_gh_issue_graphql.repository_variables_of(repo);
+  if (repository === void 0) return void 0;
+  const variables = { ...repository, labels: labels_of(label) };
+  const json = await git_gh_transport.query({ query: LISTING_QUERY, variables });
+  if (json === void 0) return void 0;
+  const data = json_value.parse_with(json, response_schema)?.data;
+  return data === void 0 ? void 0 : to_page(data);
+}
+var git_gh_issue_list_graphql = {
+  read_open_page
+};
+
+// scripts/gh/git-gh-issue-list.ts
+var PER_PAGE = 100;
+var FIRST_PAGE = 1;
+var DEFAULT_STATE = "open";
+var DEFAULT_SORT = "created";
+var LISTING_DIRECTION = "direction=desc";
+function listing_query(request) {
+  const state = request.state ?? DEFAULT_STATE;
+  const sort = request.sort ?? DEFAULT_SORT;
+  return `state=${state}&sort=${sort}&${LISTING_DIRECTION}`;
+}
+function listing_path(request, page) {
+  const label = request.label === void 0 ? "" : `&labels=${encodeURIComponent(request.label)}`;
+  const paging = `&per_page=${String(PER_PAGE)}&page=${String(page)}`;
+  return `${git_gh_api_path.issues_api_path(request.repo)}?${listing_query(request)}${label}${paging}`;
+}
+var DIGIT_PATTERN = /\d/u;
+function has_token_occurrence(body, term) {
+  let index = body.indexOf(term);
+  while (index !== -1) {
+    if (!DIGIT_PATTERN.test(body.charAt(index + term.length))) return true;
+    index = body.indexOf(term, index + 1);
+  }
+  return false;
+}
+function matches_body(rest, term) {
+  if (term === void 0) return true;
+  const { body } = rest;
+  return typeof body === "string" && has_token_occurrence(body, term);
+}
+function is_selected(rest, request) {
+  return !git_gh_issue_rest.is_pull_request(rest) && matches_body(rest, request.body_term);
+}
+async function fetch_page(request, page) {
+  const detail = await git_gh_etag_read.read_detail(listing_path(request, page));
+  const rows = git_gh_issue_rest.parse_rest_issues(detail.body);
+  return {
+    selected: rows.filter((row) => is_selected(row, request)),
+    is_full: rows.length >= PER_PAGE,
+    is_unchanged: detail.is_unchanged
+  };
+}
+var MAX_PAGES = 5;
+var MAX_SCANNED = MAX_PAGES * PER_PAGE;
+function wants_more(has_more, selected_count, limit) {
+  return has_more && selected_count < limit;
+}
+async function fetch_selected(request) {
+  const selected = [];
+  const unchanged = [];
+  let has_more = true;
+  while (unchanged.length < MAX_PAGES && wants_more(has_more, selected.length, request.limit)) {
+    const result = await fetch_page(request, FIRST_PAGE + unchanged.length);
+    selected.push(...result.selected);
+    has_more = result.is_full;
+    unchanged.push(result.is_unchanged);
+  }
+  return {
+    rows: selected.slice(0, request.limit),
+    is_capped: wants_more(has_more, selected.length, request.limit),
+    is_unchanged: unchanged.length > 0 && unchanged.every(Boolean)
+  };
+}
+async function read_relations(rows, repo) {
+  const answered = await git_gh_blocked_by_graphql.read_answered(rows);
+  return await bounded_pool.bounded_map(
+    rows,
+    GH_SPAWN_CONCURRENCY,
+    async (row) => answered.get(row) ?? await read_blocked_by(String(row.number), row, repo)
+  );
+}
+var GRAPHQL_FIELDS = /* @__PURE__ */ new Set([
+  "number",
+  "title",
+  "body",
+  "labels",
+  "createdAt",
+  "url",
+  "author_association",
+  "user",
+  BLOCKED_BY_FIELD,
+  BLOCKED_BY_COUNT_FIELD
+]);
+function is_open_newest_first(request) {
+  return (request.state ?? DEFAULT_STATE) === DEFAULT_STATE && (request.sort ?? DEFAULT_SORT) === DEFAULT_SORT;
+}
+function is_graphql_listing(request, fields) {
+  return is_open_newest_first(request) && fields.every((field) => GRAPHQL_FIELDS.has(field));
+}
+async function read_graphql(request, fields) {
+  if (!is_graphql_listing(request, fields)) return void 0;
+  const page = await git_gh_issue_list_graphql.read_open_page(request.label, request.repo);
+  if (page === void 0) return void 0;
+  const selected = page.issues.filter((issue) => is_selected(issue.rest, request));
+  if (wants_more(page.has_next_page, selected.length, request.limit)) return void 0;
+  const rows = selected.slice(0, request.limit).map((issue) => git_gh_issue_rest.to_gh_issue(issue.rest, fields, issue.blocked_by));
+  return { rows, is_capped: false, is_unchanged: false };
+}
+async function read_rest(request, fields) {
+  const { rows, is_capped, is_unchanged } = await fetch_selected(request);
+  const relations = fields.includes(BLOCKED_BY_FIELD) ? await read_relations(rows, request.repo) : void 0;
+  const mapped = rows.map(
+    (row, index) => git_gh_issue_rest.to_gh_issue(row, fields, relations?.[index])
+  );
+  return { rows: mapped, is_capped, is_unchanged };
+}
+async function issue_list(request) {
+  try {
+    const fields = git_gh_issue_rest.split_fields(request.json_fields);
+    const { rows, is_capped, is_unchanged } = await read_graphql(request, fields) ?? await read_rest(request, fields);
+    return { json: JSON.stringify(rows), is_capped, is_unchanged };
+  } catch {
+    return { json: void 0, is_capped: false };
+  }
+}
+var git_gh_issue_list = {
+  issue_list,
+  listing_path
+};
+
+export {
+  FIRST_PAGE,
+  MAX_SCANNED,
+  git_gh_issue_list
+};