@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-2MDLCJZ4.js

@@ -0,0 +1,389 @@
+import {
+  lane_plan_wait_event
+} from "./chunk-54ZLBLLE.js";
+import {
+  lane_net_time,
+  lane_stage_events,
+  lane_stop_stats
+} from "./chunk-LAUKNN57.js";
+import {
+  backlog_drive_restore
+} from "./chunk-52CGT2IN.js";
+import {
+  lane_yield
+} from "./chunk-SIPHEZXP.js";
+import {
+  lane_stage_stats
+} from "./chunk-3TN76RWK.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  run_event_setup
+} from "./chunk-WEEJU3EH.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.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
+};

package/dist/commands/chunk-2ROVUERM.js

@@ -0,0 +1,99 @@
+import {
+  cutoff_of
+} from "./chunk-SK3GDQOI.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  EPIC_LABEL,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  parse_json_array_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/epic/epic-index.ts
+import { z } from "zod";
+var epic_schema = z.object({ number: z.number(), body: z.string().nullable() });
+function build_tracking_index(epics) {
+  const index = /* @__PURE__ */ new Map();
+  for (const epic of epics) {
+    for (const child of epic_parse.parse_task_list_issue_numbers(epic.body)) {
+      index.set(child, [...index.get(child) ?? [], epic.number]);
+    }
+  }
+  return index;
+}
+function build_epic_index(epics) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [child, tracked_by] of build_tracking_index(epics)) {
+    const winner = tracked_by.at(-1);
+    if (winner !== void 0) index.set(child, winner);
+  }
+  return index;
+}
+var EPIC_LABELS = /* @__PURE__ */ new Set([EPIC_LABEL]);
+function opted_in_epic_numbers(issues) {
+  return new Set(
+    issues.filter((issue) => has_any_label(issue.labels, EPIC_LABELS)).map((issue) => issue.number)
+  );
+}
+function push_child(map, parent, child) {
+  map.set(parent, [...map.get(parent) ?? [], child]);
+}
+function invert_tracking(index) {
+  const children_of = /* @__PURE__ */ new Map();
+  for (const [child, parents] of index) {
+    for (const parent of parents) push_child(children_of, parent, child);
+  }
+  return children_of;
+}
+function child_epics_of(children_of, epic) {
+  return (children_of.get(epic) ?? []).filter((child) => children_of.has(child));
+}
+function reachable_epic_numbers(index, opted_in) {
+  const children_of = invert_tracking(index);
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [...opted_in_epic_numbers(opted_in)];
+  while (stack.length > 0) {
+    const epic = stack.pop();
+    if (epic === void 0 || visited.has(epic)) continue;
+    visited.add(epic);
+    stack.push(...child_epics_of(children_of, epic).filter((child) => !visited.has(child)));
+  }
+  return visited;
+}
+function withheld_children(index, opted_in) {
+  const epics = reachable_epic_numbers(index, opted_in);
+  const withheld = /* @__PURE__ */ new Map();
+  for (const [child, tracked_by] of index) {
+    const epic = tracked_by.find((candidate) => epics.has(candidate));
+    if (epic !== void 0) withheld.set(child, epic);
+  }
+  return withheld;
+}
+async function fetch_epics(limit) {
+  const { json, is_capped } = await git_gh_command.issue_list_by_label(EPIC_LABEL, limit);
+  if (json === void 0) return void 0;
+  const rows = parse_json_array_or_undefined(json, epic_schema);
+  if (rows === void 0) return void 0;
+  return {
+    cutoff: cutoff_of(rows.length, limit, is_capped),
+    epics: rows.map((row) => ({ number: row.number, body: row.body ?? "" }))
+  };
+}
+var epic_index = {
+  build_epic_index,
+  build_tracking_index,
+  fetch_epics,
+  reachable_epic_numbers,
+  withheld_children
+};
+
+export {
+  epic_schema,
+  epic_index
+};

package/dist/commands/chunk-2TI22UNK.js

