@joshuafolkken/kit 1.3101.0 → 1.3125.0

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

@@ -0,0 +1,566 @@
+import {
+  main_merge_guard
+} from "./chunk-LDYDRXOY.js";
+import {
+  REFUSED_VERDICT,
+  observation_record
+} from "./chunk-V7QOC5NV.js";
+import {
+  review_comment_round
+} from "./chunk-5SOU366I.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  test_related_pins
+} from "./chunk-HE5S4XRE.js";
+import {
+  whole_suite_files
+} from "./chunk-4MRBLCDB.js";
+import {
+  observation_ledger_home
+} from "./chunk-N5FT5LYP.js";
+import {
+  vitest_failure_summary
+} from "./chunk-GDP7QXYE.js";
+import {
+  import_graph
+} from "./chunk-CVZXDKCV.js";
+import {
+  yaml_document
+} from "./chunk-UCI4AL3Q.js";
+import {
+  git_branch
+} from "./chunk-C7CDGSMW.js";
+import {
+  git_gh_issue_write
+} from "./chunk-C3Y42PHX.js";
+import {
+  git_gh_helpers
+} from "./chunk-2BNLPPP4.js";
+import {
+  POLL_BACKOFF,
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/followup/followup-job-rerun.ts
+import { stripVTControlCharacters } from "node:util";
+import { z as z2 } from "zod";
+
+// scripts/followup/followup-failed-tests.ts
+import path from "node:path";
+var LOG_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\S+Z /u;
+var TEST_SUFFIX = /\.test(?<extension>\.[^./]+)$/u;
+var SEGMENT_SEPARATOR = ".";
+var OBSERVATION_SLUG = "followup-unrelated-test-rerun";
+var OBSERVATION_DEPTH = "d1";
+var NAME_SEPARATOR = "; ";
+var UNNAMED_ISSUE = "Did not record the failed tests outside the change: the branch names no issue to post them on.";
+var RERUN_VERDICT = "rerun";
+var KEPT_VERDICT = "kept";
+var UNNAMED_VERDICT = "unnamed";
+function read_failed_tests(log) {
+  const lines = log.split("\n").map((line) => line.replace(LOG_TIMESTAMP, ""));
+  const plain = lines.join("\n");
+  const names = vitest_failure_summary.failed_tests(plain);
+  const diagnostic = vitest_failure_summary.import_failure(plain);
+  return {
+    files: vitest_failure_summary.failed_files(names),
+    names,
+    ...diagnostic !== void 0 && { import_failure: diagnostic }
+  };
+}
+function subjects_of(test_file) {
+  const extension = TEST_SUFFIX.exec(test_file)?.groups?.["extension"];
+  if (extension === void 0) return [test_file];
+  const directory = path.posix.dirname(test_file);
+  const segments = path.posix.basename(test_file, `.test${extension}`).split(SEGMENT_SEPARATOR);
+  const modules = segments.map(
+    (_, index) => path.posix.join(
+      directory,
+      `${segments.slice(0, index + 1).join(SEGMENT_SEPARATOR)}${extension}`
+    )
+  );
+  return [test_file, ...modules];
+}
+function inputs_in_change(inputs, test_file, changed) {
+  if (!inputs?.includes(path.resolve(test_file))) return true;
+  return [...changed].some(
+    (file) => whole_suite_files.WHOLE_SUITE_FILES.has(file) || inputs.includes(path.resolve(file))
+  );
+}
+function is_in_change(test_file, changed, read) {
+  if (test_related_pins.pinned_tests(changed).includes(test_file) || subjects_of(test_file).some((subject) => changed.has(subject))) {
+    return true;
+  }
+  const inputs = read?.(path.resolve(test_file));
+  return inputs_in_change(inputs, test_file, changed);
+}
+function verdict_of(tests, changed, read) {
+  if (tests.import_failure !== void 0) return KEPT_VERDICT;
+  if (tests.files.length === 0) return UNNAMED_VERDICT;
+  const is_outside = tests.files.every((file) => !is_in_change(file, changed, read));
+  return is_outside ? RERUN_VERDICT : KEPT_VERDICT;
+}
+async function read_verdict(tests, changed) {
+  if (tests.import_failure !== void 0) {
+    console.info(`\u{1F527} Repair CI import failure before rerunning: ${tests.import_failure}`);
+    if (tests.files.length > 0) {
+      console.info(`${vitest_failure_summary.RERUN_PREFIX}${tests.files.join(" ")}`);
+    }
+    return KEPT_VERDICT;
+  }
+  if (tests.files.length === 0) return UNNAMED_VERDICT;
+  const graph = await import_graph.create(process.cwd());
+  return verdict_of(tests, changed, graph?.test_inputs);
+}
+function observation_of(failures) {
+  const files = new Set(failures.flatMap(({ tests }) => tests.files));
+  const names = new Set(failures.flatMap(({ tests }) => tests.names));
+  const listed = [...names].map((name) => name.replaceAll("|", "/"));
+  const jobs = failures.map(({ job }) => job);
+  return {
+    slug: OBSERVATION_SLUG,
+    depth: OBSERVATION_DEPTH,
+    where: [...files].join(", "),
+    what: `followup reran ${jobs.join(", ")}; failed outside the change: ${listed.join(NAME_SEPARATOR)}`
+  };
+}
+async function post(entry, issue) {
+  const assessment = await observation_record.assess({
+    entry,
+    checkout: observation_ledger_home.ledger_root(),
+    now: /* @__PURE__ */ new Date()
+  });
+  if (assessment.verdict === REFUSED_VERDICT) return `${REFUSED_VERDICT}: ${assessment.reason}`;
+  await git_gh_issue_write.issue_comment(
+    String(issue),
+    review_comment_round.observation_body_of([assessment.line])
+  );
+  return assessment.verdict;
+}
+async function record_entry(entry, issue) {
+  if (issue === void 0) {
+    console.info(`\u26A0\uFE0F ${UNNAMED_ISSUE}`);
+    return;
+  }
+  try {
+    console.info(`\u{1F4DD} Recorded the ${entry.slug} observation: ${await post(entry, issue)}`);
+  } catch (error) {
+    console.info(`\u26A0\uFE0F Could not record the ${entry.slug} observation: ${String(error)}`);
+  }
+}
+async function record(failures, issue) {
+  if (failures.length === 0) return;
+  await record_entry(observation_of(failures), issue);
+}
+var followup_failed_tests = {
+  observation_of,
+  read_failed_tests,
+  read_verdict,
+  record,
+  record_entry,
+  subjects_of,
+  verdict_of
+};
+
+// scripts/followup/followup-job-needs.ts
+import { readFile } from "node:fs/promises";
+import { z } from "zod";
+var EXPRESSION = /\$\{\{[^}]*\}\}/u;
+var EXPRESSION_MARK = "${{";
+var ANY_TEXT = ".+";
+var MATRIX_SUFFIX = String.raw`(?: \(.+\))?`;
+var CALLED_JOB_SUFFIX = " / .+";
+var REGEX_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
+var RESULT_READ = /\bneeds\.[\w-]+\.result\b/u;
+var PASSED_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped"]);
+var FAILURE_CONCLUSION = "failure";
+var needs_schema = z.array(z.string());
+var step_schema = z.looseObject({
+  name: z.string().optional(),
+  if: z.unknown().optional(),
+  env: z.unknown().optional()
+});
+var job_schema = z.looseObject({
+  name: z.string().optional(),
+  needs: z.union([z.string(), needs_schema]).optional(),
+  uses: z.string().optional(),
+  steps: z.array(step_schema).optional()
+});
+var workflow_schema = z.looseObject({ jobs: z.record(z.string(), job_schema) });
+function escape(text) {
+  return text.replaceAll(REGEX_SPECIAL, String.raw`\$&`);
+}
+function name_source(name) {
+  if (!name.includes(EXPRESSION_MARK)) return `${escape(name)}${MATRIX_SUFFIX}`;
+  return name.split(EXPRESSION).map((part) => escape(part)).join(ANY_TEXT);
+}
+function needs_list(needs = []) {
+  return typeof needs === "string" ? [needs] : needs;
+}
+function pattern_of(jobs, id) {
+  const job = jobs[id];
+  const suffix = job?.uses === void 0 ? "" : CALLED_JOB_SUFFIX;
+  return new RegExp(`^${name_source(job?.name ?? id)}${suffix}$`, "u");
+}
+function gate_steps(steps = []) {
+  return steps.filter((step) => RESULT_READ.test(JSON.stringify([step.if, step.env]))).flatMap((step) => step.name ?? []);
+}
+function parse_graph(workflow) {
+  const parsed = workflow_schema.safeParse(yaml_document.parse_yaml(workflow));
+  if (!parsed.success) return [];
+  const { jobs } = parsed.data;
+  return Object.entries(jobs).map(([id, job]) => ({
+    pattern: pattern_of(jobs, id),
+    needs: needs_list(job.needs).map((need) => pattern_of(jobs, need)),
+    gates: gate_steps(job.steps)
+  }));
+}
+function needs_of(graph, job_name) {
+  return graph.filter(({ pattern }) => pattern.test(job_name)).flatMap((job) => job.needs);
+}
+function is_waiting_on(graph, job_name, upstream) {
+  const needs = needs_of(graph, job_name);
+  return upstream.some((name) => needs.some((pattern) => pattern.test(name)));
+}
+function is_missing_need(graph, job_name, run_jobs) {
+  return needs_of(graph, job_name).some((pattern) => run_jobs.every((name) => !pattern.test(name)));
+}
+function has_passed(pattern, run_jobs) {
+  return run_jobs.every(
+    ({ name, conclusion }) => !pattern.test(name) || PASSED_CONCLUSIONS.has(conclusion ?? "")
+  );
+}
+function is_gate_of_successes(graph, job, run_jobs) {
+  const failed = job.steps.find(({ conclusion }) => conclusion === FAILURE_CONCLUSION)?.name;
+  const entries = graph.filter(({ pattern }) => pattern.test(job.name));
+  const needs = entries.flatMap((entry) => entry.needs);
+  if (entries.every(({ gates }) => gates.every((gate) => gate !== failed))) return false;
+  return needs.length > 0 && needs.every((pattern) => has_passed(pattern, run_jobs));
+}
+async function read_graph(workflow_path) {
+  try {
+    return parse_graph(await readFile(workflow_path, "utf8"));
+  } catch {
+    return [];
+  }
+}
+var followup_job_needs = {
+  is_gate_of_successes,
+  is_missing_need,
+  is_waiting_on,
+  parse_graph,
+  read_graph
+};
+
+// scripts/followup/followup-main-move.ts
+var OBSERVATION_SLUG2 = "followup-main-merge-first";
+var OBSERVATION_DEPTH2 = "d1";
+var LATEST_COMMIT = 1;
+var SHORT_SHA_LENGTH = 12;
+function moved_tests(test_files, incoming) {
+  return test_files.flatMap((file) => {
+    const moved = followup_failed_tests.subjects_of(file).find((subject) => incoming.has(subject));
+    return moved === void 0 ? [] : { file, moved };
+  });
+}
+async function latest_commit(file, main_reference) {
+  const [commit] = await git_command.log_first_parent(LATEST_COMMIT, file, main_reference);
+  return commit ?? main_reference;
+}
+async function read_main_move(test_files) {
+  if (test_files.length === 0) return void 0;
+  const default_branch = await git_command.get_default_branch();
+  await git_command.fetch_branch(default_branch);
+  const incoming = new Set(await main_merge_guard.incoming_paths(default_branch));
+  const moved = moved_tests(test_files, incoming);
+  const [first] = moved;
+  if (first === void 0) return void 0;
+  return {
+    files: moved.map(({ file }) => file),
+    commit: await latest_commit(first.moved, `origin/${default_branch}`)
+  };
+}
+function observation_of2(move) {
+  return {
+    slug: OBSERVATION_SLUG2,
+    depth: OBSERVATION_DEPTH2,
+    where: move.files.join(", "),
+    what: `followup put the main merge before the rerun; the failed test moved on main at ${move.commit.slice(0, SHORT_SHA_LENGTH)}`
+  };
+}
+async function read_or_rerun(test_files) {
+  try {
+    return await read_main_move(test_files);
+  } catch (error) {
+    console.info(`\u26A0\uFE0F Could not compare the failed tests with main, rerunning: ${String(error)}`);
+    return void 0;
+  }
+}
+async function should_merge_first(test_files, issue) {
+  const move = await read_or_rerun(test_files);
+  if (move === void 0) return false;
+  console.info(
+    `\u{1F500} Not rerunning: main changed the failed tests since the branch point (${move.files.join(", ")}); merge main first.`
+  );
+  await followup_failed_tests.record_entry(observation_of2(move), issue);
+  return true;
+}
+var followup_main_move = {
+  read_main_move,
+  should_merge_first
+};
+
+// scripts/followup/followup-job-rerun.ts
+var FAILURE_CONCLUSION2 = "failure";
+var FAILED_CONCLUSIONS = [FAILURE_CONCLUSION2, "cancelled", "timed_out"];
+var FAILED_JOB_CONCLUSIONS = new Set(FAILED_CONCLUSIONS);
+var ACTIONS_APP_SLUG = "github-actions";
+var PASSING_STEP_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped"]);
+var RUN_COMPLETED = "completed";
+var FIRST_ATTEMPT = 1;
+var DOWNLOAD_ERRORS = [
+  /^\S+ ##\[error\]Failed to (?:download archive|resolve action download info)/mu,
+  /^\S+ curl: \(22\) The requested URL returned error: 5\d\d\r?\n\S+ ##\[error\]Process completed with exit code 22\.$/mu,
+  /^\S+ curl: \(22\) The requested URL returned error: 5\d\d\r?\n\S+ \[ERROR\] Failed to download from https:\/\/\S+\r?\n\S+ ##\[error\]Process completed with exit code 1\.$/mu,
+  /^\S+ ##\[error\]Unable to download and extract CodeQL CLI: Unexpected HTTP response: 5\d\d$/mu
+];
+var COMPLETE_ATTEMPTS = 40;
+var COMPLETE_INTERVAL_MS = 15e3;
+var REGISTER_ATTEMPTS = 10;
+var REGISTER_INTERVAL_MS = 3e3;
+var REGISTER_BACKOFF = { ...POLL_BACKOFF, initial_ms: REGISTER_INTERVAL_MS };
+var MAX_CHECK_RERUNS = 3;
+var RERUN_BACKOFF_MS = 12e4;
+var RERUN_BACKOFF_FACTOR = 2;
+var MS_PER_SECOND = 1e3;
+var RERUNS_SPENT_MESSAGE = "CI infrastructure failures outlasted every followup rerun";
+var failed_check_schema = z2.looseObject({
+  id: z2.number(),
+  conclusion: z2.enum(FAILED_CONCLUSIONS),
+  app: z2.looseObject({ slug: z2.literal(ACTIONS_APP_SLUG) })
+});
+var rollup_schema = z2.looseObject({ statusCheckRollup: z2.array(z2.unknown()) });
+var step_schema2 = z2.looseObject({ name: z2.string().optional(), conclusion: z2.string().nullish() });
+var job_schema2 = z2.looseObject({
+  id: z2.number(),
+  name: z2.string(),
+  run_id: z2.number(),
+  run_attempt: z2.number().nullish(),
+  conclusion: z2.string().nullish(),
+  steps: z2.array(step_schema2)
+});
+var run_schema = z2.looseObject({ status: z2.string(), path: z2.string().optional() });
+var jobs_page_schema = z2.looseObject({ jobs: z2.array(job_schema2) });
+function actions_api_path(rest) {
+  return `${git_gh_api_path.repo_api_path()}/actions/${rest}`;
+}
+async function read_actions(rest, schema) {
+  const json = await git_gh_exec.exec_gh_api({ path: actions_api_path(rest) });
+  return schema.parse(JSON.parse(json));
+}
+async function read_failed_check_ids(branch_name) {
+  const { snapshot_json } = await git_gh_command.pr_get_checks_snapshot(branch_name);
+  const rollup = rollup_schema.parse(JSON.parse(snapshot_json)).statusCheckRollup;
+  return rollup.flatMap((item) => {
+    const parsed = failed_check_schema.safeParse(item);
+    return parsed.success ? parsed.data.id : [];
+  });
+}
+async function read_failed_run_ids(branch_name) {
+  const ids = await read_failed_check_ids(branch_name);
+  const jobs = await Promise.all(
+    ids.map(async (id) => await read_actions(`jobs/${String(id)}`, job_schema2))
+  );
+  return [...new Set(jobs.map((job) => job.run_id))];
+}
+async function await_run_completed(run_id) {
+  let status = "";
+  return await poll.poll_until(
+    async () => {
+      ;
+      ({ status } = await read_actions(`runs/${String(run_id)}`, run_schema));
+      return status === RUN_COMPLETED;
+    },
+    {
+      attempts: COMPLETE_ATTEMPTS,
+      interval_ms: COMPLETE_INTERVAL_MS,
+      backoff: { seen: () => status }
+    }
+  );
+}
+function has_every_step_passed(job) {
+  if (job.steps.length === 0) return false;
+  return job.steps.every((step) => PASSING_STEP_CONCLUSIONS.has(step.conclusion ?? ""));
+}
+function is_first_attempt(job) {
+  return (job.run_attempt ?? FIRST_ATTEMPT) <= FIRST_ATTEMPT;
+}
+async function read_job_log(job) {
+  return await git_gh_exec.exec_gh_api({
+    path: actions_api_path(`jobs/${String(job.id)}/logs`),
+    should_allow_escapes: true
+  });
+}
+function is_download_failure(log) {
+  const plain_log = stripVTControlCharacters(log);
+  if (followup_failed_tests.read_failed_tests(plain_log).import_failure !== void 0) return false;
+  return DOWNLOAD_ERRORS.some((error) => error.test(plain_log));
+}
+async function judge_job(job, changed) {
+  if (has_every_step_passed(job)) return { job, verdict: RERUN_VERDICT };
+  if (job.conclusion !== FAILURE_CONCLUSION2) return { job, verdict: KEPT_VERDICT };
+  const log = await read_job_log(job);
+  if (is_download_failure(log)) return { job, verdict: RERUN_VERDICT };
+  if (!is_first_attempt(job)) return { job, verdict: UNNAMED_VERDICT };
+  const tests = followup_failed_tests.read_failed_tests(log);
+  return { job, verdict: await followup_failed_tests.read_verdict(tests, changed), tests };
+}
+function is_infra_failure(job, graph, reruns, run_jobs) {
+  if (followup_job_needs.is_gate_of_successes(graph, job, run_jobs)) return true;
+  if (!is_first_attempt(job)) return false;
+  const names = run_jobs.map(({ name }) => name);
+  return followup_job_needs.is_waiting_on(graph, job.name, reruns) || followup_job_needs.is_missing_need(graph, job.name, names);
+}
+function settle_unnamed(judged, graph, run_jobs) {
+  const reruns = judged.filter(({ verdict }) => verdict === RERUN_VERDICT).map(({ job }) => job.name);
+  return judged.map((entry) => {
+    if (entry.verdict !== UNNAMED_VERDICT) return entry;
+    return is_infra_failure(entry.job, graph, reruns, run_jobs) ? { job: entry.job, verdict: RERUN_VERDICT } : entry;
+  });
+}
+async function read_needs_graph(run_id, judged) {
+  if (judged.every(({ verdict }) => verdict !== UNNAMED_VERDICT)) return [];
+  const run = await read_actions(`runs/${String(run_id)}`, run_schema);
+  return run.path === void 0 ? [] : await followup_job_needs.read_graph(run.path);
+}
+async function read_rerun_jobs(run_id, changed) {
+  if (!await await_run_completed(run_id)) return void 0;
+  const { jobs } = await read_actions(
+    `runs/${String(run_id)}/jobs?filter=latest&per_page=100`,
+    jobs_page_schema
+  );
+  const failed = jobs.filter((job) => FAILED_JOB_CONCLUSIONS.has(job.conclusion ?? ""));
+  const judged = await Promise.all(failed.map(async (job) => await judge_job(job, changed)));
+  const graph = await read_needs_graph(run_id, judged);
+  const settled = settle_unnamed(judged, graph, jobs);
+  return settled.every(({ verdict }) => verdict === RERUN_VERDICT) ? settled : void 0;
+}
+async function rerun_runs(run_ids) {
+  await Promise.all(
+    run_ids.map(
+      async (run_id) => await git_gh_exec.exec_gh_api({
+        path: actions_api_path(`runs/${String(run_id)}/rerun-failed-jobs`),
+        method: "POST",
+        should_retry: false
+      })
+    )
+  );
+}
+async function await_rerun_registered(branch_name, jobs) {
+  const rerun_ids = new Set(jobs.map((job) => job.id));
+  let failed = [];
+  await poll.poll_until(
+    async () => {
+      failed = await read_failed_check_ids(branch_name);
+      return failed.every((id) => !rerun_ids.has(id));
+    },
+    {
+      attempts: REGISTER_ATTEMPTS,
+      interval_ms: REGISTER_INTERVAL_MS,
+      backoff: { seen: () => failed.join(","), schedule: REGISTER_BACKOFF }
+    }
+  );
+}
+async function find_rerun_jobs(branch_name) {
+  const run_ids = await read_failed_run_ids(branch_name);
+  if (run_ids.length === 0) return [];
+  const changed = new Set(await changed_paths.read_changed_paths(false));
+  const per_run = await Promise.all(
+    run_ids.map(async (run_id) => await read_rerun_jobs(run_id, changed))
+  );
+  return per_run.every((jobs) => jobs !== void 0) ? per_run.flat() : [];
+}
+async function rerun(branch_name, entries) {
+  const jobs = entries.map(({ job }) => job);
+  const names = jobs.map((job) => job.name);
+  console.info(
+    `\u{1F501} Rerunning CI jobs that stopped after every step passed, failed on a download, or failed only outside the change: ${names.join(", ")}`
+  );
+  await followup_failed_tests.record(
+    entries.flatMap(({ job, tests }) => tests === void 0 ? [] : { job: job.name, tests }),
+    git_branch.issue_from_branch(branch_name)
+  );
+  await rerun_runs([...new Set(jobs.map((job) => job.run_id))]);
+  await await_rerun_registered(branch_name, jobs);
+  return names;
+}
+async function should_merge_first2(branch_name, entries) {
+  const files = [...new Set(entries.flatMap(({ tests }) => tests?.files ?? []))];
+  return await followup_main_move.should_merge_first(
+    files,
+    git_branch.issue_from_branch(branch_name)
+  );
+}
+function rerun_delay_ms(round) {
+  return round === 0 ? 0 : RERUN_BACKOFF_MS * RERUN_BACKOFF_FACTOR ** (round - 1);
+}
+async function wait_before_rerun(round) {
+  const delay_ms = rerun_delay_ms(round);
+  if (delay_ms === 0) return;
+  console.info(
+    `\u23F3 Waiting ${String(delay_ms / MS_PER_SECOND)}s before CI job rerun ${String(round + 1)}`
+  );
+  await poll.sleep(delay_ms);
+}
+function report_rerun_error(error) {
+  console.info(`\u26A0\uFE0F CI job rerun failed: ${git_gh_helpers.get_error_message_with_stderr(error)}`);
+  return [];
+}
+async function rerun_failed_jobs(branch_name, round = 0) {
+  try {
+    const entries = await find_rerun_jobs(branch_name);
+    if (entries.length === 0 || await should_merge_first2(branch_name, entries)) return [];
+    await wait_before_rerun(round);
+    return await rerun(branch_name, entries);
+  } catch (error) {
+    return report_rerun_error(error);
+  }
+}
+async function read_rerun_names(branch_name) {
+  try {
+    const entries = await find_rerun_jobs(branch_name);
+    return entries.map(({ job }) => job.name);
+  } catch (error) {
+    return report_rerun_error(error);
+  }
+}
+function reruns_spent_message(names) {
+  return `${RERUNS_SPENT_MESSAGE} (${String(MAX_CHECK_RERUNS)} reruns; still failing: ${names.join(", ")}). Rerun the failed jobs once CI recovers, then run followup again.`;
+}
+var followup_job_rerun = {
+  actions_api_path,
+  read_actions,
+  read_rerun_names,
+  rerun_failed_jobs,
+  reruns_spent_message
+};
+
+export {
+  MAX_CHECK_RERUNS,
+  RERUNS_SPENT_MESSAGE,
+  followup_job_rerun
+};

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

