@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/commands/chunk-JHN6RCE6.js

@@ -0,0 +1,123 @@
+import {
+  issue_number_shape
+} from "./chunk-66NX6EXR.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/backlog/backlog-drive-args.ts
+var LIST_SEPARATOR = ",";
+var USAGE = "Usage: josh backlog:drive [--owner <pid>] [--active <ISO-8601>] [--max <n>] [--idle <minutes>] [--only] [--exclude <n>[,<n>...]] [--await <n>[,<n>...]] [--window <minutes>] [--stopped <n>]";
+var OPTIONS = {
+  active: { type: "string" },
+  await: { type: "string" },
+  exclude: { type: "string" },
+  idle: { type: "string" },
+  max: { type: "string" },
+  only: { type: "boolean" },
+  owner: { type: "string" },
+  stopped: { type: "string" },
+  "triage-owed": { type: "boolean" },
+  "triage-pid": { type: "string" },
+  "triage-start": { type: "string" },
+  window: { type: "string" }
+};
+var START_SPACE = " ";
+var START_SPACE_TOKEN = "_";
+function beside_session(values) {
+  const pid = cli_flags.to_count(values["triage-pid"]);
+  if (pid === void 0) return {};
+  const start = values["triage-start"]?.split(START_SPACE_TOKEN).join(START_SPACE);
+  return start === void 0 ? { triage_pid: pid } : { triage_pid: pid, triage_start: start };
+}
+function triage_flags(values) {
+  const owed = values["triage-owed"] === true ? { is_triage_owed: true } : {};
+  return { ...owed, ...beside_session(values) };
+}
+function read_values(argv) {
+  return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, strict: true })?.values;
+}
+function to_issues(raw) {
+  if (raw === void 0) return [];
+  const issues = raw.split(LIST_SEPARATOR);
+  return issues.some((issue) => !issue_number_shape.is_issue_number(issue)) ? void 0 : issues;
+}
+function forwarded_of(values) {
+  const pairs = ["max", "idle"].filter((name) => values[name] !== void 0);
+  if (pairs.some((name) => cli_flags.to_count(values[name]) === void 0)) return void 0;
+  return pairs.flatMap((name) => [`--${name}`, values[name] ?? ""]);
+}
+function window_of(raw) {
+  return raw === void 0 ? void 0 : Number(raw) * MS_PER_MINUTE;
+}
+function is_count_or_absent(raw) {
+  return raw === void 0 || cli_flags.to_count(raw) !== void 0;
+}
+function is_valid_single(values) {
+  const is_valid_stopped = values.stopped === void 0 || issue_number_shape.ISSUE_NUMBER_PATTERN.test(values.stopped);
+  const is_valid_counts = is_count_or_absent(values.window) && is_count_or_absent(values["triage-pid"]);
+  return is_valid_stopped && is_valid_counts;
+}
+function owner_of(values) {
+  const owner = values?.owner ?? agent_session_environment.own_session_pid()?.toString();
+  return cli_flags.to_count(owner) === void 0 ? void 0 : owner;
+}
+function to_context(values, owner) {
+  if (!is_valid_single(values)) return void 0;
+  const forwarded = forwarded_of(values);
+  const exclude = to_issues(values.exclude);
+  const awaited = to_issues(values.await);
+  if (forwarded === void 0 || exclude === void 0 || awaited === void 0) return void 0;
+  const window_ms = window_of(values.window);
+  return {
+    owner,
+    active: values.active,
+    forwarded,
+    exclude,
+    awaited,
+    window_ms,
+    window: values.window,
+    is_only: values.only === true,
+    stopped: values.stopped,
+    ...triage_flags(values)
+  };
+}
+function parse(argv) {
+  const values = read_values(argv);
+  const owner = owner_of(values);
+  return values === void 0 || owner === void 0 ? void 0 : to_context(values, owner);
+}
+function beside_flags(pid, start) {
+  if (pid === void 0) return [];
+  const named = ["--triage-pid", String(pid)];
+  if (start === void 0) return named;
+  return [...named, "--triage-start", start.split(START_SPACE).join(START_SPACE_TOKEN)];
+}
+function triage_line_flags(state) {
+  const owed = state.is_triage_owed === true ? ["--triage-owed"] : [];
+  return [...owed, ...beside_flags(state.triage_pid, state.triage_start)];
+}
+function resume_line(state, context) {
+  const exclude = [.../* @__PURE__ */ new Set([...context.exclude, ...state.exclude])];
+  const flags = ["--owner", context.owner, "--active", state.active, ...context.forwarded];
+  if (exclude.length > 0) flags.push("--exclude", exclude.join(LIST_SEPARATOR));
+  if (context.window !== void 0) flags.push("--window", context.window);
+  if (state.stopped_by !== void 0) flags.push("--stopped", state.stopped_by);
+  return `resume: ${[...flags, ...triage_line_flags(state)].join(" ")}`;
+}
+var backlog_drive_args = {
+  USAGE,
+  beside_flags,
+  parse,
+  resume_line
+};
+
+export {
+  backlog_drive_args
+};

