@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-NTGF5N3N.js

@@ -0,0 +1,110 @@
+import {
+  security_audit,
+  security_audit_logic,
+  security_audit_provision_logic
+} from "./chunk-7DGHFBU7.js";
+import {
+  timed_fetch
+} from "./chunk-5HVYOIIK.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+
+// scripts/security/security-audit-provision.ts
+var EXECUTABLE_MODE = 493;
+var FAILURE_STAMP_PREFIX = "josh-audit-provision-";
+var FORCE_FLAG = "--force";
+var PATH_LOCATION = "on PATH";
+var { RETRY_INTERVAL_MS } = security_audit_provision_logic;
+async function download(url, timeout_ms) {
+  try {
+    const response = await timed_fetch(url, {}, timeout_ms);
+    if (!response.ok) return { reason: `HTTP ${String(response.status)}` };
+    return { content: Buffer.from(await response.arrayBuffer()), reason: "" };
+  } catch (error) {
+    return { reason: error_text.message_of(error) };
+  }
+}
+function install(target_path, content) {
+  atomic_write.replace_file(target_path, content, { mode: EXECUTABLE_MODE });
+}
+function failure_stamp_path(target_path) {
+  return stamp_file.stamp_path(FAILURE_STAMP_PREFIX, target_path);
+}
+function is_in_backoff(target_path) {
+  const recorded = Number(stamp_file.read_stamp_text(failure_stamp_path(target_path)));
+  return Number.isFinite(recorded) && Date.now() - recorded < RETRY_INTERVAL_MS;
+}
+function record_failure(target_path, message) {
+  stamp_file.write_stamp(failure_stamp_path(target_path), Date.now());
+  return message;
+}
+async function provision(target_path, asset, timeout_ms) {
+  const { format_checksum_mismatch, format_download_failure, format_installed } = security_audit_provision_logic;
+  const outcome = await download(asset.url, timeout_ms);
+  if (outcome.content === void 0) {
+    return { is_installed: false, message: format_download_failure(asset.url, outcome.reason) };
+  }
+  const actual = stamp_file.digest(outcome.content);
+  if (actual !== asset.sha256) {
+    return {
+      is_installed: false,
+      message: format_checksum_mismatch(asset.name, asset.sha256, actual)
+    };
+  }
+  install(target_path, outcome.content);
+  return { is_installed: true, message: format_installed(target_path) };
+}
+async function attempt(target_path, asset, timeout_ms) {
+  try {
+    const outcome = await provision(target_path, asset, timeout_ms);
+    if (!outcome.is_installed) return record_failure(target_path, outcome.message);
+    stamp_file.remove_stamp(failure_stamp_path(target_path));
+    return outcome.message;
+  } catch (error) {
+    return record_failure(
+      target_path,
+      security_audit_provision_logic.format_provision_error(error_text.message_of(error))
+    );
+  }
+}
+function existing_scanner(target_path) {
+  const { BINARY_NAME } = security_audit_logic;
+  if (security_audit.meets_floor(BINARY_NAME)) return PATH_LOCATION;
+  const is_managed_usable = security_audit.is_executable_file(target_path) && security_audit.meets_floor(target_path);
+  return is_managed_usable ? target_path : void 0;
+}
+async function report(project_root, platform, architecture, is_forced) {
+  const logic = security_audit_provision_logic;
+  const target_path = security_audit.managed_binary_path(project_root, platform);
+  const existing = existing_scanner(target_path);
+  if (existing !== void 0) return logic.format_already_present(existing);
+  const asset = logic.resolve_asset(platform, architecture);
+  if (asset === void 0) return logic.format_unsupported_platform(platform, architecture);
+  if (!is_forced && is_in_backoff(target_path)) return logic.format_recent_failure();
+  return await attempt(target_path, asset, logic.build_download_timeout(is_forced));
+}
+async function run(argv) {
+  const is_forced = argv.includes(FORCE_FLAG);
+  try {
+    console.info(await report(PROJECT_ROOT, process.platform, process.arch, is_forced));
+  } catch (error) {
+    console.warn(
+      security_audit_provision_logic.format_provision_error(error_text.message_of(error))
+    );
+  }
+}
+var security_audit_provision = { attempt, provision, report, run };
+
+export {
+  security_audit_provision
+};

