@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-5FBRMARM.js

@@ -1,578 +0,0 @@
-import {
-  epic_decision
-} from "./chunk-XSKB6ZUA.js";
-import {
-  epic_nested,
-  epic_next
-} from "./chunk-TYNH2R66.js";
-import {
-  epic_cross_repo,
-  epic_fetch
-} from "./chunk-OX3VQLV2.js";
-import {
-  epic_issue
-} from "./chunk-IAD4WLLI.js";
-import {
-  git_gh_issue_batch_read
-} from "./chunk-EXDFKKMH.js";
-import {
-  PAGE_CEILING_CAUSE,
-  cutoff_of
-} from "./chunk-OL6IF4JC.js";
-import {
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_audit_logic
-} from "./chunk-ILIITIMQ.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  issue_read
-} from "./chunk-2BB5ZR2F.js";
-import {
-  issue_citation,
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  parse_json_array_safe
-} from "./chunk-XDF25GSU.js";
-
-// scripts/epic/epic-audit-checks.ts
-var IMPLICIT_DEPENDENCY = "implicit dependency";
-var ORDER_CONTRADICTION = "order contradiction";
-var UNRESOLVED_REFERENCE = "unresolved reference";
-var ORPHAN_CHILD = "orphan child";
-var NESTED_EPIC = "nested epic";
-var CLOSED_EPIC_OPEN_CHILDREN = "closed epic with open children";
-var { key_of } = epic_graph;
-var { known_repos } = epic_audit_logic;
-function shown(reference, current_repo) {
-  return epic_graph.format_reference(reference, current_repo);
-}
-function find_sibling(children, reference) {
-  return children.find((candidate) => key_of(candidate) === key_of(reference));
-}
-function is_ordered(index, child, other) {
-  return epic_audit_logic.depends_on(index, child, other) || epic_audit_logic.depends_on(index, other, child);
-}
-function referenced_siblings(children, child, text, known) {
-  return epic_audit_logic.parse_issue_references(text, child.repo, known).map((reference) => find_sibling(children, reference)).filter(
-    (sibling) => sibling !== void 0 && key_of(sibling) !== key_of(child)
-  );
-}
-function pair_key(from, to) {
-  return `${key_of(from)}->${key_of(to)}`;
-}
-function reported_pairs(findings, current_repo, known) {
-  const pairs = /* @__PURE__ */ new Set();
-  for (const finding of findings) {
-    const [first, second] = epic_audit_logic.parse_issue_references(
-      finding.message,
-      current_repo,
-      known
-    );
-    if (first !== void 0 && second !== void 0) pairs.add(pair_key(first, second));
-  }
-  return pairs;
-}
-function find_implicit_dependencies(children, current_repo, already_reported = []) {
-  const index = epic_graph.index_children(children);
-  const known = known_repos(children, current_repo);
-  const reported = reported_pairs(already_reported, current_repo, known);
-  return children.flatMap(
-    (child) => referenced_siblings(children, child, child.body ?? "", known).filter((other) => !reported.has(pair_key(child, other))).filter((other) => !is_ordered(index, child, other)).map((other) => ({
-      level: "warning",
-      check: IMPLICIT_DEPENDENCY,
-      message: `${shown(child, current_repo)} refers to ${shown(other, current_repo)}, but neither declares a dependency on the other.`
-    }))
-  );
-}
-function is_closed(child) {
-  return child.state === "CLOSED";
-}
-function is_pair_settled(child, target) {
-  return is_closed(child) || is_closed(target);
-}
-function settled_clause(child, other, current_repo) {
-  if (is_closed(child) && is_closed(other)) return "both are closed";
-  return `${shown(is_closed(child) ? child : other, current_repo)} is closed`;
-}
-function order_message(child, other, current_repo, is_settled) {
-  const named = `${shown(child, current_repo)} names ${shown(other, current_repo)} in its acceptance criteria`;
-  if (is_settled) {
-    return `${named} with nothing ordering the two, but ${settled_clause(child, other, current_repo)} \u2014 the order can no longer be broken.`;
-  }
-  return `${named}, but nothing orders the two \u2014 it can run first.`;
-}
-function order_level(child, other, is_settled) {
-  if (is_settled) return "warning";
-  return child.repo === other.repo ? "error" : "warning";
-}
-function order_finding(child, other, current_repo) {
-  const is_settled = is_pair_settled(child, other);
-  return {
-    level: order_level(child, other, is_settled),
-    check: ORDER_CONTRADICTION,
-    message: order_message(child, other, current_repo, is_settled)
-  };
-}
-function find_order_contradictions(children, current_repo) {
-  const index = epic_graph.index_children(children);
-  const known = known_repos(children, current_repo);
-  return children.flatMap(
-    (child) => referenced_siblings(children, child, epic_audit_logic.acceptance_section(child.body), known).filter((other) => !is_ordered(index, child, other)).map((other) => order_finding(child, other, current_repo))
-  );
-}
-function reported_state(states, reference) {
-  const state = states.get(key_of(reference));
-  return state === "OPEN" || state === void 0 ? void 0 : state;
-}
-function reported_references(child, states, known) {
-  return epic_audit_logic.parse_issue_references(child.body ?? "", child.repo, known).filter((reference) => key_of(reference) !== key_of(child)).flatMap((reference) => {
-    const state = reported_state(states, reference);
-    return state === void 0 ? [] : { reference, state };
-  });
-}
-function unresolved_message(child, reported, current_repo) {
-  const named = `${shown(child, current_repo)} refers to ${shown(reported.reference, current_repo)}`;
-  if (reported.state === "UNRESOLVED") {
-    return `${named}, which could not be resolved \u2014 it does not exist, or the lookup failed.`;
-  }
-  return `${named}, which is already closed.`;
-}
-function find_unresolved_references(children, states, current_repo) {
-  const known = known_repos(children, current_repo);
-  return children.flatMap(
-    (child) => reported_references(child, states, known).map((reported) => ({
-      level: "warning",
-      check: UNRESOLVED_REFERENCE,
-      message: unresolved_message(child, reported, current_repo)
-    }))
-  );
-}
-function find_orphans(tracked, claiming_children) {
-  const known = new Set(tracked);
-  return claiming_children.filter((issue_number) => !known.has(issue_number)).map((issue_number) => ({
-    level: "warning",
-    check: ORPHAN_CHILD,
-    message: `${issue_cite.plain_for("linked", issue_number)} names this epic as its parent but is not in its task list.`
-  }));
-}
-function nested_epic_message(child, current_repo) {
-  const named = shown(child, current_repo);
-  return `${named} is itself an epic, so it is not work a run can implement \u2014 epic:next withholds it rather than offering it. This epic will not auto-close from ${named} finishing either: the auto-close only evaluates epics that directly track the issue a merge just closed, so a grandchild merging never reaches this one.`;
-}
-function find_nested_epics(children, current_repo) {
-  return children.filter((child) => epic_nested.is_nested_epic(child)).map((child) => ({
-    level: "warning",
-    check: NESTED_EPIC,
-    message: nested_epic_message(child, current_repo)
-  }));
-}
-function closed_epic_message(open, current_repo) {
-  const names = open.map((child) => shown(child, current_repo)).join(", ");
-  return `this epic is closed but still tracks open ${open.length === 1 ? "child" : "children"} (${names}). A closed epic never surfaces its children in the backlog \u2014 the epic opt-in only applies while the epic is open \u2014 so this work is stranded. Reopen the epic, or close or move those children.`;
-}
-function find_closed_epic_open_children(is_epic_closed, children, current_repo) {
-  if (!is_epic_closed) return [];
-  const open = children.filter((child) => !is_closed(child));
-  if (open.length === 0) return [];
-  return [
-    {
-      level: "error",
-      check: CLOSED_EPIC_OPEN_CHILDREN,
-      message: closed_epic_message(open, current_repo)
-    }
-  ];
-}
-var epic_audit_checks = {
-  IMPLICIT_DEPENDENCY,
-  ORDER_CONTRADICTION,
-  UNRESOLVED_REFERENCE,
-  ORPHAN_CHILD,
-  NESTED_EPIC,
-  CLOSED_EPIC_OPEN_CHILDREN,
-  reported_pairs,
-  find_implicit_dependencies,
-  find_order_contradictions,
-  find_unresolved_references,
-  find_orphans,
-  find_nested_epics,
-  find_closed_epic_open_children
-};
-
-// scripts/epic/epic-audit-orphans.ts
-import { z } from "zod";
-var SEARCH_LIMIT = 50;
-var ORPHAN_SEARCH = "orphan search";
-var UNREADABLE_SEARCH = "Could not list the open issues, so an issue naming this epic as its parent would not have been found.";
-var CAPPED_BY_ISSUES = `The open-issue scan ${PAGE_CEILING_CAUSE}; an issue older than that was not looked at.`;
-var CAPPED_BY_MATCHES = `The open-issue scan filled its ${String(SEARCH_LIMIT)}-match cap; an issue mentioning this epic further down the backlog was not looked at.`;
-var searched_issue_schema = z.object({ number: z.number(), body: z.string().nullable() });
-function names_this_epic(line, epic_number, repo) {
-  return epic_audit_logic.parse_issue_references(line, repo, epic_audit_logic.known_repos([], repo)).some((reference) => reference.repo === repo && reference.number === epic_number);
-}
-function claims_parent(body, epic_number, repo) {
-  return (body ?? "").split("\n").filter((line) => epic_audit_logic.has_parent_marker(line)).some((line) => names_this_epic(line, epic_number, repo));
-}
-async function find_claiming_issues(epic_number, repo) {
-  const { json, is_capped } = await git_gh_command.issue_search_body(
-    issue_cite.plain_for("github", epic_number),
-    SEARCH_LIMIT
-  );
-  if (json === void 0) return { kind: "unreadable" };
-  const rows = parse_json_array_safe(json, searched_issue_schema);
-  const numbers = rows.filter((issue) => issue.number !== epic_number && claims_parent(issue.body, epic_number, repo)).map((issue) => issue.number);
-  return { kind: "read", numbers, cutoff: cutoff_of(rows.length, SEARCH_LIMIT, is_capped) };
-}
-function search_finding(level, message) {
-  return [{ level, check: ORPHAN_SEARCH, message }];
-}
-function search_findings(search) {
-  if (search.kind === "unreadable") return search_finding("error", UNREADABLE_SEARCH);
-  if (search.cutoff === "page_ceiling") return search_finding("warning", CAPPED_BY_ISSUES);
-  if (search.cutoff === "row_limit") return search_finding("warning", CAPPED_BY_MATCHES);
-  return [];
-}
-function claimed_numbers(search) {
-  return search.kind === "read" ? search.numbers : [];
-}
-function locally_tracked(snapshot) {
-  return epic_parse.parse_task_list_issue_numbers(snapshot.body);
-}
-var epic_audit_orphans = {
-  claimed_numbers,
-  claims_parent,
-  find_claiming_issues,
-  locally_tracked,
-  search_findings
-};
-
-// scripts/epic/epic-audit-rationale.ts
-var UNJUSTIFIED_ORDER = "unjustified order";
-var { key_of: key_of2 } = epic_graph;
-function find_child(children, reference) {
-  return children.find((candidate) => key_of2(candidate) === key_of2(reference));
-}
-function is_open_local(child, current_repo) {
-  return child.state !== "CLOSED" && child.repo === current_repo;
-}
-function order_pairs(links, children, epic_repo, current_repo) {
-  return links.flatMap((link) => {
-    const blocker = find_child(children, { repo: epic_repo, number: link.blocker });
-    const blocked = find_child(children, { repo: epic_repo, number: link.blocked });
-    if (blocker === void 0 || blocked === void 0 || !is_open_local(blocker, current_repo) || !is_open_local(blocked, current_repo)) {
-      return [];
-    }
-    return [{ blocker, blocked }];
-  });
-}
-function pair_ends(pairs) {
-  const seen = /* @__PURE__ */ new Set();
-  return pairs.flatMap((pair) => [pair.blocker, pair.blocked]).filter((child) => {
-    const is_new = !seen.has(key_of2(child));
-    seen.add(key_of2(child));
-    return is_new;
-  });
-}
-function named_keys(text, pair, current_repo) {
-  const known = epic_audit_logic.known_repos([pair.blocker, pair.blocked], current_repo);
-  return new Set(
-    epic_audit_logic.parse_issue_references(text, current_repo, known).map((reference) => key_of2(reference))
-  );
-}
-function has_record_on(input, on, about, pair) {
-  return (input.comments.get(key_of2(on)) ?? []).some(
-    (comment) => named_keys(comment, pair, input.current_repo).has(key_of2(about))
-  );
-}
-function is_justified(input, pair) {
-  const declared = named_keys(input.decisions, pair, input.current_repo);
-  if (declared.has(key_of2(pair.blocker)) && declared.has(key_of2(pair.blocked))) return true;
-  return has_record_on(input, pair.blocker, pair.blocked, pair) || has_record_on(input, pair.blocked, pair.blocker, pair);
-}
-function unjustified_message(pair, current_repo) {
-  const blocker = epic_graph.format_reference(pair.blocker, current_repo);
-  const blocked = epic_graph.format_reference(pair.blocked, current_repo);
-  return `The declared order ${blocker} -> ${blocked} has no recorded reason \u2014 neither the epic's \`## Decisions\` or \`## Split rationale\` section nor a comment on either issue mentions the other. Remove it with \`josh epic --remove <E> ${String(pair.blocker.number)} ${String(pair.blocked.number)}\`, or record why with \`--decision-file\`, whose text has to name both issues for this check to find it.`;
-}
-function is_reportable(input, pair) {
-  return input.comments.has(key_of2(pair.blocker)) && input.comments.has(key_of2(pair.blocked));
-}
-function find_unjustified_orders(input) {
-  return input.pairs.filter((pair) => is_reportable(input, pair) && !is_justified(input, pair)).map((pair) => ({
-    level: "error",
-    check: UNJUSTIFIED_ORDER,
-    message: unjustified_message(pair, input.current_repo)
-  }));
-}
-var epic_audit_rationale = {
-  order_pairs,
-  pair_ends,
-  find_unjustified_orders
-};
-
-// scripts/epic/epic-audit-report.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var PASS_LINE = "\u2713 No cross-child contradictions found.";
-var UNREADABLE_CHECK = "unreadable children";
-function anomaly_findings(anomalies) {
-  return anomalies.map((anomaly) => ({
-    level: "error",
-    check: anomaly.kind.replaceAll("_", " "),
-    message: anomaly.message
-  }));
-}
-function unreadable_findings(missing, current_repo) {
-  if (missing.length === 0) return [];
-  const list = epic_graph.format_references(missing, current_repo);
-  return [
-    {
-      level: "error",
-      check: UNREADABLE_CHECK,
-      message: `Could not read ${list}; the audit would be reading an incomplete epic.`
-    }
-  ];
-}
-function has_error(findings) {
-  return findings.some((finding) => finding.level === "error");
-}
-function build_result(findings) {
-  return { findings, exit_code: has_error(findings) ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE };
-}
-function format_finding(finding) {
-  return `${finding.level === "error" ? "\u2716" : "\u26A0"} ${finding.check}: ${finding.message}`;
-}
-function sort_findings(findings) {
-  return findings.toSorted((left, right) => {
-    if (left.level === right.level) return 0;
-    return left.level === "error" ? -1 : 1;
-  });
-}
-function format_report(result) {
-  if (result.findings.length === 0) return PASS_LINE;
-  const lines = sort_findings(result.findings).map((finding) => format_finding(finding));
-  const errors = result.findings.filter((finding) => finding.level === "error").length;
-  const warnings = result.findings.length - errors;
-  return [
-    ...lines,
-    "",
-    `${String(errors)} error(s), ${String(warnings)} warning(s). Only errors fail this check.`
-  ].join("\n");
-}
-var epic_audit_report = {
-  PASS_LINE,
-  anomaly_findings,
-  unreadable_findings,
-  build_result,
-  format_report
-};
-
-// scripts/epic/epic-audit-cli.ts
-var FAILURE_EXIT_CODE2 = 1;
-var USAGE = "Usage: josh epic:audit <epic-number>";
-var UNREADABLE_REPO = "Could not read this repository as `owner/name`, so a reference could not be resolved against it \u2014 check `gh auth status` and that this checkout has a GitHub remote.";
-function body_reader(scope) {
-  return {
-    repo: scope,
-    from_json: (json) => epic_issue.parse_epic_issue(json)?.body,
-    read_rest: async (issue_number) => await git_gh_command.issue_get_body(String(issue_number), scope)
-  };
-}
-async function attach_bodies(children, repo) {
-  const bodies = await git_gh_issue_batch_read.read_across(
-    children.map((child) => ({
-      number: child.number,
-      repo: epic_fetch.scope_for(child.repo, repo)
-    })),
-    body_reader
-  );
-  return children.map((child, index) => ({ ...child, body: bodies[index] }));
-}
-async function resolve_reference_states(referenced, current_repo) {
-  const fetched = await Promise.all(
-    referenced.map(
-      async (reference) => await epic_fetch.fetch_child(
-        reference.number,
-        reference.repo,
-        epic_fetch.scope_for(reference.repo, current_repo)
-      )
-    )
-  );
-  return new Map(
-    referenced.map((reference, index) => [
-      epic_graph.key_of(reference),
-      fetched[index]?.state ?? "UNRESOLVED"
-    ])
-  );
-}
-function outside_references(children, current_repo) {
-  const own = new Set(children.map((child) => epic_graph.key_of(child)));
-  const known = epic_audit_logic.known_repos(children, current_repo);
-  const cited = children.flatMap(
-    (child) => epic_audit_logic.parse_issue_references(child.body ?? "", child.repo, known)
-  );
-  const owner = epic_cross_repo.owner_of(current_repo);
-  return epic_audit_logic.unique_references(cited).filter((reference) => !own.has(epic_graph.key_of(reference))).filter((reference) => epic_cross_repo.is_same_owner_repo(reference.repo, owner));
-}
-function body_findings(input) {
-  return [
-    ...epic_audit_checks.find_implicit_dependencies(
-      input.children,
-      input.repo,
-      input.contradictions
-    ),
-    ...epic_audit_checks.find_unresolved_references(
-      input.children,
-      input.reference_states,
-      input.repo
-    ),
-    ...epic_audit_checks.find_nested_epics(input.children, input.repo)
-  ];
-}
-function epic_findings(input) {
-  return [
-    ...epic_audit_rationale.find_unjustified_orders({
-      pairs: input.order_pairs,
-      decisions: input.decisions,
-      comments: input.order_comments,
-      current_repo: input.repo
-    }),
-    ...epic_audit_orphans.search_findings(input.claiming),
-    ...epic_audit_checks.find_orphans(
-      input.tracked,
-      epic_audit_orphans.claimed_numbers(input.claiming)
-    ),
-    ...epic_audit_checks.find_closed_epic_open_children(
-      input.is_epic_closed,
-      input.children,
-      input.repo
-    )
-  ];
-}
-function audit(input) {
-  return epic_audit_report.build_result([
-    ...input.anomalies,
-    ...input.contradictions,
-    ...body_findings(input),
-    ...epic_findings(input)
-  ]);
-}
-function graph_anomalies(snapshot, children, links) {
-  const is_declared = epic_next.is_order_declared(snapshot.body, links);
-  return epic_audit_report.anomaly_findings(
-    epic_graph.find_anomalies(children, links, is_declared, snapshot.repo)
-  );
-}
-function fetch_anomalies(snapshot, children, links) {
-  return [
-    ...epic_audit_report.unreadable_findings(
-      epic_fetch.missing_children(snapshot),
-      snapshot.current_repo
-    ),
-    ...graph_anomalies(snapshot, children, links)
-  ];
-}
-async function read_order_comments(pairs) {
-  const ends = epic_audit_rationale.pair_ends(pairs);
-  const parsed = await Promise.all(
-    ends.map(async (child) => {
-      const listing = await git_gh_command.issue_list_comments(String(child.number));
-      return await issue_read.parse_comments(listing);
-    })
-  );
-  return new Map(
-    ends.flatMap((child, index) => {
-      const comments = parsed[index];
-      return comments === void 0 ? [] : [[epic_graph.key_of(child), issue_read.trusted_bodies(comments)]];
-    })
-  );
-}
-function no_children_reason(snapshot, epic_number) {
-  const epic = session_cite.issue(epic_number, void 0, snapshot.repo);
-  if (snapshot.body_failure !== void 0) {
-    return `Could not read the body of ${epic}. Its task list is what names the children \u2014 check \`gh auth status\` and the connection.`;
-  }
-  if (snapshot.child_numbers.length === 0) return `${epic} tracks no children in a task list.`;
-  return void 0;
-}
-async function read_epic_closed(epic_number, scope) {
-  const raw = await git_gh_command.issue_get_state_and_relations(String(epic_number), scope);
-  const parsed = epic_issue.parse_epic_issue(raw);
-  return parsed !== void 0 && epic_issue.normalize_state(parsed.state) === epic_issue.CLOSED;
-}
-async function to_audit_input(snapshot, children, epic_number, repo) {
-  const links = epic_parse.parse_dependency_links(snapshot.body);
-  const order_pairs2 = epic_audit_rationale.order_pairs(links, children, snapshot.repo, repo);
-  return {
-    epic_number,
-    repo,
-    children,
-    tracked: epic_audit_orphans.locally_tracked(snapshot),
-    reference_states: await resolve_reference_states(outside_references(children, repo), repo),
-    claiming: await epic_audit_orphans.find_claiming_issues(epic_number, repo),
-    anomalies: fetch_anomalies(snapshot, children, links),
-    contradictions: epic_audit_checks.find_order_contradictions(children, repo),
-    order_pairs: order_pairs2,
-    decisions: epic_decision.read_recorded_reasons(snapshot.body),
-    order_comments: await read_order_comments(order_pairs2),
-    is_epic_closed: await read_epic_closed(epic_number, epic_fetch.scope_for(snapshot.repo, repo))
-  };
-}
-async function gather(epic_number, repo) {
-  const snapshot = await epic_fetch.fetch_epic(epic_number, repo);
-  const reason = no_children_reason(snapshot, epic_number);
-  if (reason !== void 0) {
-    console.error(reason);
-    return void 0;
-  }
-  const children = await attach_bodies(
-    snapshot.children.map((child) => ({ ...child, body: void 0 })),
-    repo
-  );
-  if (snapshot.has_external_children) console.info(epic_next.EXTERNAL_NOTICE);
-  return await to_audit_input(snapshot, children, epic_number, repo);
-}
-async function report_audit(epic_number, repo) {
-  const input = await gather(epic_number, repo);
-  if (input === void 0) return FAILURE_EXIT_CODE2;
-  const result = audit(input);
-  console.info(issue_citation.linkify(epic_audit_report.format_report(result), repo));
-  return result.exit_code;
-}
-async function run(argv) {
-  const epic_number = epic_issue.parse_epic_number(argv[0]);
-  if (epic_number === void 0) {
-    console.error(USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  const repo = await git_gh_command.repo_get_name_with_owner();
-  if (repo === void 0) {
-    console.error(UNREADABLE_REPO);
-    return FAILURE_EXIT_CODE2;
-  }
-  return await report_audit(epic_number, repo);
-}
-var epic_audit_cli = {
-  UNREADABLE_REPO,
-  parse_epic_number: epic_issue.parse_epic_number,
-  attach_bodies,
-  resolve_reference_states,
-  outside_references,
-  read_order_comments,
-  audit,
-  run
-};
-
-export {
-  epic_audit_cli
-};

package/dist/commands/chunk-5RG4S66L.js

@@ -1,47 +0,0 @@
-import {
-  figure_format
-} from "./chunk-ZZXO6TFH.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
-};