@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-JGX7JIW4.js

@@ -0,0 +1,126 @@
+import {
+  review_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+
+// scripts/review/review-round-one-blobs.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var ABSENT = review_tree.ABSENT_DIGEST;
+var SUCCESS_EXIT_CODE = 0;
+var NUL = "\0";
+var NEWLINE = "\n";
+var TAB = "	";
+var SPACE = " ";
+var OID_FIELD = 2;
+var WRITE_FLAGS = ["-w"];
+var READ_FLAGS = [];
+function repository_root() {
+  return git_spawn_sync.read(["rev-parse", "--show-toplevel"]);
+}
+function hash_paths(root, paths, flags) {
+  const present = paths.filter((relative) => existsSync(path.join(root, relative)));
+  const output = present.length === 0 ? "" : git_spawn_sync.read(["hash-object", ...flags, "--", ...present], { cwd: root });
+  if (output === void 0) return void 0;
+  const hashes = output.split(NEWLINE);
+  const hashed = new Map(present.map((relative, index) => [relative, hashes[index] ?? ABSENT]));
+  return Object.fromEntries(paths.map((relative) => [relative, hashed.get(relative) ?? ABSENT]));
+}
+function parse_entry(entry) {
+  const tab = entry.indexOf(TAB);
+  return [entry.slice(tab + 1), entry.slice(0, tab).split(SPACE)[OID_FIELD] ?? ABSENT];
+}
+function blobs_at(commit, paths, root) {
+  const result = git_spawn_sync.run(["ls-tree", "-r", "-z", commit, "--", ...paths], { cwd: root });
+  if (result.exit_code !== SUCCESS_EXIT_CODE) return void 0;
+  return Object.fromEntries(
+    result.stdout.split(NUL).filter((entry) => entry !== "").map((entry) => parse_entry(entry))
+  );
+}
+function merged_blob({ base, round_one, moved }, root) {
+  if ([base, round_one, moved].includes(ABSENT)) return void 0;
+  return git_spawn_sync.read(["merge-file", "--object-id", round_one, base, moved], { cwd: root });
+}
+function carried_blob(sides, root) {
+  if (sides.round_one === sides.base) return sides.moved;
+  if (sides.moved === sides.base || sides.moved === sides.round_one) return sides.round_one;
+  return merged_blob(sides, root);
+}
+function sides_of(relative, readings) {
+  const base = readings.before[relative] ?? ABSENT;
+  return {
+    base,
+    round_one: readings.blobs[relative] ?? base,
+    moved: readings.after[relative] ?? ABSENT
+  };
+}
+function carried_answer(relative, readings, root) {
+  const carried = carried_blob(sides_of(relative, readings), root);
+  return carried === void 0 ? void 0 : carried === readings.now[relative];
+}
+function differing(paths, readings, root) {
+  const answers = paths.map((relative) => carried_answer(relative, readings, root));
+  if (answers.includes(void 0)) return void 0;
+  return paths.filter((_relative, index) => answers[index] === false);
+}
+function read_readings(input, paths, root) {
+  const before = blobs_at(input.from, paths, root);
+  const after = blobs_at(input.to, paths, root);
+  const now = hash_paths(root, paths, READ_FLAGS);
+  if (before === void 0 || after === void 0 || now === void 0) return void 0;
+  return { blobs: input.blobs, before, after, now };
+}
+function delta_of(input, root) {
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(input.blobs), ...input.paths])].toSorted(
+    (left, right) => left.localeCompare(right)
+  );
+  const readings = paths.length === 0 ? void 0 : read_readings(input, paths, root);
+  if (paths.length === 0) return [];
+  return readings === void 0 ? void 0 : differing(paths, readings, root);
+}
+function carry_of({ blobs, from, to, paths }) {
+  if (blobs === void 0 || from === void 0 || to === void 0) return void 0;
+  return { blobs, from, to, paths };
+}
+function carried_delta(input) {
+  const carry = carry_of(input);
+  const root = repository_root();
+  return carry === void 0 || root === void 0 ? void 0 : delta_of(carry, root);
+}
+function answers_of(carry, root) {
+  const { paths } = carry;
+  const readings = paths.length === 0 ? void 0 : read_readings(carry, paths, root);
+  if (paths.length === 0) return {};
+  if (readings === void 0) return void 0;
+  return Object.fromEntries(
+    paths.map((relative) => [relative, carried_answer(relative, readings, root)])
+  );
+}
+function carried_each(input) {
+  const carry = carry_of(input);
+  const root = repository_root();
+  return carry === void 0 || root === void 0 ? void 0 : answers_of(carry, root);
+}
+function unmoved_between(from, to, paths, root) {
+  if (from === to || paths.length === 0) return paths;
+  const before = blobs_at(from, paths, root);
+  const after = blobs_at(to, paths, root);
+  if (before === void 0 || after === void 0) return void 0;
+  return paths.filter((relative) => (before[relative] ?? ABSENT) === (after[relative] ?? ABSENT));
+}
+function unmoved({ from, to, paths }) {
+  const root = repository_root();
+  if (root === void 0 || from === void 0 || to === void 0) return void 0;
+  return unmoved_between(from, to, paths, root);
+}
+function capture(paths) {
+  const root = repository_root();
+  return root === void 0 ? void 0 : hash_paths(root, paths, WRITE_FLAGS);
+}
+var review_round_one_blobs = { capture, carried_delta, carried_each, unmoved };
+
+export {
+  review_round_one_blobs
+};

