@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-VL5I2IOD.js

@@ -1,332 +0,0 @@
-import {
-  hook_lap
-} from "./chunk-RWPCK3CO.js";
-import {
-  CATEGORY_ORDER,
-  COMMAND_MAP
-} from "./chunk-CCHJZEF5.js";
-import {
-  USAGE_ERROR_EXIT_CODE,
-  composite_arguments
-} from "./chunk-RSSJWMQS.js";
-import {
-  ALIASES
-} from "./chunk-ROJXMBXP.js";
-import {
-  core_budget
-} from "./chunk-ZCHZU6NX.js";
-import {
-  josh_environment_file
-} from "./chunk-NFKULY26.js";
-import {
-  repo_origin
-} from "./chunk-4ZHWTTQW.js";
-import {
-  find_package_directory
-} from "./chunk-LR22UK5W.js";
-import {
-  resolve_local_bin,
-  resolve_package_bin
-} from "./chunk-SVV4U5AR.js";
-import {
-  package_version_schema
-} from "./chunk-RBU2NKHF.js";
-import {
-  package_manifest
-} from "./chunk-WB4T3VY2.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  resolve_spawn_exit
-} from "./chunk-KTLR4Y32.js";
-
-// scripts/josh/josh-logic.ts
-import { dirname as __josh_dirname2 } from "node:path";
-import { fileURLToPath as __josh_file_path2 } from "node:url";
-import { existsSync as existsSync2 } from "node:fs";
-import path3 from "node:path";
-import { fileURLToPath } from "node:url";
-import { execaSync } from "execa";
-
-// scripts/josh/command-suggest.ts
-var MAX_SUGGESTION_DISTANCE = 3;
-function at(values, index) {
-  return values[index] ?? 0;
-}
-function fill_distance_row(source, target, row, previous) {
-  const current = [row];
-  for (let col = 1; col <= target.length; col++) {
-    const cost = source[row - 1] === target[col - 1] ? 0 : 1;
-    const deletion = at(previous, col) + 1;
-    const insertion = at(current, col - 1) + 1;
-    const substitution = at(previous, col - 1) + cost;
-    current.push(Math.min(deletion, insertion, substitution));
-  }
-  return current;
-}
-function edit_distance(source, target) {
-  let previous = Array.from({ length: target.length + 1 }, (_unused, index) => index);
-  for (let row = 1; row <= source.length; row++) {
-    previous = fill_distance_row(source, target, row, previous);
-  }
-  return at(previous, target.length);
-}
-function closest_command(input, commands) {
-  const within = commands.map((command) => ({ command, distance: edit_distance(input, command) })).filter((scored) => scored.distance <= MAX_SUGGESTION_DISTANCE).toSorted((left, right) => left.distance - right.distance);
-  return within[0]?.command;
-}
-var command_suggest = { closest_command, edit_distance };
-
-// scripts/josh/josh-in-process.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import { realpathSync } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/josh/josh-in-process.ts", __josh_meta.url).href;
-var __josh_source_filename = __josh_file_path(__josh_source_url);
-var __josh_source_dirname = __josh_dirname(__josh_source_filename);
-var TYPESCRIPT_EXTENSION = ".ts";
-var JAVASCRIPT_EXTENSION = ".js";
-var BUNDLED_COMMAND_DIRECTORY = path.join("dist", "commands");
-var FAILURE_EXIT_CODE = 1;
-function is_typescript_dispatcher(dispatcher_url) {
-  return dispatcher_url.endsWith(TYPESCRIPT_EXTENSION);
-}
-function bundled_script_path(package_directory, script) {
-  const name = `${path.basename(script, TYPESCRIPT_EXTENSION)}${JAVASCRIPT_EXTENSION}`;
-  return path.join(package_directory, BUNDLED_COMMAND_DIRECTORY, name);
-}
-function in_process_target(script, package_directory, dispatcher_url) {
-  const script_path = path.join(package_directory, script);
-  const module_path = is_typescript_dispatcher(dispatcher_url) ? script_path : bundled_script_path(package_directory, script);
-  return { module_path, script_path };
-}
-function read_exit_code() {
-  const code = process.exitCode;
-  return typeof code === "number" ? code : 0;
-}
-function resolve_real_path(script_path) {
-  try {
-    return realpathSync(script_path);
-  } catch {
-    return script_path;
-  }
-}
-async function run_in_process(target, script_arguments) {
-  process.argv = [process.execPath, resolve_real_path(target.script_path), ...script_arguments];
-  try {
-    await import(pathToFileURL(resolve_real_path(target.module_path)).href);
-  } catch (error) {
-    console.error(error);
-    return FAILURE_EXIT_CODE;
-  }
-  return read_exit_code();
-}
-var josh_in_process = { bundled_script_path, in_process_target, run_in_process };
-
-// scripts/josh/kit-only.ts
-function kit_only_notice(cmd) {
-  return `\`josh ${cmd}\` is a kit-only command \u2014 run it from the kit repository (joshuafolkken/kit), not from a consumer project.`;
-}
-function is_kit_only(entry) {
-  return entry.is_kit_only === true;
-}
-function kit_only_command_names() {
-  return Object.entries(COMMAND_MAP).filter(([, entry]) => is_kit_only(entry)).map(([name]) => name);
-}
-var kit_only = {
-  is_kit_only,
-  command_names: kit_only_command_names,
-  notice: kit_only_notice
-};
-
-// scripts/josh/run-github-prerequisite.ts
-import { existsSync } from "node:fs";
-import path2 from "node:path";
-var GITHUB_RUN_COMMANDS = /* @__PURE__ */ new Set([
-  "run:entry",
-  "run:prep",
-  "run:next",
-  "run:step",
-  "run:merge",
-  "run:tail"
-]);
-function explanation(root, command) {
-  if (!GITHUB_RUN_COMMANDS.has(command)) return void 0;
-  if (!existsSync(path2.join(root, ".git"))) {
-    return `${command} requires Git and a GitHub origin. Run git init and add a GitHub origin first.`;
-  }
-  const url = git_spawn_sync.origin_url(root);
-  if (url !== void 0 && repo_origin.parse_origin_url(url)) return void 0;
-  return `${command} requires a GitHub origin. Add an origin pointing to GitHub first.`;
-}
-var run_github_prerequisite = { explanation };
-
-// scripts/josh/josh-logic.ts
-var __josh_meta2 = import.meta;
-var __josh_source_url2 = new URL("../../scripts/josh/josh-logic.ts", __josh_meta2.url).href;
-var __josh_source_filename2 = __josh_file_path2(__josh_source_url2);
-var __josh_source_dirname2 = __josh_dirname2(__josh_source_filename2);
-var COLUMN_WIDTH = 26;
-var ALIAS_PAD_WIDTH = 2;
-var TSX_BIN = "tsx";
-var TSX_PACKAGE = "tsx";
-var UNKNOWN_COMMAND_EXIT_CODE = -1;
-var PACKAGE_DIR = find_package_directory(path3.dirname(fileURLToPath(__josh_source_url2)));
-function resolve_tsx_executable() {
-  const candidates = [
-    resolve_local_bin(PACKAGE_DIR, TSX_BIN),
-    resolve_local_bin(process.cwd(), TSX_BIN)
-  ];
-  return candidates.find(existsSync2) ?? TSX_BIN;
-}
-function resolve_tsx_cli_entry() {
-  for (const base_directory of [PACKAGE_DIR, process.cwd()]) {
-    const cli_entry = resolve_package_bin(base_directory, TSX_PACKAGE, TSX_BIN);
-    if (cli_entry !== void 0) return cli_entry;
-  }
-  return void 0;
-}
-function resolve_tsx_runner() {
-  const cli_entry = resolve_tsx_cli_entry();
-  if (cli_entry !== void 0) {
-    return { executable: process.execPath, leading_arguments: [cli_entry] };
-  }
-  return { executable: resolve_tsx_executable(), leading_arguments: [] };
-}
-function read_package_version() {
-  return package_manifest.read_manifest(PACKAGE_DIR, package_version_schema).version;
-}
-var HEADER = `josh v${read_package_version()} \u2014 Joshua Folkken's dev toolkit`;
-var USAGE = "Usage: josh <command> [options]";
-var ALL_HINT = "Run 'josh --all' to list every available command.";
-function build_alias_lookup() {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const [alias, cmd] of Object.entries(ALIASES)) lookup.set(cmd, alias);
-  return lookup;
-}
-function resolve_alias(cmd) {
-  return Object.hasOwn(ALIASES, cmd) ? ALIASES[cmd] ?? cmd : cmd;
-}
-function format_command_line(cmd, entry, alias) {
-  const prefix = alias ? `${alias}, `.padEnd(ALIAS_PAD_WIDTH + ALIAS_PAD_WIDTH) : "";
-  return `  ${(prefix + cmd).padEnd(COLUMN_WIDTH)}${entry.description}`;
-}
-function format_category_section(category, entries, alias_lookup) {
-  const lines = entries.map(
-    ([cmd, entry]) => format_command_line(cmd, entry, alias_lookup.get(cmd))
-  );
-  return [`${category}:`, ...lines].join("\n");
-}
-function is_visible_command(entry, is_all, is_consumer) {
-  if (is_consumer && kit_only.is_kit_only(entry)) return false;
-  return is_all || entry.reference[1] === "developer";
-}
-function collect_visible(is_all, is_consumer) {
-  const by_category = new Map(
-    CATEGORY_ORDER.map((cat) => [cat, []])
-  );
-  for (const [cmd, entry] of Object.entries(COMMAND_MAP)) {
-    if (is_visible_command(entry, is_all, is_consumer)) {
-      by_category.get(entry.category)?.push([cmd, entry]);
-    }
-  }
-  return by_category;
-}
-function format_help(is_all = false, is_consumer = false) {
-  const by_category = collect_visible(is_all, is_consumer);
-  const alias_lookup = build_alias_lookup();
-  const sections = CATEGORY_ORDER.map((cat) => [cat, by_category.get(cat) ?? []]).filter(([, entries]) => entries.length > 0).map(([cat, entries]) => format_category_section(cat, entries, alias_lookup));
-  const footer = is_all ? USAGE : `${USAGE}
-${ALL_HINT}`;
-  return [HEADER, "", sections.join("\n\n"), "", footer].join("\n");
-}
-function all_command_names() {
-  return [...Object.keys(COMMAND_MAP), ...Object.keys(ALIASES)];
-}
-function format_unknown_command(cmd) {
-  const suggestion = command_suggest.closest_command(cmd, all_command_names());
-  const hint = suggestion === void 0 ? "" : ` Did you mean '${suggestion}'?`;
-  return `Unknown command: ${cmd}.${hint} Run 'josh --help' for common commands or 'josh --all' for the full list.`;
-}
-function run_shell_command(shell, extra) {
-  const [executable = "", ...rest_arguments] = shell;
-  const result = execaSync(executable, [...rest_arguments, ...extra], {
-    stdio: "inherit",
-    reject: false
-  });
-  return resolve_spawn_exit(executable, result);
-}
-async function run_script_entry(entry, script, subcommand_arguments) {
-  const script_arguments = [...entry.default_script_arguments ?? [], ...subcommand_arguments];
-  const target = josh_in_process.in_process_target(script, PACKAGE_DIR, __josh_source_url2);
-  josh_environment_file.apply_node_flags(entry.tsx_arguments ?? []);
-  return await josh_in_process.run_in_process(target, script_arguments);
-}
-function github_prerequisite_exit(resolved, is_consumer) {
-  if (!is_consumer) return void 0;
-  const prerequisite = run_github_prerequisite.explanation(process.cwd(), resolved);
-  if (prerequisite === void 0) return void 0;
-  console.error(prerequisite);
-  return USAGE_ERROR_EXIT_CODE;
-}
-function pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer) {
-  if (is_consumer && kit_only.is_kit_only(entry)) {
-    console.error(kit_only.notice(resolved));
-    return USAGE_ERROR_EXIT_CODE;
-  }
-  const prerequisite_exit = github_prerequisite_exit(resolved, is_consumer);
-  if (prerequisite_exit !== void 0) return prerequisite_exit;
-  const rejection = composite_arguments.reject_extra_arguments(
-    resolved,
-    entry,
-    subcommand_arguments
-  );
-  if (rejection === void 0) return void 0;
-  console.error(rejection);
-  return USAGE_ERROR_EXIT_CODE;
-}
-async function run_entry(entry, subcommand_arguments) {
-  if (entry.shell) return run_shell_command(entry.shell, subcommand_arguments);
-  return await run_script_entry(entry, entry.script ?? "", subcommand_arguments);
-}
-function declared(value) {
-  return typeof value === "function" ? value() : value;
-}
-async function dispatch_entry(command, entry, subcommand_arguments) {
-  const weight = declared(entry.core_weight);
-  if (weight === void 0) return await run_entry(entry, subcommand_arguments);
-  return await core_budget.with_command_reservation(
-    weight,
-    async () => await run_entry(entry, subcommand_arguments),
-    { memory_mb: declared(entry.memory_mb), command, is_unit: entry.is_unit_claim }
-  );
-}
-async function run_command(cmd, subcommand_arguments, is_consumer = false) {
-  const resolved = resolve_alias(cmd);
-  const entry = Object.hasOwn(COMMAND_MAP, resolved) ? COMMAND_MAP[resolved] : void 0;
-  if (!entry) return UNKNOWN_COMMAND_EXIT_CODE;
-  const early_exit = pre_dispatch_exit(resolved, entry, subcommand_arguments, is_consumer);
-  if (early_exit !== void 0) return early_exit;
-  return await hook_lap.timed_command(
-    resolved,
-    entry.category,
-    subcommand_arguments,
-    async () => await dispatch_entry(resolved, entry, subcommand_arguments)
-  );
-}
-var josh_logic = {
-  all_command_names,
-  format_help,
-  format_unknown_command,
-  run_command,
-  run_shell_command
-};
-
-export {
-  resolve_tsx_runner,
-  josh_logic
-};