package/dist/commands/chunk-NTIVNQKF.js

@@ -0,0 +1,73 @@
+import {
+  git_worktree
+} from "./chunk-WNBJK6QE.js";
+
+// scripts/git/base-tree.ts
+import { rmSync } from "node:fs";
+import { copyFile, mkdir, mkdtemp, rm, symlink } from "node:fs/promises";
+import { constants, tmpdir } from "node:os";
+import path from "node:path";
+var TREE_NAME = "tree";
+var NODE_MODULES = "node_modules";
+var STOP_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+var SIGNAL_EXIT_BASE = 128;
+var live_parents = /* @__PURE__ */ new Set();
+async function prepare(tree, commit) {
+  await git_worktree.worktree_add_detached(tree, commit);
+  await symlink(path.resolve(NODE_MODULES), path.join(tree, NODE_MODULES), "dir");
+}
+async function remove(base_tree2) {
+  try {
+    await git_worktree.worktree_remove(base_tree2.tree);
+  } catch {
+  }
+  await rm(base_tree2.parent, { force: true, recursive: true });
+  try {
+    await git_worktree.worktree_prune();
+  } catch {
+  }
+}
+function remove_live_trees(signal) {
+  for (const parent of live_parents) rmSync(parent, { force: true, recursive: true });
+  process.exit(SIGNAL_EXIT_BASE + constants.signals[signal]);
+}
+function track(parent) {
+  if (live_parents.size === 0) {
+    for (const signal of STOP_SIGNALS) process.on(signal, remove_live_trees);
+  }
+  live_parents.add(parent);
+}
+function untrack(parent) {
+  live_parents.delete(parent);
+  if (live_parents.size > 0) return;
+  for (const signal of STOP_SIGNALS) process.off(signal, remove_live_trees);
+}
+async function with_tree(prefix, commit, use) {
+  const parent = await mkdtemp(path.join(tmpdir(), prefix));
+  const base_tree2 = { parent, tree: path.join(parent, TREE_NAME) };
+  track(parent);
+  try {
+    await prepare(base_tree2.tree, commit);
+    return await use(base_tree2);
+  } finally {
+    await remove(base_tree2);
+    untrack(parent);
+  }
+}
+async function copy_one(tree, file) {
+  const target = path.join(tree, file);
+  await mkdir(path.dirname(target), { recursive: true });
+  await copyFile(file, target);
+}
+async function copy_in(tree, files) {
+  await Promise.all(
+    files.map(async (file) => {
+      await copy_one(tree, file);
+    })
+  );
+}
+var base_tree = { NODE_MODULES, copy_in, with_tree };
+
+export {
+  base_tree
+};

package/dist/commands/chunk-NUCFIYZL.js

