@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-KGSEWOKI.js

@@ -0,0 +1,353 @@
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/event/run-event-stream.ts
+import { z } from "zod";
+var EVENT_PREFIX = durable_state.PREFIX.EVENTS;
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 15e3;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR = "\n";
+var WORD_SEPARATOR = " ";
+var STAGE_PHASE_INDEX = 2;
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var EVENT_KIND = {
+  PLAN: "plan",
+  CHILD_LAUNCH: "child-launch",
+  MERGE: "merge",
+  PARK: "park",
+  HUMAN_REVIEW: "human-review",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  // A Claude usage limit stopped a lane child (joshuafolkken/kit#4745). Its text names the reset time,
+  // which `backlog:drive` reads to hold launches until then; it counts against no streak, so it is not an
+  // `OUTAGE`.
+  USAGE_LIMIT: "usage-limit",
+  CUT: "cut",
+  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
+  // resume clears the cut record, so without this the `cut` would stay the newest position and
+  // `run:step` would keep answering the resume command it had just run.
+  RESUME: "resume",
+  // A person stopped a running lane child and re-dispatched its issue in a fresh session
+  // (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
+  // the board, and — like that launch — a batch record a lane child never reads as its own position.
+  RESTART: "restart",
+  // A person withdrew a lane child — stopped it and left its issue open for the next run (`lane:withdraw`).
+  // It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
+  // by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
+  WITHDRAW: "withdraw",
+  // The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
+  // at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
+  // the retrospective at the drain rather than after the watch runs its course. It is not itself a
+  // stop: the run watches on once the retrospective has run, and the real `STOP` follows when the watch
+  // expires.
+  DRAIN: "drain",
+  STOP: "stop",
+  PR_OPENED: "pr-opened",
+  REVIEW_ROUND: "review-round",
+  // The end-of-run retrospective's result, recorded when the run marks the retrospective done. A
+  // retrospective that files zero improvements and one that never ran look
+  // the same from outside — no new Issue either way — so the result is put on the stream the report is
+  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
+  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
+  // what it found are one action rather than two the run could do only one of.
+  RETROSPECTIVE: "retrospective",
+  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
+  // while. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
+  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — and the line a terminal
+  // reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
+  // stalled is pointed straight at dispatching the work rather than left waiting.
+  STALL: "stall",
+  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
+  // is watching. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
+  // supervisor as it fails, leaves that state behind and has warned of it —
+  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
+  // than once, and a terminal reader following the stream sees the line. The strand is the step before
+  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
+  STRANDED: "stranded",
+  // One `josh ship` stage starting, succeeding or failing. It is a trace of the
+  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
+  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
+  // — so it is one of the `TRACE_KINDS` the last-event read skips.
+  SHIP_STAGE: "ship-stage",
+  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints. Printed only to
+  // the watcher's own output, a headless successor's heartbeat would be buried in its log after a cut;
+  // on the stream it reaches the attached session's relay. It says
+  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
+  HEARTBEAT: "heartbeat",
+  // The post-implementation region handed to a detached `josh ship --detach` supervisor. Unlike a stage
+  // trace it is a position: the agent has ended and the
+  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
+  SHIP_LAUNCH: "ship-launch",
+  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
+  // The position that hands control back: `run:step` prints the command that
+  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
+  SHIP_STOP: "ship-stop",
+  // The relaunch meant to answer a `SHIP_STOP` started nothing — the broker refused it, or the direct
+  // spawn failed (joshuafolkken/kit#4765). `run:merge` reads it, not the transcript's mtime, to tell the
+  // stop went unanswered, and a re-dispatch cap's park names its reason. A trace: the stop stays the
+  // position `run:step` answers.
+  RELAUNCH_FAILED: "relaunch-failed",
+  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
+  // still surfaces what it found — `run:board`'s findings section reads it.
+  FILED: "filed",
+  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
+  // same section.
+  NOTE: "note",
+  // A lane child reached a phase no other event marks — its first implementation edit, written by the
+  // PreToolUse hook — so `run:board` draws how far the child has got. The backlog driver writes its own
+  // `collect` / `launch` steps on a child as this kind too, which no reader draws as a phase
+  // (`backlog-drive-trace.ts`). A trace, like `SHIP_STAGE`: it says where the child's work is, not where
+  // the run is.
+  LANE_PHASE: "lane-phase",
+  // The fullrun step `run:step` or `run:entry` computed for an issue: `#<N> step <n>/<total> <name>`,
+  // written once per change of step (`run-event-step.ts`), so `run:board` draws it (joshuafolkken/kit#6598).
+  // A trace: it says which step the issue's run reached, not where the run is.
+  STEP: "step",
+  // An issue `run:add` put into the live run. The parent's `--wait` watcher
+  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
+  // trace: it says what the run was handed, not where the run is.
+  ADD: "add",
+  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
+  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
+  // already holds. A trace: it says the run gained room, not where the run is.
+  LANE_LIMIT: "lane-limit",
+  // One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
+  // lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
+  // minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
+  // getting ready, not where the run is.
+  SETUP: "setup",
+  // A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
+  // state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
+  // in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
+  // not where the run is.
+  PR_CHECKS: "pr-checks",
+  // `backlog:drive` reached a watch with no child running and nothing to dispatch — the point a person's
+  // hand is wanted. Emitted once per idle episode (`emit_once_since_with`, reset by `CHILD_LAUNCH`), it
+  // is the dedup marker for the one idle Telegram. A trace: a drain's retrospective is read off the
+  // position beneath it, so the marker must not stand over it.
+  IDLE_NOTICE: "idle-notice",
+  // A person paused or resumed a lane child (`lane:pause` / `lane:resume`), so who halted a lane and
+  // when is on the stream rather than only in a shell history (joshuafolkken/kit#4268). A trace: it
+  // says what a lane's processes were told, not where the run is.
+  LANE_STATE: "lane-state",
+  // `backlog:drive` found nothing of the run in flight and only paused lanes left, paused past the
+  // silent window (joshuafolkken/kit#4270). Emitted once per pause episode (`emit_once_since_with`,
+  // reset by `LANE_STATE`), it is the dedup marker for the one paused-lane Telegram. A trace.
+  PAUSED_NOTICE: "paused-notice",
+  // `backlog:drive` ran a due issue's measurement declaration itself, found it within its bound and
+  // closed the issue through `issue:measured` — no lane was launched for it (joshuafolkken/kit#4621).
+  // `run:board` draws it merged. A trace: the parent's position is the drive's, not this close.
+  MEASURED: "measured",
+  // `backlog:drive` ran a due issue's measurement declaration and found no sample to read yet, so the
+  // issue waits without a lane (joshuafolkken/kit#6503). A trace: `offer_exclude` keeps it out of the
+  // run's offers, the way the drive's own `waiting` list does.
+  SAMPLE_WAIT: "sample-wait",
+  // The host slept while `backlog:drive` sampled its load (joshuafolkken/kit#5032): the sampler's timer
+  // ran late by more than a few intervals. `at` is the wake and `elapsed_ms` how long the sleep
+  // lasted; every lane's net time takes it out (`lane-sleep.ts`). A trace.
+  SLEEP: "sleep",
+  // A lane's `lane:plan` blocking on a holder of its files (joshuafolkken/kit#6140): `#<N> start #<M>`
+  // as one ask begins to wait, `#<N> end #<M>` as it ends, so `lane:breakdown` counts
+  // the wait under its own row rather than the stage it fell in (`lane-plan-wait-event.ts`). A trace.
+  PLAN_WAIT: "plan-wait",
+  // GitHub's REST core rate limit read around one `backlog:drive` offer cycle (joshuafolkken/kit#6558):
+  // JSON text with the cycle's `used_delta`, `remaining` and `reset`, or `is_missing` when a read failed
+  // (`backlog-drive-rate.ts`). A trace written every cycle, so the bound rolls it off with the heartbeats.
+  RATE_LIMIT: "rate-limit"
+};
+var EVENT_KINDS = Object.values(EVENT_KIND);
+var TRACE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.FILED,
+  EVENT_KIND.NOTE,
+  EVENT_KIND.LANE_PHASE,
+  EVENT_KIND.STEP,
+  EVENT_KIND.ADD,
+  EVENT_KIND.LANE_LIMIT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.IDLE_NOTICE,
+  EVENT_KIND.LANE_STATE,
+  EVENT_KIND.PAUSED_NOTICE,
+  EVENT_KIND.MEASURED,
+  EVENT_KIND.SAMPLE_WAIT,
+  EVENT_KIND.RELAUNCH_FAILED,
+  EVENT_KIND.SLEEP,
+  EVENT_KIND.PLAN_WAIT,
+  EVENT_KIND.RATE_LIMIT
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP,
+  EVENT_KIND.PR_CHECKS,
+  EVENT_KIND.RATE_LIMIT
+]);
+var event_schema = z.object({
+  pos: z.number(),
+  at: z.string(),
+  kind: z.string(),
+  text: z.string(),
+  // The child's time on a lane, recorded once by the writer of an ending (joshuafolkken/kit#4481), so a
+  // reader never has to find its launch again. An event written before it has none. A `sleep` event
+  // carries the sleep's length here.
+  elapsed_ms: z.number().optional(),
+  // The ship stop a park was taken at — its stage and `Cause` class (joshuafolkken/kit#6864) — so a
+  // reader re-dispatching the park reads them without parsing text. Free strings: an event a later
+  // version wrote with a new class still parses. A park written before it, or no ship's, has none —
+  // as does one a lane on older code rewrote, since its schema drops the key, so none is a normal read.
+  stop: z.object({ stage: z.string(), cause: z.string() }).optional()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository) {
+  return durable_state.path(EVENT_PREFIX, repository, EVENT_SUFFIX);
+}
+function is_present(event) {
+  return event !== void 0;
+}
+function parse_line(line) {
+  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function lines_of(raw) {
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
+}
+function events_of_text(raw) {
+  return lines_of(raw).filter((event) => is_event_kind(event.kind));
+}
+function read_lines(target, is_required = false) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0 && is_required) throw new Error("Could not read the run event stream.");
+  if (raw === void 0) return [];
+  return lines_of(raw);
+}
+function read_events(target, is_required = false) {
+  return read_lines(target, is_required).filter((event) => is_event_kind(event.kind));
+}
+function last_position(events) {
+  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
+}
+function issue_of(event) {
+  return event.text.split(WORD_SEPARATOR)[FIRST_POSITION] ?? "";
+}
+function newest_by_issue(events, kind) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === kind) newest.set(issue_of(event), event);
+  }
+  return new Set(newest.values());
+}
+function is_stage_start(event) {
+  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
+  return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
+}
+function drawn_lines(events) {
+  const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP);
+  return /* @__PURE__ */ new Set([
+    ...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
+    ...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
+    ...setup === void 0 ? [] : [setup]
+  ]);
+}
+function droppable(events) {
+  const kept = drawn_lines(events);
+  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
+  return [
+    ...disposable.filter((event) => !is_stage_start(event)),
+    ...disposable.filter((event) => is_stage_start(event))
+  ];
+}
+function bounded(events) {
+  const excess = events.length - EVENT_CAP;
+  if (excess <= 0) return events;
+  const dropped = new Set(droppable(events).slice(0, excess));
+  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
+}
+function serialize(events) {
+  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
+}
+function append_held(target, event) {
+  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
+  const events = bounded([...read_events(target), { pos: position, ...event }]);
+  stamp_file.replace_text_stamp(target, serialize(events));
+  return position;
+}
+function append_event(target, event) {
+  if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target, event),
+    lock,
+    LOCK_WAIT_MS
+  );
+  if (position === void 0) {
+    const message = `run event stream: gave up waiting for the lock at ${lock}`;
+    process.stderr.write(`${message}
+`);
+    throw new Error(message);
+  }
+  return { appended: true, position };
+}
+function append(target, kind, text, at) {
+  return append_event(target, { at, kind, text });
+}
+function read_from(target, position) {
+  const events = read_events(target);
+  return {
+    events: events.filter((event) => event.pos > position),
+    next_position: last_position(events)
+  };
+}
+function read_last(target) {
+  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
+}
+function since(events, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT);
+}
+function has_since(events, kind, reset_kind) {
+  return since(events, reset_kind).some((event) => event.kind === kind);
+}
+var FIELD_SEPARATOR = " \xB7 ";
+function format_event(event) {
+  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
+}
+var run_event_stream = {
+  EVENT_CAP,
+  EVENT_KIND,
+  EVENT_KINDS,
+  TRACE_KINDS,
+  append,
+  append_event,
+  events_of_text,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  since,
+  target_of
+};
+
+export {
+  run_event_stream
+};

