@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-OHN3QARP.js

@@ -0,0 +1,769 @@
+import {
+  git_preflight
+} from "./chunk-UY62WJV6.js";
+import {
+  acceptance_map_check
+} from "./chunk-CDK7QZWG.js";
+import {
+  git_pr
+} from "./chunk-NABSSY4P.js";
+import {
+  run_ship_body_draft
+} from "./chunk-NVMV7BYX.js";
+import {
+  removed_tests_check
+} from "./chunk-WORHUJ6T.js";
+import {
+  live_evidence
+} from "./chunk-HALHQILI.js";
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  josh_command
+} from "./chunk-47J4KOZP.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  run_ship_planned
+} from "./chunk-PKXTISWR.js";
+import {
+  git_issue
+} from "./chunk-QTVVFV4Q.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  gate_ledger,
+  whole_tree_reuse
+} from "./chunk-6JD4VNO4.js";
+import {
+  check_reuse
+} from "./chunk-HSZECERZ.js";
+import {
+  test_related_synced
+} from "./chunk-JU2MAYQ3.js";
+import {
+  gate_skip
+} from "./chunk-F57LACNC.js";
+import {
+  related_scope
+} from "./chunk-KJPZPTS4.js";
+import {
+  whole_suite_files
+} from "./chunk-WEUUJIWQ.js";
+import {
+  report_format_reference
+} from "./chunk-Q6SKKQVJ.js";
+import {
+  run_ship_lap
+} from "./chunk-HRN73FQJ.js";
+import {
+  metrics_totals
+} from "./chunk-HEFUC4ZW.js";
+import {
+  scoped_green
+} from "./chunk-MHF6BDQI.js";
+import {
+  since_green
+} from "./chunk-6AHAY5VZ.js";
+import {
+  test_read_map
+} from "./chunk-B2PJEV3S.js";
+import {
+  review_stamps
+} from "./chunk-S5GX3H4P.js";
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+import {
+  run_record_path
+} from "./chunk-WL5JHB3I.js";
+import {
+  verification_inputs
+} from "./chunk-EHPTXSAT.js";
+import {
+  changed_file_scope
+} from "./chunk-QX2EMUXV.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  INSTALL_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/run/ship/run-ship-preflight.ts
+import { readFile } from "node:fs/promises";
+
+// scripts/run/ship/run-ship-lock.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { stripVTControlCharacters } from "node:util";
+var LOCK_FILE = "pnpm-lock.yaml";
+var PNPM_ERROR_CODE = "ERR_PNPM_";
+var LOCK_CHECK_ARGUMENTS = ["install", "--frozen-lockfile", "--lockfile-only", "--ignore-scripts"];
+var LOCK_DRIFT = `${LOCK_FILE} does not match its inputs (\`pnpm install --frozen-lockfile\` refuses it), so the pre-push hook's install would rewrite it under the push: run \`pnpm install\` and commit ${LOCK_FILE}.`;
+function drift_problem(output) {
+  const lines = stripVTControlCharacters(output).split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  const reason2 = lines.find((line) => line.includes(PNPM_ERROR_CODE)) ?? lines[0];
+  return reason2 === void 0 ? LOCK_DRIFT : `${LOCK_DRIFT} pnpm said: ${reason2}`;
+}
+async function lock_problems(directory = process.cwd()) {
+  if (!existsSync(path.join(directory, LOCK_FILE))) return [];
+  const result = await buffered_process.run_buffered_process(LOCK_CHECK_ARGUMENTS, {
+    cwd: directory,
+    timeout_ms: INSTALL_TIMEOUT_MS
+  });
+  return buffered_process.is_process_failed(result) ? [drift_problem(result.output)] : [];
+}
+var run_ship_lock = { LOCK_CHECK_ARGUMENTS, LOCK_DRIFT, lock_problems };
+
+// scripts/run/ship/run-ship-preflight-reuse.ts
+import { createHash } from "node:crypto";
+
+// scripts/run/ship/run-ship-tree-stamp.ts
+function matches(prior, tree) {
+  if (prior?.completed_at === void 0 || Object.keys(tree.files).length === 0) return false;
+  return file_map_stamp.describes_base(prior, tree.base) && file_map_stamp.changed_since(prior, tree.files).length === 0;
+}
+function is_reusable(stamp2, tree) {
+  const prior = stamp2.read();
+  return prior !== void 0 && stamp2.describes_inputs(prior) && matches(prior, tree);
+}
+function complete(stamp2, tree, code) {
+  if (code !== 0) return;
+  stamp2.write(tree.files, void 0, tree.base);
+  stamp2.complete();
+}
+var run_ship_tree_stamp = { complete, is_reusable };
+
+// scripts/run/ship/run-ship-preflight-reuse.ts
+var REUSED = "ready \u2014 preflight reused: it passed on this tree, base, title and body";
+function digest(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function stamp(key, root) {
+  const inputs = digest(key.inputs);
+  return file_map_stamp.create(`josh-ship-preflight-${key.issue}-`, root, () => inputs);
+}
+async function run(key, ask, root) {
+  if (key === void 0) return await ask();
+  const access = stamp(key, root);
+  const tree = await gate_tree.read_gate_tree();
+  if (run_ship_tree_stamp.is_reusable(access, tree)) return { code: 0, out: REUSED };
+  access.write(tree.files, void 0, tree.base);
+  const result = await ask();
+  run_ship_tree_stamp.complete(access, tree, result.code);
+  return result;
+}
+var run_ship_preflight_reuse = { REUSED, run, stamp };
+
+// scripts/run/ship/run-ship-gate-runs.ts
+import { createHash as createHash2 } from "node:crypto";
+var SUCCESS_EXIT_CODE = 0;
+var HASH_LENGTH = 12;
+var REASON = { MERGE: "merge", FIX: "fix", NO_RECORD: "no-record" };
+var state = {};
+function tree_hash(tree) {
+  const files = Object.entries(tree.files).toSorted(([left], [right]) => left.localeCompare(right));
+  const identity = JSON.stringify({ base: tree.base, files });
+  return createHash2("sha256").update(identity).digest("hex").slice(0, HASH_LENGTH);
+}
+function reason_of(tree) {
+  const { last } = state;
+  if (last === void 0) return REASON.NO_RECORD;
+  if (last.base !== tree.base) return REASON.MERGE;
+  return scoped_green.is_unmoved(last, tree) ? REASON.NO_RECORD : REASON.FIX;
+}
+function reused_line(tree) {
+  return `reused gate (${tree_hash(tree)})`;
+}
+function ran_line(reason2) {
+  return `josh gate runs (${reason2})`;
+}
+function met(tree, code) {
+  if (code === SUCCESS_EXIT_CODE) state.last = tree;
+}
+function forget() {
+  delete state.last;
+}
+var run_ship_gate_runs = { REASON, forget, met, ran_line, reason_of, reused_line, tree_hash };
+
+// scripts/run/ship/run-ship-narrowed.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+var should_forward_stderr = true;
+var green = {};
+function remember(tree) {
+  green.tree = tree;
+}
+function forget2() {
+  delete green.tree;
+}
+function is_nameable(checks, files, root) {
+  if (files.some((file) => !existsSync2(path2.join(root, file)))) return false;
+  return checks.every((check) => !verification_inputs.configures(check.label, files));
+}
+async function nameable(checks, files) {
+  const root = await changed_file_scope.repository_root_or_cwd();
+  return is_nameable(checks, files, root) ? files : void 0;
+}
+async function moved_since_green(checks, tree) {
+  const last = green.tree;
+  if (last?.base === void 0 || last.base !== tree.base) return void 0;
+  const moved = file_map_stamp.changed_since({ taken_at: "", files: last.files }, tree.files).filter((file) => !run_record_path.is_run_record(file));
+  return await nameable(checks, moved);
+}
+function record(checks, tree) {
+  for (const check of checks) scoped_green.record_green(check.stamp, tree);
+}
+function named_phases(checks, files) {
+  if (files.length === 0) return [];
+  return checks.map(
+    (check) => async () => await josh_command.josh_run([check.script, ...files], should_forward_stderr)
+  );
+}
+function describe(files, why) {
+  return `scoped pair: narrowed to the ${String(files.length)} file(s) ${why}.`;
+}
+var run_ship_narrowed = {
+  describe,
+  forget: forget2,
+  moved_since_green,
+  named_phases,
+  nameable,
+  record,
+  remember
+};
+
+// scripts/run/ship/run-ship-pair-runs.ts
+var SUCCESS_EXIT_CODE2 = 0;
+var REASON2 = { MOVED: "moved", RECHECK: "recheck", NO_RECORD: "no-record" };
+var state2 = { runs: 0, met_count: 0, queue: Promise.resolve() };
+async function after(ahead2, run2, queued_at) {
+  await Promise.allSettled([ahead2]);
+  delete state2.current;
+  state2.queued_at = queued_at;
+  return await run2();
+}
+async function one_at_a_time(run2) {
+  const turn = after(state2.queue, run2, state2.met_count);
+  state2.queue = turn;
+  return await turn;
+}
+function reason_of2(last, tree) {
+  if (!scoped_green.is_unmoved(last.tree, tree)) return REASON2.MOVED;
+  return last.code === SUCCESS_EXIT_CODE2 ? REASON2.NO_RECORD : REASON2.RECHECK;
+}
+function rerun_of(tree) {
+  if (state2.runs === 1 || state2.last === void 0) return void 0;
+  return reason_of2(state2.last, tree);
+}
+function begin(tree) {
+  state2.runs += 1;
+  const rerun = rerun_of(tree);
+  state2.current = rerun === void 0 ? { runs: state2.runs } : { runs: state2.runs, rerun };
+  return rerun === void 0 ? void 0 : `scoped pair run ${String(state2.runs)} (${rerun})`;
+}
+function met2(tree, code, out = "") {
+  state2.met_count += 1;
+  state2.last = { tree, code, out, seq: state2.met_count };
+}
+function is_awaited_red(last, queued_at) {
+  return last.code !== SUCCESS_EXIT_CODE2 && queued_at !== void 0 && last.seq > queued_at;
+}
+function red_on(tree) {
+  const { last, queued_at } = state2;
+  if (last === void 0 || !is_awaited_red(last, queued_at)) return void 0;
+  return scoped_green.is_unmoved(last.tree, tree) ? { code: last.code, out: last.out } : void 0;
+}
+function current() {
+  return state2.current ?? {};
+}
+function forget3() {
+  state2.runs = 0;
+  state2.met_count = 0;
+  delete state2.queued_at;
+  delete state2.last;
+  delete state2.current;
+}
+var run_ship_pair_runs = { REASON: REASON2, begin, current, forget: forget3, met: met2, one_at_a_time, red_on };
+
+// scripts/run/ship/run-ship-synced-scope.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path3 from "node:path";
+var CHECKS = [
+  {
+    script: scoped_green.LINT_SCRIPT,
+    label: gate_labels.LINT_LABEL,
+    stamp: review_stamps.lint_related_stamp
+  },
+  {
+    script: scoped_green.TEST_SCRIPT,
+    label: gate_labels.UNIT_LABEL,
+    stamp: review_stamps.test_related_stamp
+  }
+];
+async function moved_files(checks, tree) {
+  const parts = await Promise.all(
+    checks.map(
+      async (check) => await since_green.read_moved_parts(check.stamp, check.label, void 0, tree)
+    )
+  );
+  const known = parts.filter((part) => part !== void 0);
+  if (known.length === 0 || known.length !== parts.length) return void 0;
+  return {
+    changed: [...new Set(known.flatMap((part) => part.changed))].filter(
+      (file) => !run_record_path.is_run_record(file)
+    ),
+    synced: [...new Set(known.flatMap((part) => part.synced))]
+  };
+}
+async function branch_change() {
+  try {
+    return await changed_paths.read_changed_paths(false);
+  } catch {
+    return void 0;
+  }
+}
+function is_whole_suite(file) {
+  return whole_suite_files.WHOLE_SUITE_FILES.has(file);
+}
+function is_read_by_tests(map, file) {
+  if (is_whole_suite(file)) return true;
+  if (related_scope.is_relatable(file)) return false;
+  return map === void 0 || test_read_map.readers_of(map, file).length > 0;
+}
+function has_check(checks, script) {
+  return checks.some((check) => check.script === script);
+}
+function read_by_tests(checks, synced, map) {
+  if (!has_check(checks, scoped_green.TEST_SCRIPT)) return [];
+  return synced.filter((file) => is_read_by_tests(map, file));
+}
+function lint_meeting(checks, split) {
+  return has_check(checks, scoped_green.LINT_SCRIPT) ? split.meeting : [];
+}
+function test_overlap_of(root, branch, split, common) {
+  const own = split.shared.length > 0 ? branch.filter((file) => existsSync3(path3.join(root, file))) : [];
+  return [.../* @__PURE__ */ new Set([...common, ...own])];
+}
+function joined(first, second) {
+  return [.../* @__PURE__ */ new Set([...first, ...second])];
+}
+function with_own_edits(overlap, changed) {
+  if (overlap.overlap === void 0) return overlap;
+  return {
+    ...overlap,
+    overlap: joined(changed, overlap.overlap),
+    test_overlap: joined(changed, overlap.test_overlap ?? [])
+  };
+}
+function named_of(reading) {
+  if (reading.overlap === void 0) return void 0;
+  return joined(reading.overlap, reading.test_overlap ?? []);
+}
+function files_for(reading, script, files) {
+  const own = script === scoped_green.TEST_SCRIPT ? reading?.test_overlap : reading?.overlap;
+  return own ?? files;
+}
+function unsplit_line(failure) {
+  return `scoped pair: the import graph could not split the merge with the default branch (${failure}), so the pair runs as before.`;
+}
+async function overlap_of(checks, synced, branch) {
+  const root = await changed_file_scope.repository_root_or_cwd();
+  const map = test_read_map.read_map(root);
+  const split = await test_related_synced.split(root, synced, branch, map);
+  const both = synced.filter((file) => branch.includes(file));
+  const unsplit = synced.filter(
+    (file) => related_scope.is_relatable(file) && !branch.includes(file) && !split.left.includes(file)
+  );
+  if (split.failure !== void 0 && unsplit.length > 0) {
+    return { overlap: void 0, unsplit: split.failure };
+  }
+  const common = [...both, ...unsplit, ...read_by_tests(checks, synced, map)];
+  const named = [...common, ...split.shared, ...lint_meeting(checks, split)];
+  return {
+    overlap: [...new Set(named)],
+    test_overlap: test_overlap_of(root, branch, split, common)
+  };
+}
+function checks_of(scripts) {
+  return CHECKS.filter((check) => scripts.includes(check.script));
+}
+async function read_sync(tree, scripts) {
+  const checks = checks_of(scripts);
+  const parts = await moved_files(checks, tree);
+  if (parts === void 0 || parts.synced.length === 0) return void 0;
+  const branch = await branch_change();
+  if (branch === void 0) return void 0;
+  const overlap = await overlap_of(checks, parts.synced, branch);
+  return {
+    checks,
+    synced: parts.synced,
+    ...with_own_edits(overlap, parts.changed)
+  };
+}
+function reason(checks, synced) {
+  return `scoped pair: ${checks.map((check) => check.script).join(" and ")} not re-run \u2014 the ${String(synced.length)} file(s) the merge with the default branch brought in share no file or test with this branch's change.`;
+}
+function settle(reading, tree) {
+  if (reading.overlap === void 0 || reading.overlap.length > 0) return void 0;
+  run_ship_narrowed.record(reading.checks, tree);
+  return reason(reading.checks, reading.synced);
+}
+var run_ship_synced_scope = { checks_of, files_for, named_of, read_sync, settle, unsplit_line };
+
+// scripts/run/ship/run-ship-scoped.ts
+var SUCCESS_EXIT_CODE3 = 0;
+var should_forward_stderr2 = true;
+var MOVED_SINCE_GREEN = "moved since this ship last met the pair green on this base";
+var MERGE_MEETS_BRANCH = "where the merge with the default branch meets this branch's change";
+var REUSED_PAIR = "scoped pair: reused \u2014 both checks are green on this tree";
+var RED_PAIR = "scoped pair: red on this tree in this ship \u2014 not run again";
+async function run_phases(phases, after_phase) {
+  let last = { code: SUCCESS_EXIT_CODE3, out: "" };
+  for (const [index, phase] of phases.entries()) {
+    last = await phase();
+    await after_phase?.(index);
+    if (last.code !== SUCCESS_EXIT_CODE3) return last;
+  }
+  return last;
+}
+async function take_snapshot(phase, snapshot) {
+  if (phase?.script !== scoped_green.LINT_SCRIPT) return;
+  snapshot.tree = await gate_tree.read_gate_tree();
+}
+async function run_pair_phases(phases) {
+  const snapshot = { tree: await gate_tree.read_gate_tree() };
+  const result = await run_phases(
+    phases.map((phase) => phase.run),
+    async (index) => {
+      await take_snapshot(phases[index], snapshot);
+    }
+  );
+  return { ...result, verified: snapshot.tree };
+}
+function printed(line) {
+  process.stdout.write(`${line}
+`);
+  return { code: SUCCESS_EXIT_CODE3, out: line };
+}
+async function bare_pair(scripts) {
+  const outs = [];
+  const result = await run_pair_phases(
+    scripts.map((script) => ({
+      script,
+      run: async () => {
+        const ran = await josh_command.josh_run([script], should_forward_stderr2);
+        outs.push(ran.out);
+        return ran;
+      }
+    }))
+  );
+  return { ...result, out: outs.filter((out) => out !== "").join("\n") };
+}
+async function nameable_files(scripts, tree, sync) {
+  const checks = run_ship_synced_scope.checks_of(scripts);
+  if (sync === void 0) return await run_ship_narrowed.moved_since_green(checks, tree);
+  const named = run_ship_synced_scope.named_of(sync);
+  return named === void 0 ? void 0 : await run_ship_narrowed.nameable(checks, named);
+}
+function check_phases(checks, files, sync) {
+  return checks.flatMap(
+    (check) => run_ship_narrowed.named_phases([check], run_ship_synced_scope.files_for(sync, check.script, files)).map((run2) => ({ script: check.script, run: run2 }))
+  );
+}
+async function named_files(tree, scripts, sync) {
+  const files = await nameable_files(scripts, tree, sync);
+  const why = sync === void 0 ? MOVED_SINCE_GREEN : MERGE_MEETS_BRANCH;
+  return files === void 0 ? void 0 : { files, why };
+}
+async function unnamed_pair(scripts, sync) {
+  const unsplit = sync?.unsplit;
+  if (unsplit === void 0) return await bare_pair(scripts);
+  printed(run_ship_synced_scope.unsplit_line(unsplit));
+  return { ...await bare_pair(scripts), note: { unsplit } };
+}
+async function is_still(tree) {
+  return scoped_green.is_unmoved(tree, await gate_tree.read_gate_tree());
+}
+async function narrowed_or_bare(tree, scripts, sync) {
+  const named = await named_files(tree, scripts, sync);
+  if (named === void 0) return await unnamed_pair(scripts, sync);
+  printed(run_ship_narrowed.describe(named.files, named.why));
+  const checks = run_ship_synced_scope.checks_of(scripts);
+  const result = await run_pair_phases(check_phases(checks, named.files, sync));
+  const verified = result.verified ?? tree;
+  if (result.code === SUCCESS_EXIT_CODE3 && await is_still(verified)) {
+    run_ship_narrowed.record(checks, verified);
+  }
+  return { ...result, note: { named: named.files.length } };
+}
+function replayed(red) {
+  printed(RED_PAIR);
+  return red;
+}
+async function stale_pair(tree, scripts) {
+  const red = run_ship_pair_runs.red_on(tree);
+  if (red !== void 0) return replayed(red);
+  const sync = await run_ship_synced_scope.read_sync(tree, scripts);
+  const settled = sync === void 0 ? void 0 : run_ship_synced_scope.settle(sync, tree);
+  if (settled !== void 0) return printed(settled);
+  const rerun = run_ship_pair_runs.begin(tree);
+  if (rerun !== void 0) printed(rerun);
+  return await narrowed_or_bare(tree, scripts, sync);
+}
+async function remember_result(tree, result) {
+  const { verified = tree, ...answer } = result;
+  run_ship_pair_runs.met(verified, result.code, result.out);
+  if (result.code === SUCCESS_EXIT_CODE3 && await is_still(verified)) {
+    run_ship_narrowed.remember(verified);
+  }
+  return answer;
+}
+async function settled_pair() {
+  const tree = await metrics_totals.rerecorded_tree();
+  const scripts = scoped_green.missing_scripts(tree.files, tree.base);
+  if (scripts.length === 0) {
+    run_ship_narrowed.remember(tree);
+    run_ship_pair_runs.met(tree, SUCCESS_EXIT_CODE3);
+    return printed(REUSED_PAIR);
+  }
+  const result = await stale_pair(tree, scripts);
+  return await remember_result(tree, result);
+}
+function pair_note({ out, note }) {
+  const reasons = since_green.fallbacks_of(out);
+  const run2 = { ...run_ship_pair_runs.current(), ...note };
+  return reasons.length === 0 ? run2 : { ...run2, fallback: reasons.join(", ") };
+}
+async function scoped_pair() {
+  return await run_ship_pair_runs.one_at_a_time(
+    async () => await run_ship_lap.timed(run_ship_lap.STEP.SCOPED_PAIR, settled_pair, {
+      note_of: pair_note
+    })
+  );
+}
+var GATE_ARGUMENTS = ["gate", whole_tree_reuse.WHOLE_TREE_FLAG];
+async function is_reusable2(tree) {
+  if (gate_skip.reusable_green_gate(tree.files, tree.base) === void 0) return false;
+  return await whole_tree_reuse.is_reused(tree, check_reuse.DEFAULT_RECORDS);
+}
+async function reused_gate(tree) {
+  await gate_ledger.record_reused(await lane_ledger_write.target(), 0);
+  return await run_ship_lap.timed(
+    run_ship_lap.STEP.GATE,
+    async () => printed(run_ship_gate_runs.reused_line(tree)),
+    { note_of: () => ({ reused_tree: run_ship_gate_runs.tree_hash(tree) }) }
+  );
+}
+async function ran_gate(tree) {
+  const reason2 = run_ship_gate_runs.reason_of(tree);
+  printed(run_ship_gate_runs.ran_line(reason2));
+  const result = await run_ship_lap.timed(
+    run_ship_lap.STEP.GATE,
+    async () => await josh_command.josh_run(GATE_ARGUMENTS, should_forward_stderr2),
+    { note_of: () => ({ rerun: reason2 }) }
+  );
+  if (await is_still(tree)) run_ship_gate_runs.met(tree, result.code);
+  return result;
+}
+async function gate() {
+  const tree = await gate_tree.read_gate_tree();
+  if (!await is_reusable2(tree)) return await ran_gate(tree);
+  run_ship_gate_runs.met(tree, SUCCESS_EXIT_CODE3);
+  return await reused_gate(tree);
+}
+async function scoped_gate() {
+  return await run_phases([scoped_pair, gate]);
+}
+async function is_gate_green() {
+  return await is_reusable2(await gate_tree.read_gate_tree());
+}
+var run_ship_scoped = {
+  RED_PAIR,
+  REUSED_PAIR,
+  is_gate_green,
+  run_phases,
+  scoped_gate,
+  scoped_pair
+};
+
+// scripts/run/ship/run-ship-preflight.ts
+var SUCCESS_EXIT_CODE4 = 0;
+var FAILURE_EXIT_CODE = 1;
+var UNREADABLE = /* @__PURE__ */ Symbol("unreadable body");
+var PRECONDITION = {
+  LIVE_EVIDENCE: "live-evidence",
+  ACCEPTANCE_MAP: "acceptance-map",
+  REMOVED_TESTS: "removed-tests",
+  LOCK: "lock",
+  SCOPED: "scoped",
+  UNPLANNED: run_ship_planned.PRECONDITION,
+  UNREADABLE: "unreadable"
+};
+var EVIDENCE_PROBLEM = `This change touches runtime code, but the body this ship delivers has no ${live_evidence.EVIDENCE_HEADING} section: run the acceptance criteria for real and write it into the ship body draft run:prep wrote (josh ship reads it when --body-file is omitted), or pass the body with --body-file <path>. Write it ${live_evidence.EVIDENCE_FORMAT}`;
+var EVIDENCE_PENDING = `This change touches runtime code and no PR is open yet: write the ${live_evidence.EVIDENCE_HEADING} section into the ship body draft run:prep wrote (or a file handed to josh ship with --body-file <path>), or the ship refuses. Write it ${live_evidence.EVIDENCE_FORMAT}`;
+function acceptance_pending_text(draft_path) {
+  return `Fill in this ${acceptance_map.MAP_HEADING} section in the ship body draft ${draft_path} \u2014 josh ship reads it when --body-file is omitted \u2014 replacing each pending row's ending with what met or deferred it (format: ${report_format_reference.pointer(report_format_reference.ACCEPTANCE_MAP_HEADING)}), and write ${live_evidence.EVIDENCE_HEADING} there before the ship, or the ship refuses:`;
+}
+async function body_text(body_path) {
+  if (body_path !== void 0) return cli_body.read_file_or_stdin(body_path);
+  const branch = await git_branch.current();
+  const issue = git_issue.branch_number(branch);
+  const draft = issue === void 0 ? void 0 : await run_ship_body_draft.existing(issue);
+  if (draft !== void 0) return await readFile(draft, "utf8");
+  return await git_gh_command.pr_get_body(branch);
+}
+function of_kind(kind, problems) {
+  return problems.map((problem) => ({ kind, problem }));
+}
+async function evidence_problems(body_path, no_body_problem = EVIDENCE_PROBLEM) {
+  const [paths, body] = await Promise.all([
+    changed_paths.read_changed_paths(false),
+    body_text(body_path)
+  ]);
+  if (live_evidence.verdict_for(paths, body) !== "required") return [];
+  return of_kind(PRECONDITION.LIVE_EVIDENCE, [
+    body === void 0 ? no_body_problem : EVIDENCE_PROBLEM
+  ]);
+}
+function refusal(problems) {
+  const lines = problems.map(({ problem }) => `  - ${problem}`);
+  const head = `${String(problems.length)} pull-request precondition(s) unmet before the review and the gate:`;
+  const preconditions = [...new Set(problems.map(({ kind }) => kind))];
+  return { code: FAILURE_EXIT_CODE, out: [head, ...lines].join("\n"), preconditions };
+}
+async function caught(problems) {
+  try {
+    return await problems;
+  } catch (error) {
+    return of_kind(PRECONDITION.UNREADABLE, [error_text.message_of(error)]);
+  }
+}
+async function readable_body(body_path) {
+  try {
+    return await body_text(body_path);
+  } catch {
+    return UNREADABLE;
+  }
+}
+async function acceptance_problems(body_path) {
+  const issue = git_issue.branch_number(await git_branch.current());
+  const body = await readable_body(body_path);
+  if (issue === void 0 || body === UNREADABLE) return [];
+  const problem = await acceptance_map_check.body_refusal(issue, body);
+  return problem === void 0 ? [] : of_kind(PRECONDITION.ACCEPTANCE_MAP, [problem]);
+}
+async function removed_test_problems(body_path) {
+  const body = await readable_body(body_path);
+  if (body === UNREADABLE) return [];
+  const problem = await removed_tests_check.body_refusal(body);
+  return problem === void 0 ? [] : of_kind(PRECONDITION.REMOVED_TESTS, [problem]);
+}
+async function lock_problems2() {
+  return of_kind(PRECONDITION.LOCK, await run_ship_lock.lock_problems());
+}
+async function planned_problems() {
+  return of_kind(PRECONDITION.UNPLANNED, await run_ship_planned.problems());
+}
+async function asked_problems(request) {
+  const [preflight, evidence, acceptance, removed, lock, planned] = await Promise.all([
+    caught(git_preflight.problems_of({ cli_input: request.title, will_open_pr: true })),
+    caught(evidence_problems(request.body_path)),
+    caught(acceptance_problems(request.body_path)),
+    caught(removed_test_problems(request.body_path)),
+    caught(lock_problems2()),
+    caught(planned_problems())
+  ]);
+  return [...preflight, ...evidence, ...acceptance, ...removed, ...lock, ...planned];
+}
+async function asked_stage(request) {
+  const problems = await run_ship_lap.timed(
+    run_ship_lap.STEP.PRECONDITIONS,
+    async () => await asked_problems(request)
+  );
+  if (problems.length > 0) return refusal(problems);
+  const scoped = await run_ship_scoped.scoped_pair();
+  if (scoped.code === SUCCESS_EXIT_CODE4) return { code: SUCCESS_EXIT_CODE4, out: "ready" };
+  return { ...scoped, preconditions: [PRECONDITION.SCOPED] };
+}
+async function reuse_key(request) {
+  const [branch, body] = await Promise.all([git_branch.current(), readable_body(request.body_path)]);
+  const issue = git_issue.branch_number(branch);
+  if (issue === void 0 || body === UNREADABLE) return void 0;
+  return { issue, inputs: `${request.title}
+${body ?? ""}` };
+}
+async function stage(request) {
+  const key = await reuse_key(request);
+  return await run_ship_preflight_reuse.run(key, async () => await asked_stage(request));
+}
+async function classification_problems(issue_number) {
+  await git_pr.release_classification(issue_number, await git_branch.current());
+  return [];
+}
+async function pending_map(issue_number, body) {
+  if (body !== void 0) return void 0;
+  return acceptance_map.skeleton(await git_gh_command.issue_get_body(issue_number));
+}
+async function pending_text(issue_number, map) {
+  const draft = await run_ship_body_draft.prepare(issue_number, map);
+  return `${acceptance_pending_text(draft)}
+${map}`;
+}
+async function draft_refusal_text(issue_number, problem) {
+  const draft = await run_ship_body_draft.existing(issue_number);
+  return draft === void 0 ? problem : `${acceptance_pending_text(draft)}
+${problem}`;
+}
+async function acceptance_pending(issue_number) {
+  const body = await body_text(void 0);
+  const problem = await acceptance_map_check.body_refusal(issue_number, body);
+  if (problem === void 0) return [];
+  const map = await pending_map(issue_number, body);
+  const pending = map === void 0 ? await draft_refusal_text(issue_number, problem) : await pending_text(issue_number, map);
+  return of_kind(PRECONDITION.ACCEPTANCE_MAP, [pending]);
+}
+async function ahead(issue_number) {
+  const [classification, evidence, acceptance] = await Promise.all([
+    caught(classification_problems(issue_number)),
+    caught(evidence_problems(void 0, EVIDENCE_PENDING)),
+    caught(acceptance_pending(issue_number))
+  ]);
+  return [...classification, ...evidence, ...acceptance].map(({ problem }) => problem);
+}
+var run_ship_preflight = {
+  SCOPED_PRECONDITION: PRECONDITION.SCOPED,
+  EVIDENCE_PENDING,
+  EVIDENCE_PROBLEM,
+  acceptance_pending_text,
+  ahead,
+  stage
+};
+
+export {
+  run_ship_tree_stamp,
+  run_ship_scoped,
+  run_ship_preflight
+};