@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-U46YTYJQ.js

@@ -0,0 +1,92 @@
+import {
+  review_readers_scan
+} from "./chunk-W6MVQEMO.js";
+import {
+  git_grep_hits
+} from "./chunk-LU5EOGFQ.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/review/review-untouched-readers.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+var SOURCE_FILE = /\.(?:ts|js)$/u;
+var SEARCH_PATHS = ["*.ts", "*.js", "*.svelte", ":(exclude)*.snap"];
+var WORD_FLAG = "-w";
+var MAX_HITS = 10;
+var MAX_NAMES = 30;
+var HEADING = "## Readers outside the diff";
+var ROLE_LINE = "Each exported name this change edits, with every line outside the changed paths that names it (`git grep -w`). Check each reader still holds under the new meaning \u2014 the self-check's \"Every caller moved with it\" (`prompts/review.md`). A reader left on the old meaning is a finding at the reader's `file:line`. A reader reaching the name through an alias or a re-derivation is not listed.";
+var SEARCH_FAILED = "  - git grep failed; not searched";
+var READ_FAILED = "The readers outside the diff could not be read; search them yourself:";
+var OMITTED_TAIL = "not searched; search their readers yourself";
+var NO_READ = { readers: [], omitted: 0, has_failed: false };
+var FAILED_READ = { readers: [], omitted: 0, has_failed: true };
+async function file_edits(request, relative) {
+  const { root, base } = request;
+  const diff = await git_spawn.read(["-C", root, "diff", "-U0", "--no-color", base, "--", relative]);
+  if (diff.length === 0) return { relative, edits: [] };
+  try {
+    const source = readFileSync(path.join(root, relative), "utf8");
+    return { relative, edits: review_readers_scan.edited(source, diff) };
+  } catch {
+    return { relative, edits: [] };
+  }
+}
+function excluded(paths) {
+  return paths.map((relative) => `:(exclude,literal)${relative}`);
+}
+async function readers_of(request, entry, edit) {
+  const pathspecs = [...SEARCH_PATHS, ...excluded(request.paths)];
+  const found = await git_grep_hits.search(edit.target, [WORD_FLAG], pathspecs, request.root);
+  return { target: edit.target, origin: `${entry.relative}:${String(edit.line)}`, ...found };
+}
+async function read(request) {
+  const sources = request.paths.filter((relative) => SOURCE_FILE.test(relative));
+  const files = await Promise.all(
+    sources.map(async (relative) => await file_edits(request, relative))
+  );
+  const pairs = files.flatMap((entry) => entry.edits.map((edit) => ({ entry, edit })));
+  const capped = pairs.slice(0, MAX_NAMES);
+  const all = await Promise.all(
+    capped.map(async ({ entry, edit }) => await readers_of(request, entry, edit))
+  );
+  const readers = all.filter((entry) => entry.has_failed || entry.hits.length > 0);
+  return { readers, omitted: pairs.length - capped.length, has_failed: false };
+}
+function hit_line(hit) {
+  return `  - ${hit.path}:${hit.line}  ${hit.excerpt}`;
+}
+function readers_lines(readers) {
+  const head = `- \`${readers.target}\` \u2014 ${readers.origin}`;
+  if (readers.has_failed) return [head, SEARCH_FAILED];
+  const more = readers.hits.length - MAX_HITS;
+  const tail = more > 0 ? [`  - \u2026 and ${String(more)} more`] : [];
+  return [head, ...readers.hits.slice(0, MAX_HITS).map((hit) => hit_line(hit)), ...tail];
+}
+function omitted_lines(omitted) {
+  if (omitted === 0) return [];
+  return [`- \u2026 and ${String(omitted)} more edited names ${OMITTED_TAIL}`];
+}
+function brief_block(read_result = NO_READ) {
+  const { readers, omitted, has_failed } = read_result;
+  if (has_failed) return ["", `${HEADING}
+${READ_FAILED}`];
+  if (omitted === 0 && readers.length === 0) return [];
+  const listed = readers.flatMap((entry) => readers_lines(entry));
+  return ["", [HEADING, ROLE_LINE, ...listed, ...omitted_lines(omitted)].join("\n")];
+}
+var review_untouched_readers = {
+  brief_block,
+  FAILED_READ,
+  HEADING,
+  MAX_NAMES,
+  OMITTED_TAIL,
+  read,
+  READ_FAILED
+};
+
+export {
+  review_untouched_readers
+};

