@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-KJPZPTS4.js

@@ -0,0 +1,245 @@
+import {
+  whole_suite_files
+} from "./chunk-WEUUJIWQ.js";
+import {
+  since_green
+} from "./chunk-6AHAY5VZ.js";
+import {
+  test_read_map
+} from "./chunk-B2PJEV3S.js";
+import {
+  changed_file_scope
+} from "./chunk-QX2EMUXV.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+
+// scripts/test/pure-files-entries.ts
+import path from "node:path";
+var PURE_FILES_PATH = path.join("tools", "test", "pure-files.ts");
+var LIST_TESTS = [
+  path.join("tools", "test", "pure-files.test.ts"),
+  path.join("tools", "test", "classify-isolation.test.ts")
+];
+var ENTRY_LINE = /^\t'(?<entry>[^']+)',$/u;
+function entry_of(line) {
+  return ENTRY_LINE.exec(line)?.groups?.["entry"];
+}
+function lines_of(text) {
+  return text.trimEnd().split("\n");
+}
+function frame_of(text) {
+  return lines_of(text).filter((line) => entry_of(line) === void 0).join("\n");
+}
+function entries_of(text) {
+  return new Set(lines_of(text).flatMap((line) => entry_of(line) ?? []));
+}
+function missing_from(entries, other) {
+  return [...entries].filter((entry) => !other.has(entry));
+}
+function moved_entries(before, after) {
+  if (frame_of(before) !== frame_of(after)) return void 0;
+  const was = entries_of(before);
+  const is = entries_of(after);
+  return [...missing_from(is, was), ...missing_from(was, is)];
+}
+function tests_of(entries) {
+  return [...LIST_TESTS, ...entries];
+}
+async function base_text() {
+  try {
+    return await git_command.show_file(`${await git_command.change_base()}:${PURE_FILES_PATH}`);
+  } catch {
+    return void 0;
+  }
+}
+async function read_moved(root, changed) {
+  if (changed?.includes(PURE_FILES_PATH) !== true) return void 0;
+  const before = await base_text();
+  const after = file_reader.read_if_readable(path.join(root, PURE_FILES_PATH));
+  if (before === void 0 || after === void 0) return void 0;
+  return moved_entries(before, after);
+}
+var pure_files_entries = { PURE_FILES_PATH, moved_entries, read_moved, tests_of };
+
+// scripts/test/test-related-scope.ts
+import path2 from "node:path";
+var RELATABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte"
+]);
+var { WHOLE_SUITE_FILES } = whole_suite_files;
+var { UNREADABLE_REASON } = changed_file_scope;
+var NOTHING_RELATABLE_REASON = "no changed file is one a test can import or read";
+var NO_MAP_REASON = "no test-read map covers the changed non-code file";
+var { UNMOVED_REASON } = since_green;
+var WHOLE_SUITE_SUFFIX = "affects every test";
+var UNRECORDED_SUFFIX = "is read by no recorded test";
+var FALLBACK_KINDS = [
+  { kind: "unreadable", reason: UNREADABLE_REASON },
+  { kind: "nothing-relatable", reason: NOTHING_RELATABLE_REASON },
+  { kind: "no-map", reason: NO_MAP_REASON },
+  { kind: "whole-suite-file", reason: WHOLE_SUITE_SUFFIX },
+  { kind: "unrecorded-file", reason: UNRECORDED_SUFFIX }
+];
+var OTHER_FALLBACK = "other";
+var COMMAND_NAME = "test:related";
+var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
+var { LISTED_FILE_LIMIT } = changed_file_scope;
+var VOCABULARY = {
+  label: COMMAND_LABEL,
+  fallback_suffix: "running the full unit suite instead",
+  narrowed_suffix: "running only the tests related to them"
+};
+var NONE_SUFFIX = "running no tests";
+var RUN_FLAG = "--run";
+var RELATED_SUBCOMMAND = "related";
+var RUN_SUBCOMMAND = "run";
+function is_relatable(file_path) {
+  return RELATABLE_EXTENSIONS.has(path2.extname(file_path));
+}
+function is_moved(request, file) {
+  return request.since_map?.includes(file) !== true;
+}
+function is_code_input(request, file) {
+  if (!is_relatable(file)) return false;
+  if (is_moved(request, file)) return true;
+  return request.naming_moved?.has(file) === true;
+}
+function all_scope(reason, triggers = [], root = "") {
+  return { mode: "all", files: triggers.map((file) => path2.join(root, file)), reason };
+}
+function resolve_through_map(others, request) {
+  const { map, recorded } = request;
+  if (others.length === 0) return { files: [], unread: [] };
+  if (map === void 0) return { reason: `${NO_MAP_REASON} ${String(others[0])}` };
+  const unread = others.filter((file) => test_read_map.readers_of(map, file).length === 0);
+  const unknown = unread.filter(
+    (file) => is_moved(request, file) && !recorded.has(file) && !test_read_map.in_unread_directory(map, file)
+  );
+  if (unknown.length > 0) {
+    return { reason: `${String(unknown[0])} ${UNRECORDED_SUFFIX}`, triggers: unknown };
+  }
+  return { files: others.flatMap((file) => test_read_map.readers_of(map, file)), unread };
+}
+function code_readers(code, map) {
+  if (map === void 0) return [];
+  return code.flatMap((file) => test_read_map.readers_of(map, file));
+}
+function none_scope(unread, root) {
+  const files = unread.map((file) => path2.join(root, file));
+  return { mode: "none", files, reason: `${String(files.length)} changed file(s) reach no test` };
+}
+function narrowed_scope(selection, request) {
+  if (selection.files.length === 0 && selection.unread.length > 0) {
+    return none_scope(selection.unread, request.root);
+  }
+  const present = [...new Set(selection.files)].map((file) => path2.join(request.root, file)).filter((file) => request.is_present(file));
+  if (present.length === 0) return all_scope(NOTHING_RELATABLE_REASON);
+  return { mode: "related", files: present, reason: `${String(present.length)} related file(s)` };
+}
+function left_out(request, code) {
+  return (request.since_map ?? []).filter((file) => !code.includes(file));
+}
+function without_pure_entries(changed, entries) {
+  if (entries === void 0) return { files: [], unread: changed };
+  const rest = changed.filter((file) => file !== pure_files_entries.PURE_FILES_PATH);
+  return { files: pure_files_entries.tests_of(entries), unread: rest };
+}
+function is_narrowed(request, file) {
+  return request.every_test_importers?.has(file) === true;
+}
+function direct_selection(request, changed) {
+  const moved = changed.filter((file) => is_narrowed(request, file) && is_moved(request, file));
+  const tests = moved.map((file) => request.every_test_importers?.get(file) ?? []);
+  return { files: tests.flat(), unread: moved.filter((_file, index) => tests[index]?.length === 0) };
+}
+function whole_suite_triggers(request, changed) {
+  return changed.filter(
+    (file) => WHOLE_SUITE_FILES.has(file) && !is_narrowed(request, file) && is_moved(request, file)
+  );
+}
+function resolve_read(request, entry_tests) {
+  const { changed, root } = request;
+  const whole = whole_suite_triggers(request, changed);
+  if (whole.length > 0) return all_scope(`${String(whole[0])} ${WHOLE_SUITE_SUFFIX}`, whole, root);
+  const direct = direct_selection(request, changed);
+  const code = changed.filter((file) => !is_narrowed(request, file) && is_code_input(request, file));
+  const resolution = resolve_through_map(
+    changed.filter((file) => !is_relatable(file) && is_moved(request, file)),
+    request
+  );
+  if ("reason" in resolution) return all_scope(resolution.reason, resolution.triggers, root);
+  const files = [
+    ...code,
+    ...code_readers(code, request.map),
+    ...resolution.files,
+    ...entry_tests,
+    ...direct.files
+  ];
+  const unread = [...resolution.unread, ...left_out(request, code), ...direct.unread];
+  return narrowed_scope({ files, unread }, request);
+}
+function resolve_scope(request) {
+  if (request.changed === void 0) return all_scope(UNREADABLE_REASON);
+  const pure = without_pure_entries(request.changed, request.pure_entries);
+  return resolve_read({ ...request, changed: pure.unread }, pure.files);
+}
+function describe_scope(scope, root) {
+  if (scope.mode !== "none") return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+  const listing = changed_file_scope.format_file_list(scope.files, root);
+  return `${COMMAND_LABEL}: ${scope.reason} \u2014 ${NONE_SUFFIX}.
+${listing}`;
+}
+function reason_kind(reason) {
+  return FALLBACK_KINDS.find((entry) => reason.includes(entry.reason))?.kind ?? OTHER_FALLBACK;
+}
+function fallback_kind(output) {
+  const prefix = `${COMMAND_LABEL}: `;
+  const suffix = ` \u2014 ${VOCABULARY.fallback_suffix}.`;
+  const line = output.split("\n").map((candidate) => candidate.trim()).find((candidate) => candidate.startsWith(prefix) && candidate.endsWith(suffix));
+  if (line === void 0) return void 0;
+  return reason_kind(line.slice(prefix.length, -suffix.length));
+}
+function scope_kind(scope) {
+  return scope.mode === "all" ? reason_kind(scope.reason) : scope.mode;
+}
+function is_unmoved(output) {
+  const line = `${COMMAND_LABEL}: ${UNMOVED_REASON} \u2014 ${NONE_SUFFIX}.`;
+  return output.split("\n").some((candidate) => candidate.trim() === line);
+}
+function vitest_arguments(scope, extra_flags = []) {
+  if (scope.mode !== "related") return [RUN_SUBCOMMAND, ...extra_flags];
+  return [RELATED_SUBCOMMAND, ...scope.files, RUN_FLAG, ...extra_flags];
+}
+var related_scope = {
+  COMMAND_LABEL,
+  COMMAND_NAME,
+  LISTED_FILE_LIMIT,
+  NOTHING_RELATABLE_REASON,
+  NO_MAP_REASON,
+  UNMOVED_REASON,
+  UNREADABLE_REASON,
+  describe_scope,
+  fallback_kind,
+  is_relatable,
+  is_unmoved,
+  resolve_scope,
+  scope_kind,
+  vitest_arguments
+};
+
+export {
+  pure_files_entries,
+  related_scope
+};