package/dist/commands/chunk-VMG3QB6C.js

@@ -1,81 +0,0 @@
-import {
-  lane_close
-} from "./chunk-XUXCFPDK.js";
-import {
-  git_stash
-} from "./chunk-WROJTXWZ.js";
-import {
-  git_gh_issue_write
-} from "./chunk-4F4KARQN.js";
-import {
-  repository_lock
-} from "./chunk-NUCFIYZL.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/lane/lane-preserve.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-function preserved_comment(message, cause) {
-  return [
-    `The lane held uncommitted work when ${cause}, so it was stashed:`,
-    `- recover with \`pnpm josh stash:pop "${message}"\``
-  ].join("\n");
-}
-async function push_work(issue, directory, occasion) {
-  const message = git_stash.work_message(issue, occasion);
-  await git_stash.push(message, directory);
-  return message;
-}
-async function announce(issue, message, cause) {
-  await git_gh_issue_write.issue_try_comment(issue, preserved_comment(message, cause));
-}
-var KEEP_LOCK_PREFIX = "josh-lane-keep-lock-";
-var KEEP_LOCK_WAIT_MS = 6e4;
-var KEEP_LOCK_TIMEOUT = "another keep of this lane held the lock for the whole wait";
-function keep_lock_path(issue, directory) {
-  return repository_lock.lock_path(`${KEEP_LOCK_PREFIX}${issue}-`, directory);
-}
-async function stash_of(issue, directory, occasion) {
-  if (!await git_stash.has_work(directory)) return void 0;
-  return await push_work(issue, directory, occasion);
-}
-async function locked_stash_of(issue, directory, occasion) {
-  const kept = await repository_lock.with_lock(
-    async () => ({ stash: await stash_of(issue, directory, occasion) }),
-    keep_lock_path(issue, directory),
-    KEEP_LOCK_WAIT_MS
-  );
-  if (kept === void 0) return { kind: "unsaved", directory, reason: KEEP_LOCK_TIMEOUT };
-  return { kind: "saved", stash: kept.stash };
-}
-async function keep_work(issue, directory, occasion) {
-  try {
-    return await locked_stash_of(issue, directory, occasion);
-  } catch (error) {
-    return { kind: "unsaved", directory, reason: error_text.message_of(error) };
-  }
-}
-async function preserve_lane(issue, occasion, cause) {
-  const lane = await lane_close.resolve_lane(issue);
-  const { directory } = lane.targets;
-  if (!existsSync(path.join(directory, ".git"))) return true;
-  const kept = await keep_work(issue, directory, occasion);
-  if (kept.kind === "unsaved") {
-    console.error(
-      `${session_cite.issue(issue)}: uncommitted work could not be stashed \u2014 lane left at ${directory}`
-    );
-    return false;
-  }
-  if (kept.stash !== void 0) await announce(issue, kept.stash, cause);
-  return true;
-}
-var lane_preserve = { announce, keep_work, preserve_lane };
-
-export {
-  lane_preserve
-};