package/dist/commands/chunk-U5EO4QEV.js

@@ -0,0 +1,48 @@
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/git/changed-paths.ts
+function to_paths(raw) {
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+}
+async function tracked_names() {
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) {
+    return { tracked: to_paths(await git_command.diff_main_names()), base: "fallback" };
+  }
+  return { tracked: to_paths(await git_command.diff_names_since(base)), base: "merge_base" };
+}
+async function read_changed_parts() {
+  const { tracked, base } = await tracked_names();
+  const untracked = to_paths(await git_command.untracked_names());
+  return { tracked, untracked, base };
+}
+async function read_changed_paths(is_staged) {
+  if (is_staged) return to_paths(await git_command.diff_cached_names());
+  const { tracked, untracked } = await read_changed_parts();
+  return [...tracked, ...untracked];
+}
+async function read_changed_since(commit) {
+  const tracked = to_paths(await git_command.diff_names_since(commit));
+  const untracked = to_paths(await git_command.untracked_names());
+  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])];
+}
+async function read_held_at(commit, paths) {
+  if (paths.length === 0) return [];
+  return to_paths(await git_command.tree_names_at(commit, paths));
+}
+var changed_paths = {
+  read_changed_parts,
+  read_changed_paths,
+  read_changed_since,
+  read_held_at,
+  to_paths
+};
+
+export {
+  changed_paths
+};

package/dist/commands/chunk-UCO333EX.js

@@ -0,0 +1,47 @@
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  gh_author_association
+} from "./chunk-5YTEMF4O.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/issue/issue-body-or-comment.ts
+import { z } from "zod";
+var BODY_FIELDS = `body,${gh_author_association.AUTHOR_FIELDS}`;
+var body_schema = z.looseObject({
+  body: z.string().nullish(),
+  ...gh_author_association.author_fields_schema
+});
+function is_blank_body(body) {
+  return body?.trim().length === 0;
+}
+async function is_author_trusted(row, repo) {
+  const author = gh_author_association.author_of(row);
+  return await gh_author_association.is_trusted(
+    repo === void 0 ? author : { ...author, login: void 0 }
+  );
+}
+async function is_writable_body(issue_number, repo) {
+  const json = await git_gh_command.issue_view_json(issue_number, BODY_FIELDS, repo);
+  const parsed = json === void 0 ? void 0 : parse_json_object_or_undefined(json, body_schema);
+  if (parsed === void 0 || !is_blank_body(parsed.body ?? "")) return false;
+  return await is_author_trusted(parsed, repo);
+}
+async function post(issue_number, text, repo) {
+  if (await is_writable_body(issue_number, repo)) {
+    const url = await git_gh_command.issue_edit_body(issue_number, text, repo);
+    return { destination: "body", url };
+  }
+  return {
+    destination: "comment",
+    url: await git_gh_command.issue_comment(issue_number, text, repo)
+  };
+}
+var issue_body_or_comment = { is_author_trusted, post };
+
+export {
+  issue_body_or_comment
+};

package/dist/commands/chunk-UIXQ4IYT.js