package/dist/commands/chunk-JHIGDFBS.js

@@ -0,0 +1,59 @@
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/lib/settled-together.ts
+async function settled_together(first, second) {
+  const [result, other] = await Promise.allSettled([first, second]);
+  if (result.status === "rejected") throw result.reason;
+  if (other.status === "rejected") throw other.reason;
+}
+
+// scripts/followup/git-followup-issue-close.ts
+import { z } from "zod";
+var CLOSE_WAIT = { attempts: 3, interval_ms: 2e3 };
+var CLOSE_RECOVERY = "gh api -X PATCH repos/{owner}/{repo}/issues/<N> -f state=closed";
+var state_read_schema = z.object({ state: z.string().optional() });
+async function is_issue_closed(issue_number) {
+  const raw = await git_gh_command.issue_get_state_and_relations(issue_number);
+  const parsed = raw === void 0 ? void 0 : parse_json_object_or_undefined(raw, state_read_schema);
+  return epic_parse.is_state_closed(parsed?.state);
+}
+var FOLLOWUP_CLOSER = "pnpm josh followup";
+function build_close_comment(pr_url, closer = FOLLOWUP_CLOSER) {
+  return `Closed by \`${closer}\`: ${pr_url ?? "the merged pull request"} merged, but GitHub did not apply its \`closes #N\` keyword (joshuafolkken/kit#2770).`;
+}
+async function ensure_issue_closed(input, wait = CLOSE_WAIT) {
+  const { issue_number } = input;
+  const is_done = issue_number === void 0 || await poll.poll_until(async () => await is_issue_closed(issue_number), wait);
+  if (is_done) return;
+  console.warn(
+    `\u26A0\uFE0F  Issue ${session_cite.issue(issue_number)} is still open after the merge \u2014 closing it.`
+  );
+  const comment = build_close_comment(input.pr_url, input.closer);
+  if (!await git_gh_command.issue_close(issue_number, comment)) {
+    throw new Error(`gh api could not close issue ${session_cite.issue(issue_number)}`);
+  }
+}
+var git_followup_issue_close = {
+  ensure_issue_closed,
+  build_close_comment,
+  CLOSE_RECOVERY
+};
+
+export {
+  settled_together,
+  git_followup_issue_close
+};

package/dist/commands/chunk-JI2EGXZX.js

