@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-6PL2AK3C.js

@@ -0,0 +1,204 @@
+import {
+  acceptance_map
+} from "./chunk-VP3P7FLJ.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  pr_classification
+} from "./chunk-CT773QBI.js";
+import {
+  animation_helpers
+} from "./chunk-GO3GH7FG.js";
+import {
+  pr_info_schema
+} from "./chunk-34DND4BA.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-pr-error.ts
+function is_pr_already_exists_message(message) {
+  return message === "PR_ALREADY_EXISTS";
+}
+function has_error_cause(error) {
+  return error.cause instanceof Error && is_pr_already_exists_message(error.cause.message);
+}
+function is_pr_already_exists_error(error) {
+  if (error instanceof Error) {
+    if (is_pr_already_exists_message(error.message)) return true;
+    return has_error_cause(error);
+  }
+  return false;
+}
+var git_pr_error = {
+  is_pr_already_exists_error
+};
+
+// scripts/gh/git-pr-messages.ts
+function display_pr_opened_message() {
+  console.info("");
+  console.info("\u2705 Pull request opened.");
+  console.info("");
+  console.info("`pnpm josh followup` waits for the checks and merges.");
+}
+function display_pr_url(pr_url) {
+  console.info("");
+  console.info(`\u{1F517} PR: ${pr_url}`);
+}
+function display_merged_pr_message() {
+  console.info("");
+  console.info("\u2139\uFE0F  Existing PR is already merged. Creating a new PR...");
+  console.info("");
+}
+function display_pr_exists_message() {
+  console.info("");
+  console.info("\u2139\uFE0F  Pull request already exists.");
+  console.info("");
+}
+var git_pr_messages = {
+  display_pr_opened_message,
+  display_merged_pr_message,
+  display_pr_exists_message,
+  display_pr_url
+};
+
+// scripts/gh/git-pr.ts
+async function create_pr(title, body, label) {
+  const config = {
+    icon_selector: () => "\u2705",
+    error_message: "Failed to create PR",
+    result_formatter: () => "PR created."
+  };
+  try {
+    return await animation_helpers.execute_with_animation(
+      "Creating pull request...",
+      async () => await git_gh_command.pr_create(title, body, label),
+      config
+    );
+  } catch (error) {
+    if (git_pr_error.is_pr_already_exists_error(error)) {
+      git_pr_messages.display_pr_exists_message();
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function display_pr_url_if_available(branch_name) {
+  const pr_url = await git_gh_command.pr_get_url(branch_name);
+  if (pr_url !== void 0) {
+    git_pr_messages.display_pr_url(pr_url);
+  }
+}
+async function report_open_pr(branch_name, created_url) {
+  git_pr_messages.display_pr_opened_message();
+  if (created_url !== void 0 && created_url.length > 0) {
+    git_pr_messages.display_pr_url(created_url);
+    return;
+  }
+  await display_pr_url_if_available(branch_name);
+}
+var PR_STATE_MERGED = "MERGED";
+async function create_and_report(title, body, branch_name, label) {
+  const created_url = await create_pr(title, body, label);
+  await report_open_pr(branch_name, created_url);
+}
+function parse_pr_state(pr_info_json) {
+  return json_value.parse_with(pr_info_json, pr_info_schema)?.state;
+}
+async function get_pr_state(branch_name) {
+  const pr_info_json = await git_gh_command.pr_view(branch_name);
+  if (pr_info_json.length === 0) return void 0;
+  return parse_pr_state(pr_info_json);
+}
+function is_pr_state_merged(pr_state) {
+  return pr_state === PR_STATE_MERGED;
+}
+async function report_existing_pr(body, branch_name, should_replace_body, label) {
+  await git_gh_command.pr_ensure_classification(branch_name, label);
+  if (should_replace_body) await git_gh_command.pr_update_body(branch_name, body);
+  await report_open_pr(branch_name);
+}
+async function handle_existing_pr(title, body, branch_name, options) {
+  const pr_state_result = await get_pr_state(branch_name);
+  if (is_pr_state_merged(pr_state_result)) {
+    git_pr_messages.display_merged_pr_message();
+    await create_and_report(title, body, branch_name, options.label);
+    return;
+  }
+  await report_existing_pr(body, branch_name, options.should_replace_body, options.label);
+}
+async function create(title, body, branch_name, options) {
+  const { label, should_replace_body = false } = options;
+  const has_pr = await git_gh_command.pr_exists(branch_name);
+  if (!has_pr) {
+    await create_and_report(title, body, branch_name, label);
+    return;
+  }
+  await handle_existing_pr(title, body, branch_name, { label, should_replace_body });
+}
+function build_title(issue_info) {
+  return `${issue_info.title} ${issue_cite.plain_for("github", issue_info.number)}`;
+}
+function build_body(issue_info, extra_body) {
+  const closes = `closes ${issue_cite.plain_for("github", issue_info.number)}`;
+  if (extra_body === void 0) return closes;
+  return `${closes}
+
+${extra_body}`;
+}
+async function body_with_map(issue_info, extra_body) {
+  const body = build_body(issue_info, extra_body);
+  if (acceptance_map.has_map(body)) return body;
+  const map = acceptance_map.skeleton(await git_gh_command.issue_get_body(issue_info.number));
+  return map === void 0 ? body : `${body}
+
+${map}`;
+}
+async function existing_pr_label(branch_name) {
+  if (!await git_gh_command.pr_exists(branch_name) || is_pr_state_merged(await get_pr_state(branch_name))) {
+    return void 0;
+  }
+  return await git_gh_command.pr_get_classification(branch_name);
+}
+async function create_for_issue(issue_info, extra_body, label) {
+  await create(
+    build_title(issue_info),
+    await body_with_map(issue_info, extra_body),
+    issue_info.branch_name,
+    {
+      label,
+      should_replace_body: extra_body !== void 0
+    }
+  );
+}
+async function release_classification(issue_number, branch_name) {
+  const existing_label = await existing_pr_label(branch_name);
+  if (existing_label !== void 0) return existing_label;
+  const issue_json = await git_gh_command.issue_view_json(issue_number, "labels,body");
+  if (issue_json === void 0) {
+    throw new Error(
+      `Could not read issue ${session_cite.issue(issue_number)} for release classification`
+    );
+  }
+  return pr_classification.select_issue_classification(issue_json);
+}
+async function create_with_issue_info(issue_info, extra_body) {
+  const label = await release_classification(issue_info.number, issue_info.branch_name);
+  await create_for_issue(issue_info, extra_body, label);
+}
+var git_pr = {
+  create,
+  create_with_issue_info,
+  release_classification
+};
+
+export {
+  git_pr
+};

package/dist/commands/chunk-6PLIQCBG.js

@@ -0,0 +1,326 @@
+import {
+  epic_cross_repo
+} from "./chunk-AQGVQMWF.js";
+import {
+  issue_sample_prime
+} from "./chunk-FBZD6LOK.js";
+import {
+  epic_issue
+} from "./chunk-GXXWRH6F.js";
+import {
+  git_gh_issue_batch_graphql,
+  git_gh_issue_batch_read
+} from "./chunk-WHYYBPIC.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  shared_cache
+} from "./chunk-RW7OILP7.js";
+import {
+  author_fields_schema
+} from "./chunk-34DND4BA.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/epic/epic-child-source.ts
+import { z } from "zod";
+var HOURS_KEPT = 6;
+var MS_PER_HOUR = 36e5;
+var CLOSED_CACHE = { prefix: "josh-epic-closed-", ttl_ms: HOURS_KEPT * MS_PER_HOUR };
+var reference_schema = z.object({ repo: z.string(), number: z.number() });
+var child_schema = z.object({
+  number: z.number(),
+  repo: z.string(),
+  state: z.enum(["OPEN", "CLOSED"]),
+  labels: z.array(z.string()),
+  blocked_by: z.array(reference_schema),
+  body: z.string().optional(),
+  ...author_fields_schema
+});
+var entries_schema = z.array(z.object({ read_at: z.number(), child: child_schema }));
+function fresh_entries(repo, now_ms) {
+  const entries = shared_cache.read(CLOSED_CACHE, repo, entries_schema, now_ms) ?? [];
+  return entries.filter((entry) => now_ms - entry.read_at < CLOSED_CACHE.ttl_ms);
+}
+function cached_closed(repo, now_ms) {
+  return new Map(fresh_entries(repo, now_ms).map((entry) => [entry.child.number, entry.child]));
+}
+function known(source, repo, now_ms) {
+  if (source === void 0) return /* @__PURE__ */ new Map();
+  const closed = cached_closed(repo, now_ms);
+  return source.repo === repo ? new Map([...closed, ...source.listed]) : closed;
+}
+function is_closed(child) {
+  return child.state === epic_issue.CLOSED;
+}
+function remember_closed(source, repo, children, now_ms) {
+  if (source === void 0) return;
+  const fresh = fresh_entries(repo, now_ms);
+  const reopened = new Set(
+    children.filter((child) => !is_closed(child)).map((child) => child.number)
+  );
+  const kept = fresh.filter((entry) => !reopened.has(entry.child.number));
+  const cached = new Set(kept.map((entry) => entry.child.number));
+  const added = children.filter((child) => is_closed(child) && !cached.has(child.number));
+  if (added.length === 0 && kept.length === fresh.length) return;
+  const entries = [...kept, ...added.map((child) => ({ read_at: now_ms, child }))];
+  shared_cache.write(CLOSED_CACHE, repo, entries, now_ms);
+}
+function waited_closed(children, known_children, repo) {
+  const waited = children.filter((child) => !is_closed(child)).flatMap((child) => child.blocked_by).filter((blocker) => blocker.repo === repo).map((blocker) => blocker.number);
+  return new Set(waited.filter((number) => known_children.get(number)?.state === epic_issue.CLOSED));
+}
+var epic_child_source = { CLOSED_CACHE, known, remember_closed, waited_closed };
+
+// scripts/epic/epic-relation-recheck.ts
+var RECHECK_LIMIT = 20;
+function suspect_children(children, body, declared_repo) {
+  const links = epic_parse.parse_dependency_links(body);
+  const local = children.filter((child) => child.repo === declared_repo);
+  return new Set(
+    epic_graph.missing_relations(links, local, declared_repo).map((link) => link.blocked)
+  );
+}
+async function reread_child(child, read_blockers) {
+  try {
+    return { ...child, blocked_by: await read_blockers(child) };
+  } catch (error) {
+    const reason = error_text.message_of(error);
+    console.warn(
+      `\u26A0 could not re-read the blockers of ${session_cite.issue(child.number, void 0, child.repo)}: ${reason}
+  a mismatch reported below may be this read failing rather than a missing relation`
+    );
+    return child;
+  }
+}
+function skipped_over_limit(children, suspect_count) {
+  console.warn(
+    `\u26A0 ${String(suspect_count)} declared links are unrecorded, past the ${String(RECHECK_LIMIT)} this re-reads
+  the mismatch below is reported from the first read; the body is likely ahead of the relations`
+  );
+  return children;
+}
+async function recheck_missing_relations(children, body, declared_repo, read_blockers) {
+  const suspects = suspect_children(children, body, declared_repo);
+  if (suspects.size === 0) return children;
+  if (suspects.size > RECHECK_LIMIT) return skipped_over_limit(children, suspects.size);
+  return await Promise.all(
+    children.map(
+      async (child) => suspects.has(child.number) && child.repo === declared_repo ? await reread_child(child, read_blockers) : child
+    )
+  );
+}
+var epic_relation_recheck = { recheck_missing_relations, RECHECK_LIMIT };
+
+// scripts/epic/epic-fetch.ts
+var CHILD_LIMIT = 200;
+function to_child(parsed, repo) {
+  return {
+    number: parsed.number,
+    repo,
+    state: epic_issue.normalize_state(parsed.state),
+    labels: epic_issue.label_names(parsed),
+    blocked_by: epic_issue.blocker_references_of(parsed, repo),
+    body: parsed.body,
+    author_association: parsed.author_association,
+    user: parsed.user
+  };
+}
+function scope_for(child_repo, current_repo) {
+  return child_repo === current_repo ? void 0 : child_repo;
+}
+async function read_child_blockers(child, current_repo) {
+  return await git_gh_command.issue_blocked_by_references(
+    String(child.number),
+    child.repo,
+    scope_for(child.repo, current_repo)
+  );
+}
+async function fetch_epic_body(epic_number, scope) {
+  const read = await git_gh_command.issue_get_body_classified(String(epic_number), scope);
+  const body = read.kind === "read" ? read.text : void 0;
+  return {
+    body,
+    body_failure: read.kind === "read" ? void 0 : read,
+    child_numbers: epic_parse.parse_task_list_issue_numbers(body),
+    external: epic_parse.parse_external_task_list_children(body)
+  };
+}
+async function rechecked_children(children, snapshot) {
+  return await epic_relation_recheck.recheck_missing_relations(
+    children,
+    snapshot.body,
+    snapshot.repo,
+    async (child) => await read_child_blockers(child, snapshot.current_repo)
+  );
+}
+function to_references(issue_numbers, repo) {
+  return issue_numbers.map((issue_number) => ({ repo, number: issue_number }));
+}
+var NOT_READ = { child: void 0, is_unreachable: false };
+async function read_rest(issue_number, scope) {
+  return await git_gh_command.issue_get_state_and_relations_classified(String(issue_number), scope);
+}
+async function to_child_read(read, repo) {
+  if (read.kind !== "read") {
+    return { child: void 0, is_unreachable: git_gh_command.is_unreachable_read(read) };
+  }
+  const parsed = epic_issue.parse_epic_issue(read.json);
+  await issue_sample_prime.prime([parsed?.body]);
+  return { child: parsed === void 0 ? void 0 : to_child(parsed, repo), is_unreachable: false };
+}
+async function read_children(issue_numbers, repo, scope) {
+  const reads = await git_gh_issue_batch_read.read_each(issue_numbers, {
+    repo: scope,
+    from_json: git_gh_issue_batch_graphql.answered,
+    read_rest: async (issue_number) => await read_rest(issue_number, scope)
+  });
+  const entries = await Promise.all(
+    reads.map(async ([issue_number, read]) => [
+      issue_number,
+      await to_child_read(read, repo)
+    ])
+  );
+  return new Map(entries);
+}
+async function fetch_child(issue_number, repo, scope) {
+  const read = await to_child_read(await read_rest(issue_number, scope), repo);
+  return read.child;
+}
+function to_children(reads) {
+  return reads.map((read) => read.child).filter((child) => child !== void 0);
+}
+function count_unreachable(reads) {
+  return reads.filter((read) => read.is_unreachable).length;
+}
+function is_body_unreachable(failure) {
+  return failure !== void 0 && git_gh_command.is_unreachable_read(failure);
+}
+async function known_or_read(issue_number, known2, fresh) {
+  const child = known2.get(issue_number);
+  if (child === void 0) return fresh.get(issue_number) ?? NOT_READ;
+  await issue_sample_prime.prime([child.body]);
+  return { child, is_unreachable: false };
+}
+async function answer_children(issue_numbers, known2, repo, scope) {
+  const unknown = issue_numbers.filter((issue_number) => !known2.has(issue_number));
+  const fresh = await read_children(unknown, repo, scope);
+  return await Promise.all(
+    issue_numbers.map(async (issue_number) => await known_or_read(issue_number, known2, fresh))
+  );
+}
+async function recheck_blockers(reads, child_numbers, known2, repo) {
+  const waited = epic_child_source.waited_closed(to_children(reads), known2, repo);
+  if (waited.size === 0) return reads;
+  const fresh = await read_children([...waited], repo);
+  return reads.map((read, index) => fresh.get(child_numbers[index] ?? 0) ?? read);
+}
+async function fetch_children(child_numbers, repo, scope, source) {
+  const limited = child_numbers.slice(0, CHILD_LIMIT);
+  const now_ms = Date.now();
+  const known2 = epic_child_source.known(source, repo, now_ms);
+  const answered = await answer_children(limited, known2, repo, scope);
+  const reads = await recheck_blockers(answered, limited, known2, repo);
+  epic_child_source.remember_closed(source, repo, to_children(reads), now_ms);
+  return {
+    children: to_children(reads),
+    unreadable: to_references(
+      limited.filter((_, index) => reads[index]?.child === void 0),
+      repo
+    ),
+    skipped: to_references(child_numbers.slice(CHILD_LIMIT), repo),
+    unreachable_count: count_unreachable(reads)
+  };
+}
+async function read_external(allowed) {
+  const repos = [...new Set(allowed.map((child) => child.repo))];
+  const batches = await Promise.all(
+    repos.map(async (repo) => {
+      const issue_numbers = allowed.filter((child) => child.repo === repo).map((child) => child.number);
+      return await read_children(issue_numbers, repo, repo);
+    })
+  );
+  return allowed.map((child) => batches[repos.indexOf(child.repo)]?.get(child.number) ?? NOT_READ);
+}
+async function fetch_external_children(external, current_owner) {
+  const allowed = external.filter(
+    (child) => epic_cross_repo.is_same_owner_repo(child.repo, current_owner)
+  );
+  const reads = await read_external(allowed);
+  const refused = external.filter(
+    (child) => !epic_cross_repo.is_same_owner_repo(child.repo, current_owner)
+  );
+  return {
+    children: to_children(reads),
+    unreadable: [...allowed.filter((_, index) => reads[index]?.child === void 0), ...refused],
+    skipped: [],
+    // A refusal is not a transport failure: the owner restriction answers the same tomorrow.
+    unreachable_count: count_unreachable(reads)
+  };
+}
+function to_failure_counts(body_failure, groups) {
+  const body_failed = body_failure === void 0 ? 0 : 1;
+  return {
+    failed: body_failed + groups.reduce((total, group) => total + group.unreadable.length, 0),
+    unreachable: (is_body_unreachable(body_failure) ? 1 : 0) + groups.reduce((total, group) => total + group.unreachable_count, 0)
+  };
+}
+function is_snapshot_unreachable(body_failure, groups) {
+  const counts = to_failure_counts(body_failure, groups);
+  return counts.failed > 0 && counts.failed === counts.unreachable;
+}
+async function to_snapshot(epic_body, scope, local, remote) {
+  const { body, body_failure, child_numbers, external } = epic_body;
+  const children = await rechecked_children([...local.children, ...remote.children], {
+    body,
+    ...scope
+  });
+  return {
+    body,
+    repo: scope.repo,
+    current_repo: scope.current_repo,
+    children,
+    child_numbers: [...child_numbers, ...external.map((child) => child.number)],
+    unreadable: [...local.unreadable, ...remote.unreadable],
+    skipped: local.skipped,
+    has_external_children: external.length > 0,
+    body_failure,
+    is_unreachable: is_snapshot_unreachable(body_failure, [local, remote])
+  };
+}
+async function fetch_epic(epic_number, repo, current_repo = repo, source) {
+  const scope = scope_for(repo, current_repo);
+  const epic_body = await fetch_epic_body(epic_number, scope);
+  const owner = epic_cross_repo.owner_of(current_repo);
+  const local = await fetch_children(epic_body.child_numbers, repo, scope, source);
+  const remote = await fetch_external_children(epic_body.external, owner);
+  return await to_snapshot(epic_body, { repo, current_repo }, local, remote);
+}
+function missing_children(snapshot) {
+  return [...snapshot.unreadable, ...snapshot.skipped];
+}
+var epic_fetch = {
+  CHILD_LIMIT,
+  scope_for,
+  read_child_blockers,
+  missing_children,
+  fetch_child,
+  fetch_children,
+  fetch_external_children,
+  fetch_epic
+};
+
+export {
+  epic_fetch
+};

package/dist/commands/chunk-6QVDEMGB.js

@@ -0,0 +1,118 @@
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+
+// scripts/ci/ci-timing-table.ts
+import { z } from "zod";
+var MS_PER_SECOND = 1e3;
+var STEP_INDENT = "  ";
+var HEADER = ["job / step", "s", "conclusion"];
+var UNMEASURED = "\u2014";
+var COLUMN_GAP = "  ";
+var timed_schema = z.looseObject({
+  name: z.string(),
+  conclusion: z.string().nullish(),
+  started_at: z.string().nullish(),
+  completed_at: z.string().nullish()
+});
+var job_schema = timed_schema.extend({ steps: z.array(timed_schema).optional() });
+var jobs_page_schema = z.looseObject({ jobs: z.array(job_schema) });
+function seconds_of(item) {
+  if (!item.started_at || !item.completed_at) return void 0;
+  return Math.round((Date.parse(item.completed_at) - Date.parse(item.started_at)) / MS_PER_SECOND);
+}
+function row_of(item) {
+  return { name: item.name, seconds: seconds_of(item), conclusion: item.conclusion ?? void 0 };
+}
+function jobs_of(page) {
+  return jobs_page_schema.parse(page).jobs.map((job) => ({ ...row_of(job), steps: (job.steps ?? []).map((step) => row_of(step)) }));
+}
+function cells_of(row, indent) {
+  return [
+    `${indent}${row.name}`,
+    row.seconds === void 0 ? UNMEASURED : String(row.seconds),
+    row.conclusion ?? UNMEASURED
+  ];
+}
+function line_of(cells, widths) {
+  const [name, seconds, conclusion] = cells;
+  return [name.padEnd(widths[0]), seconds.padStart(widths[1]), conclusion].join(COLUMN_GAP);
+}
+function table(jobs) {
+  const cells = jobs.flatMap((job) => [
+    cells_of(job, ""),
+    ...job.steps.map((step) => cells_of(step, STEP_INDENT))
+  ]);
+  const all = [HEADER, ...cells];
+  const widths = [
+    Math.max(...all.map(([name]) => name.length)),
+    Math.max(...all.map(([, seconds]) => seconds.length))
+  ];
+  return all.map((row) => line_of(row, widths)).join("\n");
+}
+var ci_timing_table = { jobs_of, table };
+
+// scripts/ci/ci-timing.ts
+import { z as z2 } from "zod";
+var RUN_ID_FLOOR = 1e8;
+var DIGITS = /^\d+$/u;
+var JOBS_PER_PAGE = 100;
+var RUNS_PER_PAGE = 20;
+var pull_schema = z2.looseObject({ head: z2.looseObject({ ref: z2.string() }) });
+var run_schema = z2.object({
+  id: z2.number(),
+  name: z2.string().nullish(),
+  conclusion: z2.string().nullish(),
+  head_sha: z2.string(),
+  html_url: z2.string()
+});
+var runs_page_schema = z2.looseObject({ workflow_runs: z2.array(run_schema) });
+function target_of(argument) {
+  if (!DIGITS.test(argument)) return { kind: "branch", branch: argument };
+  const value = Number(argument);
+  return value >= RUN_ID_FLOOR ? { kind: "run", run_id: value } : { kind: "pr", pr: value };
+}
+async function read_json(rest) {
+  const json = await git_gh_exec.exec_gh_api({ path: `${git_gh_api_path.repo_api_path()}/${rest}` });
+  return JSON.parse(json);
+}
+async function branch_of_pr(pr) {
+  return pull_schema.parse(await read_json(`pulls/${String(pr)}`)).head.ref;
+}
+async function latest_runs_of(branch) {
+  const query = `actions/runs?branch=${encodeURIComponent(branch)}&per_page=${String(RUNS_PER_PAGE)}`;
+  const runs = runs_page_schema.parse(await read_json(query)).workflow_runs;
+  const head_sha = runs.at(0)?.head_sha;
+  return runs.filter((run) => run.head_sha === head_sha);
+}
+async function run_by_id(run_id) {
+  return run_schema.parse(await read_json(`actions/runs/${String(run_id)}`));
+}
+async function runs_of(target) {
+  if (target.kind === "run") return [await run_by_id(target.run_id)];
+  const branch = target.kind === "pr" ? await branch_of_pr(target.pr) : target.branch;
+  return await latest_runs_of(branch);
+}
+async function run_timing_of(run) {
+  const page = await read_json(
+    `actions/runs/${String(run.id)}/jobs?per_page=${String(JOBS_PER_PAGE)}`
+  );
+  return { run, jobs: ci_timing_table.jobs_of(page) };
+}
+async function timing_of(argument) {
+  const runs = await runs_of(target_of(argument));
+  if (runs.length === 0) return { kind: "none", target: argument };
+  return {
+    kind: "timed",
+    runs: await Promise.all(runs.map(async (run) => await run_timing_of(run)))
+  };
+}
+var ci_timing = { target_of, timing_of };
+
+export {
+  ci_timing_table,
+  ci_timing
+};

package/dist/commands/chunk-6T67GZMJ.js

@@ -0,0 +1,60 @@
+import {
+  hook_ledger
+} from "./chunk-5JIMCETI.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-demoted.ts
+import { readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var DEMOTED_FILE = ".josh/hook-demoted.json";
+var NOTICE_HEADER = "\u2139 Demoted rule \u2014 this call ran; do not reissue it. The refusal it would have given:\n";
+var INDENT = "	";
+var rules_schema = z.object({ rules: z.array(z.string()) });
+function read_rules(file = DEMOTED_FILE) {
+  try {
+    return new Set(json_value.parse_with(readFileSync(file, "utf8"), rules_schema)?.rules);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function rules(environment = process.env) {
+  return environment["VITEST"] === void 0 ? read_rules() : /* @__PURE__ */ new Set();
+}
+async function write_rules(demoted, file = DEMOTED_FILE) {
+  const sorted = [...demoted].toSorted((left, right) => left.localeCompare(right));
+  const body = JSON.stringify({ rules: sorted }, void 0, INDENT);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${body}
+`);
+}
+function is_demoted(reason, demoted) {
+  return demoted.has(hook_ledger.rule_of(reason));
+}
+function verdict(reasons, demoted) {
+  const blocking = reasons.find((reason) => !is_demoted(reason, demoted));
+  if (blocking !== void 0) return { reason: blocking, notice: void 0, fault: void 0 };
+  const [first] = reasons;
+  return first === void 0 ? void 0 : { reason: void 0, notice: `${NOTICE_HEADER}${first}`, fault: void 0 };
+}
+function refusal_of(notice, demoted) {
+  if (notice?.startsWith(NOTICE_HEADER) !== true) return void 0;
+  const reason = notice.slice(NOTICE_HEADER.length);
+  return is_demoted(reason, demoted) ? reason : void 0;
+}
+var hook_demoted = {
+  DEMOTED_FILE,
+  NOTICE_HEADER,
+  read_rules,
+  refusal_of,
+  rules,
+  verdict,
+  write_rules
+};
+
+export {
+  hook_demoted
+};