@@ -0,0 +1,47 @@
+import {
+  figure_format
+} from "./chunk-OYZP5ANC.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/time-runtime/time-format.ts
+var SECOND_DECIMALS = 1;
+var LABEL_WIDTH = 24;
+var MINUTES_WIDTH = 9;
+var NOT_MEASURED = "not measured";
+var NO_CALLS = "no tool call to divide";
+var MAX_ROWS = 15;
+function overflow_line(row_count) {
+  if (row_count <= MAX_ROWS) return [];
+  return [
+    `  \u2026 and ${String(row_count - MAX_ROWS)} more (--json carries every row this report holds)`
+  ];
+}
+function format_seconds(duration_ms) {
+  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
+}
+function format_columns(label, minutes, suffix) {
+  return `  ${label.padEnd(LABEL_WIDTH)}${minutes.padStart(MINUTES_WIDTH)}   ${suffix}`;
+}
+function format_row(label, duration_ms, suffix) {
+  return format_columns(label, figure_format.format_minutes(duration_ms), suffix);
+}
+function unmeasured_row(label) {
+  return format_columns(label, "", NOT_MEASURED);
+}
+var time_format = {
+  MAX_ROWS,
+  NO_CALLS,
+  overflow_line,
+  format_seconds,
+  format_columns,
+  format_row,
+  // `format_clock` stays private: `format_window` is its only caller, and a namespace that offers
+  // both invites a second renderer to join the two with its own arrow.
+  unmeasured_row
+};
+
+export {
+  time_format
+};