@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-XXC32PVL.js

@@ -1,541 +0,0 @@
-import {
-  lane_await
-} from "./chunk-IB5TT73I.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  run_board_usage_rusage
-} from "./chunk-FCINBCKB.js";
-import {
-  machine_capacity
-} from "./chunk-KXHXMERX.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  MS_PER_MINUTE,
-  MS_PER_SECOND,
-  PROBE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-load.ts
-import { loadavg } from "node:os";
-import { execa as execa2 } from "execa";
-
-// scripts/lane/lane-process-load.ts
-import { execa } from "execa";
-var { load_builtin, rusage_reader } = run_board_usage_rusage;
-var PS_ARGUMENTS = ["-A", "-o", "pid=,rss=,%cpu=,args="];
-var PS_ENVIRONMENT = { LC_ALL: "C" };
-var FIELD_SEPARATOR = /\s+/u;
-var KB_PER_MB = 1024;
-var BYTES_PER_MB = KB_PER_MB * KB_PER_MB;
-var TOP_KINDS = 5;
-var OTHER_KIND = "other";
-var RESIDENT_APPS = ["Google Chrome.app", "Visual Studio Code.app"];
-var RESIDENT_APPS_VARIABLE = "JOSH_LANE_RESIDENT_APPS";
-var NAME_SEPARATOR = ",";
-var KIND_PATTERNS = [
-  ["vscode", /Visual Studio Code|Code Helper|\.vscode\/extensions\//u],
-  ["vitest", /vitest/u],
-  ["eslint", /eslint/u],
-  ["tsc", /\btsc\b|svelte-check|typescript/u],
-  ["cspell", /cspell/u],
-  ["prettier", /prettier/u],
-  ["playwright", /playwright/u],
-  ["chrome", /Google Chrome/u],
-  ["chromium", /chromium|headless_shell/iu],
-  ["claude", /(?:^|\/)claude(?:\s|$)|@anthropic-ai\/claude-code\//u],
-  ["josh", /josh(?:-ready)?\.[jt]s|\btsx\b|(?<!\.)\bpnpm\b/u],
-  ["node", /\bnode\b/u]
-];
-function kind_of(command_line) {
-  return KIND_PATTERNS.find(([, pattern]) => pattern.test(command_line))?.[0] ?? OTHER_KIND;
-}
-function line_of(line) {
-  const [pid, rss, cpu, ...command] = line.trim().split(FIELD_SEPARATOR);
-  const reading = { pid: Number(pid), cpu_percent: Number(cpu), rss_mb: Number(rss) / KB_PER_MB };
-  if (command.length === 0 || Number.isNaN(reading.pid + reading.cpu_percent + reading.rss_mb)) {
-    return void 0;
-  }
-  return { command_line: command.join(" "), ...reading };
-}
-function footprint_mb_of(footprint, pid) {
-  const footprint_bytes = footprint?.(pid)?.footprint_bytes;
-  return footprint_bytes === void 0 ? void 0 : footprint_bytes / BYTES_PER_MB;
-}
-function process_of(line, footprint) {
-  const reading = line_of(line);
-  if (reading === void 0) return void 0;
-  return {
-    kind: kind_of(reading.command_line),
-    cpu_percent: reading.cpu_percent,
-    rss_mb: reading.rss_mb,
-    footprint_mb: footprint_mb_of(footprint, reading.pid)
-  };
-}
-function resident_apps(value = process.env[RESIDENT_APPS_VARIABLE]) {
-  if (value === void 0) return RESIDENT_APPS;
-  return value.split(NAME_SEPARATOR).map((name) => name.trim()).filter((name) => name.length > 0);
-}
-function is_resident(reading, names) {
-  return reading !== void 0 && names.some((name) => reading.command_line.includes(name));
-}
-function resident_mb(listing, names) {
-  if (names.length === 0) return void 0;
-  const readings = listing.split("\n").map((line) => line_of(line));
-  const resident = readings.filter((reading) => is_resident(reading, names));
-  return Math.round(resident.reduce((total, reading) => total + reading.rss_mb, 0));
-}
-function add_reading(total, reading) {
-  total.cpu_percent += reading.cpu_percent;
-  total.rss_mb += reading.rss_mb;
-  total.count += 1;
-  if (reading.footprint_mb !== void 0) {
-    total.footprint_mb = (total.footprint_mb ?? 0) + reading.footprint_mb;
-  }
-}
-function add_line(totals, line, footprint) {
-  const reading = process_of(line, footprint);
-  if (reading === void 0) return;
-  const { kind } = reading;
-  const total = totals.get(kind) ?? { kind, cpu_percent: 0, rss_mb: 0, count: 0 };
-  add_reading(total, reading);
-  totals.set(kind, total);
-}
-function rounded(total) {
-  const { footprint_mb, ...rest } = total;
-  const kind = {
-    ...rest,
-    cpu_percent: Math.round(rest.cpu_percent),
-    rss_mb: Math.round(rest.rss_mb)
-  };
-  return footprint_mb === void 0 ? kind : { ...kind, footprint_mb: Math.round(footprint_mb) };
-}
-function by_weight(left, right) {
-  return right.cpu_percent - left.cpu_percent || right.rss_mb - left.rss_mb;
-}
-function summarize(listing, footprint) {
-  const totals = /* @__PURE__ */ new Map();
-  for (const line of listing.split("\n")) add_line(totals, line, footprint);
-  return [...totals.values()].map((total) => rounded(total)).toSorted(by_weight).slice(0, TOP_KINDS);
-}
-async function read(names = resident_apps(), footprint = rusage_reader(process.platform, load_builtin)) {
-  try {
-    const { stdout } = await execa("ps", PS_ARGUMENTS, {
-      env: PS_ENVIRONMENT,
-      timeout: PROBE_TIMEOUT_MS
-    });
-    return { processes: summarize(stdout, footprint), resident_mb: resident_mb(stdout, names) };
-  } catch {
-    return void 0;
-  }
-}
-var lane_process_load = {
-  RESIDENT_APPS,
-  TOP_KINDS,
-  kind_of,
-  read,
-  resident_apps,
-  resident_mb,
-  summarize
-};
-
-// scripts/lane/lane-load.ts
-function count_working(lanes, is_running = lane_await.is_process_running_default) {
-  return lanes.filter((lane) => !lane.is_stranded && is_running(lane.issue)).length;
-}
-async function read_lanes() {
-  try {
-    return count_working(await lane_registry.list_lanes());
-  } catch {
-    return void 0;
-  }
-}
-function rounded2(megabytes) {
-  return megabytes === void 0 ? void 0 : Math.round(megabytes);
-}
-var CLOCK_SYSCTL_NAMES = ["hw.tbfrequency", "machdep.wake_abstime", "machdep.wake_conttime"];
-var SLEEP_SYSCTL_NAMES = [...CLOCK_SYSCTL_NAMES, "kern.boottime", "kern.waketime"];
-var SYSCTL_LINE = /^(?<name>[\w.]+): (?<value>\d+)$/gmu;
-var SYSCTL_TIME = /^kern\.(?<name>boottime|waketime): \{ sec = (?<seconds>\d+)/gmu;
-function parse_times(stdout) {
-  const times = new Map(
-    Array.from(stdout.matchAll(SYSCTL_TIME), (match) => [
-      match.groups?.["name"],
-      Number(match.groups?.["seconds"]) * MS_PER_SECOND
-    ])
-  );
-  return { booted_ms: times.get("boottime"), woke_ms: times.get("waketime") };
-}
-function parse_slept_ms(stdout) {
-  const values = new Map(
-    Array.from(stdout.matchAll(SYSCTL_LINE), (match) => [
-      match.groups?.["name"],
-      Number(match.groups?.["value"])
-    ])
-  );
-  const [frequency = 0, awake = 0, total = 0] = CLOCK_SYSCTL_NAMES.map((name) => values.get(name));
-  if ([frequency, awake, total].includes(0)) return void 0;
-  return Math.round((total - awake) / frequency * MS_PER_SECOND);
-}
-async function read_host_sleep() {
-  if (process.platform !== "darwin") return {};
-  const { stdout } = await execa2("sysctl", SLEEP_SYSCTL_NAMES, {
-    reject: false,
-    timeout: PROBE_TIMEOUT_MS
-  });
-  return { slept_ms: parse_slept_ms(stdout), ...parse_times(stdout) };
-}
-async function sample(at) {
-  const [memory, lanes, reading, host_sleep] = await Promise.all([
-    machine_capacity.read_memory(),
-    read_lanes(),
-    lane_process_load.read(),
-    read_host_sleep()
-  ]);
-  const [load = 0] = loadavg();
-  return {
-    kind: "load",
-    at,
-    load,
-    available_mb: rounded2(memory.available_mb),
-    swapped_mb: rounded2(memory.swapped_mb),
-    lanes,
-    processes: reading?.processes,
-    resident_mb: reading?.resident_mb,
-    ...host_sleep
-  };
-}
-var lane_load = {
-  count_working,
-  parse_slept_ms,
-  parse_times,
-  sample
-};
-
-// scripts/lane/lane-sleep.ts
-var { EVENT_KIND } = run_event_stream;
-var GAP_INTERVALS = 3;
-function gap_of(last_ms, now_ms, interval_ms) {
-  if (now_ms - last_ms <= interval_ms * GAP_INTERVALS) return void 0;
-  return { from_ms: last_ms + interval_ms, to_ms: now_ms };
-}
-function event_of(span) {
-  const elapsed_ms2 = span.to_ms - span.from_ms;
-  const minutes = (elapsed_ms2 / MS_PER_MINUTE).toFixed(1);
-  return {
-    at: new Date(span.to_ms).toISOString(),
-    kind: EVENT_KIND.SLEEP,
-    text: `host slept ${minutes} min`,
-    elapsed_ms: elapsed_ms2
-  };
-}
-async function record(span, events_path) {
-  const target = events_path ?? await run_event_stream_emit.stream_target();
-  if (target === void 0) return;
-  run_event_stream.append_event(target, event_of(span));
-}
-function spans(events) {
-  return events.filter((event) => event.kind === EVENT_KIND.SLEEP).map((event) => {
-    const to_ms = Date.parse(event.at);
-    return { from_ms: to_ms - (event.elapsed_ms ?? 0), to_ms };
-  });
-}
-var lane_sleep = { gap_of, record, spans };
-
-// scripts/lane/lane-sampler.ts
-var SAMPLE_INTERVAL_MS = 6e4;
-async function take(context = {}) {
-  const at = new Date(context.now_ms ?? Date.now()).toISOString();
-  const entry = await lane_load.sample(at);
-  await lane_ledger_write.record(entry, context.ledger_path);
-  return entry;
-}
-async function newest_load(ledger_path) {
-  const path = ledger_path ?? await lane_ledger.target();
-  if (path === void 0) return void 0;
-  return lane_ledger.read_entries(path).findLast((entry) => entry.kind === lane_ledger.KIND.LOAD);
-}
-function counter_growth(previous, current) {
-  if (previous.booted_ms !== current.booted_ms) return 0;
-  return (current.slept_ms ?? 0) - (previous.slept_ms ?? Infinity);
-}
-function sleep_since(previous, current) {
-  if (previous === void 0) return void 0;
-  const slept_ms = counter_growth(previous, current);
-  if (slept_ms < SAMPLE_INTERVAL_MS) return void 0;
-  const to_ms = Math.min(Date.parse(current.at), current.woke_ms ?? Infinity);
-  return { from_ms: Math.max(Date.parse(previous.at), to_ms - slept_ms), to_ms };
-}
-async function take_quietly(context) {
-  try {
-    await take(context);
-  } catch {
-  }
-}
-async function record_quietly(span, context) {
-  try {
-    await lane_sleep.record(span, context.events_path);
-  } catch {
-  }
-}
-async function take_first(context) {
-  try {
-    const previous = await newest_load(context.ledger_path);
-    const slept = sleep_since(previous, await take(context));
-    if (slept !== void 0) await record_quietly(slept, context);
-  } catch {
-  }
-}
-function start(context = {}) {
-  let last_ms = Date.now();
-  void take_first(context);
-  const timer = setInterval(() => {
-    const now_ms = Date.now();
-    const slept = lane_sleep.gap_of(last_ms, now_ms, SAMPLE_INTERVAL_MS);
-    last_ms = now_ms;
-    if (slept !== void 0) void record_quietly(slept, context);
-    void take_quietly(context);
-  }, SAMPLE_INTERVAL_MS).unref();
-  return () => {
-    clearInterval(timer);
-  };
-}
-var lane_sampler = {
-  SAMPLE_INTERVAL_MS,
-  start,
-  take
-};
-
-// scripts/lane/lane-tail-stats.ts
-var OVERRUN_LANE_MINUTES = 40;
-var TAIL_PERCENTILE = 90;
-var WHOLE_PERCENT = 100;
-function is_overrun(minutes) {
-  return minutes > OVERRUN_LANE_MINUTES;
-}
-function overrun_count(minutes) {
-  return minutes.filter((value) => is_overrun(value)).length;
-}
-function tail_minutes(minutes) {
-  if (minutes.length === 0) return void 0;
-  const sorted = minutes.toSorted((left, right) => left - right);
-  const rank = Math.ceil(TAIL_PERCENTILE / WHOLE_PERCENT * sorted.length);
-  return sorted[rank - 1];
-}
-var lane_tail_stats = { is_overrun, OVERRUN_LANE_MINUTES, overrun_count, tail_minutes };
-
-// scripts/lane/lane-stats.ts
-var MS_PER_HOUR = 36e5;
-var ACTIVE_GAP_MS = MS_PER_HOUR;
-var MS_PER_DAY = 864e5;
-var MB_PER_GB = 1024;
-var HALF = 2;
-var MIN_RATE_GAP_MS = lane_sampler.SAMPLE_INTERVAL_MS / HALF;
-var DECIMALS = 1;
-var DAY_DIGITS = 3;
-var MISSING = "\u2014";
-var CELL_SEPARATOR = " | ";
-var COLUMNS = [
-  "JOSH_LANE_LIMIT",
-  "period (days)",
-  "merges",
-  "merges / hour",
-  "effective lanes",
-  "lane median (min)",
-  `lanes over ${String(lane_tail_stats.OVERRUN_LANE_MINUTES)} min`,
-  "lane p90 (min)",
-  "gate median (min)",
-  "gate max (min)",
-  "load peak",
-  "load mean",
-  "swapped peak (GB/h)",
-  "swapped mean (GB/h)",
-  "free memory min (GB)",
-  "free memory mean (GB)",
-  "load samples"
-];
-function window_of(period_days, now_ms) {
-  return { since_ms: now_ms - period_days * MS_PER_DAY, until_ms: now_ms };
-}
-function days_of(window) {
-  return String(Number(((window.until_ms - window.since_ms) / MS_PER_DAY).toPrecision(DAY_DIGITS)));
-}
-function in_window(entries, window) {
-  return entries.filter((entry) => {
-    const at = Date.parse(entry.at);
-    return at >= window.since_ms && at <= window.until_ms;
-  });
-}
-function is_gate(entry) {
-  return entry.kind === "gate";
-}
-function is_merge(entry) {
-  return entry.kind === "merge";
-}
-function is_dispatch(entry) {
-  return entry.kind === "dispatch";
-}
-function is_load(entry) {
-  return entry.kind === "load";
-}
-function is_number(value) {
-  return value !== void 0;
-}
-function mean(values) {
-  if (values.length === 0) return void 0;
-  return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
-function median(values) {
-  if (values.length === 0) return void 0;
-  const sorted = values.toSorted((left, right) => left - right);
-  const middle = Math.floor(sorted.length / HALF);
-  return sorted.length % HALF === 0 ? mean(sorted.slice(middle - 1, middle + 1)) : sorted[middle];
-}
-function peak(values) {
-  return values.length === 0 ? void 0 : Math.max(...values);
-}
-function lowest(values) {
-  return values.length === 0 ? void 0 : Math.min(...values);
-}
-function is_working(sample2) {
-  return (sample2.lanes ?? 0) > 0;
-}
-function sample_pairs(samples) {
-  const sorted = samples.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
-  return sorted.slice(1).map((next, index) => ({ sample: sorted[index] ?? next, next }));
-}
-function elapsed_ms({ sample: sample2, next }) {
-  return Date.parse(next.at) - Date.parse(sample2.at);
-}
-function sum_hours(gaps) {
-  const active = gaps.filter((gap) => gap <= ACTIVE_GAP_MS).reduce((sum, gap) => sum + gap, 0);
-  return active > 0 ? active / MS_PER_HOUR : void 0;
-}
-function gap_hours(entries) {
-  const instants = entries.filter((entry) => entry.kind === "merge" || is_gate(entry)).map((entry) => Date.parse(entry.at)).toSorted((left, right) => left - right);
-  return sum_hours(
-    instants.slice(1).map((instant, index) => instant - (instants[index] ?? instant))
-  );
-}
-function sampled_hours(samples) {
-  const gaps = sample_pairs(samples).filter(({ sample: sample2 }) => is_working(sample2)).map((pair) => elapsed_ms(pair));
-  return sum_hours(gaps);
-}
-function swap_rate(pair) {
-  const swapped = machine_capacity.swapped_between(pair.sample.swapped_mb, pair.next.swapped_mb);
-  const elapsed = elapsed_ms(pair);
-  const is_one_interval = elapsed >= MIN_RATE_GAP_MS && elapsed <= ACTIVE_GAP_MS;
-  if (swapped === void 0 || !is_one_interval) return void 0;
-  return swapped / MB_PER_GB / (elapsed / MS_PER_HOUR);
-}
-function active_hours(entries) {
-  const samples = entries.filter(is_load);
-  return samples.some((sample2) => is_working(sample2)) ? sampled_hours(samples) : gap_hours(entries);
-}
-function gigabytes(megabytes) {
-  return megabytes === void 0 ? void 0 : megabytes / MB_PER_GB;
-}
-function cell(value) {
-  return value === void 0 ? MISSING : value.toFixed(DECIMALS);
-}
-function throughput_cells(entries) {
-  const merges = entries.filter((entry) => entry.kind === "merge").length;
-  const hours = active_hours(entries);
-  const lanes = entries.filter(is_load).filter(is_working).map((entry) => entry.lanes);
-  const per_hour = hours === void 0 ? void 0 : merges / hours;
-  return [String(merges), cell(per_hour), cell(mean(lanes))];
-}
-function dispatched_before(dispatches, merge) {
-  const merged_at = Date.parse(merge.at);
-  const starts = dispatches.filter((dispatch) => dispatch.issue === merge.issue).map((dispatch) => Date.parse(dispatch.at)).filter((at) => at <= merged_at);
-  return peak(starts);
-}
-function lane_minutes(dispatches, merge) {
-  const start2 = dispatched_before(dispatches, merge);
-  return start2 === void 0 ? void 0 : (Date.parse(merge.at) - start2) / MS_PER_MINUTE;
-}
-function merge_minutes(entries, period) {
-  const dispatches = entries.filter(is_dispatch);
-  return period.filter((entry) => is_merge(entry)).map((merge) => lane_minutes(dispatches, merge)).filter(is_number);
-}
-function lane_cells(entries, period) {
-  const minutes = merge_minutes(entries, period);
-  return [
-    cell(median(minutes)),
-    String(lane_tail_stats.overrun_count(minutes)),
-    cell(lane_tail_stats.tail_minutes(minutes))
-  ];
-}
-function gate_cells(entries) {
-  const minutes = entries.filter(is_gate).filter((entry) => entry.is_reused !== true).map((entry) => entry.elapsed_ms / MS_PER_MINUTE);
-  return [cell(median(minutes)), cell(peak(minutes))];
-}
-function swap_cells(samples) {
-  const pairs = sample_pairs(samples);
-  const rates = pairs.map((pair) => swap_rate(pair)).filter(is_number);
-  const working_rates = pairs.filter(({ sample: sample2 }) => is_working(sample2)).map((pair) => swap_rate(pair)).filter(is_number);
-  return [cell(peak(rates)), cell(mean(working_rates))];
-}
-function load_cells(samples) {
-  const working = samples.filter(is_working);
-  const free = samples.map((sample2) => sample2.available_mb).filter(is_number);
-  const working_free = working.map((sample2) => sample2.available_mb).filter(is_number);
-  return [
-    cell(peak(samples.map((sample2) => sample2.load))),
-    cell(mean(working.map((sample2) => sample2.load))),
-    ...swap_cells(samples),
-    cell(gigabytes(lowest(free))),
-    cell(gigabytes(mean(working_free))),
-    String(samples.length)
-  ];
-}
-function to_row(cells) {
-  return `| ${cells.join(CELL_SEPARATOR)} |`;
-}
-function header() {
-  return [to_row(COLUMNS), to_row(COLUMNS.map(() => "---"))].join("\n");
-}
-function row(entries, window, label) {
-  const period = in_window(entries, window);
-  return to_row([
-    label.limit,
-    days_of(window),
-    ...throughput_cells(period),
-    ...lane_cells(entries, period),
-    ...gate_cells(period),
-    ...load_cells(period.filter(is_load))
-  ]);
-}
-var lane_stats = {
-  COLUMNS,
-  MISSING,
-  header,
-  in_window,
-  mean,
-  median,
-  merge_minutes,
-  peak,
-  row,
-  to_row,
-  window_of
-};
-
-export {
-  lane_load,
-  lane_sleep,
-  lane_sampler,
-  lane_tail_stats,
-  lane_stats
-};

package/dist/commands/chunk-XXN2EZBY.js

@@ -1,133 +0,0 @@
-import {
-  hook_decision
-} from "./chunk-RLBFEHHC.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/lane/lane-investigation-switch.ts
-var INVESTIGATION_ENV_KEY = "JOSH_LANE_INVESTIGATION";
-function is_on() {
-  return hook_decision.is_switch_opt_in(INVESTIGATION_ENV_KEY);
-}
-var lane_investigation_switch = { is_on };
-
-// scripts/run/event/run-event-overrun.ts
-var WITHIN_PATTERN = /^#(?<issue>\d+) net: (?<minutes>\d+) min$/u;
-var SKIPPED_PATTERN = /^#(?<issue>\d+) overrun skipped: (?<reason>.+)$/u;
-var OVERRAN_PATTERN = /^#(?<issue>\d+) overran: (?<minutes>\d+) min net(?:, longest (?<stage>.+?) (?<stage_minutes>\d+) min)? — (?<outcome>.*)$/u;
-var INVESTIGATING_PATTERN = /^investigating in pid (?<pid>\d+)(?: started (?<start>.+))?$/u;
-var ENDED_PATTERN = /^#(?<issue>\d+) overrun: (?<result>.*)$/u;
-var FAILED_PATTERN = /^#(?<issue>\d+) overrun investigation failed: /u;
-var DISABLED_REASON = "disabled (JOSH_LANE_INVESTIGATION is not on)";
-var FILED_RESULT = "filed";
-var NONE_LEAD = "none: ";
-var NOT_REDUCIBLE_LEAD = "; not reducible: ";
-var RECURRED_PATTERN = /^recurred #(?<number>\d+)/u;
-var FOLDED_LEAD = "folded ";
-var FOLDED_SEPARATOR = ",";
-var FOLDED_PATTERN = /^folded (?<list>#\d+(?:,#\d+)*)/u;
-var NUMBER_PATTERN = /#(?<number>\d+)/gu;
-function started_text(issue, minutes, outcome, longest) {
-  const stage = longest === void 0 ? "" : `, longest ${longest.name} ${String(longest.minutes)} min`;
-  return `${issue_cite.plain_for("program", issue)} overran: ${String(minutes)} min net${stage} \u2014 ${outcome}`;
-}
-function within_text(issue, minutes) {
-  return `${issue_cite.plain_for("program", issue)} net: ${String(minutes)} min`;
-}
-function skipped_text(issue, reason) {
-  return `${issue_cite.plain_for("program", issue)} overrun skipped: ${reason}`;
-}
-function investigating(pid, start) {
-  const outcome = `investigating in pid ${String(pid)}`;
-  return start === void 0 ? outcome : `${outcome} started ${start}`;
-}
-function ended_text(issue, result) {
-  return `${issue_cite.plain_for("program", issue)} overrun: ${result}`;
-}
-function failed_text(issue, note) {
-  return `${issue_cite.plain_for("program", issue)} overrun investigation failed: ${note}`;
-}
-function none_result(reason) {
-  return `${NONE_LEAD}${reason}`;
-}
-function recurred_result(issue) {
-  return `recurred ${issue_cite.plain_for("program", issue)}`;
-}
-function recurred_of(result) {
-  const number = RECURRED_PATTERN.exec(result)?.groups?.["number"];
-  return number === void 0 ? void 0 : Number(number);
-}
-function folded_result(issues) {
-  return `${FOLDED_LEAD}${issues.map((issue) => issue_cite.plain_for("program", issue)).join(FOLDED_SEPARATOR)}`;
-}
-function folded_of(result) {
-  const list = FOLDED_PATTERN.exec(result)?.groups?.["list"] ?? "";
-  return [...list.matchAll(NUMBER_PATTERN)].map((match) => Number(match.groups?.["number"]));
-}
-function reason_of(result) {
-  const [lead = ""] = result.split(NOT_REDUCIBLE_LEAD);
-  return lead.startsWith(NONE_LEAD) ? lead.slice(NONE_LEAD.length) : lead;
-}
-function longest_of(groups) {
-  const name = groups["stage"];
-  return name === void 0 ? void 0 : { name, minutes: Number(groups["stage_minutes"]) };
-}
-function overran(groups) {
-  const issue = Number(groups["issue"]);
-  const minutes = Number(groups["minutes"]);
-  const launched = INVESTIGATING_PATTERN.exec(groups["outcome"] ?? "")?.groups;
-  if (launched === void 0) return { kind: "failed", issue, minutes };
-  const pid = Number(launched["pid"]);
-  const longest = longest_of(groups);
-  return { kind: "started", issue, minutes, pid, start: launched["start"], longest };
-}
-function within(groups) {
-  return { kind: "within", issue: Number(groups["issue"]), minutes: Number(groups["minutes"]) };
-}
-function skipped(groups) {
-  return { kind: "skipped", issue: Number(groups["issue"]), reason: groups["reason"] ?? "" };
-}
-function failed(groups) {
-  return { kind: "failed", issue: Number(groups["issue"]), minutes: void 0 };
-}
-function ended(groups) {
-  return { kind: "ended", issue: Number(groups["issue"]), result: groups["result"] ?? "" };
-}
-var READERS = [
-  [WITHIN_PATTERN, within],
-  [SKIPPED_PATTERN, skipped],
-  [OVERRAN_PATTERN, overran],
-  [FAILED_PATTERN, failed],
-  [ENDED_PATTERN, ended]
-];
-function parse(text) {
-  for (const [pattern, read] of READERS) {
-    const groups = pattern.exec(text)?.groups;
-    if (groups !== void 0) return read(groups);
-  }
-  return void 0;
-}
-var run_event_overrun = {
-  DISABLED_REASON,
-  ended_text,
-  failed_text,
-  FILED_RESULT,
-  folded_of,
-  folded_result,
-  investigating,
-  none_result,
-  NOT_REDUCIBLE_LEAD,
-  parse,
-  reason_of,
-  recurred_of,
-  recurred_result,
-  skipped_text,
-  started_text,
-  within_text
-};
-
-export {
-  lane_investigation_switch,
-  run_event_overrun
-};