@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-ICPVBHIX.js

@@ -1,48 +0,0 @@
-import {
-  run_carry_reclaim
-} from "./chunk-SKGDMAIA.js";
-import {
-  run_carry,
-  run_carry_conversation
-} from "./chunk-DS53UUDH.js";
-import {
-  agent_provider,
-  cost_transcript
-} from "./chunk-DDZVMXZD.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-
-// scripts/run/wake/run-wake-handoff.ts
-import { existsSync } from "node:fs";
-function session_owner(session) {
-  if (session.provider === agent_provider.OPENAI_PROVIDER) {
-    return { session: session.session_id, is_headless: true };
-  }
-  const directory = cost_transcript.transcript_directory(session.worktree);
-  const transcript = run_carry_conversation.transcript_of(session.session_id, directory);
-  return { transcript, is_headless: true };
-}
-function hand_off(target) {
-  const read = run_carry.read_carry(target);
-  if (read.kind !== "carried" || read.carry.is_handed_off === true) return;
-  stamp_file.replace_stamp(target, { ...read.carry, is_handed_off: true });
-}
-function hand_to(target, owner) {
-  const read = run_carry.read_carry(target);
-  if (read.kind !== "carried") return;
-  run_carry.adopt_carry(target, read.carry, { ...owner, provider: read.carry.scheduler_provider });
-}
-function hand_on(target, owner, pid) {
-  if (owner.transcript === void 0 && owner.session === void 0) return;
-  const process_owner = run_carry.owner_of(pid, void 0, owner.transcript);
-  run_carry_reclaim.reclaim_at(target, { ...process_owner, session: owner.session });
-}
-function has_session_begun(carry) {
-  return carry.owner_transcript === void 0 || existsSync(carry.owner_transcript);
-}
-var run_wake_handoff = { hand_off, session_owner, hand_to, hand_on, has_session_begun };
-
-export {
-  run_wake_handoff
-};

package/dist/commands/chunk-ILIITIMQ.js