package/dist/commands/chunk-KKHD3C2P.js

@@ -0,0 +1,114 @@
+import {
+  document_section_cli
+} from "./chunk-NR2JDBPV.js";
+import {
+  run_step_section_table
+} from "./chunk-JSJDIEGZ.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  PLATFORM_TEMP_ROOT
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/run-step-section-once.ts
+import { createHash } from "node:crypto";
+import { existsSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var MARKER_PREFIX = "josh-section-";
+var DIGEST_LENGTH = 16;
+var TEXT_KEY_PREFIX = "text\n";
+function marker_of(key) {
+  const session = process.env[agent_session_environment.SESSION_ID_KEY];
+  if (session === void 0) return void 0;
+  const digest = createHash("sha256").update(`${session}
+${key}`).digest("hex").slice(0, DIGEST_LENGTH);
+  return path.join(PLATFORM_TEMP_ROOT, `${MARKER_PREFIX}${digest}`);
+}
+function section_key(found) {
+  return `${found.document}
+${found.heading}`;
+}
+function is_key_recorded(key) {
+  const marker = marker_of(key);
+  return marker !== void 0 && existsSync(marker);
+}
+function record_key(key) {
+  const marker = marker_of(key);
+  if (marker !== void 0) writeFileSync(marker, "");
+}
+function is_recorded(found) {
+  return is_key_recorded(section_key(found));
+}
+function record(found) {
+  record_key(section_key(found));
+}
+function is_text_recorded(text) {
+  return is_key_recorded(`${TEXT_KEY_PREFIX}${text}`);
+}
+function record_text(text) {
+  record_key(`${TEXT_KEY_PREFIX}${text}`);
+}
+function repeat_line(found) {
+  const fetch = `pnpm josh doc:section ${found.document} "${found.heading}"`;
+  return `section: ${found.document} \u2192 "${found.heading}" \u2014 printed earlier this session; after a compaction: ${fetch}`;
+}
+var run_step_section_once = { is_recorded, is_text_recorded, record, record_text, repeat_line };
+
+// scripts/run/run-step-section.ts
+var JOSH_PREFIX = "pnpm josh ";
+var COMMAND_SEPARATOR = " ";
+var SUCCESS_EXIT_CODE = 0;
+var { GOVERNING_SECTIONS, LANE_CHILD_SECTIONS } = run_step_section_table;
+function key_of(action) {
+  if (action.kind !== "command") return action.line;
+  const [subcommand = ""] = action.line.slice(JOSH_PREFIX.length).split(COMMAND_SEPARATOR);
+  return subcommand;
+}
+function section_for(key, is_lane_child) {
+  const lane_child_section = is_lane_child ? LANE_CHILD_SECTIONS.get(key) : void 0;
+  return lane_child_section ?? GOVERNING_SECTIONS.get(key);
+}
+function print_section(key, root = process.cwd(), is_lane_child = false) {
+  const found = section_for(key, is_lane_child);
+  if (found === void 0) return SUCCESS_EXIT_CODE;
+  const exit_code = document_section_cli.run([found.document, found.heading], root);
+  if (exit_code === SUCCESS_EXIT_CODE) run_step_section_once.record(found);
+  return exit_code;
+}
+function print_once(key, root = process.cwd()) {
+  const is_lane_child = lane_child_marker.is_child_of(root);
+  const found = section_for(key, is_lane_child);
+  if (found === void 0 || !run_step_section_once.is_recorded(found)) {
+    return print_section(key, root, is_lane_child);
+  }
+  console.info(run_step_section_once.repeat_line(found));
+  return SUCCESS_EXIT_CODE;
+}
+function print_for(action, is_lane_child = false, root = process.cwd()) {
+  return print_section(key_of(action), root, is_lane_child);
+}
+var { CUT, ENTRY, PARK, PAUSE, PROGRESS, RESUME, RETROSPECTIVE } = run_step_section_table;
+var run_step_section = {
+  CUT,
+  ENTRY,
+  GOVERNING_SECTIONS,
+  PARK,
+  PAUSE,
+  PROGRESS,
+  RESUME,
+  RETROSPECTIVE,
+  LANE_CHILD_SECTIONS,
+  key_of,
+  print_for,
+  print_once,
+  print_section
+};
+
+export {
+  run_step_section_once,
+  run_step_section
+};

package/dist/commands/chunk-KKIIY5I5.js

@@ -0,0 +1,67 @@
+import {
+  REPOSITORY_LABELS
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/repo/repository-labels.ts
+function labels_endpoint(repo) {
+  return `repos/${repo}/labels`;
+}
+function request(api) {
+  try {
+    return git_gh_exec.exec_gh_api_sync(api);
+  } catch {
+    return void 0;
+  }
+}
+function read_existing(repo) {
+  const path = labels_endpoint(repo);
+  const listing = request({ path, should_paginate: true, jq_filter: ".[].name" });
+  return listing?.split("\n").filter((name) => name.length > 0);
+}
+function missing_labels(existing, wanted) {
+  const names = new Set(existing.map((name) => name.toLowerCase()));
+  return wanted.filter((label) => !names.has(label.name.toLowerCase()));
+}
+function create_label(label, repo) {
+  const body = JSON.stringify(label);
+  const is_created = request({ path: labels_endpoint(repo), method: "POST", body }) !== void 0;
+  if (is_created) console.info(`  \u2714 label ${label.name}`);
+  return is_created;
+}
+function label_names(labels) {
+  return labels.map((label) => label.name);
+}
+function unreadable(wanted, target = "this repository") {
+  const names = label_names(wanted);
+  console.warn(
+    `  \u26A0 could not read the labels of ${target}; make sure these exist: ${names.join(", ")}`
+  );
+  return names;
+}
+function create_missing(missing, repo) {
+  const names = label_names(missing.filter((label) => !create_label(label, repo)));
+  if (names.length > 0) {
+    console.warn(`  \u26A0 could not create these labels; create them by hand: ${names.join(", ")}`);
+  }
+  return names;
+}
+function ensure_labels(repo, extra = []) {
+  const wanted = [...REPOSITORY_LABELS, ...extra];
+  if (repo === void 0) return unreadable(wanted);
+  const existing = read_existing(repo);
+  if (existing === void 0) return unreadable(wanted, repo);
+  return create_missing(missing_labels(existing, wanted), repo);
+}
+function planned_labels(repo) {
+  if (repo === void 0) return label_names(REPOSITORY_LABELS);
+  const existing = read_existing(repo);
+  return existing === void 0 ? void 0 : label_names(missing_labels(existing, REPOSITORY_LABELS));
+}
+var repository_labels = { ensure_labels, planned_labels };
+
+export {
+  repository_labels
+};

package/dist/commands/chunk-KN46UC77.js

@@ -0,0 +1,114 @@
+import {
+  git_followup_label
+} from "./chunk-UWMB6EOU.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  run_ship_lap
+} from "./chunk-HRN73FQJ.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-VL5I2IOD.js";
+import {
+  detached_launch
+} from "./chunk-HDVSZ6CZ.js";
+import {
+  IN_PROGRESS_LABEL,
+  NEEDS_HUMAN_MERGE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  package_path
+} from "./chunk-3CCGKX7Y.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/run-maintenance.ts
+import { execa } from "execa";
+var LABEL_SCRIPT = "scripts/run/run-label-main.ts";
+var SWEEP_SCRIPT = "scripts/run/tidy/run-tidy-main.ts";
+var HOLD_PARENT = "run:entry \u203A run:hold";
+function argv(script, args) {
+  const runner = resolve_tsx_runner();
+  return {
+    command: runner.executable,
+    args: [...runner.leading_arguments, package_path(script), ...args]
+  };
+}
+function background(script, args, prefix) {
+  const log_path = stamp_file.stamp_path(prefix, process.cwd(), ".log");
+  const result = detached_launch.launch(
+    {
+      argv: argv(script, args),
+      cwd: process.cwd(),
+      log_path,
+      env: run_ship_lap.environment(HOLD_PARENT)
+    },
+    console.warn
+  );
+  const state = result.kind === "failed" ? result.note : `pid ${String(result.pid)}`;
+  console.warn(`run maintenance: ${result.kind} (${state}) \u2014 ${log_path}`);
+}
+async function label(issue) {
+  const command = argv(LABEL_SCRIPT, [issue]);
+  const result = await execa(command.command, command.args, {
+    reject: false,
+    timeout: MS_PER_MINUTE
+  });
+  if (result.exitCode === 0) return true;
+  console.warn(
+    `run label: ${result.timedOut ? "60s timeout" : "failed"}; retry queued for ${session_cite.issue(issue)}`
+  );
+  background(LABEL_SCRIPT, [issue, "--retry"], `josh-run-label-retry-${issue}-`);
+  return false;
+}
+function sweep() {
+  background(SWEEP_SCRIPT, [], "josh-run-sweep-");
+}
+var run_maintenance = { label, sweep };
+
+// scripts/run/run-label.ts
+var MARK_RECOVERY = "gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=in-progress'";
+var UNMARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress";
+var PARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/needs-human-merge";
+function warn(action, issue, recovery, label2 = IN_PROGRESS_LABEL) {
+  console.warn(
+    `\u26A0 could not ${action} \`${label2}\` on ${session_cite.issue(issue)} \u2014 run by hand: ${recovery}`
+  );
+}
+async function mark(issue) {
+  const is_marked = await run_maintenance.label(issue);
+  if (!is_marked) warn("apply", issue, MARK_RECOVERY);
+  return is_marked;
+}
+async function unmark(issue) {
+  try {
+    await git_followup_label.strip_in_progress(issue);
+    return true;
+  } catch {
+    warn("remove", issue, UNMARK_RECOVERY);
+    return false;
+  }
+}
+async function claim(issue) {
+  const is_cleared = await git_gh_command.issue_clear_label(issue, NEEDS_HUMAN_MERGE_LABEL);
+  if (!is_cleared) warn("remove", issue, PARK_RECOVERY, NEEDS_HUMAN_MERGE_LABEL);
+  return await git_gh_command.issue_apply_label(issue, IN_PROGRESS_LABEL);
+}
+var run_label = {
+  claim,
+  mark,
+  unmark
+};
+
+export {
+  run_maintenance,
+  run_label
+};

package/dist/commands/chunk-KP2BVAS5.js

@@ -0,0 +1,125 @@
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-size-stats.ts
+var COLUMNS = [
+  "measured lanes",
+  "files actual / declared median",
+  "lines actual / declared median",
+  "pre-split misses"
+];
+var MISS_COLUMNS = ["pre-split miss", "files declared \u2192 actual", "lines declared \u2192 actual"];
+var DECIMALS = 1;
+function sizes_of(entries) {
+  return entries.filter((entry) => entry.kind === "size").toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+}
+function merged_sizes(entries, window) {
+  const sizes = sizes_of(entries);
+  return lane_stats.in_window(entries, window).filter((entry) => entry.kind === "merge").map(
+    (merge) => sizes.findLast(
+      (size) => size.issue === merge.issue && Date.parse(size.at) <= Date.parse(merge.at)
+    )
+  ).filter((size) => size !== void 0);
+}
+function ratio_of(sizes, axis) {
+  const values = sizes.filter((size) => size.declared[axis] > 0).map((size) => size.actual[axis] / size.declared[axis]);
+  return lane_stats.median(values);
+}
+function ratio_cell(sizes, axis) {
+  const median = ratio_of(sizes, axis);
+  return median === void 0 ? lane_stats.MISSING : median.toFixed(DECIMALS);
+}
+function lines_ratio(entries, window) {
+  return ratio_of(merged_sizes(entries, window), "lines");
+}
+function ratios(entries, window) {
+  const sizes = merged_sizes(entries, window);
+  const files = ratio_of(sizes, "files");
+  const lines = ratio_of(sizes, "lines");
+  return { ...files !== void 0 && { files }, ...lines !== void 0 && { lines } };
+}
+function header(columns) {
+  return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => "---"))];
+}
+function change_cell(size, axis) {
+  return `${String(size.declared[axis])} \u2192 ${String(size.actual[axis])}`;
+}
+function miss_rows(misses) {
+  if (misses.length === 0) return [];
+  const rows = misses.map(
+    (size) => lane_stats.to_row([
+      issue_cite.plain_for("terminal", size.issue),
+      change_cell(size, "files"),
+      change_cell(size, "lines")
+    ])
+  );
+  return ["", ...header(MISS_COLUMNS), ...rows];
+}
+function table(entries, window) {
+  const sizes = merged_sizes(entries, window);
+  const misses = sizes.filter((size) => size.missed === true);
+  return [
+    ...header(COLUMNS),
+    lane_stats.to_row([
+      String(sizes.length),
+      ratio_cell(sizes, "files"),
+      ratio_cell(sizes, "lines"),
+      String(misses.length)
+    ]),
+    ...miss_rows(misses)
+  ].join("\n");
+}
+var lane_size_stats = { lines_ratio, merged_sizes, ratios, table };
+
+// scripts/lane/lane-implement-rate.ts
+var COLUMNS2 = ["implement-rate lanes", "implement min / 100 actual lines median"];
+var LINES_PER_RATE = 100;
+var DECIMALS2 = 1;
+function per_lines(ms, lines) {
+  return ms === void 0 ? void 0 : ms / MS_PER_MINUTE * LINES_PER_RATE / lines;
+}
+function rates_of(entries, window) {
+  const implement = lane_stage_stats.implement_by_issue(entries);
+  return lane_size_stats.merged_sizes(entries, window).filter((size) => size.actual.lines > 0).map((size) => per_lines(implement.get(size.issue), size.actual.lines)).filter((value) => lane_stage_stats.is_number(value));
+}
+function rate(entries, window) {
+  const rates = rates_of(entries, window);
+  const median = lane_stats.median(rates);
+  return median === void 0 ? void 0 : { median, lanes: rates.length };
+}
+function table2(entries, window) {
+  const measured = rate(entries, window);
+  return [
+    lane_stats.to_row(COLUMNS2),
+    lane_stats.to_row(COLUMNS2.map(() => "---")),
+    lane_stats.to_row([
+      String(measured?.lanes ?? 0),
+      measured?.median.toFixed(DECIMALS2) ?? lane_stats.MISSING
+    ])
+  ].join("\n");
+}
+function minutes_for(lines, measured) {
+  return lines * measured.median / LINES_PER_RATE;
+}
+function lines_for(minutes, measured) {
+  if (measured === void 0 || !Number.isFinite(measured.median) || measured.median <= 0) {
+    return void 0;
+  }
+  return minutes * LINES_PER_RATE / measured.median;
+}
+var lane_implement_rate = { lines_for, minutes_for, rate, table: table2 };
+
+export {
+  lane_size_stats,
+  lane_implement_rate
+};