package/dist/commands/chunk-KIS7JFNP.js

@@ -0,0 +1,217 @@
+import {
+  durable_state,
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/lane/lane-ledger-write.ts
+import { closeSync, constants, openSync, writeSync } from "node:fs";
+
+// scripts/lane/lane-ledger-kind.ts
+var KIND = {
+  STARTUP: "startup",
+  MERGE: "merge",
+  GATE: "gate",
+  LOAD: "load",
+  DISPATCH: "dispatch",
+  STAGE: "stage",
+  STOP: "stop",
+  CHAIN: "chain",
+  OVERLAP: "overlap",
+  HELD: "held",
+  RELEASED: "released",
+  ROUND_ONE: "round-one",
+  ROUND_TWO: "round-two",
+  OFFERABLE: "offerable",
+  OFFER: "offer",
+  CORE_WAIT: "core-wait",
+  CORE_ADMISSION: "core-admission",
+  UNIT_FILES: "unit-files",
+  TEST_RELATED: "test-related",
+  TEST_PINNED: "test-pinned",
+  SPLIT_NOTICE: "split-notice",
+  SPLIT_FILED: "split-filed",
+  UNPLANNED_NOTICE: "unplanned-notice",
+  LANE_STATE: "lane-state",
+  PUSH_MISS: "push-miss",
+  EARLY_PUSH: "early-push",
+  SHIP_LAP: "ship-lap",
+  SIZE: "size",
+  LIMIT: "limit"
+};
+var lane_ledger_kind = { KIND };
+
+// scripts/lane/lane-ledger-write.ts
+var LEDGER_PREFIX = durable_state.PREFIX.LANE_LEDGER;
+var LEDGER_SUFFIX = ".jsonl";
+var LINE_SEPARATOR = "\n";
+var CI_WAIT_STAGE = "ci-wait";
+var CODERABBIT_WAIT_STAGE = "coderabbit-wait";
+var CODERABBIT_RATE_LIMIT_STAGE = "coderabbit-rate-limit";
+var CODERABBIT_RETRIGGER_STAGE = "coderabbit-retriggered";
+var PRE_DETACH_STAGE = "pre-detach";
+var ROUND_ONE_REUSED = "reused";
+var LEDGER_FILE_MODE = 384;
+var { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants;
+var APPEND_FLAGS = O_WRONLY | O_APPEND | O_CREAT | O_NOFOLLOW;
+var { KIND: KIND2 } = lane_ledger_kind;
+function target_of(repository) {
+  return durable_state.path(LEDGER_PREFIX, repository, LEDGER_SUFFIX);
+}
+async function target() {
+  if (process.env["VITEST"] !== void 0) return void 0;
+  try {
+    const repository = await run_carry.repository_directory();
+    return repository === void 0 ? void 0 : target_of(repository);
+  } catch {
+    return void 0;
+  }
+}
+function append(path, entry) {
+  const descriptor = openSync(path, APPEND_FLAGS, LEDGER_FILE_MODE);
+  try {
+    if (!stamp_file.is_own_regular_file(path)) {
+      throw new Error("Ledger is not an owned regular file");
+    }
+    writeSync(descriptor, `${JSON.stringify(entry)}${LINE_SEPARATOR}`);
+  } finally {
+    closeSync(descriptor);
+  }
+}
+async function record(entry, path) {
+  try {
+    const destination = path ?? await target();
+    if (destination !== void 0) append(destination, entry);
+  } catch {
+  }
+}
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function record_gate(path, gate) {
+  await record({ kind: KIND2.GATE, at: now_iso(), ...gate }, path);
+}
+async function record_merge(issue, at = /* @__PURE__ */ new Date()) {
+  await record({ kind: KIND2.MERGE, at: at.toISOString(), issue });
+}
+async function record_dispatch(issue, path) {
+  await record({ kind: KIND2.DISPATCH, at: now_iso(), issue }, path);
+}
+async function record_stage(stage, path) {
+  await record({ kind: KIND2.STAGE, at: now_iso(), ...stage }, path);
+}
+async function record_stop(stop, path) {
+  await record({ kind: KIND2.STOP, at: now_iso(), ...stop }, path);
+}
+async function record_chain(chain, path) {
+  await record({ kind: KIND2.CHAIN, at: now_iso(), ...chain }, path);
+}
+async function record_overlap(overlap, path) {
+  await record({ kind: KIND2.OVERLAP, at: now_iso(), ...overlap }, path);
+}
+async function record_held(held, path) {
+  const waiting = held.waiting ?? [];
+  const named = waiting.length > 0 ? { waiting: [...waiting] } : {};
+  await record({ kind: KIND2.HELD, at: now_iso(), reason: held.reason, ...named }, path);
+}
+async function record_released(path) {
+  await record({ kind: KIND2.RELEASED, at: now_iso() }, path);
+}
+async function record_lane_state(change, path) {
+  await record({ kind: KIND2.LANE_STATE, at: now_iso(), ...change }, path);
+}
+async function record_offerable(is_offerable, path) {
+  await record({ kind: KIND2.OFFERABLE, at: now_iso(), is_offerable }, path);
+}
+async function record_offer(offer, path) {
+  await record({ kind: KIND2.OFFER, at: now_iso(), ...offer }, path);
+}
+async function record_round_one(round_one, path) {
+  await record({ kind: KIND2.ROUND_ONE, at: now_iso(), ...round_one }, path);
+}
+async function record_round_two(round_two, path) {
+  await record({ kind: KIND2.ROUND_TWO, at: now_iso(), ...round_two }, path);
+}
+async function record_core_wait(wait, path) {
+  const is_immediate = wait.admission_reason !== void 0 && wait.wait_reason === void 0;
+  const kind = is_immediate ? KIND2.CORE_ADMISSION : KIND2.CORE_WAIT;
+  await record({ kind, at: now_iso(), ...wait }, path);
+}
+async function record_unit_files(files, path) {
+  await record({ kind: KIND2.UNIT_FILES, at: now_iso(), files: [...files] }, path);
+}
+async function record_test_related(run, path) {
+  await record({ kind: KIND2.TEST_RELATED, at: now_iso(), ...run }, path);
+}
+async function record_test_pinned(run, path) {
+  await record({ kind: KIND2.TEST_PINNED, at: now_iso(), ...run }, path);
+}
+async function record_split_notice(notice, path) {
+  await record({ kind: KIND2.SPLIT_NOTICE, at: now_iso(), ...notice }, path);
+}
+async function record_split_filed(filed, path) {
+  const destination = path ?? await target();
+  if (destination === void 0) throw new Error("Could not resolve the split-child ledger");
+  append(destination, { kind: KIND2.SPLIT_FILED, at: now_iso(), ...filed });
+}
+async function record_push_miss(miss, path) {
+  await record({ kind: KIND2.PUSH_MISS, at: now_iso(), ...miss }, path);
+}
+async function record_early_push(push, path) {
+  await record({ kind: KIND2.EARLY_PUSH, at: now_iso(), ...push }, path);
+}
+async function record_ship_lap(lap, path) {
+  await record({ kind: KIND2.SHIP_LAP, at: now_iso(), ...lap }, path);
+}
+async function record_size(size, path) {
+  await record({ kind: KIND2.SIZE, at: now_iso(), ...size }, path);
+}
+async function record_unplanned_notice(notice, path) {
+  await record({ kind: KIND2.UNPLANNED_NOTICE, at: now_iso(), ...notice }, path);
+}
+var lane_ledger_write = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND2,
+  LINE_SEPARATOR,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  append,
+  record,
+  record_chain,
+  record_core_wait,
+  record_dispatch,
+  record_gate,
+  record_held,
+  record_lane_state,
+  record_released,
+  record_merge,
+  record_overlap,
+  record_offer,
+  record_offerable,
+  record_push_miss,
+  record_early_push,
+  record_round_one,
+  record_round_two,
+  record_ship_lap,
+  record_size,
+  record_split_filed,
+  record_split_notice,
+  record_stage,
+  record_stop,
+  record_test_pinned,
+  record_test_related,
+  record_unit_files,
+  record_unplanned_notice,
+  target,
+  target_of
+};
+
+export {
+  lane_ledger_kind,
+  lane_ledger_write
+};