@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-MLW4S35K.js

@@ -1,389 +0,0 @@
-import {
-  lane_plan_wait_event
-} from "./chunk-6DDK5XWK.js";
-import {
-  lane_net_time,
-  lane_stage_events,
-  lane_stop_stats
-} from "./chunk-MWO6FOSZ.js";
-import {
-  backlog_drive_restore
-} from "./chunk-TFLHYC2F.js";
-import {
-  lane_yield
-} from "./chunk-EGIHAEMT.js";
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  run_event_setup
-} from "./chunk-I2KCGKJI.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  run_ship_stage
-} from "./chunk-OHNP3QL2.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
-};

package/dist/commands/chunk-MN425CU6.js

@@ -1,63 +0,0 @@
-import {
-  backlog_budget
-} from "./chunk-BYSPYVLD.js";
-import {
-  stamp_record
-} from "./chunk-X3TNPALI.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/park/run-park.ts
-import { z } from "zod";
-var PARK_PREFIX = "josh-run-park-";
-var PARK_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
-var run_park_schema = z.object({
-  issue: z.string(),
-  parked_at: z.string()
-});
-function parse_park(raw) {
-  return json_value.parse_with(raw, run_park_schema);
-}
-function parked_at_of(park) {
-  return park.parked_at;
-}
-var PARK_SPEC = {
-  parse: parse_park,
-  timestamp_of: parked_at_of,
-  max_age_ms: PARK_MAX_AGE_MS
-};
-function park_path(repository, issue) {
-  return stamp_file.stamp_path(`${PARK_PREFIX}${issue}-`, repository);
-}
-function record(issue, directory, now = /* @__PURE__ */ new Date()) {
-  const repository = git_common_directory.repository(directory);
-  if (repository === void 0) return false;
-  stamp_file.replace_stamp(park_path(repository, issue), { issue, parked_at: now.toISOString() });
-  return true;
-}
-function clear(issue, directory) {
-  const repository = git_common_directory.repository(directory);
-  if (repository !== void 0) stamp_file.remove_stamp(park_path(repository, issue));
-}
-function is_parked_sync(issue, directory, now = /* @__PURE__ */ new Date()) {
-  const repository = git_common_directory.repository(directory);
-  if (repository === void 0) return false;
-  const read = stamp_record.classify(
-    stamp_file.read_stamp_text(park_path(repository, issue)),
-    PARK_SPEC,
-    now
-  );
-  return read.kind === "carried" && read.record.issue === issue;
-}
-var run_park = { PARK_MAX_AGE_MS, clear, is_parked_sync, record };
-
-export {
-  run_park
-};