package/dist/commands/chunk-JJRKTWLK.js

@@ -0,0 +1,64 @@
+import {
+  git_gh_exec
+} from "./chunk-XDF25GSU.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/repo/repo-setting.ts
+var GH_TIMEOUT_MS = 5e3;
+var REPO_PLACEHOLDER = "<owner>/<repo>";
+var UNKNOWN_REPOSITORY = "unknown repository";
+var FAILED_EXIT_CODE = 1;
+function query_repo_api(api_path) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: api_path,
+    cwd: PROJECT_ROOT,
+    timeout_ms: GH_TIMEOUT_MS
+  });
+  return stdout === void 0 ? { exit_code: FAILED_EXIT_CODE, stdout: "" } : { exit_code: 0, stdout };
+}
+function parse_payload(exit_code, stdout) {
+  if (exit_code !== 0) return void 0;
+  const parsed = json_value.parse_or_undefined(stdout);
+  return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+}
+function read_field(payload, field) {
+  return payload === void 0 ? void 0 : Reflect.get(payload, field);
+}
+function classify_boolean_setting(payload, field) {
+  const value = read_field(payload, field);
+  if (typeof value !== "boolean") return "unreadable";
+  return value ? "enabled" : "disabled";
+}
+function command_target(repo) {
+  return repo ?? REPO_PLACEHOLDER;
+}
+function report_target(repo) {
+  return repo ?? UNKNOWN_REPOSITORY;
+}
+function print_section(lines) {
+  console.info("");
+  for (const line of lines) {
+    console.info(line);
+  }
+}
+var repo_setting = {
+  GH_TIMEOUT_MS,
+  REPO_PLACEHOLDER,
+  UNKNOWN_REPOSITORY,
+  query_repo_api,
+  parse_payload,
+  read_field,
+  classify_boolean_setting,
+  command_target,
+  report_target,
+  print_section
+};
+
+export {
+  repo_setting
+};

package/dist/commands/chunk-JLREFWJ4.js

