@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-EWBEYTVS.js

@@ -0,0 +1,50 @@
+import {
+  get_exit_code,
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/git/git-grep-hits.ts
+var GREP_LINE = /^(?<path>[^:]+):(?<line>\d+):(?<text>.*)$/u;
+var MAX_EXCERPT_LENGTH = 80;
+var ELLIPSIS = "\u2026";
+var GREP_NO_MATCH_EXIT = 1;
+function shorten(text) {
+  const trimmed = text.trim();
+  if (trimmed.length <= MAX_EXCERPT_LENGTH) return trimmed;
+  return `${trimmed.slice(0, MAX_EXCERPT_LENGTH)}${ELLIPSIS}`;
+}
+function to_hit(output_line) {
+  const groups = GREP_LINE.exec(output_line)?.groups;
+  if (groups === void 0) return void 0;
+  const { path, line, text } = groups;
+  return { path, line, excerpt: shorten(text) };
+}
+function parse(stdout) {
+  const hits = stdout.split("\n").map((line) => to_hit(line));
+  return hits.filter((hit) => hit !== void 0);
+}
+async function search(target, flags, pathspecs, root) {
+  const location = root === void 0 ? [] : ["-C", root];
+  const grep_arguments = [
+    ...location,
+    "grep",
+    "-n",
+    "-I",
+    "-F",
+    ...flags,
+    "-e",
+    target,
+    "--",
+    ...pathspecs
+  ];
+  try {
+    return { hits: parse(await git_spawn.read(grep_arguments)), has_failed: false };
+  } catch (error) {
+    return { hits: [], has_failed: get_exit_code(error) !== GREP_NO_MATCH_EXIT };
+  }
+}
+var git_grep_hits = { parse, search };
+
+export {
+  git_grep_hits
+};

package/dist/commands/chunk-EYR2X5MZ.js

@@ -0,0 +1,53 @@
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+
+// scripts/josh/path-decision.ts
+var STAGED_FLAG = "--staged";
+var JSON_FLAG = "--json";
+var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
+var FAILURE_EXIT_CODE = 1;
+var MAX_LISTED_PATHS = 5;
+function has_unknown_flag(argv, known) {
+  return argv.some((argument) => !known.includes(argument));
+}
+function parse_options(argv) {
+  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
+  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
+}
+function format_path_list(paths) {
+  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+  if (paths.length <= MAX_LISTED_PATHS) return listed;
+  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
+}
+function print_decision(key, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key]: answer, reason }));
+    return;
+  }
+  console.info(answer);
+  console.error(reason);
+}
+async function run_path_decision(argv, command) {
+  const options = parse_options(argv);
+  if (options === void 0) {
+    console.error(command.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const paths = await changed_paths.read_changed_paths(options.is_staged);
+  const answer = await command.decide(paths, options.is_staged);
+  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
+  return 0;
+}
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  parse_options,
+  print_decision,
+  run_path_decision
+};
+
+export {
+  path_decision
+};

package/dist/commands/chunk-F546BPG3.js

@@ -0,0 +1,74 @@
+import {
+  issue_read
+} from "./chunk-TR6NTNWR.js";
+import {
+  git_gh_issue_read
+} from "./chunk-U6SMBYTN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/issue/issue-outcome.ts
+import { z } from "zod";
+var SUMMARY_LIMIT = 80;
+var summary_schema = z.string().min(1).max(SUMMARY_LIMIT).regex(/^[\u{20}-\u{7E}]+$/u).refine((value) => value === value.trim());
+var MARKER = /^<!-- josh:outcome (?<json>[^\n]+) -->$/gmu;
+var COMMENT_URL = /^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+#issuecomment-\d+$(?![\s\S])/u;
+var url_schema = z.string().regex(COMMENT_URL);
+var outcome_schema = z.object({ summary: summary_schema, url: url_schema.optional() });
+function body_of(note) {
+  if (note.summary === void 0 && note.url === void 0) return note.body;
+  const outcome = outcome_schema.parse({ summary: note.summary, url: note.url });
+  return `${note.body}
+
+<!-- josh:outcome ${JSON.stringify(outcome)} -->`;
+}
+function evidence_of(comment, url) {
+  if (comment.html_url === void 0 || !COMMENT_URL.test(url)) return false;
+  return url.split("#", 1)[0] === comment.html_url.split("#", 1)[0];
+}
+function record_of(body) {
+  const json = [...body.matchAll(MARKER)].at(-1)?.groups?.["json"];
+  return json_value.parse_with(json ?? "", outcome_schema);
+}
+function cited_outcome(record, comment) {
+  const url = record.url ?? comment.html_url;
+  return url === void 0 || !evidence_of(comment, url) ? void 0 : { summary: record.summary, url };
+}
+function outcome_of(comment) {
+  if (comment.is_trusted !== true) return void 0;
+  const record = record_of(comment.body);
+  return record === void 0 ? void 0 : cited_outcome(record, comment);
+}
+function from_comments(comments, candidates = comments) {
+  const outcomes = candidates.flatMap((comment) => {
+    const outcome = outcome_of(comment);
+    const evidence = comments.find((entry) => entry.html_url === outcome?.url);
+    return outcome === void 0 || evidence?.is_trusted !== true ? [] : [outcome];
+  });
+  return outcomes.at(-1);
+}
+async function read(issue) {
+  try {
+    const json = await git_gh_issue_read.issue_list_comments(
+      String(issue),
+      void 0,
+      void 0,
+      git_gh_issue_read.read_comments_conditionally
+    );
+    const comments = json === void 0 ? void 0 : await issue_read.parse_comments(json);
+    return comments === void 0 ? void 0 : from_comments(comments);
+  } catch {
+    return void 0;
+  }
+}
+async function recorded(issue, is_merged) {
+  if (is_merged) return {};
+  const outcome = await read(issue);
+  return outcome === void 0 ? {} : { outcome };
+}
+var issue_outcome = { body_of, from_comments, read, recorded, summary_schema, url_schema };
+
+export {
+  issue_outcome
+};

package/dist/commands/chunk-F7SAHNGR.js

@@ -0,0 +1,34 @@
+import {
+  run_event_scope
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+
+// scripts/run/event/run-event-retry.ts
+var RETRY_PREFIX = "retry #";
+function text_of(issue) {
+  return `${RETRY_PREFIX}${String(issue)}`;
+}
+function is_retry(event) {
+  return event.kind === run_event_stream.EVENT_KIND.ADD && event.text.startsWith(RETRY_PREFIX);
+}
+function current_attempts(events) {
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (is_retry(event)) boundaries.set(run_event_scope.issue_named(event), event.pos);
+  }
+  return events.filter(
+    (event) => event.pos >= (boundaries.get(run_event_scope.issue_named(event)) ?? 0)
+  );
+}
+function count_of(events, issue) {
+  return events.filter(
+    (event) => is_retry(event) && run_event_scope.issue_named(event) === String(issue)
+  ).length;
+}
+var run_event_retry = { count_of, current_attempts, is_retry, text_of };
+
+export {
+  run_event_retry
+};

package/dist/commands/chunk-FBWNL3UA.js

@@ -0,0 +1,209 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  PRIORITY_CRITICAL_LABEL,
+  PRIORITY_HIGH_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/issue/issue-priority.ts
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var DECLARATION_PREFIX = issue_body_keys.prefix("priority");
+var NORMAL_LINE = issue_body_keys.line("priority", "normal");
+var CRITICAL_PATTERN = new RegExp(
+  `^${issue_body_keys.line("priority", "critical")}\uFF08(?<basis>.*)\uFF09$`,
+  "u"
+);
+var HIGH_PATTERN = new RegExp(
+  `^${issue_body_keys.line("priority", "high")}\uFF08(?<basis>.*)\uFF09$`,
+  "u"
+);
+var CRITICAL_BASIS = /条件 ?[1-3]/u;
+var PLACEHOLDER = /^<.*>$/u;
+var LANE_PREFIX = issue_body_keys.prefix("cause_lane");
+var LANE_LINE = new RegExp(
+  String.raw`^${LANE_PREFIX} (?<minutes>\d+(?:\.\d+)?) 分（#[1-9]\d*）$`,
+  "u"
+);
+var CAUSE_PREFIX = issue_body_keys.prefix("cause_loss");
+var CAUSE_LINE = new RegExp(String.raw`^${CAUSE_PREFIX} (?<minutes>\d+(?:\.\d+)?) 分$`, "u");
+var LOSS_HIGH_MINUTES = 30;
+var SECURITY_PREFIX = issue_body_keys.prefix("security");
+var PARK_PREFIX = issue_body_keys.prefix("cause_park");
+var PARK_LINE = new RegExp(String.raw`^${PARK_PREFIX} #(?<issue>[1-9]\d*)$`, "u");
+var ORDER_PREFIX = issue_body_keys.prefix("order");
+var LAST_LINE = issue_body_keys.line("order", "last");
+var LEVELS = ["normal", "high", "critical"];
+var RAISED_LEVELS = /* @__PURE__ */ new Set(["high", "critical"]);
+var LABELS = {
+  critical: PRIORITY_CRITICAL_LABEL,
+  high: PRIORITY_HIGH_LABEL,
+  normal: void 0
+};
+var DECLARATION_PROBLEM = `declare at most one priority under \`${BACKGROUND_HEADING}\`: \`${issue_body_keys.line("priority", "critical")}\uFF08\u6761\u4EF6 <1-3>\uFF09\`, \`${issue_body_keys.line("priority", "high")}\uFF08<\u6839\u62E0>\uFF09\` or \`${NORMAL_LINE}\` \u2014 an urgent one names its condition, a high one its basis (\`issue-template.md\`)`;
+var LANE_PROBLEM = `state a causing lane under \`${BACKGROUND_HEADING}\` as \`${LANE_PREFIX} <\u5206> \u5206\uFF08#<N>\uFF09\` \u2014 the lane's net minutes from \`josh lane:net <N>\` (\`issue-template.md\`)`;
+var CAUSE_PROBLEM = `state a cause's lost minutes under \`${BACKGROUND_HEADING}\` as \`${CAUSE_PREFIX} <\u5206> \u5206\` (\`issue-template.md\`)`;
+var SECURITY_PROBLEM = `state a security finding under \`${BACKGROUND_HEADING}\` as \`${SECURITY_PREFIX} <\u8FC2\u56DE\u3055\u308C\u308B gate\u30FB\u30AC\u30FC\u30C9\u30FB\u6A29\u9650>\` (\`issue-template.md\`)`;
+var PARK_PROBLEM = `state a caused park under \`${BACKGROUND_HEADING}\` as \`${PARK_PREFIX} #<N>\` \u2014 the Issue the defect parked or whose run it stopped (\`issue-template.md\`)`;
+var LAST_PROBLEM = `\`${LAST_LINE}\` queues this Issue last, and an urgent or high priority runs it first \u2014 keep one of the two (\`issue-template.md\`)`;
+var HIGH_DECLARATION = "\u9AD8\uFF08\u30BB\u30AD\u30E5\u30EA\u30C6\u30A3 \u2026 / \u539F\u56E0\u306E park \u2026 / \u539F\u56E0\u306E\u640D\u5931 \u2026\uFF09";
+function unfenced_lines(body, heading) {
+  const section = markdown_section.section_lines(body, heading).join("\n");
+  return markdown_section.unfenced_lines(section).map((line) => line.trim());
+}
+function has_basis(basis) {
+  const trimmed = basis.trim();
+  return trimmed.length > 0 && !PLACEHOLDER.test(trimmed);
+}
+function has_critical_basis(basis) {
+  return CRITICAL_BASIS.test(basis);
+}
+var PARSERS = [
+  { pattern: CRITICAL_PATTERN, level: "critical", accepts: has_critical_basis },
+  { pattern: HIGH_PATTERN, level: "high", accepts: has_basis }
+];
+function parsed_level(parser, line) {
+  const basis = parser.pattern.exec(line)?.groups?.["basis"] ?? "";
+  return parser.accepts(basis) ? parser.level : void 0;
+}
+function level_of(line) {
+  if (line === NORMAL_LINE) return "normal";
+  const parser = PARSERS.find((entry) => entry.pattern.test(line));
+  return parser === void 0 ? void 0 : parsed_level(parser, line);
+}
+function background_lines(body, prefix) {
+  return unfenced_lines(body, BACKGROUND_HEADING).filter((line) => line.startsWith(prefix));
+}
+function declared_level(body) {
+  const lines = background_lines(body, DECLARATION_PREFIX);
+  if (lines.length === 0) return "normal";
+  return lines.length === 1 ? level_of(lines[0] ?? "") : void 0;
+}
+function is_lane_line(line) {
+  return LANE_LINE.test(line);
+}
+function is_cause_line(line) {
+  return CAUSE_LINE.test(line);
+}
+function is_security_line(line) {
+  return has_basis(line.slice(SECURITY_PREFIX.length));
+}
+function is_park_line(line) {
+  return PARK_LINE.test(line);
+}
+function parked_issues(body) {
+  const issues = background_lines(body, PARK_PREFIX).map((line) => PARK_LINE.exec(line)?.groups?.["issue"]).filter((issue) => issue !== void 0 && Number.isSafeInteger(Number(issue)));
+  return [...new Set(issues)];
+}
+var LANE_RANK_LINE = {
+  prefix: LANE_PREFIX,
+  accepts: is_lane_line,
+  problem: LANE_PROBLEM
+};
+var HIGH_FLOOR_LINES = [
+  { prefix: SECURITY_PREFIX, accepts: is_security_line, problem: SECURITY_PROBLEM },
+  { prefix: PARK_PREFIX, accepts: is_park_line, problem: PARK_PROBLEM }
+];
+var CAUSE_RANK_LINE = {
+  prefix: CAUSE_PREFIX,
+  accepts: is_cause_line,
+  problem: CAUSE_PROBLEM
+};
+function malformed_problem(body) {
+  return [LANE_RANK_LINE, CAUSE_RANK_LINE, ...HIGH_FLOOR_LINES].find(
+    (entry) => background_lines(body, entry.prefix).some((line) => !entry.accepts(line))
+  )?.problem;
+}
+function declared_minutes(body, prefix, pattern) {
+  return background_lines(body, prefix).map((line) => Number(pattern.exec(line)?.groups?.["minutes"])).filter((value) => Number.isFinite(value));
+}
+function cause_loss_minutes(body) {
+  return declared_minutes(body, CAUSE_PREFIX, CAUSE_LINE).reduce((sum, value) => sum + value, 0);
+}
+function is_marked(body) {
+  return HIGH_FLOOR_LINES.some((entry) => background_lines(body, entry.prefix).length > 0);
+}
+function has_loss_floor(body) {
+  return cause_loss_minutes(body) >= LOSS_HIGH_MINUTES;
+}
+function floor_of(body) {
+  return is_marked(body) || has_loss_floor(body) ? "high" : "normal";
+}
+function floor_reason(body) {
+  const loss = `the cause-loss lines' sum of ${String(cause_loss_minutes(body))} minutes (${String(LOSS_HIGH_MINUTES)} or more)`;
+  const reasons = [
+    is_marked(body) ? "the security finding or caused park" : void 0,
+    has_loss_floor(body) ? loss : void 0
+  ];
+  return reasons.filter((reason) => reason !== void 0).join(" and ");
+}
+function lane_minutes(body = "") {
+  return Math.max(0, ...declared_minutes(body, LANE_PREFIX, LANE_LINE));
+}
+function lost_minutes(body = "") {
+  const cause = cause_loss_minutes(body);
+  return cause > 0 ? cause : lane_minutes(body);
+}
+function filed_level(body) {
+  return background_lines(body, DECLARATION_PREFIX).length === 0 ? floor_of(body) : declared_level(body);
+}
+function is_typed(labels) {
+  return has_label_name(labels, PRIORITY_CRITICAL_LABEL) || has_label_name(labels, PRIORITY_HIGH_LABEL);
+}
+function labelled_level(labels) {
+  if (has_label_name(labels, PRIORITY_CRITICAL_LABEL)) return "critical";
+  return has_label_name(labels, PRIORITY_HIGH_LABEL) ? "high" : "normal";
+}
+function raise_label(labels, body) {
+  const filed = LEVELS.indexOf(filed_level(body) ?? "normal");
+  const rank = Math.max(filed, LEVELS.indexOf(floor_of(body)));
+  if (LEVELS.indexOf(labelled_level(labels)) >= rank) return void 0;
+  return LABELS[LEVELS[rank] ?? "normal"];
+}
+function floor_problem(body, level) {
+  const floor = floor_of(body);
+  if (LEVELS.indexOf(level) >= LEVELS.indexOf(floor)) return void 0;
+  return `${floor_reason(body)} ranks this Issue \`${floor}\`, above its declared \`${level}\` \u2014 declare \`${DECLARATION_PREFIX} ${HIGH_DECLARATION}\`, or drop the declaration to file at the floor (\`issue-template.md\`)`;
+}
+function is_last(body = "") {
+  return background_lines(body, ORDER_PREFIX).includes(LAST_LINE);
+}
+function order_problem(body) {
+  return is_last(body) && RAISED_LEVELS.has(filed_level(body) ?? "normal") ? LAST_PROBLEM : void 0;
+}
+function problem(body, typed) {
+  if (is_typed(typed)) return is_last(body) ? LAST_PROBLEM : void 0;
+  const level = filed_level(body);
+  if (level === void 0) return DECLARATION_PROBLEM;
+  return malformed_problem(body) ?? floor_problem(body, level);
+}
+function with_label(labels, body) {
+  const label = LABELS[filed_level(body) ?? "normal"];
+  if (label === void 0 || is_typed(labels)) return labels;
+  return [...labels, label];
+}
+var issue_priority = {
+  CAUSE_PREFIX,
+  LABELS,
+  LANE_PREFIX,
+  LOSS_HIGH_MINUTES,
+  declared_level,
+  floor_of,
+  is_last,
+  is_typed,
+  lane_minutes,
+  lost_minutes,
+  order_problem,
+  parked_issues,
+  problem,
+  raise_label,
+  with_label
+};
+
+export {
+  issue_priority
+};

package/dist/commands/chunk-FBZD6LOK.js

@@ -0,0 +1,225 @@
+import {
+  issue_observation_gate,
+  lane_early_push_count
+} from "./chunk-TKRUZZXG.js";
+import {
+  issue_sample_gate
+} from "./chunk-GY6O2WYG.js";
+import {
+  git_closes_keyword
+} from "./chunk-J3TKZLHA.js";
+import {
+  git_gh_repo
+} from "./chunk-QRY55H5U.js";
+import {
+  git_gh_pr_too_large,
+  read_pull
+} from "./chunk-3PGB2RKZ.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  git_gh_issue_rest
+} from "./chunk-U6SMBYTN.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec,
+  parse_json,
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/issue/issue-closing-pr.ts
+import { z } from "zod";
+var LINE_SEPARATOR = "\n";
+var TIMELINE_FILTER = [
+  ".[]",
+  '| if .event == "cross-referenced" and .source.issue.pull_request != null',
+  'then {url: .source.issue.html_url, repo: .source.issue.repository.full_name, body: (.source.issue.body // ""), state: (if .source.issue.pull_request.merged_at != null then "merged" else .source.issue.state end)}',
+  'elif .event == "reopened" then {reopened: true}',
+  "else empty end"
+].join(" ");
+var reference_schema = z.object({
+  url: z.string(),
+  repo: z.string(),
+  body: z.string(),
+  state: z.enum(["open", "closed", "merged"]).default("merged")
+});
+var reopen_schema = z.object({ reopened: z.literal(true) });
+var row_schema = z.union([reference_schema, reopen_schema]);
+function is_reference(row) {
+  return "url" in row;
+}
+function parse_row(line) {
+  const row = parse_json_object_or_undefined(line, row_schema);
+  if (row === void 0) throw new Error("the issue timeline contains an unreadable row");
+  return row;
+}
+function parse_references(raw) {
+  const rows = raw.split(LINE_SEPARATOR).filter((line) => line.trim() !== "").map((line) => parse_row(line));
+  const last_reopen = rows.findLastIndex((row) => !is_reference(row));
+  return rows.slice(last_reopen + 1).filter((row) => is_reference(row));
+}
+function pick_closing_pr(references, issue, repo) {
+  return references.find(
+    (reference) => reference.repo === repo && reference.state === "merged" && git_closes_keyword.parse_closes_issue_number(reference.body) === issue
+  )?.url;
+}
+async function read_closing_result(issue) {
+  try {
+    const [raw, repo] = await Promise.all([
+      git_gh_exec.exec_gh_api({
+        path: `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=100`,
+        should_paginate: true,
+        jq_filter: TIMELINE_FILTER
+      }),
+      git_gh_repo.repo_get_canonical_name_with_owner()
+    ]);
+    if (repo === void 0) return { kind: "unreadable" };
+    return { kind: "read", url: pick_closing_pr(parse_references(raw), issue, repo) };
+  } catch {
+    return { kind: "unreadable" };
+  }
+}
+async function read_closing_pr(issue) {
+  const result = await read_closing_result(issue);
+  return result.kind === "read" ? result.url : void 0;
+}
+async function read_closing_number_result(issue) {
+  const result = await read_closing_result(String(issue));
+  if (result.kind === "unreadable") return result;
+  const number = result.url === void 0 ? void 0 : Number(result.url.slice(result.url.lastIndexOf("/") + 1));
+  return { kind: "read", number };
+}
+async function read_closing_number(issue) {
+  const result = await read_closing_number_result(issue);
+  return result.kind === "read" ? result.number : void 0;
+}
+var issue_closing_pr = {
+  read_closing_number,
+  read_closing_number_result,
+  read_closing_pr
+};
+
+// scripts/issue/issue-observation-prime.ts
+import { z as z2 } from "zod";
+var comment_schema = z2.object({
+  ...gh_author_association.author_fields_schema,
+  body: z2.string(),
+  html_url: z2.string()
+});
+async function read_ledger() {
+  const path = await lane_ledger.target();
+  return path === void 0 ? [] : lane_ledger.read_entries(path);
+}
+async function read(source) {
+  const path = `${git_gh_api_path.issues_api_path(source.repo)}/comments/${source.comment}`;
+  const raw = await git_gh_exec.exec_gh_api({ path });
+  const comment = parse_json.parse_json_object_or_undefined(raw, comment_schema);
+  if (comment?.html_url !== source.url) return void 0;
+  const author = { ...gh_author_association.author_of(comment), repo: source.repo };
+  return await gh_author_association.is_trusted(author) ? comment.body : void 0;
+}
+async function remember(source, read_source2) {
+  try {
+    issue_observation_gate.record(source.url, await read_source2(source));
+  } catch {
+    issue_observation_gate.record(source.url, void 0);
+  }
+}
+async function sample(sources, read_entries) {
+  if (sources.every((source) => source.ledger === void 0)) return;
+  let entries = [];
+  try {
+    entries = await read_entries();
+  } catch {
+  }
+  issue_observation_gate.record_sample(
+    lane_early_push_count.MULTI_SLOT_EARLY_PUSH,
+    lane_early_push_count.multi_slot_pushed(entries)
+  );
+}
+async function prime(bodies, read_source2 = read, read_entries = read_ledger) {
+  const sources = issue_observation_gate.sources(bodies);
+  const unique = new Map(sources.map((source) => [source.url, source]));
+  await Promise.all([
+    sample(sources, read_entries),
+    ...[...unique.values()].map(async (source) => {
+      await remember(source, read_source2);
+    })
+  ]);
+}
+var issue_observation_prime = { prime };
+
+// scripts/issue/issue-sample-prime.ts
+async function read_as_issue(pr) {
+  const json = await git_gh_exec.exec_gh_api({ path: git_gh_api_path.issue_api_path(String(pr)) });
+  const issue = git_gh_issue_rest.parse_rest_issue(json);
+  return { body: issue.body, merged_at: issue.pull_request?.merged_at };
+}
+async function read_fields(pr) {
+  try {
+    return await read_pull(pr);
+  } catch (error) {
+    if (!git_gh_pr_too_large.is_too_many_files(error)) throw error;
+    return await read_as_issue(pr);
+  }
+}
+async function read_source(pr) {
+  const pull = await read_fields(pr);
+  const closes = git_closes_keyword.parse_closes_issue_number(pull.body ?? void 0);
+  return {
+    merged_at: pull.merged_at ?? void 0,
+    closes: closes === void 0 ? void 0 : Number(closes)
+  };
+}
+async function read_closing_source(issue) {
+  const pr = await issue_closing_pr.read_closing_number(issue);
+  if (pr === void 0) return { merged_at: void 0, closes: issue };
+  const { merged_at } = await read_source(pr);
+  return { merged_at, closes: issue };
+}
+var DEFAULT_PORTS = {
+  pull: read_source,
+  closing: read_closing_source,
+  ledger_path: lane_ledger.target
+};
+function merges_of(path) {
+  return function merges() {
+    if (path === void 0) return [];
+    return lane_ledger.read_entries(path).filter((entry) => entry.kind === lane_ledger.KIND.MERGE);
+  };
+}
+async function remember2(condition, ports) {
+  const read2 = condition.via === "pull" ? ports.pull : ports.closing;
+  try {
+    issue_sample_gate.record(condition, await read2(condition.cited));
+  } catch {
+    issue_sample_gate.record(condition, void 0);
+  }
+}
+async function prime2(bodies, ports = DEFAULT_PORTS) {
+  await issue_observation_prime.prime(bodies);
+  const unread = issue_sample_gate.unread_of(bodies);
+  if (unread.length === 0) return;
+  issue_sample_gate.use_merges(merges_of(await ports.ledger_path()));
+  await Promise.all(
+    unread.map(async (condition) => {
+      await remember2(condition, ports);
+    })
+  );
+}
+var issue_sample_prime = {
+  prime: prime2,
+  read_closing: read_closing_source,
+  read_source
+};
+
+export {
+  issue_closing_pr,
+  issue_sample_prime
+};