@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-CNGTHSUS.js

@@ -1,750 +0,0 @@
-import {
-  git_preflight
-} from "./chunk-Q7EEIOAD.js";
-import {
-  acceptance_map_check
-} from "./chunk-IYJEBWW5.js";
-import {
-  git_pr
-} from "./chunk-YDURQICF.js";
-import {
-  run_ship_body_draft
-} from "./chunk-3ZOX4G4U.js";
-import {
-  removed_tests_check
-} from "./chunk-47UZB54M.js";
-import {
-  live_evidence
-} from "./chunk-3B2HEFNO.js";
-import {
-  acceptance_map
-} from "./chunk-5PCK53WP.js";
-import {
-  josh_command
-} from "./chunk-2VRITY55.js";
-import {
-  cli_body
-} from "./chunk-7IZJ5MG2.js";
-import {
-  run_ship_planned
-} from "./chunk-TAEGXID2.js";
-import {
-  git_issue
-} from "./chunk-HI5WPM6C.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  gate_ledger,
-  whole_tree_reuse
-} from "./chunk-JCAQ7B6J.js";
-import {
-  check_reuse
-} from "./chunk-KZ5BBBMO.js";
-import {
-  test_related_synced
-} from "./chunk-LT7QSHR4.js";
-import {
-  gate_skip
-} from "./chunk-WCEUMOKK.js";
-import {
-  related_scope,
-  whole_suite_files
-} from "./chunk-CFHRNTE5.js";
-import {
-  report_format_reference
-} from "./chunk-Q6SKKQVJ.js";
-import {
-  run_ship_lap
-} from "./chunk-PE7B7242.js";
-import {
-  metrics_totals
-} from "./chunk-ORKVN2LO.js";
-import {
-  scoped_green
-} from "./chunk-WTH6NTXU.js";
-import {
-  since_green
-} from "./chunk-P3H3DKTE.js";
-import {
-  test_read_map
-} from "./chunk-OZZWRJQI.js";
-import {
-  review_stamps
-} from "./chunk-MVHPRYHE.js";
-import {
-  gate_tree
-} from "./chunk-NFPD2P3V.js";
-import {
-  file_map_stamp
-} from "./chunk-CGLLAEKZ.js";
-import {
-  run_record_path
-} from "./chunk-WL5JHB3I.js";
-import {
-  verification_inputs
-} from "./chunk-34KZDKQJ.js";
-import {
-  changed_file_scope
-} from "./chunk-7LJQMM2K.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  gate_labels
-} from "./chunk-WQ6FS544.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  buffered_process
-} from "./chunk-JZHY7D6D.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.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) {
-  let last = { code: SUCCESS_EXIT_CODE3, out: "" };
-  for (const phase of phases) {
-    last = await phase();
-    if (last.code !== SUCCESS_EXIT_CODE3) return last;
-  }
-  return last;
-}
-async function rerecorded_tree() {
-  const tree = await gate_tree.read_gate_tree();
-  const is_rerecorded = await metrics_totals.rerecord(process.cwd(), tree.files);
-  return is_rerecorded ? await gate_tree.read_gate_tree() : 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_phases(
-    scripts.map((script) => 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)
-    )
-  );
-}
-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_phases(check_phases(checks, named.files, sync));
-  if (result.code === SUCCESS_EXIT_CODE3 && await is_still(tree)) {
-    run_ship_narrowed.record(checks, tree);
-  }
-  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 settled_pair() {
-  const tree = await 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);
-  run_ship_pair_runs.met(tree, result.code, result.out);
-  if (result.code === SUCCESS_EXIT_CODE3 && await is_still(tree)) run_ship_narrowed.remember(tree);
-  return 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
-};