@@ -0,0 +1,53 @@
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+
+// scripts/josh/path-decision.ts
+var STAGED_FLAG = "--staged";
+var JSON_FLAG = "--json";
+var KNOWN_FLAGS = [STAGED_FLAG, JSON_FLAG];
+var FAILURE_EXIT_CODE = 1;
+var MAX_LISTED_PATHS = 5;
+function has_unknown_flag(argv, known) {
+  return argv.some((argument) => !known.includes(argument));
+}
+function parse_options(argv) {
+  if (has_unknown_flag(argv, KNOWN_FLAGS)) return void 0;
+  return { is_staged: argv.includes(STAGED_FLAG), is_json: argv.includes(JSON_FLAG) };
+}
+function format_path_list(paths) {
+  const listed = paths.slice(0, MAX_LISTED_PATHS).join(", ");
+  if (paths.length <= MAX_LISTED_PATHS) return listed;
+  return `${listed}, +${String(paths.length - MAX_LISTED_PATHS)} more`;
+}
+function print_decision(key, answer, reason, is_json) {
+  if (is_json) {
+    console.info(JSON.stringify({ [key]: answer, reason }));
+    return;
+  }
+  console.info(answer);
+  console.error(reason);
+}
+async function run_path_decision(argv, command) {
+  const options = parse_options(argv);
+  if (options === void 0) {
+    console.error(command.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const paths = await changed_paths.read_changed_paths(options.is_staged);
+  const answer = await command.decide(paths, options.is_staged);
+  print_decision(command.key, answer, command.explain(paths, answer), options.is_json);
+  return 0;
+}
+var path_decision = {
+  format_path_list,
+  has_unknown_flag,
+  JSON_FLAG,
+  parse_options,
+  print_decision,
+  run_path_decision
+};
+
+export {
+  path_decision
+};

package/dist/commands/chunk-JNV3VRK2.js

@@ -0,0 +1,47 @@
+import {
+  figure_format
+} from "./chunk-7EAYFMDN.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/time-runtime/time-format.ts
+var SECOND_DECIMALS = 1;
+var LABEL_WIDTH = 24;
+var MINUTES_WIDTH = 9;
+var NOT_MEASURED = "not measured";
+var NO_CALLS = "no tool call to divide";
+var MAX_ROWS = 15;
+function overflow_line(row_count) {
+  if (row_count <= MAX_ROWS) return [];
+  return [
+    `  \u2026 and ${String(row_count - MAX_ROWS)} more (--json carries every row this report holds)`
+  ];
+}
+function format_seconds(duration_ms) {
+  return `${(duration_ms / MS_PER_SECOND).toFixed(SECOND_DECIMALS)} s`;
+}
+function format_columns(label, minutes, suffix) {
+  return `  ${label.padEnd(LABEL_WIDTH)}${minutes.padStart(MINUTES_WIDTH)}   ${suffix}`;
+}
+function format_row(label, duration_ms, suffix) {
+  return format_columns(label, figure_format.format_minutes(duration_ms), suffix);
+}
+function unmeasured_row(label) {
+  return format_columns(label, "", NOT_MEASURED);
+}
+var time_format = {
+  MAX_ROWS,
+  NO_CALLS,
+  overflow_line,
+  format_seconds,
+  format_columns,
+  format_row,
+  // `format_clock` stays private: `format_window` is its only caller, and a namespace that offers
+  // both invites a second renderer to join the two with its own arrow.
+  unmeasured_row
+};
+
+export {
+  time_format
+};

package/dist/commands/chunk-JPMAW2VZ.js

@@ -0,0 +1,91 @@
+import {
+  durable_state_root
+} from "./chunk-5VQCL33M.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  GIT_LOCATION_VARIABLES,
+  git_location_environment
+} from "./chunk-B77ZMVHS.js";
+import {
+  git_utilities
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/git/git-common-directory.ts
+import { execFileSync } from "node:child_process";
+var { STATE_DIRECTORY } = durable_state_root;
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS = 5e3;
+var answers = /* @__PURE__ */ new Map();
+function probe_environment(cwd) {
+  if (cwd === void 0) return process.env;
+  return { ...process.env, ...git_location_environment.location_free_environment() };
+}
+function cache_key(cwd) {
+  if (cwd !== void 0) return `explicit\0${cwd}`;
+  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
+  return ["inherited", process.cwd(), ...locations].join("\0");
+}
+function read_directories(cwd) {
+  try {
+    const output = execFileSync(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      {
+        cwd,
+        env: probe_environment(cwd),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: PROBE_TIMEOUT_MS
+      }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function directories(cwd) {
+  const key = cache_key(cwd);
+  const known = answers.get(key);
+  if (known !== void 0) return known;
+  const read = read_directories(cwd);
+  if (read.length > 0) answers.set(key, read);
+  return read;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+async function read_repository() {
+  try {
+    const found = await git_command.git_directories();
+    return found[COMMON_GIT_DIRECTORY];
+  } catch {
+    return void 0;
+  }
+}
+function select_linked(found) {
+  const own_directory = found[OWN_GIT_DIRECTORY];
+  const common = found[COMMON_GIT_DIRECTORY];
+  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
+}
+function resolve(cwd) {
+  return select_linked(directories(cwd));
+}
+var git_common_directory = {
+  STATE_DIRECTORY,
+  directories,
+  own,
+  read_repository,
+  repository,
+  resolve,
+  select_linked
+};
+
+export {
+  git_common_directory
+};

package/dist/commands/chunk-JQEY6KDP.js

@@ -0,0 +1,90 @@
+import {
+  lane_sinks
+} from "./chunk-LIPUSINQ.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/lane/lane-stats-request.ts
+var STATS_OPTIONS = {
+  period: { type: "string" },
+  since: { type: "string" },
+  limit: { type: "string" },
+  sinks: { type: "boolean" },
+  over: { type: "string" },
+  why: { type: "string" },
+  pairs: { type: "boolean" }
+};
+function positive(text) {
+  const value = Number(text);
+  return text !== void 0 && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function since_of(text = "") {
+  const since_ms = Date.parse(text);
+  return Number.isNaN(since_ms) ? void 0 : since_ms;
+}
+function since_start(text) {
+  const since_ms = since_of(text);
+  return since_ms === void 0 ? void 0 : { since_ms };
+}
+function start_of(values) {
+  if (values.since !== void 0) {
+    return values.period === void 0 ? since_start(values.since) : void 0;
+  }
+  const period_days = positive(values.period);
+  return period_days === void 0 ? void 0 : { period_days };
+}
+function sink_threshold(limit, positionals) {
+  const [given, ...more] = positionals;
+  if (limit !== void 0) return void 0;
+  if (given === void 0) return lane_sinks.DEFAULT_MINUTES;
+  return more.length === 0 ? positive(given) : void 0;
+}
+function sink_choice(values, positionals) {
+  if (values.sinks === true) {
+    const minutes = sink_threshold(values.limit, positionals);
+    return minutes === void 0 ? void 0 : { minutes };
+  }
+  return positionals.length === 0 ? { minutes: void 0 } : void 0;
+}
+function threshold_choice(text) {
+  if (text === void 0) return { minutes: void 0 };
+  const minutes = positive(text);
+  return minutes === void 0 ? void 0 : { minutes };
+}
+function is_one_table(values) {
+  const selected = [
+    values.sinks === true,
+    values.over !== void 0,
+    values.why !== void 0,
+    values.pairs === true
+  ].filter(Boolean).length;
+  return selected <= 1 && (selected === 0 || values.limit === void 0);
+}
+function table_flags(values, positionals) {
+  const choice = sink_choice(values, positionals);
+  const over = threshold_choice(values.over);
+  const why = threshold_choice(values.why);
+  if (choice === void 0 || over === void 0 || why === void 0 || !is_one_table(values)) {
+    return void 0;
+  }
+  return {
+    sinks: choice.minutes,
+    over: over.minutes,
+    why: why.minutes,
+    is_pairs: values.pairs === true
+  };
+}
+function stats_request(rest) {
+  const parsed = cli_flags.arguments_of(rest, STATS_OPTIONS);
+  if (parsed === void 0) return void 0;
+  const start = start_of(parsed.values);
+  const table = table_flags(parsed.values, parsed.positionals);
+  if (start === void 0 || table === void 0) return void 0;
+  return { start, limit: parsed.values.limit, ...table };
+}
+var lane_stats_request = { positive, since_of, stats_request };
+
+export {
+  lane_stats_request
+};

package/dist/commands/chunk-JSJDIEGZ.js

@@ -0,0 +1,88 @@
+import {
+  run_step
+} from "./chunk-F4YMLVWN.js";
+
+// scripts/run/run-step-section-table.ts
+var ENTRY = "entry";
+function reference(document, heading) {
+  return { document, heading };
+}
+var CHAIN_RULE = "chain-rule.md";
+var CHAIN = reference(CHAIN_RULE, "Run the review-to-merge chain");
+var PROGRESS = "backlogrun-progress.md";
+var SHIP = "ship";
+var REVIEW = "run:review";
+var PROGRESS_WATCHER = "run:progress";
+var PRE_GATE_CUT = "pre-gate-cut.md";
+var CUT = "run:cut take";
+var RESUME = "run:cut";
+var PARK = "run:park";
+var PAUSE = "run:pause";
+var PARK_AND_CONTINUE = reference("backlogrun-park.md", "park and continue");
+var STEPS = "backlogrun-steps.md";
+var LOOP = reference(STEPS, "The loop");
+var RESOLVE = reference(STEPS, "Resolve what the plan can resolve");
+var RETROSPECTIVE_KEY = "retrospective";
+var RETROSPECTIVE = reference("retrospective.md", "The end-of-run retrospective");
+var HUMAN_REVIEW = reference("needs-human-review.md", "`needs-human-review`");
+var EPIC_CHILDREN = reference(PROGRESS, "Running a named epic's children");
+var GOVERNING_SECTIONS = /* @__PURE__ */ new Map([
+  [ENTRY, reference("split-assessment.md", "The question")],
+  [run_step.IMPLEMENT, CHAIN],
+  [run_step.HUMAN_REVIEW, HUMAN_REVIEW],
+  [run_step.UPDATE_DEPS, reference("latest-gate.md", "The dependency update")],
+  ["followup", reference("followup.md", "Run `pnpm josh followup`")],
+  [PROGRESS_WATCHER, reference("progress-watcher.md", "Progress while the run is quiet")],
+  ["run:merge", EPIC_CHILDREN],
+  ["backlog:next", LOOP],
+  [CUT, reference(PRE_GATE_CUT, "Taking the cut")],
+  [RESUME, reference(PRE_GATE_CUT, "Resuming")],
+  [SHIP, CHAIN],
+  [REVIEW, CHAIN],
+  [RETROSPECTIVE_KEY, RETROSPECTIVE],
+  ["run:carry", reference(PROGRESS, "The hand-off")],
+  [PARK, PARK_AND_CONTINUE],
+  [PAUSE, reference("prerequisite.md", "Each entry's branch, and the pause")]
+]);
+var LANE_CHILD_STEP = reference(CHAIN_RULE, "A lane child");
+var LANE_CHILD_SECTIONS = /* @__PURE__ */ new Map([
+  [run_step.IMPLEMENT, LANE_CHILD_STEP],
+  [SHIP, LANE_CHILD_STEP],
+  [REVIEW, LANE_CHILD_STEP],
+  [PARK, reference(PRE_GATE_CUT, "A lane child records its park before it stops")]
+]);
+var DRIVER_SECTIONS = [
+  [RETROSPECTIVE_KEY, [RETROSPECTIVE]],
+  ["merge human-review", [HUMAN_REVIEW]],
+  ["triage", [LOOP, RESOLVE]],
+  ["judge", [LOOP, reference("docs/josh-commands-backlog.md", "`josh auto-ok:judge`")]],
+  // A refused launch is parked `run:stalled` by the driver (joshuafolkken/kit#6878): its section is the
+  // retry of a recovered mechanical failure, never "park and continue".
+  ["launch #", [LOOP, RESOLVE]],
+  ["merge", [LOOP, EPIC_CHILDREN]],
+  [
+    "epic #",
+    [
+      reference(STEPS, "Named issues run first, in order"),
+      reference(STEPS, "The session cut is inside the invocation")
+    ]
+  ],
+  ["watch", [LOOP, RETROSPECTIVE]]
+];
+var run_step_section_table = {
+  CUT,
+  DRIVER_SECTIONS,
+  ENTRY,
+  GOVERNING_SECTIONS,
+  LANE_CHILD_SECTIONS,
+  LOOP,
+  PARK,
+  PAUSE,
+  PROGRESS: PROGRESS_WATCHER,
+  RESUME,
+  RETROSPECTIVE: RETROSPECTIVE_KEY
+};
+
+export {
+  run_step_section_table
+};

package/dist/commands/chunk-JT5ICRFF.js

@@ -0,0 +1,44 @@
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+
+// scripts/run/run-investigation-record.ts
+import { readFile, rm } from "node:fs/promises";
+var RECORD_SUFFIX = ".md";
+var NO_GIT_DIRECTORY = "no git directory to hold the investigation record";
+function path_of(issue_number) {
+  const repository = git_common_directory.repository();
+  if (repository === void 0) throw new Error(NO_GIT_DIRECTORY);
+  return durable_state.path(
+    durable_state.PREFIX.INVESTIGATION,
+    repository,
+    `-${issue_number}${RECORD_SUFFIX}`
+  );
+}
+async function findings_at(record_path) {
+  try {
+    const text = await readFile(record_path, "utf8");
+    return text.trim() === "" ? void 0 : text.trim();
+  } catch {
+    return void 0;
+  }
+}
+async function load(issue_number) {
+  try {
+    const record_path = path_of(issue_number);
+    return { path: record_path, findings: await findings_at(record_path) };
+  } catch {
+    return void 0;
+  }
+}
+async function remove(issue_number) {
+  await rm(path_of(issue_number), { force: true });
+}
+var run_investigation_record = { load, remove };
+
+export {
+  run_investigation_record
+};

package/dist/commands/chunk-JUCJ4Y42.js

@@ -0,0 +1,77 @@
+import {
+  issue_priority
+} from "./chunk-XI2ABCRX.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  has_label_name,
+  label_name_of
+} from "./chunk-QQBMVC5W.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/issue/issue-priority-raise.ts
+import { z } from "zod";
+var read_schema = z.object({
+  labels: z.array(issue_label_schema).optional(),
+  body: z.string().nullish()
+});
+async function read_issue(issue_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(issue_number);
+  const parsed = raw === void 0 ? void 0 : parse_json_object_or_undefined(raw, read_schema);
+  if (parsed === void 0) return void 0;
+  return { labels: (parsed.labels ?? []).map((label) => label.name), body: parsed.body ?? "" };
+}
+function decision(labels) {
+  return issue_priority.is_typed(labels) ? "labelled" : "below";
+}
+var PRIORITY_LABELS = Object.values(issue_priority.LABELS).filter(
+  (label) => label !== void 0
+);
+function priority_labels_of(labels) {
+  return PRIORITY_LABELS.map((label) => label_name_of(labels, label)).filter(
+    (name) => name !== void 0
+  );
+}
+function is_only(labels, label) {
+  const present = priority_labels_of(labels);
+  if (label === void 0) return present.length === 0;
+  return present.length === 1 && has_label_name(present, label);
+}
+async function replace(issue_number, labels, label) {
+  const kept = label === void 0 ? void 0 : label_name_of(labels, label);
+  const is_added = label === void 0 || kept !== void 0 || await git_gh_command.issue_add_label(issue_number, label);
+  if (!is_added) return false;
+  const stale = priority_labels_of(labels).filter((name) => name !== kept);
+  const cleared = await Promise.all(
+    stale.map(async (name) => await git_gh_command.issue_clear_label(issue_number, name))
+  );
+  return cleared.every(Boolean);
+}
+async function settle(issue_number, labels) {
+  const [top] = priority_labels_of(labels);
+  if (top === void 0 || is_only(labels, top)) return decision(labels);
+  return await replace(issue_number, labels, top) ? "labelled" : "failed";
+}
+async function raise(issue_number) {
+  const read = await read_issue(issue_number);
+  if (read === void 0) return "unreadable";
+  const label = issue_priority.raise_label(read.labels, read.body);
+  if (label === void 0) return await settle(issue_number, read.labels);
+  const is_applied = await replace(issue_number, read.labels, label);
+  return is_applied ? "raised" : "failed";
+}
+var FAILURES = /* @__PURE__ */ new Set(["unreadable", "failed"]);
+function is_failure(result) {
+  return FAILURES.has(result);
+}
+var issue_priority_raise = { read_issue, is_only, replace, raise, is_failure };
+
+export {
+  issue_priority_raise
+};