@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-R7PYR4HW.js

@@ -0,0 +1,389 @@
+import {
+  lane_plan_wait_event
+} from "./chunk-DDOS32JU.js";
+import {
+  lane_net_time,
+  lane_stage_events,
+  lane_stop_stats
+} from "./chunk-SNSZ25XZ.js";
+import {
+  backlog_drive_restore
+} from "./chunk-SQZZHK6X.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-breakdown-pause.ts
+var { EVENT_KIND } = run_event_stream;
+var IMPLEMENT_SUFFIX = " implement";
+var REPLAN_NOTE = "re-plan";
+var RE_RUN_LEAD = "ship \xD7";
+var RE_RUN_TAIL = " re-run";
+var WAITING_LEAD = "waiting on ";
+var PARKED_LEAD = "parked";
+var PARK_TEXT = /^#(?<issue>[1-9]\d*) (?<rest>.*)$/u;
+function name_of(rest) {
+  if (rest.startsWith(WAITING_LEAD)) return `pause for ${rest.slice(WAITING_LEAD.length)}`;
+  if (rest.startsWith(PARKED_LEAD)) return `park${rest.slice(PARKED_LEAD.length)}`;
+  return void 0;
+}
+function rest_of(event, issue) {
+  const groups = PARK_TEXT.exec(event.text)?.groups;
+  return Number(groups?.["issue"]) === issue ? groups?.["rest"] : void 0;
+}
+function mark_of(event, issue) {
+  const name = name_of(rest_of(event, issue) ?? "");
+  return name === void 0 ? [] : [{ at_ms: Date.parse(event.at), name }];
+}
+function is_planning(event) {
+  return event.kind === EVENT_KIND.PLAN || event.kind === EVENT_KIND.LANE_PHASE && event.text.endsWith(IMPLEMENT_SUFFIX);
+}
+function run_step(runs, stage) {
+  if (runs.count > 0 && !runs.started.has(stage)) {
+    return { count: runs.count, started: /* @__PURE__ */ new Set([...runs.started, stage]) };
+  }
+  return { count: runs.count + 1, started: /* @__PURE__ */ new Set([stage]) };
+}
+function runs_of(events) {
+  const starts = events.filter((event) => event.kind === EVENT_KIND.SHIP_STAGE).map((event) => run_ship_stage.words_of(event.text)).filter((words) => words.phase === run_ship_stage.PHASE.START);
+  let runs = { count: 0, started: /* @__PURE__ */ new Set() };
+  for (const words of starts) runs = run_step(runs, words.stage);
+  return runs.count;
+}
+function note_of(events) {
+  const runs = runs_of(events);
+  const parts2 = [
+    ...events.some((event) => is_planning(event)) ? [REPLAN_NOTE] : [],
+    ...runs > 0 ? [`${RE_RUN_LEAD}${String(runs)}${RE_RUN_TAIL}`] : []
+  ];
+  return parts2.length === 0 ? "" : ` (${parts2.join(", ")})`;
+}
+function between_of(events, span) {
+  return events.filter((event) => {
+    const at_ms = Date.parse(event.at);
+    return at_ms > span.from_ms && at_ms <= span.to_ms;
+  });
+}
+function of(events, issue, span) {
+  const lane = events.filter((event) => lane_stop_stats.issue_of(event) === issue);
+  const marks = events.filter((event) => event.kind === EVENT_KIND.PARK).flatMap((event) => mark_of(event, issue)).filter((mark) => mark.at_ms >= span.from_ms && mark.at_ms <= span.to_ms);
+  return marks.map((mark, index) => {
+    const after = { from_ms: mark.at_ms, to_ms: marks[index + 1]?.at_ms ?? span.to_ms };
+    return { ...mark, name: `${mark.name}${note_of(between_of(lane, after))}` };
+  });
+}
+function in_segment(marks, segment) {
+  return marks.find((mark) => mark.at_ms > segment.from_ms && mark.at_ms <= segment.to_ms);
+}
+var lane_breakdown_pause = { in_segment, is_planning, of };
+
+// scripts/lane/lane-yield-split.ts
+var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
+function points_of(entries, events) {
+  const merges = entries.filter((entry) => lane_stage_stats.is_merge(entry)).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
+  const openings = events.filter(
+    (event) => run_event_setup.is_stage(event, run_event_setup.LANE_STAGE.OPENING)
+  );
+  const done = events.filter((event) => backlog_drive_restore.DONE_KINDS.has(event.kind)).map((event) => ({ issue: lane_stop_stats.issue_of(event), at_ms: Date.parse(event.at) }));
+  return {
+    ends: [...merges, ...done],
+    openings: lane_stop_stats.events_of(openings, EVENT_KIND2.SETUP)
+  };
+}
+function first_at(points, issue, from_ms, until_ms) {
+  const inside = points.filter(
+    (point) => point.issue === issue && point.at_ms >= from_ms && point.at_ms <= until_ms
+  );
+  return inside.length === 0 ? void 0 : Math.min(...inside.map((point) => point.at_ms));
+}
+function after_holder(wait, yielder, ended_ms, points) {
+  const opened_ms = first_at(points.openings, yielder, ended_ms, wait.end_ms ?? Infinity);
+  return {
+    wait,
+    holder: { from_ms: wait.from_ms, end_ms: ended_ms },
+    offer: { from_ms: ended_ms, end_ms: opened_ms },
+    ...opened_ms !== void 0 && { launch: { from_ms: opened_ms, end_ms: wait.end_ms } }
+  };
+}
+function split_of(wait, issues, points) {
+  const [yielder, holder] = issues;
+  const ended_ms = first_at(points.ends, holder, wait.from_ms, wait.end_ms ?? Infinity);
+  return ended_ms === void 0 ? { wait, holder: { from_ms: wait.from_ms, end_ms: wait.end_ms } } : after_holder(wait, yielder, ended_ms, points);
+}
+function parts_of(note, wait, points) {
+  if (wait === void 0) return [];
+  const holder = lane_yield.holder_of(note);
+  return holder === void 0 ? [{ wait }] : [split_of(wait, [lane_stop_stats.issue_of(note), holder], points)];
+}
+function notes_with_waits(entries, events) {
+  const waits = lane_net_time.yield_spans(entries, events);
+  return events.filter((event) => lane_yield.is_yield_note(event)).map((note, index) => ({ note, wait: waits[index] }));
+}
+function parts(entries, events) {
+  const points = points_of(entries, events);
+  return notes_with_waits(entries, events).flatMap(({ note, wait }) => parts_of(note, wait, points));
+}
+function gap_ms({ wait, offer }) {
+  return offer === void 0 || wait.end_ms === void 0 ? void 0 : wait.end_ms - offer.from_ms;
+}
+function is_early({ wait, holder, offer }) {
+  return holder !== void 0 && offer === void 0 && wait.end_ms !== void 0;
+}
+function issue_yield(note, split) {
+  return {
+    holder: lane_yield.holder_of(note),
+    gap_ms: split === void 0 ? void 0 : gap_ms(split),
+    is_early: split !== void 0 && is_early(split)
+  };
+}
+function notes_of(entries, events, issue) {
+  return notes_with_waits(entries, events).filter(
+    ({ note }) => lane_stop_stats.issue_of(note) === issue
+  );
+}
+function of_issue(entries, events, issue) {
+  const points = points_of(entries, events);
+  return notes_of(entries, events, issue).map(
+    ({ note, wait }) => issue_yield(note, parts_of(note, wait, points).at(0))
+  );
+}
+function issue_parts(entries, events, issue) {
+  const points = points_of(entries, events);
+  return notes_of(entries, events, issue).flatMap(({ note, wait }) => parts_of(note, wait, points));
+}
+function part_ms(span) {
+  return span?.end_ms === void 0 ? 0 : span.end_ms - span.from_ms;
+}
+function share_of(splits) {
+  return {
+    holder_ms: splits.reduce((sum, split) => sum + part_ms(split.holder), 0),
+    gap_ms: splits.reduce((sum, split) => sum + (gap_ms(split) ?? 0), 0),
+    unsplit_ms: splits.filter((split) => split.holder === void 0).reduce((sum, split) => sum + part_ms(split.wait), 0)
+  };
+}
+var lane_yield_split = { issue_parts, of_issue, parts, share_of };
+
+// scripts/lane/lane-breakdown.ts
+var { EVENT_KIND: EVENT_KIND3 } = run_event_stream;
+var { PHASE } = run_ship_stage;
+var PLAN_STAGE = "start to plan";
+var IMPLEMENT_STAGE = "implement";
+var BETWEEN_STAGE = "between ship stages";
+var STOP_MARK = "stop";
+var SHIP_LEAD = "ship ";
+var PRE_DETACH_STAGE = `${SHIP_LEAD}${lane_ledger.PRE_DETACH_STAGE}`;
+var FOLLOWUP_STAGE = `${SHIP_LEAD}${run_ship_stage.STAGE.FOLLOWUP}`;
+var ROUND_TWO_STAGE = `${SHIP_LEAD}${run_ship_stage.STAGE.ROUND_TWO}`;
+var DRIVER_FOLLOWUP_STAGE = `driver ${run_ship_stage.STAGE.FOLLOWUP}`;
+function is_ship_stage(name) {
+  return name.startsWith(SHIP_LEAD) || name === BETWEEN_STAGE;
+}
+function is_ship(segment) {
+  return is_ship_stage(segment.stage);
+}
+function ship_stage_of(text) {
+  const { stage, phase } = run_ship_stage.words_of(text);
+  return phase === PHASE.START ? `${SHIP_LEAD}${stage}` : BETWEEN_STAGE;
+}
+function stage_of(event) {
+  if (event.kind === EVENT_KIND3.SHIP_STAGE) return ship_stage_of(event.text);
+  return lane_breakdown_pause.is_planning(event) ? IMPLEMENT_STAGE : void 0;
+}
+function is_inside(at_ms, span) {
+  return at_ms >= span.from_ms && at_ms < span.to_ms;
+}
+function is_lane_event(event, issue, span) {
+  return lane_stop_stats.issue_of(event) === issue && is_inside(Date.parse(event.at), span);
+}
+function marker_of(event, issue, span) {
+  const stage = stage_of(event);
+  const at_ms = Date.parse(event.at);
+  return stage !== void 0 && is_lane_event(event, issue, span) ? [{ at_ms, stage }] : [];
+}
+function reason_of(event, issue, span) {
+  if (event.kind !== EVENT_KIND3.SHIP_STAGE || !is_lane_event(event, issue, span)) return [];
+  const reason = run_ship_stage.reason_of(event.text);
+  const stage = `${SHIP_LEAD}${run_ship_stage.words_of(event.text).stage}`;
+  return reason === void 0 ? [] : [[stage, reason]];
+}
+function reasons_of(events, issue, span) {
+  const ordered = events.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  return new Map(ordered.flatMap((event) => reason_of(event, issue, span)));
+}
+function opens_implement(opened, edit_ms) {
+  const [first] = opened;
+  if (opened.some((marker) => marker.stage === IMPLEMENT_STAGE)) return false;
+  return first === void 0 || edit_ms < first.at_ms;
+}
+function edit_markers(opened, span, edit_ms) {
+  if (edit_ms === void 0 || !is_inside(edit_ms, span)) return [];
+  return opens_implement(opened, edit_ms) ? [{ at_ms: edit_ms, stage: IMPLEMENT_STAGE }] : [];
+}
+function stop_of(entry, issue, span) {
+  if (entry.kind !== lane_ledger.KIND.STOP || entry.issue !== issue) return [];
+  const at_ms = Date.parse(entry.at);
+  return is_inside(at_ms, span) ? [{ at_ms, stage: STOP_MARK }] : [];
+}
+function closing(marker, before) {
+  if (marker.stage !== STOP_MARK) return [marker];
+  if (before?.stage.startsWith(SHIP_LEAD) !== true) return [];
+  return [{ ...marker, stage: BETWEEN_STAGE }];
+}
+function closed(markers) {
+  return markers.flatMap((marker, index) => closing(marker, markers[index - 1]));
+}
+function opened_of(records, issue, span) {
+  const events = records.events.flatMap((event) => marker_of(event, issue, span));
+  const stops = records.entries.flatMap((entry) => stop_of(entry, issue, span));
+  return closed([...events, ...stops].toSorted((left, right) => left.at_ms - right.at_ms));
+}
+function segments_of(opened, span, edit_ms) {
+  const markers = [
+    { at_ms: span.from_ms, stage: PLAN_STAGE },
+    ...edit_markers(opened, span, edit_ms),
+    ...opened
+  ].filter((marker, index, all) => marker.stage !== all[index - 1]?.stage);
+  return markers.map((marker, index) => ({
+    stage: marker.stage,
+    from_ms: marker.at_ms,
+    to_ms: markers[index + 1]?.at_ms ?? span.to_ms
+  }));
+}
+function lane_segments(records, issue, span, edit_ms) {
+  const segments = segments_of(opened_of(records, issue, span), span, edit_ms);
+  return lane_plan_wait_event.carved(segments, lane_plan_wait_event.spans(records.events, issue));
+}
+function clipped(segment, parts2) {
+  return parts2.map((part) => ({
+    from_ms: Math.max(segment.from_ms, part.from_ms),
+    to_ms: Math.min(segment.to_ms, part.to_ms)
+  })).filter((part) => part.to_ms > part.from_ms).toSorted((left, right) => left.from_ms - right.from_ms);
+}
+function covered_ms(segment, parts2) {
+  let reached_ms = segment.from_ms;
+  let total_ms = 0;
+  for (const part of clipped(segment, parts2)) {
+    total_ms += Math.max(0, part.to_ms - Math.max(part.from_ms, reached_ms));
+    reached_ms = Math.max(reached_ms, part.to_ms);
+  }
+  return total_ms;
+}
+function ranked(parts2) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const part of parts2) totals.set(part.name, (totals.get(part.name) ?? 0) + part.ms);
+  return [...totals].map(([name, ms]) => ({ name, ms })).toSorted((left, right) => right.ms - left.ms);
+}
+function spans_ms(spans) {
+  return spans.reduce((sum, span) => sum + span.to_ms - span.from_ms, 0);
+}
+function windows_of(segments) {
+  return {
+    plan: segments.filter((segment) => segment.stage === PLAN_STAGE),
+    implement: segments.filter((segment) => segment.stage === IMPLEMENT_STAGE),
+    pre_detach: segments.filter((segment) => segment.stage === PRE_DETACH_STAGE),
+    ship: segments.filter((segment) => is_ship(segment))
+  };
+}
+function yields_of(entries, events, issue, span) {
+  const splits = lane_yield_split.issue_parts(entries, events, issue).filter((split) => is_inside(split.wait.from_ms, span));
+  return {
+    yield_ms: spans_ms(lane_net_time.yielded(entries, events, issue, span)),
+    yield_split: lane_yield_split.share_of(splits)
+  };
+}
+function net_segments_of(segments, outside) {
+  return segments.map((segment) => ({
+    ...segment,
+    net_ms: segment.to_ms - segment.from_ms - covered_ms(segment, outside)
+  }));
+}
+function stages_of(segments) {
+  const parts2 = segments.map((segment) => ({ name: segment.stage, ms: segment.net_ms }));
+  return ranked(parts2.filter((part) => part.name !== FOLLOWUP_STAGE));
+}
+function driver_of(ms) {
+  return ms > 0 ? [{ name: DRIVER_FOLLOWUP_STAGE, ms }] : [];
+}
+function breakdown_of(entries, events, issue, edit_ms) {
+  const span = lane_net_time.span_of(entries, issue);
+  if (span === void 0) return void 0;
+  const waits = lane_net_time.waits(entries, events, issue, span);
+  const outside = lane_net_time.outside(entries, events, issue, span);
+  const segments = lane_segments({ entries, events }, issue, span, edit_ms);
+  const net_segments = net_segments_of(segments, outside);
+  return {
+    stages: stages_of(net_segments),
+    driver: driver_of(spans_ms(outside) - spans_ms(waits)),
+    excluded_ms: spans_ms(waits),
+    slept_ms: spans_ms(lane_net_time.slept(events, span)),
+    ...yields_of(entries, events, issue, span),
+    waits,
+    segments: net_segments,
+    ...windows_of(segments),
+    reasons: reasons_of(events, issue, span),
+    pauses: lane_breakdown_pause.of(events, issue, span)
+  };
+}
+function of2(entries, events, issue, edit_ms) {
+  const span = lane_net_time.span_of(entries, issue);
+  const breakdown = breakdown_of(
+    entries,
+    lane_stage_events.of(entries, events, issue),
+    issue,
+    edit_ms
+  );
+  return breakdown === void 0 || span === void 0 ? void 0 : { ...breakdown, reasons: reasons_of(events, issue, span) };
+}
+function stage_at(breakdown, at_ms) {
+  const plan = (breakdown.plan ?? []).map((span) => ({ ...span, stage: PLAN_STAGE }));
+  const implement = breakdown.implement.map((span) => ({ ...span, stage: IMPLEMENT_STAGE }));
+  const segments = [...plan, ...implement, ...breakdown.ship];
+  return segments.find((segment) => is_inside(at_ms, segment))?.stage;
+}
+function minutes_text(ms) {
+  return `${(ms / MS_PER_MINUTE).toFixed(1)} min`;
+}
+function longest_of(breakdown) {
+  const [longest] = breakdown.stages;
+  return longest === void 0 ? void 0 : { name: longest.name, minutes: Math.round(longest.ms / MS_PER_MINUTE) };
+}
+var lane_breakdown = {
+  BETWEEN_STAGE,
+  DRIVER_FOLLOWUP_STAGE,
+  FOLLOWUP_STAGE,
+  IMPLEMENT_STAGE,
+  PLAN_STAGE,
+  PRE_DETACH_STAGE,
+  ROUND_TWO_STAGE,
+  covered_ms,
+  is_ship_stage,
+  longest_of,
+  minutes_text,
+  of: of2,
+  ranked,
+  stage_at
+};
+
+export {
+  lane_breakdown_pause,
+  lane_yield_split,
+  lane_breakdown
+};