@@ -1,126 +0,0 @@
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-import {
-  issue_citation
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-audit.ts
-var REFERENCE_PATTERN = /#(\d+)\b/gu;
-var PREFIX_CHARACTER = /[\w./-]/u;
-var REPO_SEPARATOR = "/";
-var REPO_PART_COUNT = 2;
-var REPO_NAME_DOT = ".";
-var NO_KNOWN_REPOS = /* @__PURE__ */ new Set();
-var ACCEPTANCE_HEADINGS = /* @__PURE__ */ new Set([
-  issue_body_keys.heading("criteria"),
-  "## Acceptance criteria"
-]);
-function prefix_before(text, index) {
-  let start = index;
-  while (start > 0 && PREFIX_CHARACTER.test(text[start - 1] ?? "")) start -= 1;
-  return text.slice(start, index);
-}
-function is_repo_shape(parts) {
-  return parts.length === REPO_PART_COUNT && parts.every((part) => part !== "");
-}
-function reference_repo(prefix, repo, known) {
-  if (prefix === "") return repo;
-  if (!is_repo_shape(prefix.split(REPO_SEPARATOR))) return void 0;
-  if (!prefix.includes(REPO_NAME_DOT)) return prefix;
-  return known.has(prefix) ? prefix : void 0;
-}
-function to_reference(text, match, repo, known) {
-  const issue_number = Number(match[1]);
-  if (!Number.isSafeInteger(issue_number)) return void 0;
-  const named_repo = reference_repo(prefix_before(text, match.index), repo, known);
-  return named_repo === void 0 ? void 0 : { repo: named_repo, number: issue_number };
-}
-function unique_references(references) {
-  const seen = /* @__PURE__ */ new Set();
-  return references.filter((reference) => {
-    const key = epic_graph.key_of(reference);
-    const is_new = !seen.has(key);
-    seen.add(key);
-    return is_new;
-  });
-}
-function parse_issue_references(text, repo, known = NO_KNOWN_REPOS) {
-  const found = [];
-  for (const match of text.matchAll(REFERENCE_PATTERN)) {
-    const reference = to_reference(text, match, repo, known);
-    if (reference !== void 0) found.push(reference);
-  }
-  return unique_references(found);
-}
-function known_repos(children, current_repo) {
-  return /* @__PURE__ */ new Set([current_repo, ...children.map((child) => child.repo)]);
-}
-function parse_references(text, repo = "") {
-  return parse_issue_references(issue_citation.prose_lines(text).join("\n"), repo).filter((reference) => reference.repo === repo).map((reference) => reference.number);
-}
-function is_acceptance_heading(line) {
-  return ACCEPTANCE_HEADINGS.has(line.trim());
-}
-function acceptance_section(body) {
-  if (body === void 0) return "";
-  return markdown_section.section_lines_matching(body, is_acceptance_heading).join("\n");
-}
-var PARENT_MARKERS = ["\u89AA:", "\u89AA\uFF1A", "Parent:", "parent:"];
-function has_parent_marker(line) {
-  return PARENT_MARKERS.some((marker) => line.includes(marker));
-}
-var PARENT_REFERENCE = /(?:親|Parent|parent)\**[:：]\**\s*(?:[\w.-]+\/[\w.-]+)?#\d+/gu;
-function parent_references(body) {
-  return issue_citation.prose_lines(body).flatMap((line) => [...line.matchAll(PARENT_REFERENCE)].map((match) => match[0])).join("\n");
-}
-function references_in(text, repo, section) {
-  return parse_references(text, repo).map((number) => ({ number, section }));
-}
-function signal_references(body, repo = "") {
-  const read = [
-    ...references_in(acceptance_section(body), repo, "acceptance criteria"),
-    ...references_in(parent_references(body), repo, "parent line")
-  ];
-  return read.filter((reference, index) => {
-    return read.findIndex((other) => other.number === reference.number) === index;
-  });
-}
-function collect_blockers(index, node) {
-  const seen = /* @__PURE__ */ new Set();
-  const pending = [...epic_graph.blockers_of(index, node)];
-  while (pending.length > 0) {
-    const current = pending.pop() ?? node;
-    if (seen.has(current)) {
-      continue;
-    }
-    seen.add(current);
-    pending.push(...epic_graph.blockers_of(index, current));
-  }
-  return seen;
-}
-function depends_on(index, node, target) {
-  return collect_blockers(index, epic_graph.key_of(node)).has(epic_graph.key_of(target));
-}
-var epic_audit_logic = {
-  unique_references,
-  known_repos,
-  parse_issue_references,
-  parse_references,
-  parent_references,
-  acceptance_section,
-  is_acceptance_heading,
-  signal_references,
-  has_parent_marker,
-  depends_on
-};
-
-export {
-  epic_audit_logic
-};

package/dist/commands/chunk-IONGJJYM.js

@@ -1,179 +0,0 @@
-import {
-  run_pr_return
-} from "./chunk-N36NZMAL.js";
-import {
-  run_add
-} from "./chunk-7JOOMFDI.js";
-import {
-  issue_state_cli
-} from "./chunk-E4PFCTXN.js";
-import {
-  run_event_retry
-} from "./chunk-MFZVRWRS.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  lane_await
-} from "./chunk-5Y7FOJLX.js";
-import {
-  run_cut
-} from "./chunk-TFDVTU6O.js";
-import {
-  lane_registry
-} from "./chunk-NEOCCN6D.js";
-import {
-  run_ship_detach
-} from "./chunk-FJM2HWKW.js";
-import {
-  run_event_scope,
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-import {
-  pr_info_schema
-} from "./chunk-34DND4BA.js";
-import {
-  repository_lock
-} from "./chunk-NUCFIYZL.js";
-import {
-  run_carry
-} from "./chunk-DS53UUDH.js";
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/run-repair-attempt.ts
-import { statSync } from "node:fs";
-var REPAIR_SUFFIX = " repair";
-var LOCK_WAIT_MS = 5e3;
-var PERMANENT_KINDS = /* @__PURE__ */ new Set(["merge", "withdraw", "split"]);
-var QUEUED_END_KINDS = /* @__PURE__ */ new Set([
-  ...PERMANENT_KINDS,
-  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
-  run_event_stream.EVENT_KIND.CHILD_LAUNCH,
-  run_event_stream.EVENT_KIND.PARK
-]);
-var WRITE_FAILED = "Could not record the repair attempt boundary.";
-function repair_text(issue) {
-  return `${run_event_retry.text_of(Number(issue))}${REPAIR_SUFFIX}`;
-}
-function issue_attempt(events, issue) {
-  return run_event_retry.current_attempts(events).filter((event) => run_event_scope.issue_named(event) === issue);
-}
-function is_queued(events, issue) {
-  return events[0]?.text === repair_text(issue) && events.every((event) => !QUEUED_END_KINDS.has(event.kind));
-}
-function reviewed_at(events) {
-  if (events.some((event) => PERMANENT_KINDS.has(event.kind))) return void 0;
-  return events.findLast((event) => event.kind === run_event_stream.EVENT_KIND.HUMAN_REVIEW)?.at;
-}
-async function is_unprotected(issue) {
-  const read = await issue_state_cli.read_issue(issue);
-  return read.kind === "state" && read.state.state === "OPEN" && run_add.protected_label(read.state.labels) === void 0;
-}
-async function is_returned(lane, since) {
-  const raw = await git_gh_command.pr_view(lane.branch);
-  if (json_value.parse_with(raw, pr_info_schema)?.state !== "OPEN") return false;
-  if (since === void 0) return true;
-  const returned = await run_pr_return.read(lane.issue, lane.directory);
-  return run_pr_return.comments_since(returned.comments, Date.parse(since)).some((comment) => comment.is_trusted === true);
-}
-function cut_target(lane) {
-  const directory = git_common_directory.own(lane.directory);
-  return directory === void 0 ? void 0 : run_cut.cut_path(directory);
-}
-function can_end_cut(target, lane) {
-  const read = run_cut.read_cut(target);
-  if (read.kind === "none") return true;
-  if (read.kind === "unreadable") return false;
-  return read.cut.issue === lane.issue && read.cut.branch === lane.branch && read.cut.invocation === run_cut.invocation_for(lane.issue);
-}
-async function append_boundary(issue) {
-  const target = await run_event_stream_emit.stream_target();
-  if (target === void 0) throw new Error(WRITE_FAILED);
-  const result = await run_event_stream_emit.append_at(
-    target,
-    run_event_stream.EVENT_KIND.ADD,
-    repair_text(issue),
-    /* @__PURE__ */ new Date()
-  );
-  if (!result.appended) throw new Error(WRITE_FAILED);
-}
-async function has_ended_ship(issue) {
-  const repository = await run_carry.repository_directory();
-  if (repository === void 0) return false;
-  const info = statSync(run_ship_detach.result_path(repository, issue), { throwIfNoEntry: false });
-  if (info === void 0) return true;
-  const result = run_ship_detach.read_result(repository, issue);
-  return result !== void 0 && result.result !== "running";
-}
-async function is_clean(lane) {
-  try {
-    return await git_command.status(lane.directory) === "";
-  } catch {
-    return false;
-  }
-}
-async function is_repairable(issue, lane) {
-  return await is_unprotected(issue) && await is_clean(lane);
-}
-async function ready_lane(issue) {
-  if (await lane_await.other_process_trace(issue) !== "none" || !await has_ended_ship(issue)) {
-    return void 0;
-  }
-  const lane = await lane_registry.find_open_lane(issue);
-  if (lane === void 0 || !await is_repairable(issue, lane)) return void 0;
-  return lane;
-}
-function eligible_cut_target(lane, expected_target) {
-  const target = cut_target(lane);
-  if (expected_target !== void 0 && expected_target !== target) return void 0;
-  return target !== void 0 && can_end_cut(target, lane) ? target : void 0;
-}
-async function finish(lane, events, since, expected_target) {
-  const target = eligible_cut_target(lane, expected_target);
-  if (target === void 0 || !await is_returned(lane, since)) return false;
-  if (!is_queued(events, lane.issue)) await append_boundary(lane.issue);
-  run_cut.end_cut(target);
-  return true;
-}
-function is_candidate(events, issue) {
-  return reviewed_at(events) !== void 0 || is_queued(events, issue);
-}
-function checked_preparation(is_prepared, events, issue) {
-  if (!is_prepared && is_queued(events, issue)) {
-    throw new Error("Could not safely resume the queued repair.");
-  }
-  return is_prepared;
-}
-async function prepare_held(issue, expected_target) {
-  const events = issue_attempt(await run_event_stream_emit.all_events(true), issue);
-  if (!is_candidate(events, issue)) return false;
-  const lane = await ready_lane(issue);
-  const is_prepared = lane === void 0 ? false : await finish(lane, events, reviewed_at(events), expected_target);
-  return checked_preparation(is_prepared, events, issue);
-}
-async function prepare(issue, expected_target) {
-  const lock = repository_lock.lock_path(`josh-repair-${issue}-`);
-  const is_prepared = await repository_lock.with_lock(
-    async () => await prepare_held(issue, expected_target),
-    lock,
-    LOCK_WAIT_MS
-  );
-  if (is_prepared === void 0) throw new Error("Could not lock the repair attempt.");
-  return is_prepared;
-}
-var run_repair_attempt = { issue_attempt, prepare, reviewed_at };
-
-export {
-  run_repair_attempt
-};

package/dist/commands/chunk-IP23WOWP.js

@@ -1,126 +0,0 @@
-import {
-  issue_publication_state
-} from "./chunk-G2DNS74C.js";
-import {
-  issue_auto_ok
-} from "./chunk-QGATHT4S.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  issue_watch_diff
-} from "./chunk-GOY5JECO.js";
-import {
-  gh_author_association
-} from "./chunk-5YTEMF4O.js";
-import {
-  issue_label_schema
-} from "./chunk-34DND4BA.js";
-import {
-  AUTO_OK_LABEL,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  read_json_listing
-} from "./chunk-43DU7DYZ.js";
-import {
-  bounded_pool
-} from "./chunk-EBVS2LKX.js";
-
-// scripts/auto-ok/auto-ok-judge-read.ts
-import { z } from "zod";
-
-// scripts/auto-ok/auto-ok-judge.ts
-import { createHash } from "node:crypto";
-var MARKER_PREFIX = "<!-- josh:auto-ok-judged v=2 body=";
-var MARKER_SUFFIX = " -->";
-var MARKER_PATTERN = /<!-- josh:auto-ok-judged v=2 body=(?<digest>[\da-f]+) -->/u;
-var DIGEST_LENGTH = 16;
-var CRLF = "\r\n";
-var LF = "\n";
-function is_candidate(issue) {
-  const is_excluded = issue_publication_state.is_pending(issue.body) || !issue.is_trusted;
-  if (is_excluded || has_label_name(issue.labels, AUTO_OK_LABEL)) return false;
-  return issue_auto_ok.exclusion_of(issue.labels) === void 0;
-}
-function body_digest(body) {
-  const normalized = body.split(CRLF).join(LF);
-  return createHash("sha256").update(normalized).digest("hex").slice(0, DIGEST_LENGTH);
-}
-function digest_of(comment) {
-  if (!comment.is_trusted) return void 0;
-  return MARKER_PATTERN.exec(comment.body)?.groups?.["digest"];
-}
-function is_person_comment(comment) {
-  return comment.is_trusted === true && !comment.is_automated;
-}
-function is_judged(body, comments) {
-  const judgement = comments.findLast((comment) => digest_of(comment) !== void 0);
-  if (judgement === void 0 || digest_of(judgement) !== body_digest(body)) return false;
-  return comments.every((comment) => comment.id <= judgement.id || !is_person_comment(comment));
-}
-function comment_of(decision, body) {
-  const marker = `${MARKER_PREFIX}${body_digest(body)}${MARKER_SUFFIX}`;
-  return `${issue_auto_ok.line_of(decision)}${LF}${LF}${marker}`;
-}
-var auto_ok_judge = { comment_of, is_candidate, is_judged };
-
-// scripts/auto-ok/auto-ok-judge-read.ts
-var LISTING_LIMIT = 200;
-var COMMENT_READ_WIDTH = 4;
-var row_schema = z.looseObject({
-  number: z.number(),
-  title: z.string(),
-  body: z.string().nullish(),
-  labels: z.array(issue_label_schema),
-  updatedAt: z.string(),
-  author_association: z.string().nullish(),
-  user: z.looseObject({ login: z.string() }).nullish()
-});
-async function to_row(raw) {
-  return {
-    number: raw.number,
-    title: raw.title,
-    body: raw.body ?? "",
-    labels: raw.labels.map((label) => label.name),
-    updated_at: raw.updatedAt,
-    is_trusted: await gh_author_association.is_trusted({
-      login: raw.user?.login,
-      association: raw.author_association
-    })
-  };
-}
-async function read_candidates() {
-  const { json } = await git_gh_command.issue_list_open_for_judgement(LISTING_LIMIT);
-  if (json === void 0) return void 0;
-  const listing = read_json_listing(json, row_schema);
-  if (listing.kind !== "read") return void 0;
-  const rows = await Promise.all(listing.rows.map(async (raw) => await to_row(raw)));
-  return rows.filter((row) => auto_ok_judge.is_candidate(row));
-}
-async function owes_judgement(row, cache) {
-  if (cache.get(row.number) === row.updated_at) return false;
-  const comments = await issue_watch_diff.parse_comments(
-    await git_gh_command.issue_list_comments(String(row.number))
-  );
-  if (comments === void 0) return false;
-  if (!auto_ok_judge.is_judged(row.body, comments)) return true;
-  cache.set(row.number, row.updated_at);
-  return false;
-}
-async function owed(cache = /* @__PURE__ */ new Map()) {
-  const candidates = await read_candidates();
-  if (candidates === void 0) return void 0;
-  const owing = await bounded_pool.bounded_map(
-    candidates,
-    COMMENT_READ_WIDTH,
-    async (row) => await owes_judgement(row, cache)
-  );
-  return candidates.filter((_row, index) => owing[index] === true);
-}
-var auto_ok_judge_read = { owed };
-
-export {
-  auto_ok_judge,
-  auto_ok_judge_read
-};

