@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-4DN4XVPL.js

@@ -1,716 +0,0 @@
-import {
-  run_merge_token
-} from "./chunk-FHFWNNUC.js";
-import {
-  backlog_named
-} from "./chunk-ZYGOZT4J.js";
-import {
-  lane_parked
-} from "./chunk-FWU3H4TX.js";
-import {
-  backlog_hold_codes
-} from "./chunk-ZAAHZY2A.js";
-import {
-  backlog_drive_restore
-} from "./chunk-TFLHYC2F.js";
-import {
-  run_event_setup
-} from "./chunk-I2KCGKJI.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-import {
-  machine_capacity
-} from "./chunk-KXHXMERX.js";
-import {
-  figure_format
-} from "./chunk-ZZXO6TFH.js";
-import {
-  ALREADY_DONE_LABEL,
-  NEEDS_DECISION_LABEL,
-  NEEDS_HUMAN_MERGE_LABEL,
-  NEEDS_HUMAN_REVIEW_LABEL,
-  RUN_STALLED_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  run_carry,
-  run_carry_added,
-  run_invocation
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  MS_PER_MINUTE,
-  MS_PER_SECOND,
-  SECONDS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/backlog/backlog-drive-named.ts
-var { MERGE_TOKEN } = run_merge_token;
-var NO_RETRIES = 0;
-var TERMINAL_OUTCOMES = /* @__PURE__ */ new Set([
-  "merged",
-  "parked",
-  "human-review",
-  "split",
-  "withdrawn"
-]);
-function is_declared(carry, issue) {
-  return run_invocation.issue_numbers(carry.invocation)?.includes(Number(issue)) === true;
-}
-function is_held(carry, in_flight, issue) {
-  return !in_flight.includes(String(issue)) || is_declared(carry, String(issue));
-}
-function next_of(carry, in_flight) {
-  const remaining = run_carry.remaining_of(carry) ?? [];
-  return remaining.find((issue) => is_held(carry, in_flight, issue));
-}
-function held_after(carry, in_flight, issue) {
-  const next = next_of(carry, in_flight);
-  if (next === void 0 || in_flight.includes(String(issue))) return void 0;
-  const declared = (run_carry.remaining_of(carry) ?? []).filter(
-    (number) => is_declared(carry, String(number))
-  );
-  const index = declared.indexOf(issue);
-  return index > declared.indexOf(next) ? declared[index - 1] : void 0;
-}
-function only_end(state) {
-  return state.in_flight.length > 0 ? { verdict: "wait", issues: [], retries: NO_RETRIES } : { verdict: "stop", issues: [], retries: NO_RETRIES, reason: "only", is_finish: true };
-}
-function offer(carry, state, is_only) {
-  const next = next_of(carry, state.in_flight);
-  if (next !== void 0) {
-    const issue = String(next);
-    return state.in_flight.includes(issue) ? { verdict: "wait", issues: [], retries: NO_RETRIES } : { verdict: "run", issues: [issue], retries: NO_RETRIES };
-  }
-  return is_only ? only_end(state) : void 0;
-}
-function is_done(result) {
-  if (TERMINAL_OUTCOMES.has(result.outcome)) {
-    return result.code === 0 && result.token !== MERGE_TOKEN.BUSY;
-  }
-  return result.outcome === "failed" && result.code === 0 && !run_merge_token.is_control_stop(result);
-}
-function can_mark(carry, issue, owner) {
-  const is_named = run_carry.remaining_of(carry)?.includes(Number(issue)) === true;
-  const is_owned = !run_carry.is_count_refused(carry, run_carry.owner_of(Number(owner)));
-  return is_named && is_owned;
-}
-function mark_one(target, issue, owner) {
-  const read = run_carry.read_carry(target);
-  if (read.kind !== "carried" || !can_mark(read.carry, issue, owner)) return false;
-  run_carry.apply_change(target, read.carry, { done: Number(issue) });
-  return true;
-}
-function skipped_of(carry, issue) {
-  if (!is_declared(carry, issue)) return [];
-  const remaining = run_carry.remaining_of({ ...carry, added: void 0 }) ?? [];
-  const named = [
-    { issue: Number(issue), is_epic: false },
-    ...remaining.map((number) => ({ issue: number, is_epic: false }))
-  ];
-  return backlog_named.after_failure(named, Number(issue)).skipped;
-}
-function skip_after_failure(target, issue, owner) {
-  const read = run_carry.read_carry(target);
-  if (read.kind !== "carried") return;
-  for (const number of skipped_of(read.carry, issue)) {
-    if (!mark_one(target, String(number), owner)) return;
-  }
-}
-async function should_skip(issue, outcome) {
-  if (outcome === "failed") return true;
-  if (outcome !== "parked") return false;
-  return await lane_parked.is_parked(issue);
-}
-async function carry_target() {
-  const directory = await run_carry.repository_directory();
-  return directory === void 0 ? void 0 : run_carry.carry_path(directory);
-}
-async function mark_done(issue, result, owner) {
-  if (!is_done(result)) return;
-  const target = await carry_target();
-  if (target === void 0 || !mark_one(target, issue, owner)) return;
-  if (await should_skip(issue, result.outcome)) skip_after_failure(target, issue, owner);
-}
-async function mark_settled(issue, owner) {
-  const target = await carry_target();
-  if (target !== void 0) mark_one(target, issue, owner);
-}
-async function reconcile(carry, events, owner) {
-  const named = run_carry.remaining_of(carry) ?? [];
-  const settled = backlog_drive_restore.settled_issues(events);
-  const parked = backlog_drive_restore.parked_issues(events);
-  const merged = new Set(carry.merged_issues);
-  const completed = named.filter((issue) => settled.has(issue) || merged.has(issue));
-  for (const issue of completed) {
-    const outcome = parked.has(issue) ? "parked" : "merged";
-    await mark_done(String(issue), { outcome, code: 0, token: "none", is_offer: true }, owner);
-  }
-}
-function named_issues(carry) {
-  return run_carry_added.ordered(run_invocation.issue_numbers(carry.invocation) ?? [], carry.added);
-}
-function own_carried(carry, dispatched, is_only) {
-  if (!is_only) return dispatched;
-  const named = named_issues(carry);
-  return dispatched.filter((issue) => named.includes(Number(issue)));
-}
-var backlog_drive_named = {
-  is_declared,
-  next_of,
-  offer,
-  held_after,
-  mark_done,
-  mark_settled,
-  named_issues,
-  own_carried,
-  reconcile
-};
-
-// scripts/run/board/run-board-labels.ts
-import { WriteStream } from "node:tty";
-import { styleText } from "node:util";
-import cli_spinners from "cli-spinners";
-
-// scripts/run/board/run-board-length.ts
-var MINUTES_PER_HOUR = 60;
-var SPAN_UNITS = { hours: "\xB0", minutes: "\u2032", seconds: "\u2033" };
-var ZERO_SECONDS = `00${SPAN_UNITS.seconds}`;
-var { two_digits } = figure_format;
-function span_fields(ms) {
-  const seconds = Math.floor(Math.max(0, ms) / MS_PER_SECOND);
-  const minutes = Math.floor(seconds / SECONDS_PER_MINUTE);
-  const hours = Math.floor(minutes / MINUTES_PER_HOUR);
-  return [
-    { value: hours, unit: SPAN_UNITS.hours },
-    { value: minutes % MINUTES_PER_HOUR, unit: SPAN_UNITS.minutes },
-    { value: seconds % SECONDS_PER_MINUTE, unit: SPAN_UNITS.seconds }
-  ];
-}
-function span_of(ms) {
-  const fields = span_fields(ms);
-  const lead = fields.findIndex((field, index) => field.value > 0 || index === fields.length - 1);
-  const [first, ...rest] = fields.slice(lead);
-  const head = first === void 0 ? "" : `${String(first.value)}${first.unit}`;
-  return head + rest.map((field) => `${two_digits(field.value)}${field.unit}`).join("");
-}
-function minute_span_of(ms) {
-  const minutes = Math.max(1, Math.ceil(ms / MS_PER_MINUTE));
-  return span_of(minutes * MS_PER_MINUTE).slice(0, -ZERO_SECONDS.length);
-}
-var run_board_length = { minute_span_of, span_of };
-
-// scripts/run/board/run-board-labels.ts
-var BAR_WIDTH = 10;
-var BAR_DONE = "\u25A0";
-var BAR_LEFT = "\u2500";
-var BAR_DONE_COLOR = "cyan";
-var BAR_LEFT_COLOR = "dim";
-var SPINNER_FRAMES = cli_spinners.dots.frames;
-var SPINNER_INTERVAL_MS = cli_spinners.dots.interval;
-var RGB_COLOR_DEPTH = 24;
-var ESC = "\x1B";
-var DEFAULT_FOREGROUND = `${ESC}[39m`;
-var WORDS = {
-  no_run: "no run",
-  plan: "plan",
-  // The reads off this machine — the run's stream, its lanes and the gauges — that last failed.
-  read: "read",
-  merged: "merged",
-  parked: "parked",
-  done: "done",
-  already_done: "already done",
-  withdrawn: "withdrawn",
-  in_progress: "running",
-  stopped: "stopped",
-  paused: "paused",
-  earlier: "earlier run's lane, not counted",
-  unknown: "lane state unknown",
-  waiting: "waiting",
-  queued: "queued",
-  not_before: "not before",
-  decision: "decision",
-  waits: "waits on",
-  // What a waiting row waits on, where the legend names its icon.
-  opening: "opening lane",
-  installing: "installing",
-  dispatching: "dispatching",
-  lane: "free lane",
-  path: "path held",
-  named: "named order",
-  held: "held by triage",
-  headroom: "memory headroom",
-  usage_limit: "usage limit",
-  untriaged: "untriaged",
-  solo: "runs alone",
-  solo_ahead: "behind solo",
-  solo_running: "solo running",
-  // A blocker this run will not finish, which a person has to move (joshuafolkken/kit#4292).
-  on_human: "needs a person",
-  human_merge: "human merge",
-  // A lane held back by the machine-wide core budget, and why.
-  held_check: "held",
-  memory: "waits for memory",
-  cores: "waits for CPU",
-  // How long a lane has run, which the lanes rule's ⏰ stands over.
-  elapsed: "elapsed",
-  investigate: "investigate",
-  implement: "implement",
-  ship: "ship",
-  review: "review",
-  gate: "gate",
-  sync: "sync",
-  commit: "commit",
-  round_two: "round-2",
-  followup: "followup",
-  report: "report",
-  failed: "failed",
-  notes: "findings",
-  more: "more",
-  filed: "filed",
-  filed_run: "filed this run",
-  breaking: "breaking",
-  feature: "feature",
-  fix: "fix",
-  park: "park",
-  note: "note",
-  found_during: " (found during {n})",
-  overrun: "overrun investigation",
-  // What the run is doing now, where no stage of its own says it.
-  watching: "watching",
-  pool_empty: "pool empty",
-  on_person: "waiting on a person",
-  operation: "operation",
-  ended: "ended",
-  estimate: "estimated finish",
-  // The session a stopped run waits in, and what closing the board leaves.
-  resume: "stopped \u2014 resume with",
-  keeps_running: "Closing this screen leaves the run going \xB7 reopen with `pnpm josh backlogrun`"
-};
-var STATE_ICONS = {
-  running: "\u{1F504}",
-  merged: "\u2705",
-  parked: "\u{1F4A4}",
-  done: "\u{1F3C1}",
-  already_done: "\u23E9",
-  waiting: "\u23F3",
-  human: "\u{1F64B}",
-  stopped: "\u{1F6D1}",
-  paused: "\u{1F9CA}",
-  withdrawn: "\u{1F6AB}",
-  unknown: "\u2754"
-};
-var WAITS_ICON = "\u{1F517}";
-var NOT_BEFORE_ICON = "\u{1F4C5}";
-var LANES_ICON = "\u{1F9F5}";
-var PHASE_ICONS = {
-  investigate: "\u{1F50D}",
-  plan: "\u{1F4DD}",
-  implement: "\u{1F528}",
-  ship: "\u{1F6A2}",
-  review: "\u{1F440}",
-  gate: "\u{1F6A6}",
-  sync: "\u{1F500}",
-  commit: "\u{1F4E6}",
-  round_two: "\u{1F502}",
-  followup: "\u2693",
-  report: "\u{1F4E3}",
-  failed: "\u{1F4A5}"
-};
-var PHASE_WORDS = {
-  investigate: "investigate",
-  plan: "plan",
-  implement: "implement",
-  ship: "ship",
-  review: "review",
-  gate: "gate",
-  sync: "sync",
-  commit: "commit",
-  round_two: "round_two",
-  followup: "followup",
-  report: "report",
-  failed: "failed"
-};
-var NOTES_ICON = "\u{1F4CC}";
-var FILED_RUN_MARK = "\u271A";
-var OVERRUN_MARK = PHASE_ICONS.investigate;
-var NOTE_ICONS = {
-  filed: "\u{1F195}",
-  park: STATE_ICONS.parked,
-  note: "\u{1F4AC}"
-};
-var FILED_KIND_ICONS = {
-  "breaking-change": "\u{1F9E8}",
-  bug: "\u{1F41B}",
-  enhancement: "\u2728"
-};
-var KIND_BLANK = "  ";
-var KIND_WORDS = {
-  "breaking-change": "breaking",
-  enhancement: "feature",
-  bug: "fix"
-};
-var HEADER_ICONS = {
-  cpu: "\u{1F4AA}",
-  memory: "\u{1F9E0}",
-  swap: "\u{1F4BE}",
-  ended: "\u{1F51A}",
-  loading: "\u23F3",
-  elapsed: "\u23F0",
-  heartbeat: "\u{1F493}",
-  // A failed plan read: ❗ rather than ⚠, a text symbol drawn two columns wide over the blank after it.
-  warning: "\u2757",
-  // The estimated finish: 🎯 rather than 🏁, a done row's state icon, so the legend names each once
-  // (joshuafolkken/kit#4538).
-  estimate: "\u{1F3AF}"
-};
-var NOW_ICONS = { operation: "\u{1F527}", watching: "\u{1F52D}", ended: HEADER_ICONS.ended };
-var { STAGE, LANE_STAGE } = run_event_setup;
-var LANE_STAGE_ICONS = { opening: "\u{1F6AA}", installing: "\u{1F4E5}", dispatching: "\u{1F4E4}" };
-var STAGE_ICONS = {
-  [STAGE.STARTING]: "\u{1F680}",
-  [STAGE.PLANNING]: "\u{1F4DD}",
-  [STAGE.HANDING_OFF]: "\u{1F91D}",
-  [STAGE.JUDGING]: "\u{1F914}",
-  [STAGE.SESSION]: "\u{1F4AD}",
-  [STAGE.RETROSPECTIVE]: PHASE_ICONS.investigate,
-  [STAGE.NO_CHILD]: "\u{1F6AB}",
-  [LANE_STAGE.OPENING]: LANE_STAGE_ICONS.opening,
-  [LANE_STAGE.INSTALLING]: LANE_STAGE_ICONS.installing,
-  [LANE_STAGE.DISPATCHING]: LANE_STAGE_ICONS.dispatching
-};
-var WAIT_ICONS = {
-  human_merge: "\u{1F50F}",
-  usage_limit: "\u{1FAAB}",
-  path: "\u{1F4C2}",
-  named: "\u{1F4CB}",
-  held: "\u270B",
-  untriaged: "\u2753",
-  solo: "\u{1F9CD}",
-  solo_ahead: "\u{1F645}",
-  solo_running: "\u{1F512}",
-  lane: LANES_ICON,
-  memory: HEADER_ICONS.memory,
-  blocker: WAITS_ICON,
-  not_before: NOT_BEFORE_ICON
-};
-var WAIT_WORDS = [
-  [WAIT_ICONS.human_merge, "human_merge"],
-  [LANE_STAGE_ICONS.opening, "opening"],
-  [LANE_STAGE_ICONS.installing, "installing"],
-  [LANE_STAGE_ICONS.dispatching, "dispatching"],
-  [WAIT_ICONS.lane, "lane"],
-  [WAIT_ICONS.path, "path"],
-  [WAIT_ICONS.named, "named"],
-  [WAIT_ICONS.held, "held"],
-  [WAIT_ICONS.solo, "solo"],
-  [WAIT_ICONS.solo_ahead, "solo_ahead"],
-  [WAIT_ICONS.solo_running, "solo_running"],
-  [WAIT_ICONS.usage_limit, "usage_limit"],
-  [WAIT_ICONS.memory, "headroom"],
-  [WAIT_ICONS.untriaged, "untriaged"],
-  [WAIT_ICONS.blocker, "waits"],
-  [STATE_ICONS.human, "on_human"],
-  [WAIT_ICONS.not_before, "not_before"]
-];
-var GAUGE_SHADES = {
-  normal: { rgb: "48;209;88", named: "green" },
-  yellow: { rgb: "255;214;10", named: "yellow" },
-  red: { rgb: "255;69;58", named: "red" }
-};
-var { two_digits: two_digits2, clock_of, minute_of } = figure_format;
-var { minute_span_of: minute_span_of2, span_of: span_of2 } = run_board_length;
-function day_minute_of(ms) {
-  const date = new Date(ms);
-  const day = [date.getMonth() + 1, date.getDate()].map((value) => two_digits2(value));
-  return `${day.join("-")} ${minute_of(ms)}`;
-}
-function is_shade(color) {
-  return typeof color === "object" && "rgb" in color;
-}
-function shaded(shade, text) {
-  const named = styleText(shade.named, text);
-  if (named === text || WriteStream.prototype.getColorDepth() < RGB_COLOR_DEPTH) return named;
-  return `${ESC}[38;2;${shade.rgb}m${text}${DEFAULT_FOREGROUND}`;
-}
-function painted(color, text) {
-  if (color === void 0 || text === "") return text;
-  return is_shade(color) ? shaded(color, text) : styleText(color, text);
-}
-function bar_of(done, total, width = BAR_WIDTH, color = BAR_DONE_COLOR) {
-  const filled = total === 0 ? 0 : Math.round(Math.min(done, total) / total * width);
-  return painted(color, BAR_DONE.repeat(filled)) + painted(BAR_LEFT_COLOR, BAR_LEFT.repeat(width - filled));
-}
-function spinner_of(now_ms) {
-  const step = Math.floor(Math.max(0, now_ms) / SPINNER_INTERVAL_MS);
-  return SPINNER_FRAMES[step % SPINNER_FRAMES.length] ?? "";
-}
-var run_board_labels = {
-  FILED_KIND_ICONS,
-  FILED_RUN_MARK,
-  GAUGE_SHADES,
-  HEADER_ICONS,
-  KIND_BLANK,
-  KIND_WORDS,
-  NOTES_ICON,
-  NOTE_ICONS,
-  NOW_ICONS,
-  OVERRUN_MARK,
-  PHASE_ICONS,
-  PHASE_WORDS,
-  SPINNER_INTERVAL_MS,
-  STAGE_ICONS,
-  STATE_ICONS,
-  WAITS_ICON,
-  WORDS,
-  bar_of,
-  LANES_ICON,
-  WAIT_ICONS,
-  WAIT_WORDS,
-  clock_of,
-  day_minute_of,
-  minute_of,
-  minute_span_of: minute_span_of2,
-  painted,
-  span_of: span_of2,
-  spinner_of
-};
-
-// scripts/run/board/run-board-machine.ts
-var { GAUGE_SHADES: GAUGE_SHADES2, HEADER_ICONS: HEADER_ICONS2, bar_of: bar_of2, painted: painted2 } = run_board_labels;
-var PERCENT = 100;
-var PERCENT_WIDTH = "100%".length;
-var RATE_WIDTH = "3.1M/s".length;
-var RATE_DECIMAL_BELOW = 10;
-var GAP = "  ";
-var CPU_YELLOW = 70;
-var CPU_RED = 90;
-var MEMORY_YELLOW = 70;
-var MEMORY_RED = 85;
-var SWAP_FULL_MB_PER_S = 20;
-var SWAP_YELLOW_MB_PER_S = 1;
-var SWAP_RED_MB_PER_S = 10;
-var PRESSURE_NORMAL = 1;
-var PRESSURE_WARNING = 2;
-var PRESSURE_CRITICAL = 4;
-var PRESSURE_ALERTS = /* @__PURE__ */ new Map([
-  [PRESSURE_NORMAL, "normal"],
-  [PRESSURE_WARNING, "yellow"],
-  [PRESSURE_CRITICAL, "red"]
-]);
-function percent_text(value) {
-  return `${String(Math.round(value))}%`.padStart(PERCENT_WIDTH);
-}
-function rate_text(value) {
-  const figure = value < RATE_DECIMAL_BELOW ? value.toFixed(1) : String(Math.round(value));
-  return `${figure}M/s`.padStart(RATE_WIDTH);
-}
-var SPECS = {
-  cpu: {
-    icon: HEADER_ICONS2.cpu,
-    normal: GAUGE_SHADES2.normal,
-    full: PERCENT,
-    yellow: CPU_YELLOW,
-    red: CPU_RED,
-    format: percent_text
-  },
-  memory: {
-    icon: HEADER_ICONS2.memory,
-    normal: GAUGE_SHADES2.normal,
-    full: PERCENT,
-    yellow: MEMORY_YELLOW,
-    red: MEMORY_RED,
-    format: percent_text
-  },
-  swap: {
-    icon: HEADER_ICONS2.swap,
-    normal: void 0,
-    full: SWAP_FULL_MB_PER_S,
-    yellow: SWAP_YELLOW_MB_PER_S,
-    red: SWAP_RED_MB_PER_S,
-    format: rate_text
-  }
-};
-function cpu_percent(before, after) {
-  if (before === void 0) return void 0;
-  const share = machine_capacity.busy_share_between(before.sample.cpu, after.sample.cpu);
-  return share === void 0 ? void 0 : share * PERCENT;
-}
-function memory_percent(sample) {
-  const { available_mb } = sample.memory;
-  return available_mb === void 0 ? void 0 : PERCENT - available_mb / sample.total_mb * PERCENT;
-}
-function swap_rate(before, after) {
-  if (before === void 0) return void 0;
-  const swapped = machine_capacity.swapped_between(
-    before.sample.memory.swapped_mb,
-    after.sample.memory.swapped_mb
-  );
-  const seconds = (after.at_ms - before.at_ms) / MS_PER_SECOND;
-  return swapped === void 0 || seconds <= 0 ? void 0 : swapped / seconds;
-}
-function gauges_of(before, after) {
-  return {
-    cpu_percent: cpu_percent(before, after),
-    memory_percent: memory_percent(after.sample),
-    swap_mb_per_s: swap_rate(before, after),
-    memory_pressure: after.sample.memory.pressure_level
-  };
-}
-function threshold_alert(value, spec) {
-  if (value >= spec.red) return "red";
-  return value >= spec.yellow ? "yellow" : "normal";
-}
-function alert_of(spec, value, pressure) {
-  const verdict = pressure === void 0 ? void 0 : PRESSURE_ALERTS.get(pressure);
-  return verdict ?? threshold_alert(value, spec);
-}
-function gauge(spec, reading) {
-  const { value, width } = reading;
-  if (value === void 0) return void 0;
-  const alert = alert_of(spec, value, reading.pressure);
-  const warning = alert === "normal" ? void 0 : GAUGE_SHADES2[alert];
-  const bar = bar_of2(value, spec.full, void 0, warning ?? spec.normal);
-  return `${spec.icon} ${painted2(warning, spec.format(value).padStart(width))} ${bar}`;
-}
-function line_of(gauges, width = 0) {
-  if (gauges === void 0) return void 0;
-  const parts = [
-    gauge(SPECS.cpu, { value: gauges.cpu_percent, width }),
-    gauge(SPECS.memory, { value: gauges.memory_percent, width, pressure: gauges.memory_pressure }),
-    gauge(SPECS.swap, { value: gauges.swap_mb_per_s, width })
-  ].filter((part) => part !== void 0);
-  return parts.length === 0 ? void 0 : parts.join(GAP);
-}
-var run_board_machine = {
-  CPU_YELLOW,
-  GAP,
-  MEMORY_RED,
-  MEMORY_YELLOW,
-  PERCENT_WIDTH,
-  SWAP_RED_MB_PER_S,
-  SWAP_YELLOW_MB_PER_S,
-  gauges_of,
-  line_of,
-  percent_text,
-  rate_text
-};
-
-// scripts/backlog/backlog-drive-memory.ts
-var { MEMORY_RED: MEMORY_RED2, MEMORY_YELLOW: MEMORY_YELLOW2, SWAP_RED_MB_PER_S: SWAP_RED_MB_PER_S2, SWAP_YELLOW_MB_PER_S: SWAP_YELLOW_MB_PER_S2 } = run_board_machine;
-var { PRESSURE_HOLD } = machine_capacity;
-var MIN_RATE_MS = 1e3;
-var HOLD_REASON = backlog_hold_codes.MEMORY_REASON;
-function is_kernel_pressured(gauges) {
-  return (gauges.memory_pressure ?? 0) >= PRESSURE_HOLD;
-}
-function is_stop(gauges) {
-  return is_kernel_pressured(gauges) || (gauges.memory_percent ?? 0) >= MEMORY_RED2 || (gauges.swap_mb_per_s ?? 0) >= SWAP_RED_MB_PER_S2;
-}
-function is_resume(gauges) {
-  return !is_kernel_pressured(gauges) && (gauges.memory_percent ?? 0) < MEMORY_YELLOW2 && (gauges.swap_mb_per_s ?? 0) < SWAP_YELLOW_MB_PER_S2;
-}
-var PRODUCTION = { read: machine_capacity.read_sample, now: Date.now };
-function is_rate_of(last, mark) {
-  return last !== void 0 && mark.at_ms - last.at_ms >= MIN_RATE_MS;
-}
-function rated(memo, mark) {
-  const { last } = memo;
-  const is_rated = is_rate_of(last, mark);
-  if (last === void 0 || is_rated) memo.last = mark;
-  const gauges = run_board_machine.gauges_of(is_rated ? last : void 0, mark);
-  if (is_rated) memo.swap_mb_per_s = gauges.swap_mb_per_s;
-  return { ...gauges, swap_mb_per_s: memo.swap_mb_per_s };
-}
-function gauge2(ports = PRODUCTION) {
-  const memo = { last: void 0, swap_mb_per_s: void 0, is_held: false };
-  return async function memory_held() {
-    const gauges = rated(memo, { sample: await ports.read(), at_ms: ports.now() });
-    memo.is_held = memo.is_held ? !is_resume(gauges) : is_stop(gauges);
-    return memo.is_held;
-  };
-}
-async function held(state, ports) {
-  await ports.hold(HOLD_REASON);
-  return { kind: "continue", state: { ...state, is_memory_held: true } };
-}
-async function is_cleared(state, ports) {
-  return state.is_memory_held === true && !await ports.memory_held();
-}
-var backlog_drive_memory = { HOLD_REASON, gauge: gauge2, held, is_cleared };
-
-// scripts/issue/issue-human-stops.ts
-var UNTRUSTED_AUTHOR_KEY = "untrusted-author";
-var HUMAN_STOPS = [
-  {
-    key: NEEDS_DECISION_LABEL,
-    label: NEEDS_DECISION_LABEL,
-    reason: "A judgement only a person can make; the run parks that issue and continues.",
-    idle_heading: `Waiting on a decision (${NEEDS_DECISION_LABEL}):`
-  },
-  {
-    key: NEEDS_HUMAN_REVIEW_LABEL,
-    label: NEEDS_HUMAN_REVIEW_LABEL,
-    reason: "A person's explicit instruction on the issue; only a person removes it."
-  },
-  {
-    key: NEEDS_HUMAN_MERGE_LABEL,
-    label: NEEDS_HUMAN_MERGE_LABEL,
-    reason: "A PR changing `.github/workflows/**` rewrites its own CI gate; merging it unattended would weaken the gate.",
-    idle_heading: `Waiting on a person to merge (${NEEDS_HUMAN_MERGE_LABEL}):`
-  },
-  {
-    key: ALREADY_DONE_LABEL,
-    label: ALREADY_DONE_LABEL,
-    reason: "The work is already merged but the evidence cites no merged PR or commit on main that `issue:already-done` can check, so a person closes it.",
-    idle_heading: `Waiting on a person to close (${ALREADY_DONE_LABEL}):`
-  },
-  {
-    key: UNTRUSTED_AUTHOR_KEY,
-    reason: "An author without write access is untrusted input, never run unattended.",
-    idle_heading: "Waiting on a person to vouch for the body (author without write access):"
-  },
-  {
-    key: "third-party-write",
-    reason: "A tracker we do not own is never written unattended; the lane drafts it under `## Upstream candidate` and continues."
-  },
-  {
-    key: "dev-engines-edit",
-    reason: "A `devEngines` / overrides edit is Tier C; only that issue parks."
-  },
-  {
-    key: "irreversible-op",
-    reason: "Force push, branch delete and destructive ops are never done; the run takes the reversible way instead."
-  },
-  {
-    key: "unauthenticated",
-    reason: "Only a person can run `/login`; the batch waits without stopping."
-  },
-  {
-    key: "filing-exclusion",
-    reason: `\`release\`, \`breaking-change\`, \`deferred\`, \`epic\` and \`${issue_body_keys.line("judgement", "needed")}\` keep an issue out of the pool by a person's choice (\`issue-auto-ok.ts\`).`
-  }
-];
-var AUTO_RESOLVED_PARK_LABELS = /* @__PURE__ */ new Map([
-  [RUN_STALLED_LABEL, "backlog-drive-stalled-retry.ts"]
-]);
-function labels() {
-  return new Set(HUMAN_STOPS.flatMap((stop) => stop.label ?? []));
-}
-function idle_stops() {
-  return HUMAN_STOPS.filter((stop) => stop.idle_heading !== void 0);
-}
-var issue_human_stops = {
-  AUTO_RESOLVED_PARK_LABELS,
-  HUMAN_STOPS,
-  UNTRUSTED_AUTHOR_KEY,
-  idle_stops,
-  labels
-};
-
-export {
-  run_board_labels,
-  issue_human_stops,
-  run_board_machine,
-  backlog_drive_named,
-  backlog_drive_memory
-};