@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-LZ5QXE5N.js

@@ -1,244 +0,0 @@
-import {
-  epic_add_body,
-  epic_chains,
-  epic_read,
-  epic_shape
-} from "./chunk-XPBF5DG3.js";
-import {
-  epic_decision
-} from "./chunk-XSKB6ZUA.js";
-import {
-  epic_relations
-} from "./chunk-FQGWO2ZH.js";
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  chain_links,
-  epic_parse
-} from "./chunk-VDGNXSP3.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  format_dependency_link,
-  format_dependency_links
-} from "./chunk-2ADQ5XRD.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  issue_read
-} from "./chunk-2BB5ZR2F.js";
-import {
-  NEEDS_DECISION_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/epic/epic-decide.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-function format_list(numbers) {
-  return numbers.map((issue_number) => session_cite.issue(issue_number)).join(", ");
-}
-function untracked_error(epic_number, untracked) {
-  return `${format_list(untracked)} not tracked by ${session_cite.issue(epic_number)}; place it with \`pnpm josh epic --add ${String(epic_number)} <N> --decision-file <path>\`. Nothing was written.`;
-}
-function size_error(input) {
-  if (input.children.length === 1 || size_estimate.stated_line(input.decision) === void 0) {
-    return void 0;
-  }
-  return `The record states a size estimate but names ${format_list(input.children)}; an estimate is one child's, so record it with \`--decide\` for that child alone. Nothing was written.`;
-}
-async function read_decision_target(input) {
-  const record_error = epic_decision.find_decision_error(input.decision) ?? size_error(input);
-  if (record_error !== void 0) return { error: record_error };
-  const subject = await epic_read.read_subject(input.epic_number);
-  if (subject === void 0) {
-    return { error: `Could not read issue ${session_cite.issue(input.epic_number)}.` };
-  }
-  const tracked = epic_parse.parse_task_list_issue_numbers(subject.body);
-  const untracked = input.children.filter((child) => !tracked.includes(child));
-  return untracked.length === 0 ? subject : { error: untracked_error(input.epic_number, untracked) };
-}
-async function record_on_epic(subject, decision) {
-  const epic = session_cite.issue(subject.number);
-  if (epic_decision.has_decision(subject.body, decision)) {
-    return `\u{1F4DD} ${epic} already records this decision.`;
-  }
-  const body = epic_decision.append_decision(subject.body ?? "", decision);
-  await git_gh_command.issue_edit_body(String(subject.number), body);
-  return `\u{1F4DD} Decision recorded in ${epic}'s \`## Decisions\`.`;
-}
-async function has_comment(child, decision) {
-  const comments = await issue_read.parse_comments(
-    await git_gh_command.issue_list_comments(String(child))
-  );
-  return comments?.some((comment) => comment.body.trim() === decision.trim());
-}
-async function try_edit_body(child, body) {
-  try {
-    await git_gh_command.issue_edit_body(String(child), body);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function restate_size(child, decision) {
-  const line = size_estimate.stated_line(decision);
-  if (line === void 0) return true;
-  const subject = await epic_read.read_subject(child);
-  if (subject === void 0) return false;
-  const body = subject.body ?? "";
-  const restated = size_estimate.restated(body, line);
-  return restated === body || await try_edit_body(child, restated);
-}
-async function record_on_child(child, decision) {
-  const has_record = await has_comment(child, decision);
-  if (has_record === void 0) return false;
-  const is_commented = has_record || await git_gh_command.issue_try_comment(String(child), decision);
-  if (!is_commented || !await restate_size(child, decision)) return false;
-  return await git_gh_command.issue_clear_label(String(child), NEEDS_DECISION_LABEL);
-}
-function format_child_report(total, failures) {
-  if (failures === 0) return epic_decision.format_decision_report({ total, failures });
-  return `\u26A0\uFE0F  ${String(failures)} of ${String(total)} child issue(s) could not be given the comment or lose \`${NEEDS_DECISION_LABEL}\`; rerun the same command \u2014 nothing is written twice.`;
-}
-async function decide(input) {
-  const epic = await read_decision_target(input);
-  if ("error" in epic) {
-    console.error(`\u2716 ${epic.error}`);
-    return FAILURE_EXIT_CODE;
-  }
-  console.info(await record_on_epic(epic, input.decision));
-  const recorded = await Promise.all(
-    input.children.map(async (child) => await record_on_child(child, input.decision))
-  );
-  const failures = recorded.filter((is_recorded) => !is_recorded).length;
-  console.info(format_child_report(input.children.length, failures));
-  return failures === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
-}
-var epic_decide = {
-  decide
-};
-
-// scripts/epic/epic-remove-plan.ts
-var MINIMUM_PATH_LENGTH = 2;
-function to_path_links(path) {
-  return chain_links(path);
-}
-function find_path_error(path) {
-  if (path.length < MINIMUM_PATH_LENGTH) {
-    return "Two issue numbers are required after the epic: the order to remove is `<M> <N>`, and a longer list removes each consecutive pair.";
-  }
-  return to_path_links(path).length === path.length - 1 ? void 0 : "The path names the same issue twice in a row, which declares no order.";
-}
-function find_undeclared_error(links, chains) {
-  const declared = new Set(epic_chains.links_of(chains).map((link) => format_dependency_link(link)));
-  const missing = links.filter((link) => !declared.has(format_dependency_link(link)));
-  return missing.length === 0 ? void 0 : `The declared dependency order does not name ${format_dependency_links(missing)}; there is nothing to remove.`;
-}
-function find_decision_error(decision) {
-  return decision === void 0 ? void 0 : epic_decision.find_decision_error(decision);
-}
-function find_input_error(input, tracked, chains) {
-  return epic_shape.find_subject_error(input, tracked) ?? find_path_error(input.path) ?? find_undeclared_error(to_path_links(input.path), chains) ?? find_decision_error(input.decision);
-}
-function to_ends(links) {
-  return [...new Set(links.flatMap((link) => [link.blocker, link.blocked]))];
-}
-function to_body(input, chains_after) {
-  return epic_add_body.rewrite_body({
-    body: input.body ?? "",
-    placed: [],
-    chains_after,
-    decision: input.decision,
-    does_clear_declaration: true
-  });
-}
-function build_removal_plan(input) {
-  const tracked = epic_parse.parse_task_list_issue_numbers(input.body);
-  const chains_before = epic_parse.parse_dependency_chains(input.body);
-  const error = find_input_error(input, tracked, chains_before);
-  if (error !== void 0) return { error };
-  const links = to_path_links(input.path);
-  const chains_after = epic_chains.remove_links(chains_before, links);
-  const rewritten = to_body(input, chains_after);
-  if ("error" in rewritten) return { error: rewritten.error };
-  return {
-    plan: {
-      body: rewritten.body,
-      links,
-      // Only the links a relation actually backs: asking `gh` to remove one that was never
-      // recorded is reported as a failure the user cannot act on.
-      removed: epic_graph.recorded_relations(links, input.recorded, input.repo),
-      ends: to_ends(links)
-    }
-  };
-}
-var epic_remove_plan = {
-  build_removal_plan
-};
-
-// scripts/epic/epic-remove.ts
-var FAILURE_EXIT_CODE2 = 1;
-var SUCCESS_EXIT_CODE2 = 0;
-async function comment_decision(ends, decision) {
-  const posted = await Promise.all(
-    ends.map(async (end) => await git_gh_command.issue_try_comment(String(end), decision))
-  );
-  console.info(
-    epic_decision.format_decision_report({
-      total: ends.length,
-      failures: posted.filter((is_posted) => !is_posted).length
-    })
-  );
-}
-function report_relations(plan, failures) {
-  if (plan.removed.length === 0) return;
-  console.info(
-    epic_relations.format_relation_report({ links: plan.removed, failures, action: "drop" })
-  );
-}
-async function write_plan(epic_number, plan, decision) {
-  await git_gh_command.issue_edit_body(String(epic_number), plan.body);
-  console.info(
-    session_cite.text(
-      `\u{1F4CB} Removed ${format_dependency_links(plan.links)} from epic ${session_cite.issue(epic_number)}.`
-    )
-  );
-  report_relations(plan, await epic_relations.apply_relations(plan.removed, "drop"));
-  if (decision !== void 0) await comment_decision(plan.ends, decision);
-}
-async function remove_order(input) {
-  const epic = await epic_read.read_epic(input.epic_number);
-  if ("error" in epic) {
-    console.error(`\u2716 ${epic.error}`);
-    return FAILURE_EXIT_CODE2;
-  }
-  const outcome = epic_remove_plan.build_removal_plan({
-    epic_number: input.epic_number,
-    body: epic.subject.body,
-    labels: epic.subject.labels,
-    path: input.path,
-    recorded: epic.recorded,
-    repo: epic.repo,
-    decision: input.decision
-  });
-  if ("error" in outcome) {
-    console.error(`\u2716 ${outcome.error}`);
-    return FAILURE_EXIT_CODE2;
-  }
-  await write_plan(input.epic_number, outcome.plan, input.decision);
-  return SUCCESS_EXIT_CODE2;
-}
-var epic_remove = {
-  remove_order
-};
-
-export {
-  epic_decide,
-  epic_remove
-};

package/dist/commands/chunk-M4UV3BEV.js

@@ -1,313 +0,0 @@
-import {
-  backlog_hold_codes
-} from "./chunk-ZAAHZY2A.js";
-import {
-  backlog_next_shared
-} from "./chunk-ELY76WAR.js";
-import {
-  backlog_wait_cause
-} from "./chunk-KCFOP5RI.js";
-import {
-  lane_room
-} from "./chunk-TYNH2R66.js";
-import {
-  lane_capacity
-} from "./chunk-EFDVE5P5.js";
-import {
-  epic_triage
-} from "./chunk-VQRT32JB.js";
-import {
-  backlog_drive_restore,
-  backlog_offer_exclude
-} from "./chunk-TFLHYC2F.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  run_headless
-} from "./chunk-7C7FOKJK.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  run_event_scope,
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  run_invocation
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/backlog/backlog-hold-text.ts
-var {
-  DRIVERLESS_PREFIX,
-  HAND_BACK_PREFIX,
-  MEMORY_REASON,
-  OFFER_PREFIX,
-  REASON_SEPARATOR,
-  USAGE_LIMIT_REASON
-} = backlog_hold_codes;
-var NOT_FOUND = -1;
-var AWAIT_TRIAGE = "open issues await your triage";
-var HAND_BACK_TEXT = /* @__PURE__ */ new Map([
-  ["judge", AWAIT_TRIAGE],
-  ["triage", "a parked issue awaits your triage"],
-  ["merge", "the driver paused after a merge; the session restarts it"],
-  ["launch", "a lane launch failed; the session restarts the driver"],
-  ["offer", "the backlog offer failed; the session restarts the driver"],
-  ["window", "the run's time window closed; the session restarts the driver"]
-]);
-var OFFER_TEXT = /* @__PURE__ */ new Map([
-  ["solo", "a run:solo issue must finish first"],
-  ["blocked", "every queued issue is blocked"],
-  ["exhausted", "the backlog has nothing left to start"],
-  ["untriaged", AWAIT_TRIAGE],
-  ["parked", "parked issues await your decision"],
-  ["unreadable", "the backlog could not be read"]
-]);
-var CAUSE_TEXT = {
-  chain: "other issues",
-  gate: "a start condition",
-  lane: "a running lane"
-};
-var CAUSE_JOINER = " or ";
-var MEMORY_TEXT = "memory pressure is high; lanes resume when it eases";
-var USAGE_LIMIT_TEXT = "the usage limit is reached; lanes resume when it resets";
-var DRIVERLESS_TEXT = "no driver is running";
-function rest_after(code, prefix) {
-  const head = `${prefix}${REASON_SEPARATOR}`;
-  return code.startsWith(head) ? code.slice(head.length) : void 0;
-}
-function hand_back_text(reason) {
-  return HAND_BACK_TEXT.get(reason) ?? `the driver paused (${reason}); the session restarts it`;
-}
-function cause_text(detail) {
-  const causes = backlog_wait_cause.causes_of_tag(detail);
-  if (causes === void 0) return void 0;
-  return `queued issues wait on ${causes.map((cause) => CAUSE_TEXT[cause]).join(CAUSE_JOINER)}`;
-}
-function offer_text(rest) {
-  const index = rest.indexOf(REASON_SEPARATOR);
-  const detail = index === NOT_FOUND ? "" : rest.slice(index + REASON_SEPARATOR.length);
-  return OFFER_TEXT.get(detail) ?? cause_text(detail) ?? `the backlog is waiting (${rest})`;
-}
-function prefixed_text(code) {
-  const hand_back = rest_after(code, HAND_BACK_PREFIX);
-  if (hand_back !== void 0) return hand_back_text(hand_back);
-  const offer = rest_after(code, OFFER_PREFIX);
-  return offer === void 0 ? void 0 : offer_text(offer);
-}
-function whole_text(code) {
-  if (code === MEMORY_REASON) return MEMORY_TEXT;
-  return code === USAGE_LIMIT_REASON ? USAGE_LIMIT_TEXT : void 0;
-}
-function text_of(code) {
-  if (code.startsWith(DRIVERLESS_PREFIX)) {
-    return `${DRIVERLESS_TEXT}; ${text_of(code.slice(DRIVERLESS_PREFIX.length))}`;
-  }
-  return prefixed_text(code) ?? whole_text(code) ?? code;
-}
-var backlog_hold_text = { text_of };
-
-// scripts/backlog/backlog-stalled.ts
-var STALL_THRESHOLD_MINUTES = 10;
-var STALL_THRESHOLD_MS = STALL_THRESHOLD_MINUTES * MS_PER_MINUTE;
-var NONE = 0;
-var STALLED = "stalled";
-var OK = "ok";
-var UNREADABLE = "unreadable";
-function is_stalled(reading, threshold_ms) {
-  return reading.ready_count > NONE && reading.free_lanes > NONE && reading.waiting_ms > threshold_ms;
-}
-function assess(reading, threshold_ms) {
-  if (reading === void 0) return UNREADABLE;
-  if (is_stalled(reading, threshold_ms)) return STALLED;
-  return OK;
-}
-function dispatch_reference_iso(events) {
-  const last_launch = events.findLast(
-    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH
-  );
-  return last_launch?.at ?? events[0]?.at;
-}
-function dispatch_reference_ms(events) {
-  const iso = dispatch_reference_iso(events);
-  const at = iso === void 0 ? NaN : Date.parse(iso);
-  return Number.isNaN(at) ? void 0 : at;
-}
-function dispatch_age_ms(events, now_ms) {
-  const at = dispatch_reference_ms(events);
-  return at === void 0 ? void 0 : now_ms - at;
-}
-function open_offerable_ms(entries, reference_ms) {
-  const newest = entries.findLast(
-    (entry) => entry.kind === lane_ledger.KIND.OFFERABLE && Date.parse(entry.at) >= reference_ms
-  );
-  if (newest?.kind !== lane_ledger.KIND.OFFERABLE || !newest.is_offerable) return void 0;
-  return Date.parse(newest.at);
-}
-function open_hold(entries) {
-  const { HELD, RELEASED, DISPATCH } = lane_ledger.KIND;
-  const hold_kinds = /* @__PURE__ */ new Set([HELD, RELEASED, DISPATCH]);
-  const newest = entries.findLast((entry) => hold_kinds.has(entry.kind));
-  return newest?.kind === lane_ledger.KIND.HELD ? newest.reason : void 0;
-}
-function describe(reading) {
-  const minutes = Math.floor(reading.waiting_ms / MS_PER_MINUTE);
-  const held = reading.hold === void 0 ? "" : ` (${backlog_hold_text.text_of(reading.hold)})`;
-  return `${String(reading.ready_count)} ready, ${String(reading.free_lanes)} free lane(s), ${String(minutes)}m waiting with both${held}`;
-}
-function ready_tokens(out) {
-  return out.split("\n").map((token) => token.trim()).filter((token) => issue_number_shape.is_issue_number(token));
-}
-function count_ready_tokens(out) {
-  return ready_tokens(out).length;
-}
-function needs_triage(out) {
-  return out.split("\n").some((token) => token.trim() === epic_triage.TRIAGE_VERDICT);
-}
-var backlog_stalled = {
-  STALLED,
-  OK,
-  UNREADABLE,
-  STALL_THRESHOLD_MS,
-  assess,
-  count_ready_tokens,
-  describe,
-  dispatch_age_ms,
-  needs_triage,
-  open_hold,
-  open_offerable_ms,
-  ready_tokens
-};
-
-// scripts/backlog/backlog-ready.ts
-var NO_FREE = 0;
-var NONE2 = 0;
-var lane_room2 = lane_room.read;
-async function lane_use(lanes) {
-  const room = await lane_room2(lanes);
-  return room.use;
-}
-function free_of(limit, use) {
-  return lane_capacity.free_lanes(limit, use.occupied, use.seated);
-}
-async function count_in(room) {
-  const limit = await lane_capacity.lane_limit();
-  if (limit.kind !== "limit") return void 0;
-  return { limit: limit.limit, free: free_of(limit.limit, room.use) };
-}
-async function free_lanes_beside(lanes) {
-  const count = await count_in(await lane_room2(lanes));
-  return count?.free;
-}
-async function free_under(limit) {
-  return free_of(limit, await lane_use());
-}
-async function free_lane_count() {
-  return await free_lanes_beside(await lane_registry.list_lanes()) ?? NO_FREE;
-}
-async function drive_limit() {
-  const limit = await lane_capacity.lane_limit();
-  if (limit.kind !== "limit") throw new Error(limit.problem);
-  return limit.limit;
-}
-async function drive_free_lane_count() {
-  return await free_under(await drive_limit());
-}
-async function drive_limit_room() {
-  const limit = await drive_limit();
-  const use = await lane_use();
-  return lane_capacity.limit_room(limit, use.occupied);
-}
-function drains_pool(carry) {
-  return carry === void 0 || !run_invocation.has_only(carry.invocation);
-}
-async function stream_exclude(carry) {
-  const target = await run_event_stream_emit.stream_target();
-  if (target === void 0 || carry === void 0) return [];
-  const scope = run_event_scope.scope_of({ kind: "carried", carry });
-  const events = run_event_scope.scoped_events(run_event_stream.read_events(target), scope) ?? [];
-  return backlog_drive_restore.offer_exclude(events);
-}
-async function read_backlog_next(timeout_ms) {
-  const carry = await run_headless.current_carry();
-  if (!drains_pool(carry)) return void 0;
-  const argv = ["backlog:next", ...backlog_offer_exclude.exclude_argv(await stream_exclude(carry))];
-  return await backlog_next_shared.read(argv, timeout_ms === void 0, timeout_ms);
-}
-async function ready_issues() {
-  const result = await read_backlog_next();
-  return result === void 0 ? [] : backlog_stalled.ready_tokens(result.out);
-}
-var DEFAULT_PORTS = { free_lane_count, ready_issues };
-async function read_ready(ports = DEFAULT_PORTS) {
-  const free_lanes = await ports.free_lane_count();
-  if (free_lanes <= NO_FREE) return { issues: [], free_lanes };
-  return { issues: await ports.ready_issues(), free_lanes };
-}
-function ready_line(reading, slug) {
-  if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
-  const cite = issue_cite.citer(slug, /* @__PURE__ */ new Map());
-  const issues = reading.issues.map((issue) => cite(issue)).join(" ");
-  return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
-}
-async function parent_ready_line(ports, is_parent, read_repo) {
-  if (!await is_parent()) return void 0;
-  const reading = await read_ready(ports);
-  return reading.issues.length === NONE2 ? void 0 : ready_line(reading, await read_repo());
-}
-function print_line(line) {
-  if (line !== void 0) console.info(line);
-}
-async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent, read_repo = git_gh_command.repo_get_name_with_owner) {
-  try {
-    print_line(await parent_ready_line(ports, is_parent, read_repo));
-  } catch {
-  }
-}
-var OFFER_HINT = "\u21BB backlogrun parent: a child just entered an epic \u2014 run `pnpm josh backlog:offer` next, so a runnable filing is dispatched now rather than on the next wake.";
-async function print_offer_hint(is_parent = run_headless.is_backlog_parent) {
-  try {
-    if (await is_parent()) console.info(OFFER_HINT);
-  } catch {
-  }
-}
-var backlog_ready = {
-  DEFAULT_PORTS,
-  OFFER_HINT,
-  read_backlog_next,
-  print_offer_hint,
-  free_lane_count,
-  free_lanes_beside,
-  count_in,
-  lane_room: lane_room2,
-  lane_use,
-  drive_free_lane_count,
-  drive_limit_room,
-  drains_pool,
-  print_ready_line,
-  read_ready,
-  ready_issues,
-  ready_line
-};
-
-export {
-  backlog_hold_text,
-  backlog_stalled,
-  backlog_ready
-};

package/dist/commands/chunk-M6JDU5EK.js

@@ -1,133 +0,0 @@
-import {
-  measure_declaration
-} from "./chunk-34JJYCIY.js";
-import {
-  baseline_measure
-} from "./chunk-BMM4RHCG.js";
-import {
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  git_gh_exec,
-  parse_json_object_or_undefined
-} from "./chunk-XDF25GSU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/issue/trusted-measure.ts
-import { execSync } from "node:child_process";
-
-// scripts/issue/trusted-measure-source.ts
-import { z } from "zod";
-var QUERY = "query($id: ID!) { node(id: $id) { ... on Issue { body authorAssociation author { login } editor { login } lastEditedAt } } }";
-var actor_schema = z.object({ login: z.string().min(1) });
-var source_schema = z.object({
-  body: z.string(),
-  authorAssociation: z.string(),
-  author: actor_schema.nullable(),
-  editor: actor_schema.nullable(),
-  lastEditedAt: z.string().nullable()
-});
-var response_schema = z.object({ data: z.object({ node: source_schema }) });
-var node_schema = z.object({ node_id: z.string().min(1) });
-async function read(issue) {
-  try {
-    const rest = await git_gh_issue_read.issue_view_json(issue, "node_id");
-    const node = parse_json_object_or_undefined(rest ?? "", node_schema);
-    if (node === void 0) return void 0;
-    const json = await git_gh_exec.exec_gh_api({
-      path: "graphql",
-      body: JSON.stringify({ query: QUERY, variables: { id: node.node_id } })
-    });
-    return parse_json_object_or_undefined(json, response_schema)?.data.node;
-  } catch {
-    return void 0;
-  }
-}
-var trusted_measure_source = { read };
-
-// scripts/issue/trusted-measure.ts
-var MEASURE_TIMEOUT_MS = 6e4;
-function declared_commands(body) {
-  const baselines = baseline_measure.parse_baselines(body).map((baseline) => baseline.command);
-  const declaration = measure_declaration.parse(body);
-  const premises = measure_declaration.premises(body).map((premise) => premise.command);
-  const declared = declaration === void 0 ? [] : [declaration.command];
-  return [...baselines, ...declared, ...premises];
-}
-function audit(command, source) {
-  console.error(
-    JSON.stringify({
-      event: "trusted-measure",
-      issue: source.issue,
-      author: source.author,
-      editor: source.editor,
-      command
-    })
-  );
-}
-function run_command(command, source) {
-  if (!declared_commands(source.body).includes(command)) {
-    return { kind: "failed", message: "command is not declared in the verified issue body" };
-  }
-  audit(command, source);
-  try {
-    return {
-      kind: "ok",
-      output: execSync(command, { encoding: "utf8", timeout: MEASURE_TIMEOUT_MS }).trim()
-    };
-  } catch (error) {
-    return { kind: "failed", message: error_text.message_of(error) };
-  }
-}
-function text_of(run) {
-  return run.kind === "ok" ? run.output : `(command failed: ${run.message})`;
-}
-function is_unedited(source) {
-  return source.lastEditedAt === null && source.editor === null;
-}
-async function trusted_editor(source) {
-  if (is_unedited(source)) return source.author?.login;
-  const login = source.editor?.login;
-  const is_trusted = await gh_author_association.is_trusted({ login, association: "COLLABORATOR" });
-  return is_trusted ? login : void 0;
-}
-async function trusted_author(issue) {
-  const login = issue.author?.login;
-  if (login === void 0) return void 0;
-  const is_trusted = await gh_author_association.is_trusted({
-    login,
-    association: issue.authorAssociation
-  });
-  return is_trusted ? login : void 0;
-}
-async function read_trusted_body(issue_number) {
-  const issue = await trusted_measure_source.read(issue_number);
-  if (issue === void 0) {
-    return { kind: "refused", reason: `could not read issue ${session_cite.issue(issue_number)}` };
-  }
-  const author = await trusted_author(issue);
-  if (author === void 0) {
-    return {
-      kind: "refused",
-      reason: `refusing ${session_cite.issue(issue_number)}: untrusted author (${issue.authorAssociation})`
-    };
-  }
-  const editor = await trusted_editor(issue);
-  return editor === void 0 ? {
-    kind: "refused",
-    reason: `refusing ${session_cite.issue(issue_number)}: untrusted or unknown last editor`
-  } : { kind: "trusted", body: issue.body, issue: issue_number, author, editor };
-}
-var trusted_measure = { read_trusted_body, run_command, text_of };
-
-export {
-  trusted_measure
-};