@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-EXDFKKMH.js

@@ -1,113 +0,0 @@
-import {
-  git_gh_blocked_by_graphql
-} from "./chunk-CQZI7RIK.js";
-import {
-  ISSUE_FIELDS,
-  STATE_AND_RELATIONS_FIELDS,
-  git_gh_issue_graphql,
-  git_gh_issue_rest,
-  issue_fields_schema
-} from "./chunk-ENKFCOVY.js";
-import {
-  git_gh_transport
-} from "./chunk-TVZXG4Y4.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gh/git-gh-issue-batch-graphql.ts
-import { z } from "zod";
-var ALIAS_PREFIX = "issue";
-var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
-var repository_schema = z.record(z.string(), z.unknown());
-var data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
-var response_schema = z.looseObject({ data: data_schema });
-function alias_of(issue_number) {
-  return `${ALIAS_PREFIX}${String(issue_number)}`;
-}
-function query_of(issue_numbers) {
-  const aliases = issue_numbers.map(
-    (issue_number) => `${alias_of(issue_number)}: issueOrPullRequest(number: ${String(issue_number)}) { ... on Issue { ${ISSUE_FIELDS} } }`
-  );
-  return `query($owner: String!, $name: String!) {
-	rateLimit { cost remaining }
-	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
-}`;
-}
-function answered(json) {
-  return { kind: "read", json };
-}
-function to_read(issue, fields) {
-  const issue_json = git_gh_issue_rest.to_gh_issue(
-    git_gh_issue_graphql.to_rest_issue(issue),
-    git_gh_issue_rest.split_fields(fields),
-    git_gh_issue_graphql.to_blocked_by(issue)
-  );
-  return answered(JSON.stringify(issue_json));
-}
-async function query_chunk(issue_numbers, variables) {
-  const json = await git_gh_transport.query_partial({ query: query_of(issue_numbers), variables });
-  if (json === void 0) return void 0;
-  return json_value.parse_with(json, response_schema)?.data;
-}
-function answered_reads(request, data) {
-  return request.issue_numbers.flatMap((issue_number) => {
-    const issue = issue_fields_schema.safeParse(data.repository[alias_of(issue_number)]);
-    return issue.success ? [[issue_number, to_read(issue.data, request.fields)]] : [];
-  });
-}
-function with_chunk(batch, request, data) {
-  if (data === void 0) return batch;
-  return {
-    reads: new Map([...batch.reads, ...answered_reads(request, data)]),
-    cost: batch.cost + data.rateLimit.cost,
-    remaining: data.rateLimit.remaining
-  };
-}
-function empty_batch() {
-  return { reads: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
-}
-async function read_many(issue_numbers, repo, fields = STATE_AND_RELATIONS_FIELDS) {
-  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
-  let batch = empty_batch();
-  if (variables === void 0) return batch;
-  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
-  for (const chunk of chunks) {
-    const request = { issue_numbers: chunk, fields };
-    batch = with_chunk(batch, request, await query_chunk(chunk, variables));
-  }
-  return batch;
-}
-var git_gh_issue_batch_graphql = { answered, empty_batch, read_many };
-
-// scripts/gh/git-gh-issue-batch-read.ts
-async function read_each(issue_numbers, reader) {
-  const { reads } = await git_gh_issue_batch_graphql.read_many(
-    issue_numbers,
-    reader.repo,
-    reader.fields
-  );
-  return await Promise.all(
-    issue_numbers.map(async (issue_number) => {
-      const read = reads.get(issue_number);
-      const value = read?.kind === "read" ? reader.from_json(read.json) : await reader.read_rest(issue_number);
-      return [issue_number, value];
-    })
-  );
-}
-async function read_across(issues, reader_for) {
-  const repos = [...new Set(issues.map((issue) => issue.repo))];
-  const reads = await Promise.all(
-    repos.map(async (repo) => {
-      const numbers = issues.filter((issue) => issue.repo === repo).map((issue) => issue.number);
-      return new Map(await read_each(numbers, reader_for(repo)));
-    })
-  );
-  return issues.map((issue) => reads[repos.indexOf(issue.repo)]?.get(issue.number));
-}
-var git_gh_issue_batch_read = { read_across, read_each };
-
-export {
-  git_gh_issue_batch_graphql,
-  git_gh_issue_batch_read
-};

package/dist/commands/chunk-EXWB34R2.js

@@ -1,238 +0,0 @@
-import {
-  test_declared_logic
-} from "./chunk-7HCPRVMB.js";
-import {
-  hook_decision,
-  hook_tool_payload
-} from "./chunk-RLBFEHHC.js";
-import {
-  agent_session_role
-} from "./chunk-U3IVVR4W.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/hooks/bash-revert.ts
-import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import path2 from "node:path";
-import { z } from "zod";
-
-// scripts/hooks/step-zero-notice.ts
-import { tmpdir } from "node:os";
-import path from "node:path";
-var STAMP_PREFIX = "josh-step-zero-notice-";
-var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
-var PARENT_PREFIX = "..";
-var NOTICE = "Before writing any implementation code: present the two-layer work summary (Now / Change / Check, then every change with its test) once per Issue. Full rule: Code Change Rules Step 0 in CLAUDE.md.";
-var STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX);
-function edited_paths(tool_input) {
-  if (!json_value.is_record(tool_input)) return [];
-  const { file_path, file_paths } = tool_input;
-  const listed = Array.isArray(file_paths) ? file_paths : [];
-  return [file_path, ...listed].filter(
-    (entry) => typeof entry === "string" && entry.length > 0
-  );
-}
-function is_external(relative) {
-  return relative.startsWith(PARENT_PREFIX) || path.isAbsolute(relative);
-}
-function is_scratch_record(file_path, scratch_root = tmpdir()) {
-  const relative = path.relative(scratch_root, file_path);
-  const is_scratch = !is_external(relative);
-  return is_scratch && [".md", ".json", ".txt"].includes(path.extname(file_path));
-}
-function should_skip_external(relative, file_path, should_include_external) {
-  return is_external(relative) && (!should_include_external || is_scratch_record(file_path));
-}
-function is_runtime_file(file_path, root, should_include_external = false) {
-  const relative = path.relative(root, path.resolve(root, file_path));
-  if (is_scratch_record(path.resolve(root, file_path), path.join(root, ".josh/tmp")) || should_skip_external(relative, path.resolve(root, file_path), should_include_external)) {
-    return false;
-  }
-  return !test_declared_logic.is_exempt(relative.split(path.sep).join("/"));
-}
-function is_runtime_edit(raw_payload, root = process.cwd(), should_include_external = false) {
-  const payload = hook_tool_payload.parse(raw_payload);
-  if (payload === void 0 || !EDIT_TOOLS.has(payload.tool_name)) return false;
-  return edited_paths(payload.tool_input).some(
-    (file_path) => is_runtime_file(file_path, root, should_include_external)
-  );
-}
-function is_candidate(raw_payload, root) {
-  const payload = hook_decision.parse_hook_payload(raw_payload);
-  if (payload === void 0 || !is_runtime_edit(raw_payload, root)) return void 0;
-  return payload.transcript_path;
-}
-function notice(raw_payload, root = process.cwd()) {
-  const transcript = is_candidate(raw_payload, root);
-  if (transcript === void 0) return void 0;
-  const target = STAMP.path(transcript);
-  if (STAMP.last_ms(target) !== hook_decision.NEVER_MS || !STAMP.record(target, Date.now())) {
-    return void 0;
-  }
-  return NOTICE;
-}
-var step_zero_notice = {
-  NOTICE,
-  edited_paths,
-  is_runtime_edit,
-  is_runtime_file,
-  notice,
-  stamp_path: STAMP.path
-};
-
-// scripts/hooks/bash-revert.ts
-var STAMP_PREFIX2 = "josh-bash-revert-";
-var UNTRACKED = "??";
-var ABSENT = "absent";
-var STATUS_WIDTH = 3;
-var OPERATIONAL_RECORDS = ".josh/";
-var BACKUP_DIRECTORY = ".josh/tmp/bash-revert";
-var BEFORE_CALL_DIRECTORY = "before-call";
-var STAMP_EXTENSION = ".json";
-var snapshot_schema = z.record(z.string(), z.string());
-var NONE_MOVED = { revert: [], restore: [], keep: [] };
-var HANDOFF = "This shell wrote runtime files; hand implementation to a worker lane.";
-function content_hash(file) {
-  return existsSync(file) ? stamp_file.digest(readFileSync(file)) : ABSENT;
-}
-function dirty_entries(root) {
-  const status = git_spawn_sync.run(
-    ["status", "--porcelain=v1", "-z", "--no-renames", "--untracked-files=all"],
-    { cwd: root }
-  );
-  const entries = status.exit_code === 0 ? status.stdout.split("\0") : [];
-  return entries.filter((entry) => entry.length > STATUS_WIDTH && !entry.endsWith("/"));
-}
-function is_guarded_file(file, root) {
-  return !file.startsWith(OPERATIONAL_RECORDS) && step_zero_notice.is_runtime_file(file, root);
-}
-function snapshot(root, entries = dirty_entries(root)) {
-  const runtime = entries.map((entry) => entry.slice(STATUS_WIDTH)).filter((file) => is_guarded_file(file, root));
-  return Object.fromEntries(runtime.map((file) => [file, content_hash(path2.join(root, file))]));
-}
-function guarded_transcript(raw_payload) {
-  if (agent_session_role.can_implement()) return void 0;
-  const payload = hook_decision.parse_hook_payload(raw_payload);
-  return payload?.tool_name === "Bash" ? payload.transcript_path : void 0;
-}
-function copy_into(source, destination) {
-  mkdirSync(path2.dirname(destination), { recursive: true });
-  copyFileSync(source, destination);
-}
-function saved_directory(transcript, root) {
-  const key = path2.basename(stamp_file.stamp_path(STAMP_PREFIX2, transcript), STAMP_EXTENSION);
-  return path2.join(root, BACKUP_DIRECTORY, BEFORE_CALL_DIRECTORY, key);
-}
-function save_dirty(before, root, saved) {
-  rmSync(saved, { recursive: true, force: true });
-  for (const [file, hash] of Object.entries(before)) {
-    if (hash !== ABSENT) copy_into(path2.join(root, file), path2.join(saved, file));
-  }
-}
-function stamp(raw_payload, root = process.cwd()) {
-  const transcript = guarded_transcript(raw_payload);
-  if (transcript === void 0) return;
-  const target = stamp_file.stamp_path(STAMP_PREFIX2, transcript);
-  try {
-    const before = snapshot(root);
-    stamp_file.write_text_stamp(target, JSON.stringify(before));
-    save_dirty(before, root, saved_directory(transcript, root));
-  } catch {
-  }
-}
-function stamped(transcript) {
-  const text = stamp_file.read_stamp_text(stamp_file.stamp_path(STAMP_PREFIX2, transcript));
-  return text === void 0 ? void 0 : json_value.parse_with(text, snapshot_schema);
-}
-function entry_file(entry) {
-  return entry.slice(STATUS_WIDTH);
-}
-function moved_entries(transcript, root) {
-  const before = stamped(transcript);
-  if (before === void 0) return NONE_MOVED;
-  const entries = dirty_entries(root);
-  const after = snapshot(root, entries);
-  const saved = saved_directory(transcript, root);
-  const dirty = Object.keys(before).filter(
-    (file) => content_hash(path2.join(root, file)) !== before[file]
-  );
-  const intact = dirty.filter((file) => content_hash(path2.join(saved, file)) === before[file]);
-  return {
-    revert: entries.filter((entry) => {
-      const file = entry_file(entry);
-      return Object.hasOwn(after, file) && !Object.hasOwn(before, file);
-    }),
-    restore: intact,
-    keep: dirty.filter((file) => !intact.includes(file))
-  };
-}
-function restore(file, root) {
-  const restored = git_spawn_sync.run(["checkout", "HEAD", "--", file], { cwd: root });
-  if (restored.exit_code !== 0) git_spawn_sync.run(["rm", "-q", "-f", "--", file], { cwd: root });
-}
-function back_up(file, root, backup) {
-  const source = path2.join(root, file);
-  if (existsSync(source)) copy_into(source, path2.join(backup, file));
-}
-function revert_file(entry, root, backup) {
-  const file = entry_file(entry);
-  back_up(file, root, backup);
-  if (entry.startsWith(UNTRACKED)) rmSync(path2.join(root, file), { force: true });
-  else restore(file, root);
-}
-function restore_saved(file, root, backup, saved) {
-  const copy = path2.join(saved, file);
-  back_up(file, root, backup);
-  if (existsSync(copy)) copy_into(copy, path2.join(root, file));
-  else rmSync(path2.join(root, file), { force: true });
-}
-function put_back(moved, root, backup, saved) {
-  for (const entry of moved.revert) revert_file(entry, root, backup);
-  for (const file of moved.restore) restore_saved(file, root, backup, saved);
-}
-function block_reason(moved, backup) {
-  const parts = [HANDOFF];
-  if (moved.revert.length > 0) {
-    parts.push(`Reverted: ${moved.revert.map((entry) => entry_file(entry)).join(", ")}.`);
-  }
-  if (moved.restore.length > 0) {
-    parts.push(`Restored to their content before the call: ${moved.restore.join(", ")}.`);
-  }
-  if (moved.revert.length + moved.restore.length > 0) {
-    parts.push(`Their content before the revert: ${backup}/.`);
-  }
-  if (moved.keep.length > 0) {
-    parts.push(`Changed, kept as dirty before the call: ${moved.keep.join(", ")}.`);
-  }
-  return parts.join(" ");
-}
-function revert(raw_payload, root = process.cwd()) {
-  const transcript = guarded_transcript(raw_payload);
-  if (transcript === void 0) return void 0;
-  const moved = moved_entries(transcript, root);
-  if (moved.revert.length + moved.restore.length + moved.keep.length === 0) return void 0;
-  const backup = path2.join(BACKUP_DIRECTORY, (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-"));
-  put_back(moved, root, path2.join(root, backup), saved_directory(transcript, root));
-  return JSON.stringify({ decision: "block", reason: block_reason(moved, backup) });
-}
-function is_shell(raw_payload) {
-  return hook_decision.parse_hook_payload(raw_payload)?.tool_name === "Bash";
-}
-function respond(raw_payload) {
-  const envelope = revert(raw_payload);
-  if (envelope !== void 0) process.stdout.write(`${envelope}
-`);
-}
-var bash_revert = { is_shell, respond, revert, stamp };
-
-export {
-  step_zero_notice,
-  bash_revert
-};

package/dist/commands/chunk-EYMPBHDN.js

@@ -1,61 +0,0 @@
-import {
-  run_preflight
-} from "./chunk-AJ65WNJB.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/git/stash/stash-orphans.ts
-var HASH_PATTERN = /#(?<issue>\d+)\b/u;
-var LEADING_PATTERN = /(?:^|: )(?<issue>\d+): /u;
-var MESSAGE_PATTERNS = [HASH_PATTERN, LEADING_PATTERN];
-var ALL_ISSUE_PATTERN = new RegExp(HASH_PATTERN.source, "gu");
-var BRANCH_PATTERN = /^(?:WIP on|On) (?<issue>\d+)-lane: /u;
-var WIP_PREFIX = "WIP on ";
-var NO_PATTERNS = [];
-var HEADER = "Stashes whose issue is closed, or whose owner cannot be read \u2014 decide for each whether to revive or discard it (none is dropped automatically):";
-var FOOTER = 'Revive: `pnpm josh stash:pop "<message>"` \xB7 Discard: `git stash drop <selector>` \u2014 re-read the selector first, the stack is shared by every lane.';
-var UNKNOWN_OWNER = "owner unknown";
-var COLUMN_SEPARATOR = "  ";
-var LINE_SEPARATOR = "\n";
-function patterns_for(subject) {
-  if (subject.includes(run_preflight.STASH_LABEL_PREFIX)) return NO_PATTERNS;
-  return subject.startsWith(WIP_PREFIX) ? [BRANCH_PATTERN] : [...MESSAGE_PATTERNS, BRANCH_PATTERN];
-}
-function issue_of(subject) {
-  for (const pattern of patterns_for(subject)) {
-    const issue = pattern.exec(subject)?.groups?.["issue"];
-    if (issue !== void 0) return issue;
-  }
-  return void 0;
-}
-function issues_of(entries) {
-  const issues = entries.map((entry) => issue_of(entry.subject));
-  return [...new Set(issues.filter((issue) => issue !== void 0))];
-}
-function message_issues(subject) {
-  const hashed = [...subject.matchAll(ALL_ISSUE_PATTERN)].map((match) => match.groups?.["issue"]);
-  return [...hashed, LEADING_PATTERN.exec(subject)?.groups?.["issue"]];
-}
-function issues_named(subject) {
-  const branch = BRANCH_PATTERN.exec(subject)?.groups?.["issue"];
-  const named = subject.startsWith(WIP_PREFIX) ? [] : message_issues(subject);
-  const found = [...named, branch].filter((issue) => issue !== void 0);
-  return [...new Set(found)];
-}
-function orphans(entries, closed) {
-  return entries.map((entry) => ({ ...entry, issue: issue_of(entry.subject) })).filter((entry) => entry.issue === void 0 || closed.has(entry.issue));
-}
-function format_line(orphan) {
-  const owner = orphan.issue === void 0 ? UNKNOWN_OWNER : `${session_cite.issue(orphan.issue)} closed`;
-  return `  ${[orphan.selector, owner, orphan.subject].join(COLUMN_SEPARATOR)}`;
-}
-function format_report(found) {
-  if (found.length === 0) return void 0;
-  return [HEADER, ...found.map((orphan) => format_line(orphan)), FOOTER].join(LINE_SEPARATOR);
-}
-var stash_orphans = { format_report, issue_of, issues_named, issues_of, orphans };
-
-export {
-  stash_orphans
-};

package/dist/commands/chunk-EZ7IPKIH.js

@@ -1,20 +0,0 @@
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-
-// scripts/issue/issue-declared-size.ts
-async function read(issue) {
-  const body = await git_gh_command.issue_get_body_classified(issue);
-  if (body.kind !== "read") throw new Error(`issue ${issue} body: ${body.kind}`);
-  if (body.text === void 0) return void 0;
-  const estimate = size_estimate.declared_size(body.text);
-  return estimate === void 0 ? void 0 : { files: estimate.files, lines: estimate.lines };
-}
-var issue_declared_size = { read };
-
-export {
-  issue_declared_size
-};

package/dist/commands/chunk-EZSO25UZ.js

@@ -1,80 +0,0 @@
-import {
-  agent_safe_text
-} from "./chunk-3LZXX5GL.js";
-import {
-  agent_provider
-} from "./chunk-JQXPLMCO.js";
-
-// scripts/agent/agent-profile-schema.ts
-import { z } from "zod";
-
-// scripts/agent/agent-model-alias.ts
-var CLAUDE_MODEL_PATTERN = /^claude-(?<family>opus|sonnet|haiku|fable)-/u;
-function alias_of(model) {
-  return CLAUDE_MODEL_PATTERN.exec(model)?.groups?.["family"];
-}
-function suffix_of(model) {
-  const alias = alias_of(model);
-  return alias === void 0 ? "" : ` (${alias})`;
-}
-var agent_model_alias = { alias_of, suffix_of };
-
-// scripts/agent/agent-profile-schema.ts
-var ROLE_SCHEMA = z.enum(["scheduler", "worker", "reviewer"]);
-var EFFORT_SCHEMA = z.enum(["low", "medium", "high", "xhigh", "max"]);
-var PHASE_SCHEMA = z.enum(["implementation", "pre-gate"]);
-var PROFILE_SCHEMA = z.object({
-  provider: agent_provider.PROVIDER_SCHEMA.default("anthropic"),
-  role: ROLE_SCHEMA,
-  model: z.string(),
-  effort: EFFORT_SCHEMA
-});
-var SCHEDULER = "scheduler";
-var WORKER = "worker";
-var REVIEWER = "reviewer";
-var IMPLEMENTATION_PHASE = "implementation";
-var PRE_GATE_PHASE = "pre-gate";
-var OPENAI_MODEL = "gpt-6.1-sol";
-var ANTHROPIC_MODEL = "claude-opus-5-5";
-var REVIEW_EFFORT = "medium";
-var { ANTHROPIC_PROVIDER, OPENAI_PROVIDER } = agent_provider;
-var { is_safe_value } = agent_safe_text;
-function role_profiles(provider, model) {
-  return {
-    scheduler: { provider, role: SCHEDULER, model, effort: "medium" },
-    worker: { provider, role: WORKER, model, effort: "medium" },
-    reviewer: { provider, role: REVIEWER, model, effort: REVIEW_EFFORT }
-  };
-}
-var DEFAULT_PROFILES = role_profiles(ANTHROPIC_PROVIDER, ANTHROPIC_MODEL);
-var OPENAI_PROFILES = role_profiles(OPENAI_PROVIDER, OPENAI_MODEL);
-function describe(profile) {
-  return `provider=${profile.provider} role=${profile.role} model=${profile.model}${agent_model_alias.suffix_of(profile.model)} effort=${profile.effort}`;
-}
-function describe_review(round, profile) {
-  return `review round ${String(round)} \xB7 ${describe(profile)}`;
-}
-function parse(value) {
-  const parsed = PROFILE_SCHEMA.safeParse(value);
-  return parsed.success && is_safe_value(parsed.data.model) ? parsed.data : void 0;
-}
-var agent_profile_schema = {
-  DEFAULT_PROFILES,
-  EFFORT_SCHEMA,
-  IMPLEMENTATION_PHASE,
-  OPENAI_MODEL,
-  OPENAI_PROFILES,
-  PHASE_SCHEMA,
-  PRE_GATE_PHASE,
-  PROFILE_SCHEMA,
-  REVIEWER,
-  SCHEDULER,
-  WORKER,
-  describe,
-  describe_review,
-  parse
-};
-
-export {
-  agent_profile_schema
-};

package/dist/commands/chunk-F6IQHZYY.js

@@ -1,94 +0,0 @@
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-
-// scripts/lane/lane-held-stats.ts
-var COLUMNS = [
-  "held by",
-  "total (min)",
-  "median (min)",
-  "max (min)",
-  "holds",
-  "not ended"
-];
-var MS_PER_HOUR = 36e5;
-var MAX_HOLD_MS = MS_PER_HOUR;
-var LAUNCH_COMMAND = "lane:launch";
-var { NOT_MEASURED } = lane_stage_stats;
-var NONE_ROW = ["none", NOT_MEASURED, NOT_MEASURED, NOT_MEASURED, "0", "0"];
-var { is_dispatch, is_number } = lane_stage_stats;
-function is_held(entry) {
-  return entry.kind === lane_ledger.KIND.HELD;
-}
-function is_hold_end(entry) {
-  return is_held(entry) || is_dispatch(entry) || entry.kind === lane_ledger.KIND.RELEASED;
-}
-function end_times(entries) {
-  return entries.filter((entry) => is_hold_end(entry)).map((entry) => Date.parse(entry.at)).filter((at) => Number.isFinite(at)).toSorted((left, right) => left - right);
-}
-function wait_ms(held, ends) {
-  const from_ms = Date.parse(held.at);
-  const end_ms = ends.find((at) => at > from_ms);
-  return end_ms === void 0 ? void 0 : Math.min(end_ms - from_ms, MAX_HOLD_MS);
-}
-function holds_of(entries) {
-  const ends = end_times(entries);
-  return entries.filter(is_held).map((held) => ({ reason: held.reason, wait_ms: wait_ms(held, ends) }));
-}
-function launch_holds(entries) {
-  return entries.flatMap(
-    (entry) => entry.kind === lane_ledger.KIND.CORE_WAIT && entry.command === LAUNCH_COMMAND ? { reason: LAUNCH_COMMAND, wait_ms: entry.waited_ms } : []
-  );
-}
-function total(values) {
-  return values.reduce((sum, value) => sum + value, 0);
-}
-function ended_of(holds, reason) {
-  return holds.filter((hold) => hold.reason === reason).map((hold) => hold.wait_ms).filter((value) => is_number(value));
-}
-function reason_row(reason, holds) {
-  const ended = ended_of(holds, reason);
-  const count = holds.filter((hold) => hold.reason === reason).length;
-  return lane_stats.to_row([
-    reason,
-    lane_stage_stats.cell(ended.length === 0 ? void 0 : total(ended)),
-    lane_stage_stats.cell(lane_stats.median(ended)),
-    lane_stage_stats.cell(lane_stats.peak(ended)),
-    String(count),
-    String(count - ended.length)
-  ]);
-}
-function reasons_of(holds) {
-  const reasons = [...new Set(holds.map((hold) => hold.reason))];
-  return reasons.toSorted(
-    (left, right) => total(ended_of(holds, right)) - total(ended_of(holds, left))
-  );
-}
-function table(entries, window) {
-  const period = lane_stats.in_window(entries, window);
-  const holds = [...holds_of(period), ...launch_holds(period)];
-  const rows = reasons_of(holds).map((reason) => reason_row(reason, holds));
-  return [
-    lane_stats.to_row(COLUMNS),
-    lane_stats.to_row(COLUMNS.map(() => "---")),
-    ...rows.length === 0 ? [lane_stats.to_row(NONE_ROW)] : rows
-  ].join("\n");
-}
-function is_open_at(held, now_ms) {
-  return now_ms - Date.parse(held.at) < MAX_HOLD_MS;
-}
-function open_reason(entries, now_ms) {
-  const last = entries.findLast((entry) => is_hold_end(entry));
-  return last !== void 0 && is_held(last) && is_open_at(last, now_ms) ? last.reason : void 0;
-}
-var lane_held_stats = { open_reason, table };
-
-export {
-  lane_held_stats
-};