@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-SNSZ25XZ.js

@@ -0,0 +1,393 @@
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  run_ship_planned
+} from "./chunk-PKXTISWR.js";
+import {
+  lane_sleep,
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  lane_spans
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-stop-stats.ts
+var COLUMNS = [
+  "stop",
+  "wait median (min)",
+  "wait max (min)",
+  "wait total (min)",
+  "runs",
+  "not resumed",
+  "causes"
+];
+var { STAGE } = run_ship_stage;
+var { is_dispatch, is_number, is_stage } = lane_stage_stats;
+var REASONS = [
+  STAGE.PREFLIGHT,
+  STAGE.REVIEW,
+  STAGE.SYNC,
+  run_ship_stage.CONFLICT,
+  STAGE.GATE,
+  STAGE.COMMIT,
+  STAGE.ROUND_TWO,
+  STAGE.FOLLOWUP,
+  STAGE.REPORT
+];
+var EVENT_ISSUE = /#([1-9]\d*)\b/u;
+var UNRECORDED_CAUSE = "unrecorded";
+var NO_CAUSES = "-";
+var NOTICED = " (noticed)";
+function is_stop(entry) {
+  return entry.kind === lane_ledger.KIND.STOP;
+}
+function issue_of(event) {
+  return Number(EVENT_ISSUE.exec(event.text)?.[1]);
+}
+function events_of(events, kind) {
+  return events.filter((event) => event.kind === kind).map((event) => ({ issue: issue_of(event), at_ms: Date.parse(event.at) }));
+}
+function parks_of(events) {
+  return events_of(events, run_event_stream.EVENT_KIND.PARK);
+}
+function dispatches_of(entries) {
+  return entries.filter((entry) => is_dispatch(entry)).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+}
+function ends_of(entries, parks) {
+  const resumes = entries.filter((entry) => is_stage(entry)).map((stage) => ({ issue: stage.issue, at_ms: lane_stage_stats.started_ms(stage) }));
+  return [...resumes, ...dispatches_of(entries), ...parks];
+}
+function wait_ms(stop, ends) {
+  const later = ends.filter((end) => end.issue === stop.issue && end.at_ms >= stop.at_ms).map((end) => end.at_ms - stop.at_ms);
+  return later.length === 0 ? void 0 : Math.min(...later);
+}
+function instant_of(stop) {
+  return { issue: stop.issue, at_ms: Date.parse(stop.at) };
+}
+function notices_of(entries) {
+  return entries.filter((entry) => entry.kind === lane_ledger.KIND.UNPLANNED_NOTICE).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+}
+function noticed(cause, stop, notices) {
+  if (cause !== run_ship_planned.PRECONDITION) return cause;
+  const is_noticed = notices.some(
+    (notice) => notice.issue === stop.issue && notice.at_ms <= stop.at_ms
+  );
+  return is_noticed ? `${cause}${NOTICED}` : cause;
+}
+function causes_of(stop, notices) {
+  const { preconditions = [], findings = [] } = stop;
+  const kinds = [...preconditions, ...findings];
+  if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE];
+  return kinds.map((kind) => noticed(kind, instant_of(stop), notices));
+}
+function waits_of(entries, ends, notices) {
+  return entries.filter(is_stop).map((stop) => ({
+    stop,
+    reason: stop.reason,
+    causes: causes_of(stop, notices),
+    wait_ms: wait_ms(instant_of(stop), ends)
+  }));
+}
+function total(values) {
+  return values.length === 0 ? void 0 : values.reduce((sum, value) => sum + value, 0);
+}
+function causes_cell(waits2) {
+  const all = waits2.flatMap((wait) => wait.causes);
+  const counted = [...new Set(all)].map((cause) => ({
+    cause,
+    count: all.filter((each) => each === cause).length
+  }));
+  const ranked = counted.toSorted((left, right) => right.count - left.count);
+  return ranked.length === 0 ? NO_CAUSES : ranked.map(({ cause, count }) => `${cause} ${String(count)}`).join(", ");
+}
+function reason_row(reason, waits2) {
+  const of_reason = waits2.filter((wait) => wait.reason === reason);
+  const ended = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value));
+  return lane_stats.to_row([
+    reason,
+    lane_stage_stats.cell(lane_stats.median(ended)),
+    lane_stage_stats.cell(lane_stats.peak(ended)),
+    lane_stage_stats.cell(total(ended)),
+    String(ended.length),
+    String(of_reason.length - ended.length),
+    causes_cell(of_reason)
+  ]);
+}
+function waits_in(entries, window, events = []) {
+  const ends = ends_of(entries, parks_of(events));
+  return waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries));
+}
+function table(entries, window, events = []) {
+  const waits2 = waits_in(entries, window, events);
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...REASONS.map((reason) => reason_row(reason, waits2))
+  ].join("\n");
+}
+var lane_stop_stats = {
+  REASONS,
+  dispatches_of,
+  ends_of,
+  events_of,
+  issue_of,
+  table,
+  total,
+  wait_ms,
+  waits_in
+};
+
+// scripts/lane/lane-stage-events.ts
+var { EVENT_KIND } = run_event_stream;
+var { PHASE, STAGE: STAGE2 } = run_ship_stage;
+var SHIP_STAGES = /* @__PURE__ */ new Set([
+  ...Object.values(STAGE2),
+  lane_ledger.PRE_DETACH_STAGE
+]);
+function is_ship(entry, issue) {
+  return entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && SHIP_STAGES.has(entry.stage);
+}
+function event_at(at_ms, issue, words) {
+  return {
+    pos: 0,
+    at: new Date(at_ms).toISOString(),
+    kind: EVENT_KIND.SHIP_STAGE,
+    text: `${issue_cite.plain_for("program", issue)} ${words}`
+  };
+}
+function interval_events(entry, issue) {
+  const end_ms = Date.parse(entry.at);
+  if (!Number.isFinite(end_ms) || entry.elapsed_ms <= 0) return [];
+  return [
+    event_at(end_ms - entry.elapsed_ms, issue, `${entry.stage} ${PHASE.START}`),
+    event_at(end_ms, issue, `${entry.stage} ${PHASE.DONE}`)
+  ];
+}
+function is_lane_ship(event, issue) {
+  return event.kind === EVENT_KIND.SHIP_STAGE && lane_stop_stats.issue_of(event) === issue;
+}
+function change(active, event) {
+  if (event.kind === EVENT_KIND.STOP) {
+    active.clear();
+    return;
+  }
+  const { stage, phase } = run_ship_stage.words_of(event.text);
+  if (phase === PHASE.SKIPPED) return;
+  if (phase === PHASE.START) active.set(stage, event);
+  else active.delete(stage);
+}
+function exclusive(events, issue) {
+  const active = /* @__PURE__ */ new Map();
+  return events.map((event) => {
+    change(active, event);
+    const latest = [...active.values()].at(-1);
+    if (latest === void 0) return event;
+    const { stage } = run_ship_stage.words_of(latest.text);
+    return event_at(Date.parse(event.at), issue, `${stage} ${PHASE.START}`);
+  });
+}
+function stop_events(entries, issue) {
+  return entries.flatMap(
+    (entry) => entry.kind === lane_ledger.KIND.STOP && entry.issue === issue ? { ...event_at(Date.parse(entry.at), issue, entry.reason), kind: EVENT_KIND.STOP } : []
+  );
+}
+function of(entries, events, issue) {
+  const restored = entries.filter((entry) => is_ship(entry, issue)).flatMap((entry) => interval_events(entry, issue));
+  const ship = [
+    ...events.filter((event) => is_lane_ship(event, issue)),
+    ...restored,
+    ...stop_events(entries, issue)
+  ].toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  return [
+    ...events.filter((event) => !is_lane_ship(event, issue)),
+    ...exclusive(ship, issue)
+  ].toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+}
+var lane_stage_events = { of };
+
+// scripts/lane/lane-net-time.ts
+var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
+var { PHASE: PHASE2, STAGE: STAGE3 } = run_ship_stage;
+function entries_of(entries, issue) {
+  return entries.filter((entry) => "issue" in entry && entry.issue === issue);
+}
+function span_of(entries, issue) {
+  const of_issue = entries_of(entries, issue).toSorted(
+    (left, right) => Date.parse(left.at) - Date.parse(right.at)
+  );
+  const from = of_issue.find((entry) => lane_stage_stats.is_dispatch(entry));
+  const to = of_issue.findLast((entry) => lane_stage_stats.is_merge(entry));
+  if (from === void 0 || to === void 0) return void 0;
+  const span = { from_ms: Date.parse(from.at), to_ms: Date.parse(to.at) };
+  return span.to_ms < span.from_ms ? void 0 : span;
+}
+function holds_of(events) {
+  return [
+    ...lane_stop_stats.events_of(events, EVENT_KIND2.PARK),
+    ...lane_stop_stats.events_of(events, EVENT_KIND2.OUTAGE),
+    ...lane_stop_stats.events_of(events, EVENT_KIND2.USAGE_LIMIT)
+  ];
+}
+function held_ms(hold, ends, to_ms) {
+  const left_ms = to_ms - hold.at_ms;
+  return Math.min(lane_stop_stats.wait_ms(hold, ends) ?? left_ms, left_ms);
+}
+function hold_waits(entries, events, issue, span) {
+  const holds = holds_of(events);
+  const inside = holds.filter(
+    (hold) => hold.issue === issue && hold.at_ms >= span.from_ms && hold.at_ms < span.to_ms
+  );
+  return inside.map((hold) => {
+    const ends = lane_stop_stats.ends_of(
+      entries,
+      holds.filter((other) => other.at_ms > hold.at_ms)
+    );
+    return { from_ms: hold.at_ms, to_ms: hold.at_ms + held_ms(hold, ends, span.to_ms) };
+  });
+}
+function joined(spans) {
+  const sorted = spans.toSorted((left, right) => left.from_ms - right.from_ms);
+  const kept = [];
+  for (const next of sorted) {
+    const last = kept.at(-1);
+    if (last === void 0 || next.from_ms > last.to_ms) kept.push({ ...next });
+    else last.to_ms = Math.max(last.to_ms, next.to_ms);
+  }
+  return kept;
+}
+function slept(events, span) {
+  const cut = lane_sleep.spans(events).map((sleep) => ({
+    from_ms: Math.max(sleep.from_ms, span.from_ms),
+    to_ms: Math.min(sleep.to_ms, span.to_ms)
+  }));
+  return joined(cut.filter((sleep) => sleep.to_ms > sleep.from_ms));
+}
+function yield_spans(entries, events) {
+  const yields = lane_stop_stats.events_of(
+    events.filter((event) => lane_yield.is_yield_note(event)),
+    EVENT_KIND2.NOTE
+  );
+  return lane_spans.issue_spans({
+    starts: yields,
+    bounds: yields,
+    ends: lane_stop_stats.dispatches_of(entries)
+  });
+}
+function run_start_ms(dispatches, split) {
+  const start = dispatches.findLast(
+    (entry) => entry.issue === split.issue && entry.at_ms <= split.at_ms
+  );
+  return start?.at_ms ?? split.at_ms;
+}
+function split_spans(entries, events) {
+  const splits = lane_stop_stats.events_of(events, EVENT_KIND2.SPLIT);
+  const dispatches = lane_stop_stats.dispatches_of(entries);
+  const spans = lane_spans.issue_spans({ starts: splits, bounds: splits, ends: dispatches });
+  return splits.map((split, index) => ({
+    from_ms: run_start_ms(dispatches, split),
+    end_ms: spans[index]?.end_ms
+  })).filter((wait) => wait.end_ms !== void 0);
+}
+function cut_inside(spans, span) {
+  const inside = spans.filter((wait) => wait.from_ms >= span.from_ms && wait.from_ms < span.to_ms);
+  return inside.map((wait) => ({
+    from_ms: wait.from_ms,
+    to_ms: Math.min(wait.end_ms ?? span.to_ms, span.to_ms)
+  }));
+}
+function events_of_issue(events, issue) {
+  return events.filter((event) => lane_stop_stats.issue_of(event) === issue);
+}
+function yielded(entries, events, issue, span) {
+  return cut_inside(yield_spans(entries, events_of_issue(events, issue)), span);
+}
+function split_waits(entries, events, issue, span) {
+  return cut_inside(split_spans(entries, events_of_issue(events, issue)), span);
+}
+function waiting(entries, events, issue, span) {
+  return joined([
+    ...hold_waits(entries, events, issue, span),
+    ...yielded(entries, events, issue, span),
+    ...slept(events, span)
+  ]);
+}
+function waits(entries, events, issue, span) {
+  return joined([
+    ...waiting(entries, events, issue, span),
+    ...split_waits(entries, events, issue, span)
+  ]);
+}
+function is_followup_start(event) {
+  const { stage, phase } = run_ship_stage.words_of(event.text);
+  return stage === STAGE3.FOLLOWUP && phase === PHASE2.START;
+}
+function followed(events, issue, span) {
+  const lines = events.filter((event) => event.kind === EVENT_KIND2.SHIP_STAGE).filter((event) => lane_stop_stats.issue_of(event) === issue).map((event) => ({ event, at_ms: Date.parse(event.at) })).filter((line) => line.at_ms >= span.from_ms && line.at_ms < span.to_ms).toSorted((left, right) => left.at_ms - right.at_ms);
+  return lines.map((line, index) => ({ line, to_ms: lines[index + 1]?.at_ms ?? span.to_ms })).filter(({ line }) => is_followup_start(line.event)).map(({ line, to_ms }) => ({ from_ms: line.at_ms, to_ms }));
+}
+function automatic_waits(entries, events, issue, span) {
+  const stages = lane_stage_events.of(entries, events, issue);
+  return joined([...waiting(entries, events, issue, span), ...followed(stages, issue, span)]);
+}
+function outside(entries, events, issue, span) {
+  return joined([
+    ...automatic_waits(entries, events, issue, span),
+    ...split_waits(entries, events, issue, span)
+  ]);
+}
+function net_ms(entries, events, issue) {
+  const span = span_of(entries, issue);
+  if (span === void 0) return void 0;
+  return outside(entries, events, issue, span).reduce(
+    (left, wait) => left - (wait.to_ms - wait.from_ms),
+    span.to_ms - span.from_ms
+  );
+}
+function net_minutes(entries, events, issue) {
+  const net = net_ms(entries, events, issue);
+  return net === void 0 ? void 0 : Math.ceil(net / MS_PER_MINUTE);
+}
+function missing_reason(entries, issue) {
+  const of_issue = entries_of(entries, issue);
+  if (of_issue.every((entry) => !lane_stage_stats.is_dispatch(entry))) return "no dispatch";
+  if (of_issue.every((entry) => !lane_stage_stats.is_merge(entry))) return "no merge";
+  return "cause unknown";
+}
+var lane_net_time = {
+  automatic_waits,
+  hold_waits,
+  missing_reason,
+  net_minutes,
+  net_ms,
+  outside,
+  slept,
+  span_of,
+  waits,
+  yield_spans,
+  yielded
+};
+
+export {
+  lane_stop_stats,
+  lane_stage_events,
+  lane_net_time
+};