package/dist/commands/chunk-VO25PMGS.js

@@ -1,58 +0,0 @@
-import {
-  eslint_daemon,
-  eslint_daemon_calls
-} from "./chunk-KTV2HNWB.js";
-import {
-  resolve_tsx_runner
-} from "./chunk-VL5I2IOD.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  LINT_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lint/eslint-warm.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/lint/eslint-warm.ts", __josh_meta.url).href;
-var __josh_source_filename = __josh_file_path(__josh_source_url);
-var __josh_source_dirname = __josh_dirname(__josh_source_filename);
-var WARM_CLI = fileURLToPath(new URL("eslint-warm-cli.ts", __josh_source_url));
-var TYPED_SOURCES = ["ls-files", "--", "*.ts", ":!*.d.ts"];
-var FALLBACK_TARGET = "eslint.config.js";
-var LINE_SEPARATOR = "\n";
-function warm_target(project_root) {
-  const listed = git_spawn_sync.read(TYPED_SOURCES, { cwd: project_root }) ?? "";
-  const [first] = listed.split(LINE_SEPARATOR);
-  return first === void 0 || first === "" ? FALLBACK_TARGET : first;
-}
-async function warm(project_root) {
-  await eslint_daemon.run(["exec", "eslint", warm_target(project_root)], {
-    project_root,
-    timeout_ms: LINT_TIMEOUT_MS,
-    call: { caller: eslint_daemon_calls.DAEMON_CALLER.WARM, files: 1 }
-  });
-}
-function ignore_error() {
-}
-function start(project_root) {
-  if (process.env["VITEST"] !== void 0) return;
-  try {
-    const runner = resolve_tsx_runner();
-    const options = { cwd: project_root, detached: true, stdio: "ignore" };
-    const child = spawn(runner.executable, [...runner.leading_arguments, WARM_CLI], options);
-    child.on("error", ignore_error);
-    child.unref();
-  } catch {
-    ignore_error();
-  }
-}
-var eslint_warm = { start, warm };
-
-export {
-  eslint_warm
-};

