@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-TYNH2R66.js

@@ -1,1150 +0,0 @@
-import {
-  lane_capacity
-} from "./chunk-EFDVE5P5.js";
-import {
-  epic_triage
-} from "./chunk-VQRT32JB.js";
-import {
-  lane_spent
-} from "./chunk-77BIN247.js";
-import {
-  epic_label_age
-} from "./chunk-ANUTT56I.js";
-import {
-  epic_cross_repo,
-  epic_fetch
-} from "./chunk-OX3VQLV2.js";
-import {
-  issue_not_before
-} from "./chunk-FKZ5E4JD.js";
-import {
-  epic_issue
-} from "./chunk-IAD4WLLI.js";
-import {
-  issue_rank
-} from "./chunk-HLKAFSN4.js";
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  expected_effect_lint
-} from "./chunk-XZQWEVR3.js";
-import {
-  issue_priority
-} from "./chunk-XI2ABCRX.js";
-import {
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  epic_busy
-} from "./chunk-QABRNGQV.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  lane_await
-} from "./chunk-IB5TT73I.js";
-import {
-  lane_process_table,
-  lane_registry,
-  lane_snapshot_trace
-} from "./chunk-452HWOJ7.js";
-import {
-  lane_state
-} from "./chunk-ZZXO6TFH.js";
-import {
-  EPIC_LABEL,
-  IN_PROGRESS_LABEL,
-  RUN_SOLO_LABEL,
-  has_any_label,
-  has_label_name,
-  has_parked_label
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_citation,
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  repo_discovery
-} from "./chunk-MDKDJF2K.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/epic/epic-report.ts
-function to_path_field(path) {
-  return path === void 0 ? {} : { path };
-}
-function bundle_by_repo(children, paths = /* @__PURE__ */ new Map()) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const child of children) {
-    const bucket = grouped.get(child.repo) ?? [];
-    bucket.push(child);
-    grouped.set(child.repo, bucket);
-  }
-  const repos = [];
-  for (const [repo] of grouped) repos.push(repo);
-  return repos.toSorted((left, right) => left.localeCompare(right)).map((repo) => ({
-    repo,
-    children: grouped.get(repo) ?? [],
-    ...to_path_field(paths.get(repo.toLowerCase()))
-  }));
-}
-function decide_verdict(classification, anomalies) {
-  if (anomalies > 0) return "error";
-  if (classification.runnable.length > 0) return "run";
-  if (classification.time.length > 0) return "wait";
-  if (classification.human.length > 0) return "stop";
-  return "complete";
-}
-function build_result(classification, anomalies, paths = /* @__PURE__ */ new Map()) {
-  const verdict = decide_verdict(classification, anomalies.length);
-  return {
-    verdict,
-    candidates: verdict === "error" ? [] : bundle_by_repo(classification.runnable, paths),
-    waiting: classification.time,
-    blocked_on_people: classification.human,
-    anomalies
-  };
-}
-function candidates_for_repo(result, repo) {
-  return result.candidates.find((bundle) => bundle.repo === repo)?.children ?? [];
-}
-function format_bundle_heading(bundle) {
-  return `  ${bundle.repo}  ${bundle.path ?? "(no local checkout)"}`;
-}
-function format_child(child, current_repo) {
-  return `    ${epic_graph.format_reference(child, current_repo)}`;
-}
-function format_group(label, children, current_repo) {
-  if (children.length === 0) return [];
-  return [label, ...children.map((child) => format_child(child, current_repo))];
-}
-var VERDICT_LINES = {
-  run: "Runnable children (each takes a free lane in its repository):",
-  wait: "Nothing is runnable yet, but these resolve on their own \u2014 wait and ask again:",
-  stop: "Nothing will resolve on its own. These need a person:",
-  complete: "Every child is closed; the epic is complete.",
-  error: "The dependency graph is unusable:"
-};
-function format_result(result, current_repo) {
-  if (result.verdict === "error") {
-    return [VERDICT_LINES.error, ...result.anomalies.map((anomaly) => anomaly.message)].join("\n");
-  }
-  const lines = [VERDICT_LINES[result.verdict]];
-  for (const bundle of result.candidates) {
-    lines.push(
-      format_bundle_heading(bundle),
-      ...bundle.children.map((child) => format_child(child, current_repo))
-    );
-  }
-  lines.push(
-    ...format_group("  Waiting on time:", result.waiting, current_repo),
-    ...format_group("  Waiting on a person:", result.blocked_on_people, current_repo)
-  );
-  return lines.join("\n");
-}
-var epic_report = {
-  bundle_by_repo,
-  format_bundle_heading,
-  decide_verdict,
-  build_result,
-  candidates_for_repo,
-  format_result
-};
-
-// scripts/epic/epic-nested.ts
-function is_nested_epic(child) {
-  return has_label_name(child.labels, EPIC_LABEL);
-}
-var epic_nested = {
-  is_nested_epic
-};
-
-// scripts/epic/epic-outside-blocker.ts
-var NOTICE_ICON = "\u2757";
-var CLOSED = "CLOSED";
-function name_of(child) {
-  return session_cite.issue(child.number, void 0, child.repo);
-}
-function as_closed_child(reference) {
-  return {
-    number: reference.number,
-    repo: reference.repo,
-    state: CLOSED,
-    labels: [],
-    blocked_by: []
-  };
-}
-function unread_answer(child, reference) {
-  const blocker = epic_graph.key_of(reference);
-  return {
-    category: "time",
-    notice: {
-      key: `unread:${epic_graph.key_of(child)}:${blocker}`,
-      message: `${NOTICE_ICON} ${name_of(child)} is blocked by ${blocker}, whose state could not be read \u2014 it waits rather than runs`
-    }
-  };
-}
-function open_answer(child, reference, running) {
-  if (running.has(epic_graph.blocker_key(reference))) return { category: "time" };
-  const blocker = epic_graph.key_of(reference);
-  return {
-    category: "human",
-    notice: {
-      key: `outside:${epic_graph.key_of(child)}:${blocker}`,
-      message: `${NOTICE_ICON} ${name_of(child)} waits on ${blocker}, which this run will not finish \u2014 withheld for a person`
-    }
-  };
-}
-function closed_category(verdict) {
-  if (verdict === "resolved") return void 0;
-  return verdict === "human" ? "human" : "time";
-}
-function outside_category(child, reference, resolve, running) {
-  if (reference.state === void 0) return unread_answer(child, reference);
-  if (reference.state !== CLOSED) return open_answer(child, reference, running);
-  return { category: closed_category(resolve(as_closed_child(reference), child)) };
-}
-function running_keys(issues) {
-  return new Set(issues.map((issue) => epic_graph.key_of(issue)));
-}
-var epic_outside_blocker = { outside_category, running_keys };
-
-// scripts/epic/epic-classify.ts
-var CLOSED2 = "CLOSED";
-function resolve_by_state(blocker) {
-  return blocker.state === CLOSED2 ? "resolved" : "inherit";
-}
-function has_label(child, label) {
-  return has_label_name(child.labels, label);
-}
-function has_human_label(child) {
-  return has_parked_label(child.labels);
-}
-function is_waiting(child) {
-  return has_label(child, IN_PROGRESS_LABEL) || !issue_not_before.is_due(child.body);
-}
-function local_category(child) {
-  if (child.state === CLOSED2) return "done";
-  if (epic_nested.is_nested_epic(child) || has_human_label(child)) return "human";
-  if (is_waiting(child)) return "time";
-  return void 0;
-}
-function inherited_category(blocker_category) {
-  return blocker_category === "human" ? "human" : "time";
-}
-function dependency_category(verdict, blocker_category) {
-  if (verdict === "resolved") return void 0;
-  if (verdict === "inherit") return inherited_category(blocker_category);
-  return verdict;
-}
-var reported = /* @__PURE__ */ new Set();
-function reset_reported() {
-  reported.clear();
-}
-var silence = { is_muted: false };
-function mute_notices() {
-  silence.is_muted = true;
-}
-function report_notice(notice) {
-  if (silence.is_muted || reported.has(notice.key)) return;
-  reported.add(notice.key);
-  console.warn(notice.message);
-}
-function outside_category2(child, reference, context) {
-  const answer = epic_outside_blocker.outside_category(
-    child,
-    reference,
-    context.resolve,
-    context.running
-  );
-  if (answer.notice !== void 0) report_notice(answer.notice);
-  return answer.category;
-}
-function report_nested_epic(child) {
-  const line = `epic:${epic_graph.key_of(child)}`;
-  if (reported.has(line)) return;
-  reported.add(line);
-  console.warn(
-    `\u26A0 ${epic_graph.key_of(child)} is itself an epic \u2014 a run cannot implement one, so it is withheld rather than offered`
-  );
-}
-function report_nested_epics(children) {
-  for (const child of children) {
-    if (child.state !== CLOSED2 && epic_nested.is_nested_epic(child)) report_nested_epic(child);
-  }
-}
-function relation_category(child, blocker_reference, context) {
-  const blocker = context.index.get(epic_graph.blocker_key(blocker_reference));
-  if (blocker === void 0) return outside_category2(child, blocker_reference, context);
-  return dependency_category(
-    context.resolve(blocker, child),
-    context.memo.get(epic_graph.key_of(blocker)) ?? "time"
-  );
-}
-function blocker_categories(child, context) {
-  return child.blocked_by.map((blocker) => relation_category(child, blocker, context)).filter((category) => category !== void 0);
-}
-function from_blockers(categories) {
-  if (categories.includes("human")) return "human";
-  return categories.length > 0 ? "time" : "runnable";
-}
-function compute_category(child, context) {
-  return local_category(child) ?? from_blockers(blocker_categories(child, context));
-}
-function is_ready(node, context) {
-  return epic_graph.blockers_of(context.index, node).every((blocker) => !context.index.has(blocker) || context.memo.has(blocker));
-}
-function fill_memo(children, context) {
-  const pending = new Set(children.map((child) => epic_graph.key_of(child)));
-  function peel() {
-    const ready = [...pending].filter((node) => is_ready(node, context));
-    for (const node of ready) {
-      const child = context.index.get(node);
-      if (child !== void 0) context.memo.set(node, compute_category(child, context));
-      pending.delete(node);
-    }
-    return ready.length;
-  }
-  while (peel() > 0) {
-  }
-  for (const node of pending) context.memo.set(node, "time");
-}
-function new_context(children, resolve = resolve_by_state, running = epic_outside_blocker.running_keys(children)) {
-  return {
-    index: epic_graph.index_children(children),
-    resolve,
-    memo: /* @__PURE__ */ new Map(),
-    running
-  };
-}
-function classify_children(children, resolve, running) {
-  const context = new_context(children, resolve, running);
-  const buckets = {
-    runnable: [],
-    time: [],
-    human: []
-  };
-  fill_memo(children, context);
-  report_nested_epics(children);
-  for (const child of children) {
-    const category = context.memo.get(epic_graph.key_of(child)) ?? "time";
-    if (category !== "done") buckets[category].push(child);
-  }
-  return buckets;
-}
-var epic_classify = {
-  resolve_by_state,
-  mute_notices,
-  reset_reported,
-  local_category,
-  classify_children
-};
-
-// scripts/epic/epic-candidate-confirm.ts
-var NO_ANOMALIES = 0;
-var NO_LANES = 0;
-var ONE_LANE = 1;
-function is_same_blockers(left, right) {
-  function sorted(blockers) {
-    return blockers.map((blocker) => epic_graph.key_of(blocker)).toSorted((first, second) => first.localeCompare(second)).join(",");
-  }
-  return sorted(left) === sorted(right);
-}
-function with_blockers(children, target, blocked_by) {
-  const key = epic_graph.key_of(target);
-  return children.map(
-    (child) => epic_graph.key_of(child) === key ? { ...child, blocked_by } : child
-  );
-}
-function is_still_runnable(child, children, context) {
-  const key = epic_graph.key_of(child);
-  return epic_classify.classify_children(children, context.resolve, context.running).runnable.some((candidate) => epic_graph.key_of(candidate) === key);
-}
-async function read_or_withhold(candidate, read_blockers) {
-  try {
-    return await read_blockers(candidate);
-  } catch (error) {
-    const reason = error_text.message_of(error);
-    console.warn(
-      `\u26A0 could not confirm the blockers of ${session_cite.issue(candidate.number, void 0, candidate.repo)}: ${reason}
-  it is withheld rather than offered; asking again is what resolves this`
-    );
-    return void 0;
-  }
-}
-function warn_withheld(candidate, listed) {
-  const named = listed.map((blocker) => epic_graph.key_of(blocker)).join(", ");
-  console.warn(
-    `\u26A0 ${session_cite.issue(candidate.number, void 0, candidate.repo)} is withheld: its relations listing names ${named}, which the dependency summary it was classified from did not count`
-  );
-}
-function untracked_blockers(listed, children) {
-  const index = epic_graph.index_children(children);
-  return listed.filter((blocker) => !index.has(epic_graph.blocker_key(blocker)));
-}
-function warn_untracked(candidate, untracked) {
-  const named = untracked.map((blocker) => epic_graph.key_of(blocker)).join(", ");
-  console.warn(
-    `\u26A0 ${session_cite.issue(candidate.number, void 0, candidate.repo)} is offered although its relations listing names ${named}: this epic does not track those, and every one of them is already finished`
-  );
-}
-function warn_recovered(candidate, listed, children, is_confirmed) {
-  if (!is_confirmed) {
-    warn_withheld(candidate, listed);
-    return;
-  }
-  const untracked = untracked_blockers(listed, children);
-  if (untracked.length > 0) warn_untracked(candidate, untracked);
-}
-async function confirm_one(candidate, context) {
-  const listed = await read_or_withhold(candidate, context.read_blockers);
-  if (listed === void 0) return { is_confirmed: false, children: context.children };
-  if (is_same_blockers(candidate.blocked_by, listed)) {
-    return { is_confirmed: true, children: context.children };
-  }
-  const children = with_blockers(context.children, candidate, listed);
-  const is_confirmed = is_still_runnable(candidate, children, context);
-  warn_recovered(candidate, listed, children, is_confirmed);
-  return { is_confirmed, children };
-}
-async function confirm_candidates(candidates, context, wanted) {
-  const [candidate, ...rest] = candidates;
-  if (candidate === void 0 || wanted <= NO_LANES) {
-    return { children: context.children, confirmed: [] };
-  }
-  const verdict = await confirm_one(candidate, context);
-  const taken = verdict.is_confirmed ? [candidate] : [];
-  const next = { ...context, children: verdict.children };
-  const walk = await confirm_candidates(rest, next, wanted - taken.length);
-  return { children: walk.children, confirmed: [...taken, ...walk.confirmed] };
-}
-function withheld_verdict(children, context) {
-  return epic_report.decide_verdict(
-    epic_classify.classify_children(children, context.resolve, context.running),
-    NO_ANOMALIES
-  );
-}
-async function answer_for_repo(candidates, context, wanted = ONE_LANE) {
-  const outcome = await confirm_candidates(candidates, context, wanted);
-  if (outcome.confirmed.length > NO_LANES) return { children: outcome.confirmed, verdict: "run" };
-  return { children: [], verdict: withheld_verdict(outcome.children, context) };
-}
-var epic_candidate_confirm = {
-  is_same_blockers,
-  answer_for_repo
-};
-
-// scripts/backlog/backlog-occupied.ts
-function is_never_merge_waiting() {
-  return false;
-}
-function occupied_lanes(lanes, idle, records, is_merge_waiting = is_never_merge_waiting) {
-  const live = lanes.filter((lane) => !lane.is_stranded);
-  const idle_issues = new Set(idle(live));
-  return live.filter((lane) => {
-    const state = records.get(lane.issue)?.state;
-    return !idle_issues.has(lane.issue) && state !== "paused" && !is_merge_waiting(lane.issue);
-  });
-}
-function unknown_lanes(lanes, records) {
-  return lanes.filter((lane) => !lane.is_stranded && !records.has(lane.issue)).map((lane) => lane.issue);
-}
-var backlog_occupied = { occupied_lanes, unknown_lanes };
-
-// scripts/lane/lane-room.ts
-async function occupancy_of(open, table) {
-  const rows = await table();
-  const issues = open.map((lane) => lane.issue);
-  const trace = { process_trace: await lane_snapshot_trace.traces_of(issues, rows) };
-  const records = await lane_state.read_states(issues);
-  const is_merge_waiting = await lane_snapshot_trace.merge_waits_of(issues, rows);
-  const occupied = backlog_occupied.occupied_lanes(
-    open,
-    (live) => lane_spent.idle_lanes(live, trace),
-    records,
-    is_merge_waiting
-  );
-  const unknown = backlog_occupied.unknown_lanes(open, records);
-  return { occupied, idle: lane_spent.idle_lanes(open, trace), unknown };
-}
-async function read(lanes, table = lane_process_table.read_table) {
-  const open = lanes ?? await lane_registry.list_lanes();
-  const occupancy = await occupancy_of(open, table);
-  const seated = lane_registry.used_seats(open).length;
-  const use = { occupied: occupancy.occupied.length, seated, unknown: occupancy.unknown };
-  return { ...occupancy, use };
-}
-var lane_room = { read };
-
-// scripts/epic/epic-lane-occupancy.ts
-var SOLO_LABELS = /* @__PURE__ */ new Set([RUN_SOLO_LABEL]);
-function is_local(issue, lanes) {
-  return lanes.some((lane) => lane.issue === String(issue.number));
-}
-function confirmed_stopped(lanes, room) {
-  const occupied = new Set(room.occupied.map((lane) => lane.issue));
-  return new Set(
-    lanes.filter((lane) => !lane.seat_held && lane.seat_problem === void 0).map((lane) => lane.issue).filter(
-      (issue) => room.idle.includes(issue) && !room.unknown.includes(issue) && !occupied.has(issue)
-    )
-  );
-}
-function reconcile(issues, lanes, room) {
-  const stopped = confirmed_stopped(lanes, room);
-  const holders = issues.filter(
-    (issue) => has_any_label(issue.labels, SOLO_LABELS) || !stopped.has(String(issue.number))
-  );
-  const remote = holders.filter((issue) => !is_local(issue, lanes)).length;
-  const occupied = new Set(room.occupied.map((lane) => lane.issue));
-  const unknown = holders.filter(
-    (issue) => room.unknown.includes(String(issue.number)) && !occupied.has(String(issue.number))
-  ).length;
-  const use = {
-    ...room.use,
-    occupied: room.use.occupied + remote + unknown,
-    seated: room.use.seated + remote
-  };
-  return { read: holders.length > 0 ? { kind: "busy", issues: holders } : { kind: "idle" }, use };
-}
-async function read2(reading, is_this_checkout) {
-  if (!is_this_checkout || reading.kind !== "busy") return { read: reading };
-  try {
-    const lanes = await lane_registry.list_lanes();
-    if (reading.issues.every((issue) => !is_local(issue, lanes))) return { read: reading };
-    return reconcile(reading.issues, lanes, await lane_room.read(lanes));
-  } catch {
-    return { read: reading };
-  }
-}
-var epic_lane_occupancy = { read: read2 };
-
-// scripts/epic/epic-rank.ts
-var CLOSED3 = "CLOSED";
-function dependents_of(pool) {
-  return issue_rank.count_dependents(
-    pool.filter((child) => child.state !== CLOSED3).map((child) => ({
-      key: epic_graph.key_of(child),
-      blockers: child.blocked_by.map((blocker) => epic_graph.blocker_key(blocker))
-    }))
-  );
-}
-function rank(children, pool) {
-  const dependents = dependents_of(pool);
-  return issue_rank.rank(children, (child) => ({
-    is_resumable: child.is_resumable,
-    is_last: issue_priority.is_last(child.body),
-    labels: child.labels,
-    lost_minutes: issue_priority.lost_minutes(child.body),
-    gain_minutes: expected_effect_lint.weekly_minutes(child.body),
-    dependents: dependents.get(epic_graph.key_of(child)) ?? 0,
-    estimated_lines: size_estimate.declared_size(child.body ?? "")?.lines
-  }));
-}
-var epic_rank = { rank };
-
-// scripts/epic/epic-solo.ts
-function is_solo(child) {
-  return has_label_name(child.labels, RUN_SOLO_LABEL);
-}
-function holder_of(running) {
-  return running.find((issue) => is_solo(issue))?.number;
-}
-function solo_holder(read3) {
-  if (read3.kind !== "busy") return void 0;
-  const running = read3.issues.map((issue) => ({
-    number: issue.number,
-    labels: (issue.labels ?? []).map((label) => label.name)
-  }));
-  return holder_of(running);
-}
-var HELD_MARK = `carries \`${RUN_SOLO_LABEL}\` and is running in`;
-var WAITING_MARK = `carries \`${RUN_SOLO_LABEL}\` and waits for`;
-function held_message(holder, repo) {
-  return issue_citation.linkify(
-    `${issue_cite.plain_for("linked", holder)} ${HELD_MARK} ${repo}; nothing else starts until it merges or is parked.`,
-    repo
-  );
-}
-function waiting_message(solo, repo) {
-  return issue_citation.linkify(
-    `${issue_cite.plain_for("linked", solo)} ${WAITING_MARK} ${repo}'s running lanes to finish; nothing ranked below it is offered past it.`,
-    repo
-  );
-}
-function is_solo_wait(text) {
-  return text.includes(HELD_MARK) || text.includes(WAITING_MARK);
-}
-function first_of(children, keep) {
-  return { offered: children.slice(0, keep), withheld: children.slice(keep) };
-}
-function none_of(children, notice) {
-  return { offered: [], withheld: [...children], notice };
-}
-function queue_of(children) {
-  const index = children.findIndex((child) => is_solo(child));
-  const solo = children[index];
-  return solo === void 0 ? void 0 : { solo, index, behind: children.slice(index + 1) };
-}
-function select_candidates(children, read3, repo, occupied) {
-  const queue = queue_of(children);
-  if (queue === void 0) return first_of(children, children.length);
-  if (queue.index > 0) return first_of(children, queue.index);
-  if (occupied === 0 && read3.kind === "idle") return first_of(children, 1);
-  return none_of(children, waiting_message(queue.solo.number, repo));
-}
-function select(children, read3, repo, occupied = epic_busy.occupied_lanes(read3)) {
-  if (read3.kind === "unreadable" || read3.kind === "truncated") {
-    return none_of(children, epic_busy.busy_reason(read3, repo, 0));
-  }
-  const holder = solo_holder(read3);
-  if (holder !== void 0) return none_of(children, held_message(holder, repo));
-  return select_candidates(children, read3, repo, occupied);
-}
-function withhold(result, repo, selection) {
-  return {
-    ...result,
-    candidates: result.candidates.map(
-      (bundle) => bundle.repo === repo ? { ...bundle, children: selection.offered } : bundle
-    ),
-    waiting: [...result.waiting, ...selection.withheld]
-  };
-}
-function gate(result, read3, repo, selector = select) {
-  if (result.verdict !== "run") return { result };
-  const selection = selector(epic_report.candidates_for_repo(result, repo), read3, repo);
-  const gated = withhold(result, repo, selection);
-  return selection.notice === void 0 ? { result: gated } : { result: gated, notice: selection.notice };
-}
-var epic_solo = { gate, holder_of, is_solo, is_solo_wait, queue_of, select };
-
-// scripts/epic/epic-solo-stale.ts
-import { setTimeout as sleep } from "node:timers/promises";
-var SOLO_LABELS2 = /* @__PURE__ */ new Set([RUN_SOLO_LABEL]);
-function is_absent_solo(issue) {
-  if (!has_any_label(issue.labels, SOLO_LABELS2)) return false;
-  return !lane_await.is_process_running_default(String(issue.number));
-}
-async function local_lanes() {
-  try {
-    const lanes = await lane_registry.list_lanes();
-    return new Set(lanes.map((lane) => lane.issue));
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-async function settle() {
-  await sleep(lane_await.RECONFIRM_MS);
-}
-var io = { local_lanes, settle };
-async function find_stale(issues) {
-  const absent = issues.filter((issue) => is_absent_solo(issue));
-  if (absent.length === 0) return [];
-  const lanes = await io.local_lanes();
-  const dispatched = absent.filter((issue) => lanes.has(String(issue.number)));
-  if (dispatched.length === 0) return [];
-  await io.settle();
-  return dispatched.filter((issue) => is_absent_solo(issue));
-}
-function stale_message(stale, repo) {
-  const named = stale.map((issue) => issue_cite.plain_for("linked", issue.number)).join(", ");
-  return issue_citation.linkify(
-    `${named} carries \`${RUN_SOLO_LABEL}\` and \`${IN_PROGRESS_LABEL}\`, but no process of it is running in ${repo} \u2014 the \`${IN_PROGRESS_LABEL}\` label is stale, so it does not hold the backlog. Remove the label once you have confirmed nothing is running it.`,
-    repo
-  );
-}
-async function release(read3, repo) {
-  if (read3.kind !== "busy") return { read: read3 };
-  const stale = await find_stale(read3.issues);
-  if (stale.length === 0) return { read: read3 };
-  const holders = read3.issues.filter((issue) => !stale.includes(issue));
-  const released = holders.length > 0 ? { kind: "busy", issues: holders } : { kind: "idle" };
-  return { read: released, notice: stale_message(stale, repo) };
-}
-var epic_solo_stale = { io, release };
-
-// scripts/epic/epic-lane-offer.ts
-var WAIT_VERDICT = "wait";
-var RUN_VERDICT = "run";
-var NO_LANES2 = 0;
-var ONE_LANE2 = 1;
-function is_held(read3) {
-  return read3.kind === "unreadable" || read3.kind === "truncated";
-}
-function free_lanes(read3, limit, merge_waiting) {
-  if (is_held(read3)) return NO_LANES2;
-  const holders = epic_busy.occupied_lanes(read3);
-  return lane_capacity.free_lanes(limit, holders - merge_waiting, holders);
-}
-async function merge_waiting_holders(read3, request) {
-  if (read3.kind !== "busy" || !request.is_this_checkout) return NO_LANES2;
-  return await lane_snapshot_trace.count_merge_waiting(
-    read3.issues.map((issue) => String(issue.number))
-  );
-}
-async function room_in(occupancy, request) {
-  if (occupancy.use !== void 0) {
-    return lane_capacity.free_lanes(request.limit, occupancy.use.occupied, occupancy.use.seated);
-  }
-  return free_lanes(
-    occupancy.read,
-    request.limit,
-    await merge_waiting_holders(occupancy.read, request)
-  );
-}
-function wanted_of(request, free) {
-  return request.is_all_lanes ? free : Math.min(ONE_LANE2, free);
-}
-function withheld_message(repo) {
-  return `No runnable child in ${repo}: every candidate was withheld when its blocker relations were confirmed \u2014 the reason for each is above.`;
-}
-function offered_notice(children, read3, request, ages) {
-  if (children.length === NO_LANES2) return withheld_message(request.repo);
-  if (read3.kind !== "busy") return "";
-  return epic_busy.occupancy_message(read3.issues, request.repo, request.limit, ages);
-}
-async function holder_ages(read3, repo) {
-  if (read3.kind !== "busy") return /* @__PURE__ */ new Map();
-  return await epic_label_age.read_ages(
-    read3.issues.map((issue) => issue.number),
-    repo,
-    /* @__PURE__ */ new Date()
-  );
-}
-var VERDICT_PRIORITY = [RUN_VERDICT, WAIT_VERDICT, "stop", "complete"];
-function combine_verdicts(left, right) {
-  return VERDICT_PRIORITY.indexOf(left) <= VERDICT_PRIORITY.indexOf(right) ? left : right;
-}
-function candidates_in(pool, repo) {
-  return { ...pool, candidates: pool.candidates.filter((child) => child.repo === repo) };
-}
-function ranked_in(pool, repo) {
-  const scoped = candidates_in(pool, repo);
-  return { ...scoped, candidates: epic_rank.rank(scoped.candidates, pool.context.children) };
-}
-function unseen_candidates(pool, seen) {
-  const candidates = [];
-  for (const child of pool.candidates) {
-    const key = epic_graph.key_of(child);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    candidates.push(child);
-  }
-  return { ...pool, candidates };
-}
-function dedupe_pools(pools) {
-  const seen = /* @__PURE__ */ new Set();
-  return pools.map((pool) => unseen_candidates(pool, seen));
-}
-async function ask_pool(pool, wanted) {
-  return await epic_candidate_confirm.answer_for_repo(pool.candidates, pool.context, wanted);
-}
-async function collect(pools, wanted) {
-  const children = [];
-  let verdict = "complete";
-  for (const pool of pools) {
-    if (children.length >= wanted) break;
-    const answer = await ask_pool(pool, wanted - children.length);
-    children.push(...answer.children);
-    verdict = combine_verdicts(verdict, answer.verdict);
-  }
-  return { children, verdict: children.length > NO_LANES2 ? RUN_VERDICT : verdict };
-}
-function solo_offer(answer, occupancy, request, ages) {
-  const { read: read3, use } = occupancy;
-  const { offered, notice = "" } = epic_solo.select(
-    answer.children,
-    read3,
-    request.repo,
-    use?.occupied
-  );
-  if (offered.length === NO_LANES2 && answer.children.length > NO_LANES2) {
-    return { children: [], verdict: WAIT_VERDICT, notice };
-  }
-  return { ...answer, children: offered, notice: offered_notice(offered, read3, request, ages) };
-}
-function triage_offer(pools, request) {
-  if (!request.is_all_lanes) return void 0;
-  const untriaged = epic_triage.untriaged(
-    dedupe_pools(pools.map((pool) => candidates_in(pool, request.repo))).flatMap(
-      (pool) => pool.candidates
-    )
-  );
-  if (untriaged.length === NO_LANES2) return void 0;
-  return {
-    children: [],
-    verdict: epic_triage.TRIAGE_VERDICT,
-    notice: epic_triage.message(untriaged, request.repo)
-  };
-}
-function full_notice(occupancy, request, ages) {
-  if (occupancy.use === void 0) {
-    return epic_busy.busy_reason(occupancy.read, request.repo, request.limit, ages);
-  }
-  return `${String(occupancy.use.occupied)} of ${String(request.limit)} lanes in use in ${request.repo}; ${String(occupancy.use.seated)} port seats held. No lane is free, so nothing is offered here.`;
-}
-async function offer_after_triage(pools, request) {
-  const released = await epic_solo_stale.release(
-    await epic_busy.read_repository(request.repo),
-    request.repo
-  );
-  if (released.notice !== void 0) console.error(released.notice);
-  const occupancy = await epic_lane_occupancy.read(released.read, request.is_this_checkout);
-  const { read: read3 } = occupancy;
-  const free = await room_in(occupancy, request);
-  const ages = await holder_ages(read3, request.repo);
-  if (free === NO_LANES2) {
-    return {
-      children: [],
-      verdict: WAIT_VERDICT,
-      notice: full_notice(occupancy, request, ages)
-    };
-  }
-  const for_repo = dedupe_pools(pools.map((pool) => ranked_in(pool, request.repo)));
-  return solo_offer(await collect(for_repo, wanted_of(request, free)), occupancy, request, ages);
-}
-async function offer_for_repo(pools, request) {
-  return triage_offer(pools, request) ?? await offer_after_triage(pools, request);
-}
-function lane_request(asked, limit, current_repo) {
-  const is_this_checkout = asked.repo.toLowerCase() === current_repo.toLowerCase();
-  return { ...asked, limit, is_this_checkout };
-}
-var epic_lane_offer = {
-  combine_verdicts,
-  dedupe_pools,
-  lane_request,
-  offer_for_repo
-};
-
-// scripts/epic/epic-next-read.ts
-var FOREIGN_EPIC = "That epic belongs to another owner; this command only reads our own.";
-var NO_CHILDREN = 0;
-function epic_repo_of(reference, current_repo) {
-  const epic_repo = reference.repo ?? current_repo;
-  const owner = epic_cross_repo.owner_of(current_repo);
-  return epic_cross_repo.is_same_owner_repo(epic_repo, owner) ? epic_repo : void 0;
-}
-function childless(reference) {
-  return `${session_cite.issue(reference.number, void 0, reference.repo)} tracks no children in a task list.`;
-}
-function unique_references(references, current_repo) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const reference of references) {
-    const repo = reference.repo ?? current_repo;
-    const key = epic_graph.key_of({ repo, number: reference.number });
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(reference);
-  }
-  return unique;
-}
-function is_childless(snapshot) {
-  if (snapshot.body_failure !== void 0) return false;
-  return snapshot.child_numbers.length === NO_CHILDREN;
-}
-async function read_one(reference, current_repo, source) {
-  const epic_repo = epic_repo_of(reference, current_repo);
-  if (epic_repo === void 0) return { refusal: FOREIGN_EPIC };
-  const snapshot = await epic_fetch.fetch_epic(reference.number, epic_repo, current_repo, source);
-  if (is_childless(snapshot)) return { notice: childless(reference) };
-  return { read: { reference, snapshot } };
-}
-function collect2(outcome, reads, notices) {
-  if (outcome.read !== void 0) reads.push(outcome.read);
-  if (outcome.notice !== void 0) notices.push(outcome.notice);
-}
-async function read_snapshots(references, current_repo, source) {
-  const reads = [];
-  const notices = [];
-  for (const reference of unique_references(references, current_repo)) {
-    const outcome = await read_one(reference, current_repo, source);
-    if (outcome.refusal !== void 0) return { reads, notices, refusal: outcome.refusal };
-    collect2(outcome, reads, notices);
-  }
-  return { reads, notices };
-}
-var epic_next_read = {
-  FOREIGN_EPIC,
-  childless,
-  unique_references,
-  read_snapshots
-};
-
-// scripts/epic/epic-next-views.ts
-var COMPLETE_VERDICT = "complete";
-var ERROR_VERDICT = "error";
-var ONE_EPIC = 1;
-var BLOCK_SEPARATOR = "\n\n";
-function format_reference(reference) {
-  return issue_cite.plain_for("linked", reference.number, reference.repo);
-}
-function confirm_context(snapshot, running) {
-  return {
-    children: snapshot.children,
-    running,
-    resolve: epic_cross_repo.resolve_cross_repo,
-    read_blockers: async (child) => await epic_fetch.read_child_blockers(child, snapshot.current_repo)
-  };
-}
-function pools_of(views, repo) {
-  return views.map((view) => ({
-    candidates: epic_report.candidates_for_repo(view.result, repo),
-    context: confirm_context(view.snapshot, view.running)
-  }));
-}
-function combined_verdict(views) {
-  let verdict = COMPLETE_VERDICT;
-  for (const view of views) verdict = epic_lane_offer.combine_verdicts(verdict, view.result.verdict);
-  return verdict;
-}
-function error_view(views) {
-  return views.find((view) => view.result.verdict === ERROR_VERDICT);
-}
-function format_view(view, is_many, current_repo) {
-  const text = epic_report.format_result(view.result, current_repo);
-  return is_many ? `${format_reference(view.reference)}
-${text}` : text;
-}
-function aggregate_text(views, current_repo) {
-  const is_many = views.length > ONE_EPIC;
-  return views.map((view) => format_view(view, is_many, current_repo)).join(BLOCK_SEPARATOR);
-}
-function settle_views(running, build) {
-  const views = build(running);
-  const stuck = new Set(
-    views.flatMap((view) => view.result.blocked_on_people.map((child) => epic_graph.key_of(child)))
-  );
-  const settled = new Set(running);
-  for (const key of stuck) settled.delete(key);
-  return settled.size === running.size ? views : settle_views(settled, build);
-}
-var epic_next_views = {
-  settle_views,
-  format_reference,
-  pools_of,
-  combined_verdict,
-  error_view,
-  format_view,
-  aggregate_text
-};
-
-// scripts/epic/epic-next.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var OPTIONS = { repo: { type: "string" }, lanes: { type: "boolean" } };
-var USAGE = "Usage: josh epic:next <epic-number|owner/repo#number>... [--repo <owner/repo>] [--lanes]";
-var UNKNOWN_REPO = "Could not read this repository from `git remote`, so the children cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
-var EXTERNAL_NOTICE = "Note: this epic tracks children in other repositories.";
-var { FOREIGN_EPIC: FOREIGN_EPIC2 } = epic_next_read;
-var NO_CHILDREN2 = 0;
-var ONE_EPIC2 = 1;
-var UNCHECKED_EXCLUSION = "Note: the per-repository lane count is applied by `--repo`; a child listed here may still be held back there while every lane is in use.";
-function parse_references(head) {
-  const references = [];
-  for (const entry of head) {
-    const reference = epic_issue.parse_epic_reference(entry);
-    if (reference === void 0) return void 0;
-    references.push(reference);
-  }
-  return references.length === 0 ? void 0 : references;
-}
-function with_repo(references, values) {
-  const { repo, lanes: is_all_lanes = false } = values;
-  if (repo === void 0) return is_all_lanes ? { usage: USAGE } : { references };
-  return { references, repo, is_all_lanes };
-}
-function parse_options(argv) {
-  const parsed = cli_flags.arguments_of(argv, OPTIONS);
-  if (parsed === void 0) return { usage: USAGE };
-  const references = parse_references(parsed.positionals);
-  if (references === void 0 || parsed.values.repo === "") return { usage: USAGE };
-  return with_repo(references, parsed.values);
-}
-function body_anomaly(snapshot) {
-  if (snapshot.body_failure === void 0) return void 0;
-  return {
-    kind: "unreadable_epic_body",
-    message: `Could not read the body of the epic in ${snapshot.repo}. Its task list is what names the children, so nothing is offered \u2014 check \`gh auth status\` and that the epic exists.`,
-    is_unreachable: snapshot.is_unreachable
-  };
-}
-function unreadable_anomaly(snapshot) {
-  const missing = epic_fetch.missing_children(snapshot);
-  if (missing.length === 0) return void 0;
-  const list = epic_graph.format_references(missing, snapshot.current_repo);
-  return {
-    kind: "unreadable_children",
-    message: `Could not read ${list}. The dependency graph would be missing them, so nothing is offered \u2014 check \`gh auth status\` and that the issues exist.`,
-    is_unreachable: snapshot.is_unreachable
-  };
-}
-function is_order_declared(body, links) {
-  return links.length > 0 || epic_parse.has_unordered_declaration(body);
-}
-function decide(snapshot, paths = /* @__PURE__ */ new Map(), running) {
-  const links = epic_parse.parse_dependency_links(snapshot.body);
-  const unreadable = body_anomaly(snapshot) ?? unreadable_anomaly(snapshot);
-  const anomalies = unreadable === void 0 ? epic_graph.find_anomalies(
-    snapshot.children,
-    links,
-    is_order_declared(snapshot.body, links),
-    snapshot.repo
-  ) : [unreadable];
-  const classification = epic_classify.classify_children(
-    snapshot.children,
-    epic_cross_repo.resolve_cross_repo,
-    running
-  );
-  return epic_report.build_result(classification, anomalies, paths);
-}
-function refuse(reason) {
-  console.error(reason);
-  return FAILURE_EXIT_CODE;
-}
-function repo_verdict(verdict) {
-  return verdict === "run" ? "wait" : verdict;
-}
-function report_offer(offer) {
-  if (offer.notice !== "") console.error(offer.notice);
-  if (offer.children.length === NO_CHILDREN2) {
-    console.info(repo_verdict(offer.verdict));
-    return SUCCESS_EXIT_CODE;
-  }
-  for (const child of offer.children) console.info(String(child.number));
-  return SUCCESS_EXIT_CODE;
-}
-async function offer_children(views, request) {
-  const pools = epic_next_views.pools_of(views, request.repo);
-  return report_offer(await epic_lane_offer.offer_for_repo(pools, request));
-}
-async function report_single(views, request) {
-  const broken = epic_next_views.error_view(views);
-  if (broken !== void 0) {
-    return refuse(epic_next_views.format_view(broken, views.length > ONE_EPIC2, request.repo));
-  }
-  const has_candidate = views.some(
-    (view) => epic_report.candidates_for_repo(view.result, request.repo).length > NO_CHILDREN2
-  );
-  if (!has_candidate) {
-    console.error(`No runnable child in ${request.repo}.`);
-    console.info(repo_verdict(epic_next_views.combined_verdict(views)));
-    return SUCCESS_EXIT_CODE;
-  }
-  return await offer_children(views, request);
-}
-function note_unchecked_exclusion(views) {
-  if (epic_next_views.combined_verdict(views) === "run") console.error(UNCHECKED_EXCLUSION);
-}
-function report_aggregate(views, current_repo) {
-  note_unchecked_exclusion(views);
-  const text = epic_next_views.aggregate_text(views, current_repo);
-  if (epic_next_views.error_view(views) !== void 0) {
-    console.error(text);
-    return FAILURE_EXIT_CODE;
-  }
-  console.info(issue_citation.linkify(text, current_repo));
-  return SUCCESS_EXIT_CODE;
-}
-function external_notice(view, is_many) {
-  return is_many ? `${epic_next_views.format_reference(view.reference)} ${EXTERNAL_NOTICE}` : EXTERNAL_NOTICE;
-}
-function note_external(views) {
-  const is_many = views.length > ONE_EPIC2;
-  for (const view of views) {
-    if (view.snapshot.has_external_children) console.error(external_notice(view, is_many));
-  }
-}
-async function report(views, request, current_repo) {
-  note_external(views);
-  if (request !== void 0) return await report_single(views, request);
-  return report_aggregate(views, current_repo);
-}
-async function report_epics(views, options, current_repo) {
-  if (options.repo === void 0) return await report(views, void 0, current_repo);
-  const choice = await lane_capacity.lane_limit();
-  if (choice.kind === "problem") return refuse(choice.problem);
-  const request = epic_lane_offer.lane_request(
-    { repo: options.repo, is_all_lanes: options.is_all_lanes ?? false },
-    choice.limit,
-    current_repo
-  );
-  return await report(views, request, current_repo);
-}
-function views_of(reads, running = epic_outside_blocker.running_keys(reads.flatMap((read3) => read3.snapshot.children))) {
-  const paths = repo_discovery.discover_repositories(PROJECT_ROOT);
-  epic_cross_repo.reset_publish_cache();
-  epic_classify.reset_reported();
-  return epic_next_views.settle_views(
-    running,
-    (settled) => reads.map((read3) => ({
-      ...read3,
-      running: settled,
-      result: decide(read3.snapshot, paths, settled)
-    }))
-  );
-}
-function refuse_reads(result) {
-  if (result.refusal !== void 0) return refuse(result.refusal);
-  if (result.reads.length === NO_CHILDREN2) return refuse(result.notices.join("\n"));
-  for (const notice of result.notices) console.error(notice);
-  return void 0;
-}
-async function run_epics(options) {
-  const references = options.references ?? [];
-  if (references.length === NO_CHILDREN2) return refuse(USAGE);
-  const current_repo = await git_gh_command.repo_get_name_with_owner();
-  if (current_repo === void 0) return refuse(UNKNOWN_REPO);
-  const result = await epic_next_read.read_snapshots(references, current_repo);
-  const stopped = refuse_reads(result);
-  return stopped ?? await report_epics(views_of(result.reads), options, current_repo);
-}
-async function run(argv) {
-  const options = parse_options(argv);
-  if (options.references === void 0) {
-    console.error(options.usage ?? USAGE);
-    return FAILURE_EXIT_CODE;
-  }
-  return await run_epics(options);
-}
-var epic_next = {
-  EXTERNAL_NOTICE,
-  FOREIGN_EPIC: FOREIGN_EPIC2,
-  is_order_declared,
-  repo_verdict,
-  UNCHECKED_EXCLUSION,
-  parse_options,
-  refuse_reads,
-  views_of,
-  run,
-  run_epics,
-  decide,
-  report
-};
-
-export {
-  lane_room,
-  epic_nested,
-  epic_outside_blocker,
-  epic_classify,
-  epic_report,
-  epic_rank,
-  epic_solo,
-  epic_solo_stale,
-  epic_next_read,
-  epic_next
-};