@@ -0,0 +1,137 @@
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  repository_lock
+} from "./chunk-GC73YEU7.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-ledger-archive.ts
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fstatSync,
+  openSync,
+  readSync,
+  statSync,
+  truncateSync,
+  writeSync
+} from "node:fs";
+import { z } from "zod";
+var RETENTION_DAYS = 14;
+var MS_PER_DAY = 864e5;
+var LEDGER_SUFFIX_PATTERN = /\.jsonl$/u;
+var ARCHIVE_SUFFIX = "-archive.jsonl";
+var LOCK_SUFFIX = ".rotate.lock";
+var LEDGER_FILE_MODE = 384;
+var { O_APPEND, O_CREAT, O_NOFOLLOW, O_RDONLY, O_WRONLY } = constants;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var READ_FLAGS = O_RDONLY | O_NOFOLLOW;
+var NO_WAIT_MS = 0;
+var { LINE_SEPARATOR } = lane_ledger_write;
+var { KIND } = lane_ledger;
+var record_schema = z.looseObject({ kind: z.string(), at: z.string() });
+function archive_of(ledger) {
+  return `${ledger.replace(LEDGER_SUFFIX_PATTERN, "")}${ARCHIVE_SUFFIX}`;
+}
+function is_past(line, cutoff_ms) {
+  const record = record_schema.safeParse(json_value.parse_or_undefined(line)).data;
+  if (record === void 0 || record.kind === KIND.MERGE) return false;
+  return Date.parse(record.at) < cutoff_ms;
+}
+function partition(text, cutoff_ms) {
+  const archived = [];
+  const kept = [];
+  const lines = text.split(LINE_SEPARATOR).slice(0, -1);
+  for (const line of lines) {
+    const side = is_past(line, cutoff_ms) ? archived : kept;
+    side.push(`${line}${LINE_SEPARATOR}`);
+  }
+  return { archived: archived.join(""), count: archived.length, kept: kept.join("") };
+}
+function bytes_past(descriptor, from) {
+  const buffer = Buffer.alloc(Math.max(fstatSync(descriptor).size - from, 0));
+  const read = readSync(descriptor, buffer, 0, buffer.length, from);
+  return buffer.subarray(0, read);
+}
+function append_text(target, text) {
+  const descriptor = openSync(target, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (!stamp_file.is_own_regular_file(target)) {
+      throw new Error(`Not an owned regular file: ${target}`);
+    }
+    writeSync(descriptor, text);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function size_of(target) {
+  return existsSync(target) ? statSync(target).size : 0;
+}
+function move(ledger, moved) {
+  const archive = archive_of(ledger);
+  const previous = size_of(archive);
+  append_text(archive, Buffer.from(moved.archived));
+  try {
+    const landed = bytes_past(moved.descriptor, moved.end);
+    atomic_write.replace_file(ledger, Buffer.concat([Buffer.from(moved.kept), landed]), {
+      mode: LEDGER_FILE_MODE
+    });
+    return moved.end + landed.length;
+  } catch (error) {
+    truncateSync(archive, previous);
+    throw error;
+  }
+}
+function rotate_open(ledger, descriptor, cutoff_ms) {
+  const read = bytes_past(descriptor, 0);
+  const end = read.lastIndexOf(LINE_SEPARATOR) + 1;
+  const split = partition(read.toString("utf8", 0, end), cutoff_ms);
+  if (split.count === 0) return 0;
+  const carried = move(ledger, { ...split, descriptor, end });
+  const late = bytes_past(descriptor, carried);
+  if (late.length > 0) append_text(ledger, late);
+  return split.count;
+}
+function rotate_held(ledger, cutoff_ms) {
+  const descriptor = openSync(ledger, READ_FLAGS);
+  try {
+    return rotate_open(ledger, descriptor, cutoff_ms);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+function rotate(ledger, now_ms = Date.now()) {
+  if (!existsSync(ledger) || !stamp_file.is_own_regular_file(ledger)) return 0;
+  const cutoff_ms = now_ms - RETENTION_DAYS * MS_PER_DAY;
+  const lock = `${ledger}${LOCK_SUFFIX}`;
+  return repository_lock.with_lock_sync(() => rotate_held(ledger, cutoff_ms), lock, NO_WAIT_MS) ?? 0;
+}
+async function rotate_target() {
+  const ledger = await lane_ledger.target();
+  return ledger === void 0 ? 0 : rotate(ledger);
+}
+function history_at(ledger) {
+  return [...lane_ledger.read_entries(archive_of(ledger)), ...lane_ledger.read_entries(ledger)];
+}
+async function read_history(context) {
+  const ledger = context.ledger_path ?? await lane_ledger.target();
+  return ledger === void 0 ? [] : history_at(ledger);
+}
+var lane_ledger_archive = { archive_of, history_at, read_history, rotate, rotate_target };
+
+export {
+  lane_ledger_archive
+};