package/dist/commands/chunk-IPS7EBE5.js

@@ -1,140 +0,0 @@
-import {
-  shared_cache
-} from "./chunk-WXLW7S4M.js";
-import {
-  gh_call_kind,
-  gh_failure,
-  gh_request_tally,
-  gh_retry,
-  git_gh_exec,
-  has_stdout_field,
-  parse_json_array_or_undefined
-} from "./chunk-43DU7DYZ.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-
-// scripts/gh/git-gh-conditional.ts
-var NOT_MODIFIED_STATUS = 304;
-var OK_STATUS = 200;
-var INCLUDE_FLAG = "--include";
-var HEADER_FLAG = "-H";
-var IF_NONE_MATCH = "If-None-Match: ";
-var HEADER_BODY_SEPARATOR = /\r?\n\r?\n/u;
-var ETAG_HEADER = /^etag: *(?<etag>[^\r\n]+)/imu;
-var UNCHANGED = { kind: "unchanged" };
-var UNREADABLE = { kind: "unreadable" };
-function to_args(path, etag) {
-  const header = etag === void 0 ? [] : [HEADER_FLAG, `${IF_NONE_MATCH}${etag}`];
-  return ["api", INCLUDE_FLAG, ...header, path];
-}
-function to_changed(output) {
-  const [headers = "", ...rest] = output.split(HEADER_BODY_SEPARATOR);
-  const etag = ETAG_HEADER.exec(headers)?.groups?.["etag"];
-  return { kind: "changed", etag, body: rest.join("\n\n") };
-}
-function to_read(output) {
-  return git_gh_exec.parse_status_line(output) === OK_STATUS ? to_changed(output) : UNREADABLE;
-}
-function failure_status(error) {
-  const cause = error instanceof Error ? error.cause : void 0;
-  return has_stdout_field(cause) ? git_gh_exec.parse_status_line(cause.stdout) : void 0;
-}
-function not_modified(path) {
-  gh_request_tally.count_not_modified(gh_call_kind.of_api(path));
-  return UNCHANGED;
-}
-function rethrow_failure(error, path) {
-  const status = failure_status(error);
-  if (status === NOT_MODIFIED_STATUS) return not_modified(path);
-  if (status !== void 0 && error instanceof Error) gh_failure.attach(error, { status });
-  throw error;
-}
-async function request_conditional(path, etag, timeout_ms) {
-  try {
-    return to_read(await git_gh_exec.exec_gh_command(to_args(path, etag), timeout_ms));
-  } catch (error) {
-    return rethrow_failure(error, path);
-  }
-}
-async function read_conditional(path, etag, timeout_ms) {
-  const retry = timeout_ms === void 0 ? gh_retry.with_read_retry : gh_retry.with_retry;
-  try {
-    return await retry(async () => await request_conditional(path, etag, timeout_ms));
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-var git_gh_conditional = { read_conditional, to_args };
-
-// scripts/gh/git-gh-etag-read.ts
-import { z } from "zod";
-var SLOT_PREFIX = "josh-gh-etag-";
-var PATH_DIGEST_LENGTH = 16;
-var HOURS_KEPT = 24;
-var MS_PER_HOUR = 36e5;
-var UNREADABLE_MESSAGE = "gh api could not read";
-var kept_schema = z.object({ etag: z.string(), body: z.string() });
-function settle(previous, answer) {
-  if (previous !== void 0 && answer.kind === "unchanged") return { body: previous.body };
-  if (answer.kind !== "changed") return void 0;
-  if (answer.etag === void 0) return { body: answer.body };
-  return { body: answer.body, kept: { etag: answer.etag, body: answer.body } };
-}
-function slot_of(path) {
-  const name = stamp_file.digest(path).slice(0, PATH_DIGEST_LENGTH);
-  return { prefix: `${SLOT_PREFIX}${name}-`, ttl_ms: HOURS_KEPT * MS_PER_HOUR };
-}
-function unreadable(path, answer) {
-  const cause = answer.kind === "unreadable" ? answer.cause : void 0;
-  return cause ?? new Error(`${UNREADABLE_MESSAGE}: ${path}`);
-}
-async function read_detail(path, timeout_ms) {
-  const slot = slot_of(path);
-  const previous = shared_cache.read(slot, path, kept_schema, Date.now());
-  const answer = await git_gh_conditional.read_conditional(path, previous?.etag, timeout_ms);
-  const settled = settle(previous, answer);
-  if (settled === void 0) throw unreadable(path, answer);
-  if (settled.kept !== void 0) shared_cache.write(slot, path, settled.kept, Date.now());
-  return { body: settled.body, is_unchanged: answer.kind === "unchanged" };
-}
-async function read(path, timeout_ms) {
-  const { body } = await read_detail(path, timeout_ms);
-  return body;
-}
-async function read_listing(path, per_page, read_page = read) {
-  const first = await read_page(path);
-  const rows = parse_json_array_or_undefined(first, z.unknown());
-  if (rows === void 0 || rows.length < per_page) return first;
-  return await git_gh_exec.exec_gh_api({ path, should_paginate: true });
-}
-var git_gh_etag_read = { read, read_detail, read_listing, settle, slot_of };
-
-// scripts/gh/git-gh-issue-memo.ts
-var FRESH_MS = 1e4;
-var read_by_path = /* @__PURE__ */ new Map();
-function fresh_entry(path, now_ms) {
-  const entry = read_by_path.get(path);
-  return entry !== void 0 && now_ms - entry.at_ms < FRESH_MS ? entry : void 0;
-}
-async function read2(path) {
-  const now_ms = Date.now();
-  const entry = fresh_entry(path, now_ms) ?? { read: git_gh_etag_read.read(path), at_ms: now_ms };
-  read_by_path.set(path, entry);
-  try {
-    return await entry.read;
-  } catch (error) {
-    if (read_by_path.get(path) === entry) read_by_path.delete(path);
-    throw error;
-  }
-}
-function forget() {
-  read_by_path.clear();
-}
-var git_gh_issue_memo = { read: read2, forget, FRESH_MS };
-
-export {
-  git_gh_conditional,
-  git_gh_etag_read,
-  git_gh_issue_memo
-};