@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-3PGB2RKZ.js

@@ -0,0 +1,333 @@
+import {
+  MERGED_STATE,
+  git_gh_helpers,
+  to_gh_state
+} from "./chunk-2BNLPPP4.js";
+import {
+  git_gh_issue_memo
+} from "./chunk-V6WWW6HX.js";
+import {
+  rest_comment_schema
+} from "./chunk-34DND4BA.js";
+import {
+  FULL_PAGE_QUERY,
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  gh_failure,
+  git_gh_exec,
+  parse_json_array_or_undefined,
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/gh/git-gh-comments-unreadable.ts
+var UNREADABLE_COMMENTS_STOP = "the merge gate stopped on reviewer comments it could not read";
+var RETRY_PENDING_KEY = "JOSH_SHIP_RETRY_PENDING";
+var RETRY_PENDING_VALUE = "1";
+function note_unreadable_comments(branch_name, reason) {
+  console.warn(`\u26A0 pull request comments could not be read for ${branch_name}: ${reason}`);
+}
+function note_unreadable_stop() {
+  console.info(`\u26A0\uFE0F ${UNREADABLE_COMMENTS_STOP}`);
+}
+function is_retry_pending() {
+  return process.env[RETRY_PENDING_KEY] === RETRY_PENDING_VALUE;
+}
+
+// scripts/gh/git-gh-pr-rest.ts
+import { z } from "zod";
+var rest_repo_schema = z.looseObject({ full_name: z.string().optional() }).nullish();
+var rest_pull_side_schema = z.looseObject({ ref: z.string().optional(), repo: rest_repo_schema });
+var rest_pull_schema = z.looseObject({
+  number: z.number(),
+  html_url: z.string().optional(),
+  body: z.string().nullish(),
+  state: z.string().optional(),
+  merged: z.boolean().nullish(),
+  merged_at: z.string().nullish(),
+  mergeable: z.boolean().nullish(),
+  mergeable_state: z.string().optional(),
+  // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
+  // REST hangs the check runs and the status contexts off the commit rather than off the pull
+  // request.
+  head: z.looseObject({ ref: z.string().optional(), sha: z.string().optional(), repo: rest_repo_schema }).nullish(),
+  base: rest_pull_side_schema.nullish(),
+  // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
+  // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`.
+  node_id: z.string().optional(),
+  auto_merge: z.looseObject({}).nullish()
+});
+var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
+var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
+var NOT_A_COMMENT_LISTING_MESSAGE = "gh api answered something other than a comment listing";
+var OPEN_STATE = "open";
+var EMPTY_BODY = "";
+function parse_rest_pull(rest_json) {
+  const parsed = parse_json_object_or_undefined(rest_json, rest_pull_schema);
+  if (parsed === void 0) throw new Error(NOT_A_PULL_MESSAGE);
+  return parsed;
+}
+function parse_rest_pulls(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_pull_schema);
+  if (parsed === void 0) throw new Error(NOT_A_PULL_LISTING_MESSAGE);
+  return parsed;
+}
+function select_pull(pulls) {
+  return pulls.find((pull) => pull.state === OPEN_STATE) ?? pulls[0];
+}
+function is_merged(pull) {
+  return pull.merged === true || typeof pull.merged_at === "string";
+}
+function to_pr_state(pull) {
+  return is_merged(pull) ? MERGED_STATE : to_gh_state(pull.state);
+}
+function to_repo_name(side) {
+  return side?.repo?.full_name;
+}
+function is_same_repository_head(pull) {
+  const head_repo = to_repo_name(pull.head);
+  return head_repo !== void 0 && head_repo === to_repo_name(pull.base);
+}
+function to_pr_info(pull) {
+  return {
+    mergeable: pull.mergeable,
+    mergeStateStatus: to_gh_state(pull.mergeable_state),
+    state: to_pr_state(pull)
+  };
+}
+function to_pr_comments(rest_json) {
+  const parsed = parse_json_array_or_undefined(rest_json, rest_comment_schema);
+  if (parsed === void 0) throw new Error(NOT_A_COMMENT_LISTING_MESSAGE);
+  return parsed.map((comment) => ({
+    body: comment.body ?? EMPTY_BODY,
+    url: comment.html_url,
+    author: { login: comment.user?.login },
+    updatedAt: comment.updated_at
+  }));
+}
+var git_gh_pr_rest = {
+  parse_rest_pull,
+  parse_rest_pulls,
+  select_pull,
+  is_same_repository_head,
+  is_merged,
+  to_pr_state,
+  to_pr_info,
+  to_pr_comments
+};
+
+// scripts/gh/git-gh-pr-too-large.ts
+var UNPROCESSABLE_STATUS = 422;
+var TOO_MANY_FILES_TEXT = "too many files changed";
+function is_too_many_files(error) {
+  if (gh_failure.failure_of(error)?.status !== UNPROCESSABLE_STATUS) return false;
+  return error_text.message_of(error).includes(TOO_MANY_FILES_TEXT);
+}
+var git_gh_pr_too_large = { is_too_many_files };
+
+// scripts/gh/git-gh-pr-read.ts
+var pr_number_by_branch = /* @__PURE__ */ new Map();
+var LOOKUP_QUERY = "state=all&sort=created&direction=desc&per_page=100";
+var COMMENTS_QUERY = FULL_PAGE_QUERY;
+var OWNER_PLACEHOLDER = "{owner}";
+var NO_PULL_REQUEST_MESSAGE = "gh api found no pull request for branch";
+var UNREADABLE_PULL_REQUEST_MESSAGE = "gh api could not read the pull requests for branch";
+function lookup_path(branch_name) {
+  const head = `${OWNER_PLACEHOLDER}:${encodeURIComponent(branch_name)}`;
+  return `${git_gh_api_path.pulls_api_path()}?head=${head}&${LOOKUP_QUERY}`;
+}
+async function fetch_branch_pull(branch_name) {
+  const json = await git_gh_exec.exec_gh_api({ path: lookup_path(branch_name) });
+  return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json));
+}
+async function fetch_pr_number(branch_name) {
+  const pull = await fetch_branch_pull(branch_name);
+  return pull?.number;
+}
+var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
+var pull_by_number = /* @__PURE__ */ new Map();
+async function fetch_pr_number_read(branch_name) {
+  try {
+    const pr_number = await fetch_pr_number(branch_name);
+    if (pr_number === void 0) return { kind: "missing" };
+    pr_number_by_branch.set(branch_name, pr_number);
+    return { kind: "read", pr_number };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function start_pr_number_read(branch_name) {
+  const pending = pending_pr_number_by_branch.get(branch_name);
+  if (pending !== void 0) return await pending;
+  const lookup = fetch_pr_number_read(branch_name);
+  pending_pr_number_by_branch.set(branch_name, lookup);
+  try {
+    return await lookup;
+  } finally {
+    pending_pr_number_by_branch.delete(branch_name);
+  }
+}
+function forget_pr_numbers() {
+  pr_number_by_branch.clear();
+  pending_pr_number_by_branch.clear();
+  pull_by_number.clear();
+  git_gh_issue_memo.forget();
+}
+async function read_pr_number(branch_name) {
+  const cached = pr_number_by_branch.get(branch_name);
+  if (cached !== void 0) return { kind: "read", pr_number: cached };
+  return await start_pr_number_read(branch_name);
+}
+async function resolve_pr_number(branch_name) {
+  const read = await read_pr_number(branch_name);
+  return read.kind === "read" ? read.pr_number : void 0;
+}
+function to_unreadable_error(branch_name, cause) {
+  const [gist = ""] = error_text.message_of(cause).split("\n", 1);
+  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name} (${gist})`, { cause });
+}
+async function require_pr_number(branch_name) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind === "read") return read.pr_number;
+  if (read.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
+  throw to_unreadable_error(branch_name, read.cause);
+}
+async function read_pull(pr_number) {
+  const json = await git_gh_exec.exec_gh_api({
+    path: git_gh_api_path.pull_api_path(String(pr_number))
+  });
+  return git_gh_pr_rest.parse_rest_pull(json);
+}
+async function read_remembered_pull(pr_number) {
+  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
+  pull_by_number.set(pr_number, pending);
+  try {
+    return await pending;
+  } catch (error) {
+    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
+    throw error;
+  }
+}
+async function read_listed_pull(detail_error, branch_name, pr_number) {
+  if (!git_gh_pr_too_large.is_too_many_files(detail_error)) return void 0;
+  const pull = await fetch_branch_pull(branch_name);
+  return pull?.number === pr_number ? pull : void 0;
+}
+async function read_pull_or_listed(branch_name, pr_number, read) {
+  try {
+    return await read(pr_number);
+  } catch (error) {
+    const listed = await read_listed_pull(error, branch_name, pr_number);
+    if (listed === void 0) throw error;
+    return listed;
+  }
+}
+async function read_pull_of_branch(branch_name, read = read_remembered_pull) {
+  const number_read = await read_pr_number(branch_name);
+  if (number_read.kind !== "read") return number_read;
+  try {
+    return {
+      kind: "read",
+      pull: await read_pull_or_listed(branch_name, number_read.pr_number, read)
+    };
+  } catch (error) {
+    return { kind: "unreadable", cause: error };
+  }
+}
+async function read_pull_or_undefined(branch_name) {
+  const read = await read_pull_of_branch(branch_name);
+  return read.kind === "read" ? read.pull : void 0;
+}
+async function pr_exists(branch_name) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
+  return read.kind === "read";
+}
+async function pr_get_number(branch_name) {
+  return await resolve_pr_number(branch_name);
+}
+async function pr_get_url(branch_name) {
+  const pull = await read_pull_or_undefined(branch_name);
+  if (pull?.html_url === void 0) return void 0;
+  return git_gh_helpers.parse_pr_state_string(pull.html_url);
+}
+async function pr_get_merge_state(branch_name) {
+  const read = await read_pull_of_branch(branch_name, read_pull);
+  if (read.kind !== "read") return void 0;
+  const { pull } = read;
+  return {
+    is_merged: git_gh_pr_rest.is_merged(pull),
+    merged_at: pull.merged_at ?? void 0,
+    head_sha: pull.head?.sha,
+    merge_state_status: to_gh_state(pull.mergeable_state)
+  };
+}
+async function pr_get_body(branch_name) {
+  const pull = await read_pull_or_undefined(branch_name);
+  const body = pull?.body;
+  return typeof body === "string" && body.length > 0 ? body : void 0;
+}
+async function pr_view(branch_name) {
+  const read = await read_pull_of_branch(branch_name, read_pull);
+  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
+  if (read.kind === "missing") return "";
+  return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull));
+}
+function unresolved_reason(read) {
+  return read.kind === "unreadable" ? error_text.message_of(read.cause) : NO_PULL_REQUEST_MESSAGE;
+}
+async function read_comments(branch_name, to_path, to_json) {
+  const read = await read_pr_number(branch_name);
+  if (read.kind !== "read") {
+    note_unreadable_comments(branch_name, unresolved_reason(read));
+    return void 0;
+  }
+  const path = `${to_path(String(read.pr_number))}${COMMENTS_QUERY}`;
+  try {
+    return to_json(await git_gh_exec.exec_gh_api({ path, should_paginate: true }));
+  } catch (error) {
+    note_unreadable_comments(branch_name, error_text.message_of(error));
+    return void 0;
+  }
+}
+function to_comments_json(raw) {
+  return JSON.stringify(git_gh_pr_rest.to_pr_comments(raw));
+}
+function as_served(raw) {
+  return raw;
+}
+async function pr_get_comments(branch_name) {
+  return await read_comments(branch_name, git_gh_api_path.issue_comments_api_path, to_comments_json);
+}
+async function pr_get_review_comments(branch_name) {
+  return await read_comments(branch_name, git_gh_api_path.pull_comments_api_path, as_served);
+}
+var git_gh_pr_read = {
+  pr_exists,
+  pr_get_number,
+  pr_get_url,
+  pr_get_body,
+  pr_get_merge_state,
+  pr_view,
+  pr_get_comments,
+  pr_get_review_comments
+};
+
+export {
+  UNREADABLE_COMMENTS_STOP,
+  RETRY_PENDING_KEY,
+  RETRY_PENDING_VALUE,
+  note_unreadable_stop,
+  is_retry_pending,
+  git_gh_pr_rest,
+  git_gh_pr_too_large,
+  forget_pr_numbers,
+  require_pr_number,
+  read_pull,
+  read_listed_pull,
+  read_pull_or_listed,
+  git_gh_pr_read
+};

package/dist/commands/chunk-3QNEEG5O.js

@@ -0,0 +1,117 @@
+// scripts/document/document-byte-budget.ts
+var BLOCK_BYTES = 4096;
+function block_ceiling(size) {
+  return Math.ceil(size / BLOCK_BYTES) * BLOCK_BYTES;
+}
+var DOCUMENT_BYTE_BUDGET = [
+  { path: ".claude/skills/dependency-update/SKILL.md", bytes: 4096 },
+  { path: ".claude/skills/epic-commands/SKILL.md", bytes: 8192 },
+  { path: ".claude/skills/epic-commands/epic-bundle.md", bytes: 4096 },
+  { path: ".claude/skills/epic-commands/execution-waves.md", bytes: 4096 },
+  { path: ".claude/skills/verify-ui/SKILL.md", bytes: 4096 },
+  { path: ".claude/skills/workflow-commands/backlogrun-handoff-report.md", bytes: 4096 },
+  { path: ".claude/skills/workflow-commands/fullrun-steps.md", bytes: 8192 },
+  { path: ".claude/skills/workflow-commands/into-target.md", bytes: 4096 },
+  { path: ".claude/skills/workflow-commands/issue-comments.md", bytes: 8192 },
+  { path: ".claude/skills/workflow-commands/issue-fold-existing.md", bytes: 4096 },
+  { path: ".claude/skills/workflow-commands/needs-human-review.md", bytes: 4096 },
+  { path: ".claude/skills/workflow-commands/observation-filing.md", bytes: 8192 },
+  { path: ".claude/skills/workflow-commands/observation-ledger.md", bytes: 8192 },
+  { path: ".claude/skills/workflow-commands/prerequisite.md", bytes: 8192 },
+  { path: ".claude/skills/workflow-commands/target-repository.md", bytes: 4096 },
+  { path: ".claude/skills/workflow-commands/working-tree-hold.md", bytes: 8192 },
+  // `command:derive`'s usage section (joshuafolkken/kit#4970) crossed the 45056 block.
+  // `ui:shot`'s usage section (joshuafolkken/kit#5633) crossed the 49152 block.
+  // `usage:tee`'s usage section (joshuafolkken/kit#6316) crossed the 53248 block.
+  // `issue:consolidate`'s usage section (joshuafolkken/kit#6609) crossed the 57344 block.
+  { path: "docs/josh-commands-automation.md", bytes: 61440 },
+  // The run reference crossed a block in eleven lanes (joshuafolkken/kit#4775 …
+  // joshuafolkken/kit#6540), so joshuafolkken/kit#6676 split its board, lane and session commands
+  // into pages of their own, each at its smallest block.
+  // The drive's own `run:stalled` retry under `run:add --retry` (joshuafolkken/kit#7076) crossed the 53248 block.
+  { path: "docs/josh-commands-run.md", bytes: 57344 },
+  // The finished rows' icons, `⏩` already done among them (joshuafolkken/kit#7095), crossed the 20480 block.
+  { path: "docs/josh-commands-board.md", bytes: 24576 },
+  // The `concurrent lanes` table's core-wait columns (joshuafolkken/kit#7550) crossed the 32768 block.
+  { path: "docs/josh-commands-lane.md", bytes: 36864 },
+  // `cost:audit`'s dated period and usage breakdown (joshuafolkken/kit#7042) crossed the 16384 block.
+  { path: "docs/josh-commands-session.md", bytes: 20480 },
+  // `josh effect:audit` (joshuafolkken/kit#4958) and `issue:priority`'s usage section (joshuafolkken/kit#4960) crossed the 57344 block;
+  // `josh prose:stale` (joshuafolkken/kit#5287) crossed the 61440 block; `josh diff:summary`
+  // (joshuafolkken/kit#5547) crossed the 65536 block; solo evidence in `backlog:triage`
+  // (joshuafolkken/kit#6463) crossed the 73728 block; the drive's sample wait (joshuafolkken/kit#6503)
+  // crossed the 77824 block; `issue:fold-existing --found-during` (joshuafolkken/kit#6641) crossed the 81920 block.
+  { path: "docs/josh-commands-backlog.md", bytes: 81920 },
+  // `run:merge` withdrawing a lane closed without a merge (joshuafolkken/kit#4916) crossed the 53248 block;
+  // `gate --static-group` (joshuafolkken/kit#5215) crossed the 57344 block; `lint:rule`'s usage span
+  // (joshuafolkken/kit#5664) crossed the 61440 block; `test:related`'s own-change hub
+  // (joshuafolkken/kit#6193) crossed the 65536 block; project gate steps narrowed by `paths`
+  // (joshuafolkken/kit#7205) crossed the 69632 block.
+  { path: "docs/josh-commands.md", bytes: 73728 },
+  // The auto-retry of every `run:stalled` cause (joshuafolkken/kit#7076) crossed the 8192 block.
+  { path: "docs/labels-and-run-states.md", bytes: 12288 },
+  { path: "prompts/coding-standards.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/file-edits.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/gh-rest.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/glossary.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/issue-citation.md", bytes: 4096 },
+  // The priority declaration and its criteria (joshuafolkken/kit#4383) crossed the 8192 block; the
+  // causing-lane declaration and criteria F / G (joshuafolkken/kit#4749) crossed the 12288 one; the
+  // premise row (joshuafolkken/kit#7021) crossed the 16384 one.
+  // The template's en column (joshuafolkken/kit#7211).
+  { path: "prompts/collaboration-workflow/issue-template.en.md", bytes: 8192 },
+  { path: "prompts/collaboration-workflow/issue-template.md", bytes: 20480 },
+  { path: "prompts/collaboration-workflow/lane-instructions.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/measurement.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/operating-rules.md", bytes: 12288 },
+  { path: "prompts/collaboration-workflow/output-bounds.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/overview.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/plan-comment.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/principles.md", bytes: 12288 },
+  { path: "prompts/collaboration-workflow/proposal-request.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/report-format.md", bytes: 12288 },
+  { path: "prompts/collaboration-workflow/residency.md", bytes: 8192 },
+  { path: "prompts/collaboration-workflow/rule-delivery.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/shell-body.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/turn-batching.md", bytes: 4096 },
+  { path: "prompts/collaboration-workflow/upstream-interrupt.md", bytes: 8192 },
+  { path: "prompts/collaboration-workflow/wip-cap.md", bytes: 8192 },
+  { path: "prompts/refactoring.md", bytes: 8192 },
+  { path: "prompts/review-rubric.md", bytes: 12288 },
+  { path: "prompts/review.md", bytes: 12288 },
+  { path: "prompts/sonar-hotspot-handling.md", bytes: 8192 },
+  { path: "prompts/testing-guide.md", bytes: 12288 }
+];
+function recorded_bytes_for(relative_path) {
+  return DOCUMENT_BYTE_BUDGET.find((entry) => entry.path === relative_path)?.bytes;
+}
+function remaining_bytes(recorded_bytes, current_bytes) {
+  return recorded_bytes - current_bytes;
+}
+function over_budget_message(relative_path, current_bytes, recorded_bytes) {
+  const ceiling = recorded_bytes.toString();
+  const current = current_bytes.toString();
+  const next = block_ceiling(current_bytes).toString();
+  const raise_hint = `raise its recorded size to ${next} in scripts/document/document-byte-budget.ts so the reason shows in the PR diff`;
+  return `${relative_path} is ${current} bytes, over its ${ceiling}-byte ceiling. Shrink the document, or ${raise_hint}.`;
+}
+function stale_budget_message(relative_path, recorded_bytes, current_bytes) {
+  const recorded = recorded_bytes.toString();
+  const current = current_bytes.toString();
+  const next = block_ceiling(current_bytes).toString();
+  const lower_hint = `lower its recorded size to ${next} in scripts/document/document-byte-budget.ts so the ratchet holds the reduction`;
+  return `${relative_path} records ${recorded} bytes but is ${current}, more than a block above actual. ${lower_hint}.`;
+}
+var document_byte_budget = {
+  DOCUMENT_BYTE_BUDGET,
+  BLOCK_BYTES,
+  block_ceiling,
+  over_budget_message,
+  recorded_bytes_for,
+  remaining_bytes,
+  stale_budget_message
+};
+
+export {
+  document_byte_budget
+};

package/dist/commands/chunk-3TN76RWK.js

@@ -0,0 +1,156 @@
+import {
+  lane_stats
+} from "./chunk-WYAY6CQI.js";
+import {
+  lane_ledger
+} from "./chunk-I2RBOH4F.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-stage-stats.ts
+var DECIMALS = 1;
+var NOT_MEASURED = "not measured";
+var IMPLEMENT = "implement";
+var DRIVER_NOTE = "(driver, outside lane net)";
+var COLUMNS = ["stage", "median (min)", "max (min)", "runs"];
+var { STAGE } = run_ship_stage;
+var STAGES = [
+  IMPLEMENT,
+  STAGE.PREFLIGHT,
+  lane_ledger.PRE_DETACH_STAGE,
+  STAGE.REVIEW,
+  STAGE.SYNC,
+  STAGE.GATE,
+  STAGE.COMMIT,
+  STAGE.ROUND_TWO,
+  STAGE.FOLLOWUP,
+  lane_ledger.CI_WAIT_STAGE,
+  lane_ledger.CODERABBIT_WAIT_STAGE,
+  lane_ledger.CODERABBIT_RATE_LIMIT_STAGE,
+  lane_ledger.CODERABBIT_RETRIGGER_STAGE,
+  STAGE.REPORT
+];
+function is_stage(entry) {
+  return entry.kind === lane_ledger.KIND.STAGE;
+}
+function is_dispatch(entry) {
+  return entry.kind === lane_ledger.KIND.DISPATCH;
+}
+function is_merge(entry) {
+  return entry.kind === lane_ledger.KIND.MERGE;
+}
+function is_number(value) {
+  return value !== void 0;
+}
+function started_ms(stage) {
+  return Date.parse(stage.at) - stage.elapsed_ms;
+}
+function starts_by_issue(stages) {
+  const index = /* @__PURE__ */ new Map();
+  for (const stage of stages) {
+    if (stage.issue === void 0) continue;
+    const starts = index.get(stage.issue) ?? [];
+    starts.push(started_ms(stage));
+    index.set(stage.issue, starts);
+  }
+  return index;
+}
+function next_dispatches_ms(sorted) {
+  const later = /* @__PURE__ */ new Map();
+  return sorted.toReversed().map((dispatch) => {
+    const next_ms = later.get(dispatch.issue) ?? Infinity;
+    later.set(dispatch.issue, Date.parse(dispatch.at));
+    return next_ms;
+  }).toReversed();
+}
+function implement_ms(from_ms, until_ms, starts) {
+  const inside = starts.filter((start) => start >= from_ms && start < until_ms);
+  return inside.length === 0 ? void 0 : Math.min(...inside) - from_ms;
+}
+function implement_spans(entries) {
+  const starts = starts_by_issue(entries.filter(is_stage));
+  const sorted = entries.filter(is_dispatch).toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  const next_ms = next_dispatches_ms(sorted);
+  return sorted.map((dispatch, index) => {
+    const from_ms = Date.parse(dispatch.at);
+    const until_ms = next_ms[index] ?? Infinity;
+    const ms = implement_ms(from_ms, until_ms, starts.get(dispatch.issue) ?? []);
+    return {
+      issue: dispatch.issue,
+      from_ms,
+      to_ms: ms === void 0 ? until_ms : from_ms + ms,
+      is_open: ms === void 0
+    };
+  });
+}
+function implements_of(entries) {
+  return implement_spans(entries).filter((span) => !span.is_open).map(({ issue, from_ms, to_ms }) => ({ issue, ms: to_ms - from_ms }));
+}
+function implement_by_issue(entries) {
+  return new Map(implements_of(entries).map(({ issue, ms }) => [issue, ms]));
+}
+function durations_of(stage, measured) {
+  if (stage === IMPLEMENT) return measured.implement;
+  return measured.stages.filter((entry) => entry.stage === stage).map((entry) => entry.elapsed_ms);
+}
+function cell(milliseconds) {
+  return milliseconds === void 0 ? NOT_MEASURED : (milliseconds / MS_PER_MINUTE).toFixed(DECIMALS);
+}
+function label_of(stage) {
+  return stage === STAGE.FOLLOWUP ? `${stage} ${DRIVER_NOTE}` : stage;
+}
+function stage_row(stage, measured) {
+  const durations = durations_of(stage, measured);
+  return lane_stats.to_row([
+    label_of(stage),
+    cell(lane_stats.median(durations)),
+    cell(lane_stats.peak(durations)),
+    String(durations.length)
+  ]);
+}
+function measured_of(entries) {
+  return {
+    implement: implements_of(entries).map(({ ms }) => ms),
+    stages: entries.filter(is_stage)
+  };
+}
+function table(entries, window) {
+  const measured = measured_of(lane_stats.in_window(entries, window));
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...STAGES.map((stage) => stage_row(stage, measured))
+  ].join("\n");
+}
+function medians(entries) {
+  const measured = measured_of(entries);
+  return new Map(
+    STAGES.flatMap((stage) => {
+      const median = lane_stats.median(durations_of(stage, measured));
+      return median === void 0 ? [] : [[stage, median]];
+    })
+  );
+}
+var lane_stage_stats = {
+  IMPLEMENT,
+  NOT_MEASURED,
+  STAGES,
+  cell,
+  implement_by_issue,
+  implement_spans,
+  is_dispatch,
+  is_merge,
+  is_number,
+  is_stage,
+  medians,
+  started_ms,
+  table
+};
+
+export {
+  lane_stage_stats
+};

package/dist/commands/chunk-3W2TJZMD.js

@@ -0,0 +1,77 @@
+import {
+  inherited_scope
+} from "./chunk-5OF2B4BF.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+
+// scripts/run/ship/run-ship-lap.ts
+import { z } from "zod";
+var ENVIRONMENT_KEY = "JOSH_SHIP_LAP_SCOPE";
+var PARENT_SEPARATOR = " \u203A ";
+var STARTUP_STEP = "startup";
+var lap_scope_schema = z.object({
+  issue: z.number(),
+  stage: z.string(),
+  parent: z.string().optional()
+});
+var STEP = {
+  PRECONDITIONS: "preconditions",
+  SCOPED_PAIR: "scoped pair",
+  GATE: "josh gate",
+  OVERLAP_WAIT: "overlap wait",
+  LOCAL_COMMIT: "local commit",
+  MERGE: "merge",
+  PUSH: "push",
+  COMMIT: "josh git"
+};
+var scope = inherited_scope.create(ENVIRONMENT_KEY, lap_scope_schema);
+async function to_ledger(lap) {
+  await lane_ledger_write.record_ship_lap(lap);
+}
+async function within(issue, stage, run, parent) {
+  return await scope.within({ issue: Number(issue), stage, parent }, run);
+}
+function current_scope() {
+  return scope.current();
+}
+function environment(parent) {
+  const current = current_scope();
+  if (current === void 0) return {};
+  return {
+    [ENVIRONMENT_KEY]: JSON.stringify({ issue: current.issue, stage: current.stage, parent })
+  };
+}
+function lap_of(current, step, started_ms, note) {
+  const { parent, ...place } = current;
+  const name = parent === void 0 ? step : `${parent}${PARENT_SEPARATOR}${step}`;
+  return { ...place, step: name, elapsed_ms: performance.now() - started_ms, ...note };
+}
+function no_note() {
+  return {};
+}
+var startup = { recorded: false };
+async function record_startup(current, sink, is_wanted) {
+  if (!is_wanted || startup.recorded || scope.local() !== void 0) return;
+  startup.recorded = true;
+  await sink(lap_of(current, STARTUP_STEP, 0, {}));
+}
+async function timed(step, run, { sink = to_ledger, note_of = no_note, startup: with_startup } = {}) {
+  const current = current_scope();
+  if (current === void 0) return await run();
+  await record_startup(current, sink, with_startup !== false);
+  const started_ms = performance.now();
+  const noted = { note: {} };
+  try {
+    const result = await run();
+    noted.note = note_of(result);
+    return result;
+  } finally {
+    await sink(lap_of(current, step, started_ms, noted.note));
+  }
+}
+var run_ship_lap = { ENVIRONMENT_KEY, STARTUP_STEP, STEP, environment, timed, within };
+
+export {
+  run_ship_lap
+};