@@ -0,0 +1,119 @@
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/git/repository-lock.ts
+import { randomUUID } from "node:crypto";
+import { linkSync, renameSync, rmSync } from "node:fs";
+var POLL_INTERVAL_MS = 200;
+var SYNC_POLL_INTERVAL_MS = 10;
+var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function lock_path(prefix, cwd) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
+}
+function parse_owner(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function read_owner(target) {
+  return parse_owner(stamp_file.read_stamp_text(target));
+}
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+}
+function restore(aside, target) {
+  try {
+    linkSync(aside, target);
+  } catch {
+  }
+}
+function stale_record(target, is_gone) {
+  const raw = stamp_file.read_stamp_text(target);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone(owner) ? raw : void 0;
+}
+function move_aside(target) {
+  const aside = `${target}.${String(process.pid)}.${randomUUID()}`;
+  try {
+    renameSync(target, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
+}
+function clear_stale(target, is_gone = is_owner_gone) {
+  const raw = stale_record(target, is_gone);
+  if (raw === void 0) return;
+  const aside = move_aside(target);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
+  rmSync(aside, { force: true });
+}
+function claim(target) {
+  clear_stale(target);
+  return stamp_file.create_stamp(target, process_identity.own_fields());
+}
+function release(target) {
+  const owner = read_owner(target);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target);
+  }
+}
+async function acquire(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  return await poll.wait_for(
+    () => {
+      if (claim(target)) return true;
+      return Date.now() >= deadline ? false : void 0;
+    },
+    { interval_ms: POLL_INTERVAL_MS }
+  );
+}
+function sleep_sync(ms) {
+  Atomics.wait(SLEEP_CELL, 0, 0, ms);
+}
+function acquire_sync(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    sleep_sync(SYNC_POLL_INTERVAL_MS);
+  }
+  return true;
+}
+async function with_lock(work, target, max_wait_ms) {
+  if (!await acquire(target, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target);
+  }
+}
+function with_lock_sync(work, target, max_wait_ms) {
+  if (!acquire_sync(target, max_wait_ms)) return void 0;
+  try {
+    return work();
+  } finally {
+    release(target);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
+
+export {
+  repository_lock
+};

package/dist/commands/chunk-NVMV7BYX.js

@@ -0,0 +1,88 @@
+import {
+  live_evidence
+} from "./chunk-HALHQILI.js";
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  removed_tests
+} from "./chunk-U7Y6RKLK.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/run/ship/run-ship-body-draft.ts
+import { access, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+var BODY_FILE_OPTION = "body-file";
+var DRAFT_PREFIX = "josh-ship-body-";
+var DRAFT_SUFFIX = ".md";
+var EXISTS_CODE = "EEXIST";
+var NO_GIT_DIRECTORY = "no git directory to hold the ship body draft";
+async function path_of(issue_number) {
+  const [git_directory] = await git_command.git_directories();
+  if (git_directory === void 0) throw new Error(NO_GIT_DIRECTORY);
+  return path.join(git_directory, `${DRAFT_PREFIX}${issue_number}${DRAFT_SUFFIX}`);
+}
+function is_exists_error(error) {
+  return error instanceof Error && "code" in error && error.code === EXISTS_CODE;
+}
+var FORMAT_HINTS = [
+  acceptance_map.ROW_FORMAT,
+  live_evidence.EVIDENCE_FORMAT,
+  `when the change removes or renames a test, ${removed_tests.ROW_FORMAT}`
+];
+function hint_line(format) {
+  return `<!-- ${format} -->`;
+}
+function draft_text(acceptance_rows) {
+  const hints = FORMAT_HINTS.map((format) => hint_line(format)).join("\n");
+  return `${acceptance_rows}
+
+${hints}
+
+${live_evidence.EVIDENCE_HEADING}
+`;
+}
+async function prepare(issue_number, acceptance_rows) {
+  const target = await path_of(issue_number);
+  try {
+    await writeFile(target, draft_text(acceptance_rows), { flag: "wx" });
+  } catch (error) {
+    if (!is_exists_error(error)) throw error;
+  }
+  return target;
+}
+async function existing(issue_number) {
+  const target = await path_of(issue_number);
+  try {
+    await access(target);
+    return target;
+  } catch {
+    return void 0;
+  }
+}
+async function remove(issue_number) {
+  await rm(await path_of(issue_number), { force: true });
+}
+function body_arguments(body_path) {
+  return body_path === void 0 ? [] : [`--${BODY_FILE_OPTION}`, body_path];
+}
+async function with_draft(args) {
+  if (args.body_path !== void 0) return args;
+  const draft = await existing(args.number);
+  return draft === void 0 ? args : { ...args, body: body_arguments(draft), body_path: draft };
+}
+var run_ship_body_draft = {
+  BODY_FILE_OPTION,
+  body_arguments,
+  existing,
+  path_of,
+  prepare,
+  remove,
+  with_draft
+};
+
+export {
+  run_ship_body_draft
+};

package/dist/commands/chunk-NYWPTYGL.js

@@ -0,0 +1,169 @@
+import {
+  epic_body,
+  epic_promote
+} from "./chunk-LJZERYLG.js";
+import {
+  epic_relations
+} from "./chunk-WTIPX5NG.js";
+import {
+  epic_validate
+} from "./chunk-RFWB2KAV.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  EPIC_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-run.ts
+var EPIC_LABEL_COLOR = "#5319e7";
+var EPIC_LABEL_DESCRIPTION = "Tracks a batch of child issues from one split";
+var FAILURE_EXIT_CODE = 1;
+var SUCCESS_EXIT_CODE = 0;
+async function apply_dependencies(input) {
+  const pairs = epic_body.build_dependency_pairs(input.children, input.is_ordered);
+  if (pairs.length === 0) return;
+  const failures = await epic_relations.apply_relations(pairs, "record");
+  console.info(
+    epic_relations.format_relation_report({
+      links: pairs,
+      failures,
+      action: "record"
+    })
+  );
+}
+var ISSUE_URL_NUMBER = /\/(?<number>\d+)\s*$/u;
+function parse_created_number(url) {
+  const { groups } = ISSUE_URL_NUMBER.exec(url.trim()) ?? {};
+  const { number: raw } = groups ?? {};
+  if (raw === void 0) return void 0;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+async function fill_run_command(epic_number, input) {
+  if (epic_number === void 0) {
+    console.info(
+      `\u26A0\uFE0F  Could not read the new epic's number from its URL; the Execution section still says \`${epic_body.format_run_command(void 0)}\`.`
+    );
+    return;
+  }
+  try {
+    await git_gh_command.issue_edit_body(
+      String(epic_number),
+      epic_body.build_epic_body({
+        children: input.children,
+        rationale: input.rationale,
+        is_ordered: input.is_ordered,
+        origin: input.origin,
+        epic_number
+      })
+    );
+  } catch {
+    console.info("\u26A0\uFE0F  Could not substitute the epic number into the Execution section.");
+  }
+}
+async function create_epic_number(input) {
+  await git_gh_command.label_ensure({
+    name: EPIC_LABEL,
+    color: EPIC_LABEL_COLOR,
+    description: EPIC_LABEL_DESCRIPTION
+  });
+  const body = epic_body.build_epic_body({
+    children: input.children,
+    rationale: input.rationale,
+    is_ordered: input.is_ordered,
+    origin: input.origin
+  });
+  const url = await git_gh_command.issue_create_with_label({
+    title: input.title,
+    label: EPIC_LABEL,
+    body
+  });
+  const epic_number = parse_created_number(url);
+  console.info(`\u{1F4CB} Created epic: ${url}`);
+  await apply_dependencies({ children: input.children, is_ordered: input.is_ordered });
+  await fill_run_command(epic_number, input);
+  console.info(`\u25B6 Run the children with: ${epic_body.format_run_command(epic_number)}`);
+  return epic_number;
+}
+async function create_epic(input) {
+  await create_epic_number(input);
+  return SUCCESS_EXIT_CODE;
+}
+async function write_promoted_issue(input, body) {
+  const issue_number = String(input.epic_number);
+  if (input.title !== void 0) {
+    console.info(`title: ${await git_gh_command.issue_edit_title(issue_number, input.title)}`);
+  }
+  await git_gh_command.issue_edit_body(issue_number, body);
+}
+async function read_promotion_subject(epic_number) {
+  const subject = epic_validate.parse_epic_subject(
+    await git_gh_command.issue_get_labels_and_body(String(epic_number))
+  );
+  if (subject === void 0) {
+    console.error(`\u2716 Could not read issue ${session_cite.issue(epic_number)}.`);
+    return void 0;
+  }
+  if (epic_promote.has_conflicting_tracking(subject.body)) {
+    const reason = epic_promote.conflict_reason(subject.body);
+    console.error(`\u2716 Cannot promote ${session_cite.issue(epic_number)}: ${reason}.`);
+    return void 0;
+  }
+  return subject;
+}
+async function write_promotion(input, existing_body) {
+  const body = epic_promote.build_promoted_body({ ...input, body: existing_body });
+  const tracking_error = epic_promote.find_tracking_error(body, input.children);
+  if (tracking_error !== void 0) {
+    console.error(`\u2716 ${tracking_error}`);
+    return FAILURE_EXIT_CODE;
+  }
+  await write_promoted_issue(input, body);
+  if (await git_gh_command.issue_add_label(String(input.epic_number), EPIC_LABEL)) {
+    return SUCCESS_EXIT_CODE;
+  }
+  console.error(
+    `\u2716 Wrote the epic sections to ${session_cite.issue(input.epic_number)} but could not apply the \`${EPIC_LABEL}\` label; apply it by hand.`
+  );
+  return FAILURE_EXIT_CODE;
+}
+async function promote_epic(input) {
+  const subject = await read_promotion_subject(input.epic_number);
+  if (subject === void 0) return FAILURE_EXIT_CODE;
+  await git_gh_command.label_ensure({
+    name: EPIC_LABEL,
+    color: EPIC_LABEL_COLOR,
+    description: EPIC_LABEL_DESCRIPTION
+  });
+  const written = await write_promotion(input, subject.body);
+  if (written !== SUCCESS_EXIT_CODE) return written;
+  console.info(`\u{1F4CB} Promoted ${session_cite.issue(input.epic_number)} to an epic.`);
+  await apply_dependencies({ children: input.children, is_ordered: input.is_ordered });
+  console.info(`\u25B6 Run the children with: ${epic_body.format_run_command(input.epic_number)}`);
+  return SUCCESS_EXIT_CODE;
+}
+async function check_epic(epic_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(String(epic_number));
+  const subject = epic_validate.parse_epic_subject(raw);
+  if (subject === void 0) {
+    console.error(`\u2716 Could not read issue ${session_cite.issue(epic_number)}.`);
+    return FAILURE_EXIT_CODE;
+  }
+  const results = epic_validate.validate_epic(subject);
+  console.info(epic_validate.format_check_report(subject.number, results));
+  return epic_validate.is_epic_valid(results) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+var epic_run = {
+  create_epic,
+  create_epic_number,
+  promote_epic,
+  check_epic
+};
+
+export {
+  epic_run
+};

package/dist/commands/chunk-NZ45KOLL.js

@@ -0,0 +1,104 @@
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/process-directories.ts
+import { spawnSync } from "node:child_process";
+import path2 from "node:path";
+
+// scripts/lane/process-linux.ts
+import { readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import path from "node:path";
+var GONE_CODES = /* @__PURE__ */ new Set(["ENOENT", "ESRCH"]);
+var PID_DIRECTORY = /^\d+$/u;
+var MARK_PREFIX = `${lane_child_marker.KEY}=`;
+function is_gone(error) {
+  return error instanceof Error && "code" in error && GONE_CODES.has(String(error.code));
+}
+function marked_issue(content) {
+  const assignment = content.split("\0").find((entry) => entry.startsWith(MARK_PREFIX));
+  const value = assignment?.slice(MARK_PREFIX.length);
+  return lane_child_marker.marked_issue({ [lane_child_marker.KEY]: value });
+}
+function read_process(root, pid, uid) {
+  const directory = path.join(root, pid);
+  try {
+    if (statSync(directory).uid !== uid) return { kind: "skip" };
+    const cwd = readlinkSync(path.join(directory, "cwd"));
+    const issue = marked_issue(readFileSync(path.join(directory, "environ"), "utf8"));
+    return { kind: "read", process: { pid: Number(pid), directory: cwd, issue } };
+  } catch (error) {
+    return { kind: is_gone(error) ? "skip" : "unknown" };
+  }
+}
+function processes(readings) {
+  return readings.flatMap((reading) => reading.kind === "read" ? [reading.process] : []);
+}
+function read_owned(root, uid) {
+  try {
+    const pids = readdirSync(root).filter((entry) => PID_DIRECTORY.test(entry));
+    const readings = pids.map((pid) => read_process(root, pid, uid));
+    if (readings.some((reading) => reading.kind === "unknown")) return void 0;
+    return processes(readings);
+  } catch {
+    return void 0;
+  }
+}
+function read_processes(root = "/proc", uid = process.getuid?.()) {
+  return uid === void 0 ? void 0 : read_owned(root, uid);
+}
+function directories() {
+  const read = read_processes();
+  return read === void 0 ? void 0 : new Map(read.map((entry) => [entry.pid, entry.directory]));
+}
+function marks() {
+  const marked = read_processes()?.filter((entry) => entry.issue !== void 0);
+  return marked === void 0 ? void 0 : new Map(
+    marked.flatMap((entry) => entry.issue === void 0 ? [] : [[entry.pid, entry.issue]])
+  );
+}
+var process_linux = { directories, marks, read_processes };
+
+// scripts/lane/process-directories.ts
+var LSOF_COMMAND = "lsof";
+var CWD_ARGUMENTS = ["-a", "-d", "cwd", "-Fn"];
+var LSOF_PROCESS = /^(?=p)/mu;
+var LSOF_NAME = "n";
+var LISTING_PLATFORMS = /* @__PURE__ */ new Set(["darwin"]);
+function lsof_block(block) {
+  const [process_line = "", ...rest] = block.trim().split("\n");
+  const name = rest.find((line) => line.startsWith(LSOF_NAME));
+  return name === void 0 ? void 0 : [Number(process_line.slice(1)), name.slice(1)];
+}
+function parse(output) {
+  const blocks = output.split(LSOF_PROCESS).map((block) => lsof_block(block));
+  return new Map(blocks.filter((block) => block !== void 0));
+}
+function list_all(platform = process.platform) {
+  if (platform === "linux") return process_linux.directories();
+  if (!LISTING_PLATFORMS.has(platform)) return /* @__PURE__ */ new Map();
+  const result = spawnSync(LSOF_COMMAND, CWD_ARGUMENTS, {
+    encoding: "utf8",
+    timeout: PROBE_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return result.error === void 0 ? parse(result.stdout) : void 0;
+}
+function lane_of(directory, root) {
+  const parts = directory.split(path2.sep);
+  const ancestors = parts.map((_, index) => parts.slice(0, index + 1).join(path2.sep)).slice(1);
+  const environment = { [lane_paths.LANE_ROOT_KEY]: root };
+  return ancestors.map((ancestor) => lane_paths.lane_issue_of(ancestor, environment)).find(Boolean);
+}
+var process_directories = { CWD_ARGUMENTS, lane_of, list_all, parse };
+
+export {
+  process_linux,
+  process_directories
+};

package/dist/commands/chunk-O45BX4EL.js

@@ -0,0 +1,39 @@
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/gh/gh-usage-log.ts
+var USAGE_SUFFIX = ".jsonl";
+var USAGE_CAP = 2e3;
+var LOCK_SUFFIX = ".lock";
+var LOCK_WAIT_MS = 5e3;
+var LINE_SEPARATOR = "\n";
+function target_of(repository) {
+  return durable_state.path(durable_state.PREFIX.GH_USAGE, repository, USAGE_SUFFIX);
+}
+function read_lines(target) {
+  const raw = stamp_file.read_stamp_text(target) ?? "";
+  return raw.split(LINE_SEPARATOR).filter((line) => line !== "");
+}
+function append_held(target, line) {
+  const lines = [...read_lines(target), line].slice(-USAGE_CAP);
+  stamp_file.replace_text_stamp(target, `${lines.join(LINE_SEPARATOR)}${LINE_SEPARATOR}`);
+  return true;
+}
+function append(target, record) {
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const line = JSON.stringify(record);
+  if (repository_lock.with_lock_sync(() => append_held(target, line), lock, LOCK_WAIT_MS)) return;
+  throw new Error(`gh usage log: gave up waiting for the lock at ${lock}`);
+}
+var gh_usage_log = { USAGE_CAP, append, read_lines, target_of };
+
+export {
+  gh_usage_log
+};