@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-BFKTUD3V.js

@@ -1,33 +0,0 @@
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec
-} from "./chunk-43DU7DYZ.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/gh/gh-spawn.ts
-var NO_BUDGET = 0;
-function fetch_repo_name(timeout_ms) {
-  const stdout = git_gh_exec.read_gh_api_sync({
-    path: git_gh_api_path.repo_api_path(),
-    jq_filter: ".full_name",
-    cwd: PROJECT_ROOT,
-    timeout_ms: timeout_ms ?? NO_BUDGET
-  });
-  const name = stdout?.trim();
-  return name === "" ? void 0 : name;
-}
-function get_repo_name_with_owner() {
-  return fetch_repo_name(void 0);
-}
-function get_repo_name_with_owner_within(timeout_ms) {
-  return fetch_repo_name(timeout_ms);
-}
-var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
-
-export {
-  gh_spawn
-};

package/dist/commands/chunk-BLRXHK2V.js

@@ -1,17 +0,0 @@
-import {
-  issue_state_cli
-} from "./chunk-E4PFCTXN.js";
-import {
-  has_parked_label
-} from "./chunk-QQBMVC5W.js";
-
-// scripts/lane/lane-parked.ts
-async function is_parked(issue) {
-  const read = await issue_state_cli.read_issue(issue);
-  return read.kind === "state" && has_parked_label(read.state.labels);
-}
-var lane_parked = { is_parked };
-
-export {
-  lane_parked
-};

package/dist/commands/chunk-BML6MEUB.js

@@ -1,326 +0,0 @@
-import {
-  epic_cross_repo
-} from "./chunk-YTXCLGGL.js";
-import {
-  issue_sample_prime
-} from "./chunk-WWLCQREY.js";
-import {
-  epic_issue
-} from "./chunk-YEAE46TS.js";
-import {
-  git_gh_issue_batch_graphql,
-  git_gh_issue_batch_read
-} from "./chunk-HYE3MBAN.js";
-import {
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  shared_cache
-} from "./chunk-WXLW7S4M.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-BMM4RHCG.js

@@ -1,69 +0,0 @@
-import {
-  markdown_section
-} from "./chunk-JZK33TA5.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-
-// scripts/issue/baseline-measure.ts
-var BASELINE_HEADING = issue_body_keys.heading("baseline");
-var BASELINE_LINE = /^-\s*`([^`]+)`\s*(?:→|->)\s*(\S.*)$/u;
-var VALUE_GROUP = 2;
-var LEDGER_KEY_PREFIX = "- k:";
-var LEDGER_DEPTH = "d1";
-var FIELD_SEPARATOR = " | ";
-var FIELD_SEPARATOR_REPLACEMENT = " ; ";
-var REMEASURE_COMMAND = "pnpm josh measure:rerun";
-var NON_SLUG_RUN = /[^a-z0-9]+/gu;
-var EMPTY_SLUG_FALLBACK = "baseline";
-function normalize(value) {
-  return value.trim();
-}
-function parse_baselines(body) {
-  return markdown_section.section_lines(body, BASELINE_HEADING).map((line) => BASELINE_LINE.exec(line.trim())).filter((match) => match !== null).map((match) => ({ command: match[1] ?? "", value: normalize(match[VALUE_GROUP] ?? "") }));
-}
-function has_command_value(body) {
-  return parse_baselines(body).length > 0;
-}
-function is_no_change(before, after) {
-  return normalize(before) === normalize(after);
-}
-function format_pair(baseline, after) {
-  return [
-    `\`${baseline.command}\``,
-    `  before: ${normalize(baseline.value)}`,
-    `  after:  ${normalize(after)}`
-  ].join("\n");
-}
-function sanitize_field(text) {
-  return text.split(FIELD_SEPARATOR).join(FIELD_SEPARATOR_REPLACEMENT).trim();
-}
-function slug_of(command) {
-  const runs = command.toLowerCase().replaceAll(NON_SLUG_RUN, "-").split("-");
-  const slug = runs.filter(Boolean).join("-");
-  return slug === "" ? EMPTY_SLUG_FALLBACK : slug;
-}
-function ledger_line(baseline, date) {
-  const what = sanitize_field(
-    `\u53CD\u8A3C: ${baseline.command} \u306F before/after \u3068\u3082 ${normalize(baseline.value)}\uFF08\u5909\u5316\u306A\u3057\uFF09`
-  );
-  return [
-    `${LEDGER_KEY_PREFIX}${slug_of(baseline.command)}`,
-    LEDGER_DEPTH,
-    date,
-    REMEASURE_COMMAND,
-    what
-  ].join(FIELD_SEPARATOR);
-}
-var baseline_measure = {
-  parse_baselines,
-  has_command_value,
-  is_no_change,
-  format_pair,
-  ledger_line,
-  slug_of
-};
-
-export {
-  baseline_measure
-};

package/dist/commands/chunk-BPDNGJXY.js

@@ -1,63 +0,0 @@
-import {
-  backlog_budget
-} from "./chunk-BYSPYVLD.js";
-import {
-  stamp_record
-} from "./chunk-F5N2QIFD.js";
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/park/run-park.ts
-import { z } from "zod";
-var PARK_PREFIX = "josh-run-park-";
-var PARK_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
-var run_park_schema = z.object({
-  issue: z.string(),
-  parked_at: z.string()
-});
-function parse_park(raw) {
-  return json_value.parse_with(raw, run_park_schema);
-}
-function parked_at_of(park) {
-  return park.parked_at;
-}
-var PARK_SPEC = {
-  parse: parse_park,
-  timestamp_of: parked_at_of,
-  max_age_ms: PARK_MAX_AGE_MS
-};
-function park_path(repository, issue) {
-  return stamp_file.stamp_path(`${PARK_PREFIX}${issue}-`, repository);
-}
-function record(issue, directory, now = /* @__PURE__ */ new Date()) {
-  const repository = git_common_directory.repository(directory);
-  if (repository === void 0) return false;
-  stamp_file.replace_stamp(park_path(repository, issue), { issue, parked_at: now.toISOString() });
-  return true;
-}
-function clear(issue, directory) {
-  const repository = git_common_directory.repository(directory);
-  if (repository !== void 0) stamp_file.remove_stamp(park_path(repository, issue));
-}
-function is_parked_sync(issue, directory, now = /* @__PURE__ */ new Date()) {
-  const repository = git_common_directory.repository(directory);
-  if (repository === void 0) return false;
-  const read = stamp_record.classify(
-    stamp_file.read_stamp_text(park_path(repository, issue)),
-    PARK_SPEC,
-    now
-  );
-  return read.kind === "carried" && read.record.issue === issue;
-}
-var run_park = { PARK_MAX_AGE_MS, clear, is_parked_sync, record };
-
-export {
-  run_park
-};

package/dist/commands/chunk-BQLKWGGC.js

@@ -1,118 +0,0 @@
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec
-} from "./chunk-43DU7DYZ.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
-};