@@ -0,0 +1,445 @@
+import {
+  lane_stage_budget
+} from "./chunk-AXXEMVRJ.js";
+import {
+  lane_breakdown_laps
+} from "./chunk-K6P5PISC.js";
+import {
+  lane_breakdown_calls,
+  lane_breakdown_implement
+} from "./chunk-A3JYZWBS.js";
+import {
+  lane_breakdown
+} from "./chunk-R7PYR4HW.js";
+import {
+  lane_net_time
+} from "./chunk-SNSZ25XZ.js";
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-breakdown-pinned.ts
+var MAX_SHOWN = 5;
+var DISCARDED_LABEL = "background test:pinned probes discarded";
+var TYPE_CHECK_LABEL = "type check";
+function is_lane_row(entry, issue) {
+  return entry.kind === lane_ledger.KIND.TEST_PINNED && entry.issue === issue;
+}
+function is_discarded(entry) {
+  return entry.discarded === true;
+}
+function is_in_pre_detach(entry, breakdown) {
+  const at_ms = Date.parse(entry.at);
+  return breakdown.pre_detach.some((span) => at_ms >= span.from_ms && at_ms <= span.to_ms);
+}
+function rows_of(entries, issue, breakdown) {
+  return entries.filter((entry) => is_lane_row(entry, issue)).filter((entry) => !is_discarded(entry) && is_in_pre_detach(entry, breakdown));
+}
+function discarded_text(entries, issue) {
+  const rows = entries.filter((entry) => is_lane_row(entry, issue)).filter((entry) => is_discarded(entry));
+  if (rows.length === 0) return "";
+  const elapsed_ms = rows.reduce((sum, row) => sum + row.elapsed_ms, 0);
+  return `${DISCARDED_LABEL} ${String(rows.length)}, ${lane_breakdown.minutes_text(elapsed_ms)}`;
+}
+function probe_text(probe) {
+  const tests = probe.tests === void 0 ? "" : ` ${String(probe.tests)} test files`;
+  const pinned_by = probe.pinned_by === void 0 ? "" : ` (${TYPE_CHECK_LABEL})`;
+  return `${probe.file}${tests} ${lane_breakdown.minutes_text(probe.elapsed_ms)}${pinned_by}`;
+}
+function skipped_counts(rewired, over_cap) {
+  const named = [
+    [rewired, "rewired"],
+    [over_cap, "over cap"]
+  ];
+  return named.filter(([count2]) => count2 > 0).map(([count2, label]) => `${String(count2)} ${label}`);
+}
+function detail_text(rows) {
+  if (rows.length === 0) return "";
+  const probes = rows.flatMap((row) => row.probes).toSorted((left, right) => right.elapsed_ms - left.elapsed_ms);
+  const held = rows.reduce((sum, row) => sum + row.held, 0);
+  const rewired = rows.reduce((sum, row) => sum + (row.rewired ?? 0), 0);
+  const over_cap = rows.reduce((sum, row) => sum + (row.over_cap ?? 0), 0);
+  const total = held + rewired + over_cap + probes.length;
+  const head = `test:pinned ${String(total)} hunks, ${String(held)} cached, ${String(probes.length)} probed`;
+  const counts = [head, ...skipped_counts(rewired, over_cap)];
+  return ` (${[...counts, ...probes.slice(0, MAX_SHOWN).map((probe) => probe_text(probe))].join(", ")})`;
+}
+var lane_breakdown_pinned = { detail_text, discarded_text, rows_of };
+
+// scripts/lane/lane-breakdown-related.ts
+var LABEL = "test:related";
+function is_lane_row2(entry, issue) {
+  return entry.kind === lane_ledger.KIND.TEST_RELATED && entry.issue === issue;
+}
+function top_hub(rows) {
+  const tally = /* @__PURE__ */ new Map();
+  for (const { over_cap_hub } of rows) {
+    if (over_cap_hub !== void 0) tally.set(over_cap_hub, (tally.get(over_cap_hub) ?? 0) + 1);
+  }
+  return [...tally].toSorted((first, second) => second[1] - first[1])[0]?.[0];
+}
+function over_cap_text(entries, issue) {
+  const rows = entries.filter((entry) => is_lane_row2(entry, issue));
+  const over_cap = Math.max(0, ...rows.map((row) => row.over_cap ?? 0));
+  if (over_cap === 0) return "";
+  const capped = rows.filter((row) => (row.over_cap ?? 0) > 0).length;
+  const hub = top_hub(rows);
+  const text2 = `${LABEL} ${String(over_cap)} over cap, in ${String(capped)} of ${String(rows.length)} runs`;
+  return hub === void 0 ? text2 : `${text2}, hub ${hub}`;
+}
+var lane_breakdown_related = { over_cap_text };
+
+// scripts/lane/lane-check-stats.ts
+var DECIMALS = 1;
+var WHOLE_GATE_LABEL = "gate (whole)";
+var COLUMNS = ["check", "median (s)", "max (s)", "runs", "reused", "no-op", "fallback"];
+var FALLBACK_COLUMNS = ["fallback reason", "runs"];
+var RELATED_LABEL = "test:related";
+function is_gate(entry) {
+  return entry.kind === lane_ledger.KIND.GATE;
+}
+function cell(milliseconds) {
+  return milliseconds === void 0 ? lane_stage_stats.NOT_MEASURED : (milliseconds / MS_PER_SECOND).toFixed(DECIMALS);
+}
+function header(columns) {
+  return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => "---"))];
+}
+function count(runs, is_counted) {
+  return String(runs.filter((check) => is_counted(check)).length);
+}
+function check_row(label, checks) {
+  const runs = checks.filter((check) => check.label === label);
+  const timed = runs.filter((check) => check.is_reused !== true && check.is_unmoved !== true);
+  const elapsed = timed.map((check) => check.elapsed_ms);
+  return lane_stats.to_row([
+    label,
+    cell(lane_stats.median(elapsed)),
+    cell(lane_stats.peak(elapsed)),
+    String(runs.length),
+    count(runs, (check) => check.is_reused === true),
+    count(runs, (check) => check.is_unmoved === true),
+    count(runs, (check) => check.fallback !== void 0)
+  ]);
+}
+function whole_gate(gate) {
+  return {
+    label: WHOLE_GATE_LABEL,
+    elapsed_ms: gate.elapsed_ms,
+    is_passed: gate.is_passed,
+    is_reused: gate.is_reused
+  };
+}
+function is_push_miss(entry) {
+  return entry.kind === lane_ledger.KIND.PUSH_MISS;
+}
+function is_related_lap(entry) {
+  return entry.kind === lane_ledger.KIND.SHIP_LAP && entry.step.split(" \u203A ").at(-1) === RELATED_LABEL;
+}
+function related_checks(entries) {
+  return entries.filter(is_related_lap).map((entry) => ({
+    label: RELATED_LABEL,
+    elapsed_ms: entry.elapsed_ms,
+    is_reused: entry.is_reused
+  }));
+}
+function push_reason(miss) {
+  return `pre-push ${miss.scope}: ${miss.reason}`;
+}
+function fallback_table(checks, misses) {
+  const fallbacks = checks.map((check) => check.fallback).filter((reason) => reason !== void 0);
+  const reasons = [...fallbacks, ...misses.map((miss) => push_reason(miss))];
+  const kinds = [...new Set(reasons)];
+  const rows = kinds.map(
+    (kind) => lane_stats.to_row([kind, String(reasons.filter((reason) => reason === kind).length)])
+  );
+  return [...header(FALLBACK_COLUMNS), ...rows].join("\n");
+}
+function table(entries, window) {
+  const windowed = lane_stats.in_window(entries, window);
+  const gates = windowed.filter(is_gate);
+  const checks = [...gates.flatMap((gate) => gate.checks ?? []), ...related_checks(windowed)];
+  const rows = [...gates.map((gate) => whole_gate(gate)), ...checks];
+  const labels = [...new Set(rows.map((row) => row.label))];
+  return [
+    [...header(COLUMNS), ...labels.map((label) => check_row(label, rows))].join("\n"),
+    fallback_table(checks, windowed.filter(is_push_miss))
+  ].join("\n\n");
+}
+var lane_check_stats = { WHOLE_GATE_LABEL, cell, header, table };
+
+// scripts/lane/lane-ci-path-stats.ts
+var COLUMNS2 = ["followup critical path", "runs", "median (s)", "max (s)"];
+function settled({ last_check, check_ms }) {
+  if (last_check === void 0) return void 0;
+  const elapsed_ms = check_ms?.[last_check];
+  return elapsed_ms === void 0 ? void 0 : { name: last_check, elapsed_ms };
+}
+function last_check_of(entry) {
+  if (entry.kind !== lane_ledger.KIND.STAGE || entry.stage !== lane_ledger_write.CI_WAIT_STAGE) {
+    return void 0;
+  }
+  return settled(entry);
+}
+function name_row(name, lasts) {
+  const elapsed = lasts.filter((last) => last.name === name).map((last) => last.elapsed_ms);
+  return lane_stats.to_row([
+    name,
+    String(elapsed.length),
+    lane_check_stats.cell(lane_stats.median(elapsed)),
+    lane_check_stats.cell(lane_stats.peak(elapsed))
+  ]);
+}
+function table2(entries, window) {
+  const lasts = lane_stats.in_window(entries, window).filter((entry) => entry.kind !== lane_ledger.KIND.STAGE || entry.has_rerun !== true).map((entry) => last_check_of(entry)).filter((last) => last !== void 0);
+  const names = [...new Set(lasts.map((last) => last.name))];
+  return [...lane_check_stats.header(COLUMNS2), ...names.map((name) => name_row(name, lasts))].join(
+    "\n"
+  );
+}
+function latest_check(entries, issue) {
+  return entries.filter((entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue).map((entry) => last_check_of(entry)).findLast((found) => found !== void 0);
+}
+function last_check_name(entries, issue) {
+  return latest_check(entries, issue)?.name;
+}
+function last_check_text(entries, issue) {
+  const last = latest_check(entries, issue);
+  return last === void 0 ? "" : ` (last check: ${last.name} ${lane_check_stats.cell(last.elapsed_ms)}s)`;
+}
+var lane_ci_path_stats = { last_check_name, last_check_text, table: table2 };
+
+// scripts/lane/lane-elapsed-time.ts
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
+var AUTOMATIC_STAGES = /* @__PURE__ */ new Set([
+  "gate",
+  "pre-detach",
+  "followup",
+  lane_ledger.CI_WAIT_STAGE
+]);
+function tool_spans(calls) {
+  return calls.flatMap(
+    (call) => call.duration_ms === void 0 || EDIT_TOOLS.has(call.tool ?? "") ? [] : { from_ms: call.started_ms, to_ms: call.started_ms + call.duration_ms }
+  );
+}
+function stage_spans(entries, issue) {
+  return entries.flatMap(
+    (entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && AUTOMATIC_STAGES.has(entry.stage) ? { from_ms: Date.parse(entry.at) - entry.elapsed_ms, to_ms: Date.parse(entry.at) } : []
+  );
+}
+function human_spans(entries, events, issue, span) {
+  return lane_net_time.hold_waits(
+    entries,
+    events.filter((event) => event.kind === "park"),
+    issue,
+    span
+  );
+}
+function tool_ms(span, calls) {
+  return tool_spans(calls).reduce((sum, call) => sum + lane_breakdown.covered_ms(span, [call]), 0);
+}
+function partition(span, human, automatic, calls) {
+  const total_ms = span.to_ms - span.from_ms;
+  const human_ms = lane_breakdown.covered_ms(span, human);
+  const occupied_ms = lane_breakdown.covered_ms(span, [...human, ...automatic]);
+  const remainder_ms = total_ms - occupied_ms;
+  return {
+    total_ms,
+    human_ms,
+    automatic_ms: occupied_ms - human_ms,
+    work_ms: calls.length > 0 ? remainder_ms : 0,
+    unclassified_ms: calls.length > 0 ? 0 : remainder_ms,
+    tool_ms: tool_ms(span, calls),
+    within_target: total_ms <= lane_stage_budget.TARGET_MINUTES * MS_PER_MINUTE
+  };
+}
+function of(entries, events, issue, calls) {
+  const span = lane_net_time.span_of(entries, issue);
+  if (span === void 0) return void 0;
+  const human = human_spans(entries, events, issue, span);
+  const automatic = [
+    ...lane_net_time.automatic_waits(entries, events, issue, span),
+    ...stage_spans(entries, issue),
+    ...tool_spans(calls)
+  ];
+  return partition(span, human, automatic, calls);
+}
+function text(timing) {
+  const minutes = lane_breakdown.minutes_text;
+  const status = timing.within_target ? "within target" : "over target";
+  return [
+    `End-to-end ${minutes(timing.total_ms)} (${status}); ${lane_stage_budget.DESCRIPTION}`,
+    `Exclusive wall clock: off-tool work ${minutes(timing.work_ms)}; automatic wait ${minutes(timing.automatic_ms)}; human wait ${minutes(timing.human_ms)}; unclassified (missing transcripts) ${minutes(timing.unclassified_ms)}`,
+    `Tool cumulative ${minutes(timing.tool_ms)} (parallel calls overlap; not additive to wall clock). Off-tool work includes unrecorded activity; automatic wait includes tool responses, gate, CI, yield, outage and sleep. Legacy net excludes more than human wait.`
+  ].join("\n");
+}
+var lane_elapsed_time = { of, text };
+
+// scripts/lane/lane-breakdown-text.ts
+var HEADING = "Net time by stage, longest first";
+var EXCLUDED = "waits taken out (park, outage, usage limit, yield, split run, host sleep)";
+var SLEPT = "of which host sleep";
+var YIELDED = "of which yield wait";
+var HOLDER = "yield wait: holder remaining";
+var GAP = "yield wait: redispatch gap (offer + launch)";
+var UNSPLIT = "yield wait: no holder named, unsplit";
+var OUTSIDE = "outside calls";
+var DRIVER = "(outside lane net)";
+function part_text(part) {
+  return `${part.name} ${lane_breakdown.minutes_text(part.ms)}`;
+}
+function budget_of(name) {
+  const stages = {
+    [lane_breakdown.PLAN_STAGE]: "plan",
+    [lane_breakdown.IMPLEMENT_STAGE]: "implement",
+    [lane_breakdown.DRIVER_FOLLOWUP_STAGE]: "followup"
+  };
+  const ship = lane_breakdown.is_ship_stage(name) ? "ship" : void 0;
+  return stages[name] ?? ship;
+}
+function over_text(stage) {
+  const budget = budget_of(stage.name);
+  const over = budget === void 0 ? void 0 : lane_stage_budget.over_minutes(budget, stage.ms);
+  return over === void 0 ? "" : `, over budget +${String(over)} min`;
+}
+function kind_text(kind, untimed) {
+  const count2 = untimed.get(kind.name) ?? 0;
+  return count2 > 0 ? `${part_text(kind)} + ${String(count2)} backgrounded, untimed` : part_text(kind);
+}
+function detail_text2(detail) {
+  const kinds = detail.kinds.map((kind) => kind_text(kind, detail.untimed));
+  const count2 = String(detail.background);
+  const background = detail.background > 0 ? [`${count2} backgrounded calls, their waits in editing & thinking`] : [];
+  return ` (${[...kinds, ...background].join(", ")})`;
+}
+function reason_text(reason) {
+  return reason === void 0 ? "" : ` (${reason})`;
+}
+function outside_text(outside) {
+  if (outside === void 0) return void 0;
+  const minutes = `${OUTSIDE} ${lane_breakdown.minutes_text(outside.ms)}`;
+  const count2 = String(outside.background);
+  const background = outside.background > 0 ? [`${count2} backgrounded calls, their waits in it`] : [];
+  return ` (${[minutes, ...background].join(", ")})`;
+}
+function suffix_of(name, report) {
+  const suffixes = {
+    [lane_breakdown.PLAN_STAGE]: outside_text(report.plan_outside),
+    [lane_breakdown.IMPLEMENT_STAGE]: detail_text2(report.detail),
+    [lane_breakdown.PRE_DETACH_STAGE]: report.pinned
+  };
+  return suffixes[name] ?? reason_text(report.breakdown.reasons?.get(name));
+}
+function implement_calls(detail) {
+  return detail.kinds.flatMap(
+    (kind) => (detail.calls?.get(kind.name) ?? []).map(
+      (group) => `${kind.name} \u203A ${lane_breakdown_calls.group_text(group)}`
+    )
+  );
+}
+function calls_of(name, report) {
+  if (name === lane_breakdown.IMPLEMENT_STAGE) return implement_calls(report.detail);
+  if (name !== lane_breakdown.PLAN_STAGE) return [];
+  return (report.plan_calls ?? []).map((group) => lane_breakdown_calls.group_text(group));
+}
+function stage_entry(stage, report) {
+  const laps = report.laps?.get(stage.name) ?? [];
+  return {
+    text: `${part_text(stage)}${over_text(stage)}${suffix_of(stage.name, report)}`,
+    laps: laps.map((lap) => part_text(lap)),
+    calls: calls_of(stage.name, report)
+  };
+}
+function yield_lines(breakdown) {
+  const split = breakdown.yield_split;
+  if (split === void 0 || breakdown.yield_ms === 0) return [];
+  const named = [
+    { name: HOLDER, ms: split.holder_ms },
+    { name: GAP, ms: split.gap_ms }
+  ];
+  const unsplit = [{ name: UNSPLIT, ms: split.unsplit_ms }];
+  return [
+    ...split.holder_ms + split.gap_ms > 0 ? named : [],
+    ...split.unsplit_ms > 0 ? unsplit : []
+  ].map((part) => part_text(part));
+}
+function excluded_entry(breakdown) {
+  const yielded = `${YIELDED} ${lane_breakdown.minutes_text(breakdown.yield_ms)}`;
+  const slept = `${SLEPT} ${lane_breakdown.minutes_text(breakdown.slept_ms)}`;
+  const excluded = `${EXCLUDED} ${lane_breakdown.minutes_text(breakdown.excluded_ms)}, ${yielded}, ${slept}`;
+  return { text: excluded, laps: yield_lines(breakdown), calls: [] };
+}
+function driver_entry(stage, report) {
+  const laps = report.laps?.get(lane_breakdown.FOLLOWUP_STAGE) ?? [];
+  return {
+    text: `${part_text(stage)} ${DRIVER}${over_text(stage)}${report.critical ?? ""}`,
+    laps: laps.map((lap) => part_text(lap)),
+    calls: []
+  };
+}
+function entries_of(report) {
+  const { breakdown } = report;
+  const notes = [report.discarded, report.related].filter((text2) => text2 !== void 0 && text2 !== "").map((text2) => ({ text: text2, laps: [], calls: [] }));
+  return [
+    ...breakdown.stages.map((stage) => stage_entry(stage, report)),
+    ...notes,
+    excluded_entry(breakdown),
+    ...(breakdown.driver ?? []).map((stage) => driver_entry(stage, report))
+  ];
+}
+function bullets_of(entry) {
+  return [`- ${entry.text}`, ...[...entry.laps, ...entry.calls].map((lap) => `  - ${lap}`)];
+}
+function inline_of(entry) {
+  return entry.laps.length > 0 ? `${entry.text} [${entry.laps.join(", ")}]` : entry.text;
+}
+function report_of(issue, breakdown, entries, events = []) {
+  const calls = lane_breakdown_implement.read(issue, breakdown);
+  const rows = lane_breakdown_pinned.rows_of(entries, issue, breakdown);
+  const timing = lane_elapsed_time.of(entries, events, issue, calls);
+  return {
+    elapsed: timing === void 0 ? void 0 : lane_elapsed_time.text(timing),
+    breakdown,
+    detail: lane_breakdown_implement.of(calls, breakdown),
+    laps: lane_breakdown_laps.of(entries, issue, breakdown, calls),
+    pinned: lane_breakdown_pinned.detail_text(rows),
+    discarded: lane_breakdown_pinned.discarded_text(entries, issue),
+    related: lane_breakdown_related.over_cap_text(entries, issue),
+    critical: lane_ci_path_stats.last_check_text(entries, issue),
+    plan_calls: lane_breakdown_implement.plan_calls(calls, breakdown),
+    plan_outside: lane_breakdown_implement.plan_outside(calls, breakdown)
+  };
+}
+function comment(issue, minutes, report) {
+  const lead = `${HEADING}, ${String(minutes)} min of net time`;
+  const source = `(\`pnpm josh lane:breakdown ${String(issue)}\`):`;
+  return [
+    `${lead} ${source}`,
+    "",
+    ...entries_of(report).flatMap((entry) => bullets_of(entry)),
+    ...report.elapsed === void 0 ? [] : [report.elapsed]
+  ].join("\n");
+}
+function line(report) {
+  return `${HEADING}: ${entries_of(report).map((entry) => inline_of(entry)).join("; ")}.`;
+}
+var lane_breakdown_text = { budget_of, comment, line, report_of };
+
+export {
+  lane_breakdown_related,
+  lane_check_stats,
+  lane_ci_path_stats,
+  lane_breakdown_text
+};