@@ -0,0 +1,244 @@
+import {
+  epic_add_body,
+  epic_chains,
+  epic_read,
+  epic_shape
+} from "./chunk-K7GL3BGI.js";
+import {
+  epic_decision
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_relations
+} from "./chunk-OI7KM4K3.js";
+import {
+  size_estimate
+} from "./chunk-7ZECP3J6.js";
+import {
+  chain_links,
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  format_dependency_link,
+  format_dependency_links
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-RX5JSPPH.js";
+import {
+  issue_read
+} from "./chunk-HBNB3TLG.js";
+import {
+  NEEDS_DECISION_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-X7PN54LZ.js";
+
+// scripts/epic/epic-decide.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function format_list(numbers) {
+  return numbers.map((issue_number) => session_cite.issue(issue_number)).join(", ");
+}
+function untracked_error(epic_number, untracked) {
+  return `${format_list(untracked)} not tracked by ${session_cite.issue(epic_number)}; place it with \`pnpm josh epic --add ${String(epic_number)} <N> --decision-file <path>\`. Nothing was written.`;
+}
+function size_error(input) {
+  if (input.children.length === 1 || size_estimate.stated_line(input.decision) === void 0) {
+    return void 0;
+  }
+  return `The record states a size estimate but names ${format_list(input.children)}; an estimate is one child's, so record it with \`--decide\` for that child alone. Nothing was written.`;
+}
+async function read_decision_target(input) {
+  const record_error = epic_decision.find_decision_error(input.decision) ?? size_error(input);
+  if (record_error !== void 0) return { error: record_error };
+  const subject = await epic_read.read_subject(input.epic_number);
+  if (subject === void 0) {
+    return { error: `Could not read issue ${session_cite.issue(input.epic_number)}.` };
+  }
+  const tracked = epic_parse.parse_task_list_issue_numbers(subject.body);
+  const untracked = input.children.filter((child) => !tracked.includes(child));
+  return untracked.length === 0 ? subject : { error: untracked_error(input.epic_number, untracked) };
+}
+async function record_on_epic(subject, decision) {
+  const epic = session_cite.issue(subject.number);
+  if (epic_decision.has_decision(subject.body, decision)) {
+    return `\u{1F4DD} ${epic} already records this decision.`;
+  }
+  const body = epic_decision.append_decision(subject.body ?? "", decision);
+  await git_gh_command.issue_edit_body(String(subject.number), body);
+  return `\u{1F4DD} Decision recorded in ${epic}'s \`## Decisions\`.`;
+}
+async function has_comment(child, decision) {
+  const comments = await issue_read.parse_comments(
+    await git_gh_command.issue_list_comments(String(child))
+  );
+  return comments?.some((comment) => comment.body.trim() === decision.trim());
+}
+async function try_edit_body(child, body) {
+  try {
+    await git_gh_command.issue_edit_body(String(child), body);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function restate_size(child, decision) {
+  const line = size_estimate.stated_line(decision);
+  if (line === void 0) return true;
+  const subject = await epic_read.read_subject(child);
+  if (subject === void 0) return false;
+  const body = subject.body ?? "";
+  const restated = size_estimate.restated(body, line);
+  return restated === body || await try_edit_body(child, restated);
+}
+async function record_on_child(child, decision) {
+  const has_record = await has_comment(child, decision);
+  if (has_record === void 0) return false;
+  const is_commented = has_record || await git_gh_command.issue_try_comment(String(child), decision);
+  if (!is_commented || !await restate_size(child, decision)) return false;
+  return await git_gh_command.issue_clear_label(String(child), NEEDS_DECISION_LABEL);
+}
+function format_child_report(total, failures) {
+  if (failures === 0) return epic_decision.format_decision_report({ total, failures });
+  return `\u26A0\uFE0F  ${String(failures)} of ${String(total)} child issue(s) could not be given the comment or lose \`${NEEDS_DECISION_LABEL}\`; rerun the same command \u2014 nothing is written twice.`;
+}
+async function decide(input) {
+  const epic = await read_decision_target(input);
+  if ("error" in epic) {
+    console.error(`\u2716 ${epic.error}`);
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(await record_on_epic(epic, input.decision));
+  const recorded = await Promise.all(
+    input.children.map(async (child) => await record_on_child(child, input.decision))
+  );
+  const failures = recorded.filter((is_recorded) => !is_recorded).length;
+  console.info(format_child_report(input.children.length, failures));
+  return failures === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+var epic_decide = {
+  decide
+};
+
+// scripts/epic/epic-remove-plan.ts
+var MINIMUM_PATH_LENGTH = 2;
+function to_path_links(path) {
+  return chain_links(path);
+}
+function find_path_error(path) {
+  if (path.length < MINIMUM_PATH_LENGTH) {
+    return "Two issue numbers are required after the epic: the order to remove is `<M> <N>`, and a longer list removes each consecutive pair.";
+  }
+  return to_path_links(path).length === path.length - 1 ? void 0 : "The path names the same issue twice in a row, which declares no order.";
+}
+function find_undeclared_error(links, chains) {
+  const declared = new Set(epic_chains.links_of(chains).map((link) => format_dependency_link(link)));
+  const missing = links.filter((link) => !declared.has(format_dependency_link(link)));
+  return missing.length === 0 ? void 0 : `The declared dependency order does not name ${format_dependency_links(missing)}; there is nothing to remove.`;
+}
+function find_decision_error(decision) {
+  return decision === void 0 ? void 0 : epic_decision.find_decision_error(decision);
+}
+function find_input_error(input, tracked, chains) {
+  return epic_shape.find_subject_error(input, tracked) ?? find_path_error(input.path) ?? find_undeclared_error(to_path_links(input.path), chains) ?? find_decision_error(input.decision);
+}
+function to_ends(links) {
+  return [...new Set(links.flatMap((link) => [link.blocker, link.blocked]))];
+}
+function to_body(input, chains_after) {
+  return epic_add_body.rewrite_body({
+    body: input.body ?? "",
+    placed: [],
+    chains_after,
+    decision: input.decision,
+    does_clear_declaration: true
+  });
+}
+function build_removal_plan(input) {
+  const tracked = epic_parse.parse_task_list_issue_numbers(input.body);
+  const chains_before = epic_parse.parse_dependency_chains(input.body);
+  const error = find_input_error(input, tracked, chains_before);
+  if (error !== void 0) return { error };
+  const links = to_path_links(input.path);
+  const chains_after = epic_chains.remove_links(chains_before, links);
+  const rewritten = to_body(input, chains_after);
+  if ("error" in rewritten) return { error: rewritten.error };
+  return {
+    plan: {
+      body: rewritten.body,
+      links,
+      // Only the links a relation actually backs: asking `gh` to remove one that was never
+      // recorded is reported as a failure the user cannot act on.
+      removed: epic_graph.recorded_relations(links, input.recorded, input.repo),
+      ends: to_ends(links)
+    }
+  };
+}
+var epic_remove_plan = {
+  build_removal_plan
+};
+
+// scripts/epic/epic-remove.ts
+var FAILURE_EXIT_CODE2 = 1;
+var SUCCESS_EXIT_CODE2 = 0;
+async function comment_decision(ends, decision) {
+  const posted = await Promise.all(
+    ends.map(async (end) => await git_gh_command.issue_try_comment(String(end), decision))
+  );
+  console.info(
+    epic_decision.format_decision_report({
+      total: ends.length,
+      failures: posted.filter((is_posted) => !is_posted).length
+    })
+  );
+}
+function report_relations(plan, failures) {
+  if (plan.removed.length === 0) return;
+  console.info(
+    epic_relations.format_relation_report({ links: plan.removed, failures, action: "drop" })
+  );
+}
+async function write_plan(epic_number, plan, decision) {
+  await git_gh_command.issue_edit_body(String(epic_number), plan.body);
+  console.info(
+    session_cite.text(
+      `\u{1F4CB} Removed ${format_dependency_links(plan.links)} from epic ${session_cite.issue(epic_number)}.`
+    )
+  );
+  report_relations(plan, await epic_relations.apply_relations(plan.removed, "drop"));
+  if (decision !== void 0) await comment_decision(plan.ends, decision);
+}
+async function remove_order(input) {
+  const epic = await epic_read.read_epic(input.epic_number);
+  if ("error" in epic) {
+    console.error(`\u2716 ${epic.error}`);
+    return FAILURE_EXIT_CODE2;
+  }
+  const outcome = epic_remove_plan.build_removal_plan({
+    epic_number: input.epic_number,
+    body: epic.subject.body,
+    labels: epic.subject.labels,
+    path: input.path,
+    recorded: epic.recorded,
+    repo: epic.repo,
+    decision: input.decision
+  });
+  if ("error" in outcome) {
+    console.error(`\u2716 ${outcome.error}`);
+    return FAILURE_EXIT_CODE2;
+  }
+  await write_plan(input.epic_number, outcome.plan, input.decision);
+  return SUCCESS_EXIT_CODE2;
+}
+var epic_remove = {
+  remove_order
+};
+
+export {
+  epic_decide,
+  epic_remove
+};

package/dist/commands/chunk-JLYW7CP6.js

@@ -0,0 +1,43 @@
+import {
+  doctor_consumer
+} from "./chunk-O26Y2FOJ.js";
+import {
+  NOTHING_TO_CHECK_MARKER
+} from "./chunk-IW6NWCSN.js";
+
+// scripts/exports/unused-members-check.ts
+import path from "node:path";
+var CHECK = "exports";
+var FAIL_EXIT_CODE = 1;
+var CONSUMER_NOTICE = `josh ${CHECK}: checks only the kit repository itself \u2014 ${NOTHING_TO_CHECK_MARKER} in a consumer project.`;
+function format_member(root, member) {
+  return `${path.relative(root, member.file)}:${String(member.line)}  ${member.namespace}.${member.member}`;
+}
+function report(root, members) {
+  if (members.length === 0) return `josh ${CHECK}: no unused namespace member`;
+  return [
+    `josh ${CHECK}: ${String(members.length)} namespace member(s) nothing reads \u2014 remove each from its namespace object (and the declaration, if nothing in its file uses it either):`,
+    ...members.map((member) => `  ${format_member(root, member)}`)
+  ].join("\n");
+}
+async function find_members(root, files) {
+  const { unused_members } = await import("./unused-members-STULPRBU.js");
+  if (files === void 0) return unused_members.find_unused_members(root);
+  return await unused_members.find_unused_members_in(root, files);
+}
+async function run_unused_members(root, files) {
+  if (doctor_consumer.is_kit_consumer(root)) {
+    console.info(CONSUMER_NOTICE);
+    return 0;
+  }
+  const members = await find_members(root, files);
+  const output = report(root, members);
+  if (members.length === 0) console.info(output);
+  else console.error(output);
+  return members.length === 0 ? 0 : FAIL_EXIT_CODE;
+}
+var unused_members_check = { run_unused_members, CONSUMER_NOTICE };
+
+export {
+  unused_members_check
+};

package/dist/commands/chunk-JNWHX25C.js

@@ -0,0 +1,36 @@
+import {
+  COMMAND_MAP
+} from "./chunk-5HWZFL4D.js";
+import {
+  canonical_command
+} from "./chunk-ROJXMBXP.js";
+
+// scripts/josh/josh-read-only.ts
+var HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "--help", "-h"]);
+var ALL_FLAG = "--all";
+function is_help_request(command) {
+  return command === void 0 || command === ALL_FLAG || HELP_COMMANDS.has(command);
+}
+function entry_of(name) {
+  const command = canonical_command(name);
+  return Object.hasOwn(COMMAND_MAP, command) ? COMMAND_MAP[command] : void 0;
+}
+function is_read_only_call(entry, rest) {
+  const write_flags = entry.write_flags ?? [];
+  if (rest.some((argument) => write_flags.includes(argument.split("=", 1)[0] ?? ""))) return false;
+  if (entry.is_read_only === true) return true;
+  const flags = entry.read_only_flags ?? [];
+  return rest.some((argument) => flags.includes(argument));
+}
+function refusal(args) {
+  const [command = "", ...rest] = args;
+  if (is_help_request(args[0])) return void 0;
+  const entry = entry_of(command);
+  if (entry !== void 0 && is_read_only_call(entry, rest)) return void 0;
+  return `\`josh ${command}\` is not read-only: it carries a declared write flag, or its entry is not declared read-only and it carries no read-only flag its entry declares; read its usage with \`pnpm josh help ${command}\``;
+}
+var josh_read_only = { ALL_FLAG, entry_of, is_help_request, refusal };
+
+export {
+  josh_read_only
+};

package/dist/commands/chunk-JOARHU3M.js

@@ -0,0 +1,137 @@
+import {
+  lane_ledger
+} from "./chunk-XYAK53TK.js";
+import {
+  repository_lock
+} from "./chunk-P4KIQRSL.js";
+import {
+  lane_ledger_write
+} from "./chunk-I63RNFFR.js";
+import {
+  stamp_file
+} from "./chunk-QWWTC3XR.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
+};