@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-KGSEWOKI.js

@@ -1,353 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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
-};