@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-UIXQ4IYT.js

@@ -1,445 +0,0 @@
-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
-};