package/dist/commands/chunk-VPRQFM2T.js

@@ -1,37 +0,0 @@
-import {
-  lane_plan_check
-} from "./chunk-ZJJLROJY.js";
-import {
-  plan_consumers_section
-} from "./chunk-SRG6PKVS.js";
-import {
-  backlog_overlap
-} from "./chunk-MDGPJOLK.js";
-import {
-  shell_quote
-} from "./chunk-W2IA2LV3.js";
-
-// scripts/lane/lane-plan-auto.ts
-var SUCCESS_EXIT_CODE = 0;
-var PATH_PLACEHOLDER = "<path>...";
-var IMPORTS_HINT = "Append `--imports <path>...` naming the existing modules the new code imports \u2014 lane:plan probes their main guards before the first edit.";
-function command_of(issue_number, paths) {
-  const named = paths.length === 0 ? PATH_PLACEHOLDER : paths.map((path) => shell_quote.word(path)).join(" ");
-  return `pnpm josh lane:plan ${issue_number} ${named}`;
-}
-function paths_of(plan) {
-  return [...backlog_overlap.declared_paths(plan_consumers_section.without(plan))];
-}
-async function run_from_plan(issue_number, plan, directory = process.cwd()) {
-  const paths = paths_of(plan);
-  const lane = lane_plan_check.plan_of([issue_number, ...paths], /* @__PURE__ */ new Date());
-  console.info(command_of(issue_number, paths));
-  console.info(IMPORTS_HINT);
-  if (lane === void 0) return SUCCESS_EXIT_CODE;
-  return await lane_plan_check.check_plan(lane_plan_check.placed(lane, directory), directory);
-}
-var lane_plan_auto = { IMPORTS_HINT, command_of, paths_of, run_from_plan };
-
-export {
-  lane_plan_auto
-};

package/dist/commands/chunk-VTLWODJ2.js

@@ -1,133 +0,0 @@
-import {
-  hook_decision
-} from "./chunk-GB2BRQVL.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
-};