@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-RG53UFNW.js

@@ -1,418 +0,0 @@
-import {
-  review_round_reuse,
-  run_ship_probe
-} from "./chunk-NILSN7A4.js";
-import {
-  review_reviewed_tree
-} from "./chunk-GITT5A5A.js";
-import {
-  review_record
-} from "./chunk-JVKXJ763.js";
-import {
-  review_comment_carry
-} from "./chunk-3Z425MM3.js";
-import {
-  review_comment_round
-} from "./chunk-CKUKK7JG.js";
-import {
-  review_record_pinned
-} from "./chunk-CJBW6BWG.js";
-import {
-  review_finding_text,
-  review_fix_round,
-  review_round
-} from "./chunk-EKLU6QR7.js";
-import {
-  review_interaction
-} from "./chunk-TJKM56WJ.js";
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  review_attest,
-  review_checkout
-} from "./chunk-KIILCKQR.js";
-import {
-  observation_ledger_home
-} from "./chunk-WWVYEHQT.js";
-import {
-  review_stamps
-} from "./chunk-MVHPRYHE.js";
-import {
-  file_map_stamp
-} from "./chunk-CGLLAEKZ.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  run_ship_detach
-} from "./chunk-G4E4M2P4.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_number_shape
-} from "./chunk-66NX6EXR.js";
-import {
-  cli_flags
-} from "./chunk-2FE3C4PH.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-
-// scripts/review/review-lane-handover.ts
-var SHIP_STEP = 'pnpm josh ship --detach --review "<title> #<N>"';
-var NEXT_STEP_LINE = `Next: hand over to \`${SHIP_STEP}\` \u2014 round 2 is the ship's; never reopen \`run:review\` (chain-rule.md step 0).`;
-var SHIP_REVIEWS_LINE = `Files moved since \u2014 a widened \`lane:plan\`'s included \u2014 are the ship's: hand over to \`${SHIP_STEP}\`, whose round 2 reads them, or whose own round 1 reviews again where it does not reuse this one; never reopen \`run:review\` (chain-rule.md step 0).`;
-var UNANSWERED_CAUSE = "git could not answer the reuse question";
-async function answer_here(issue) {
-  try {
-    return await review_round_reuse.answer_here(issue);
-  } catch (error) {
-    error_text.trace_swallowed("review_lane_handover.answer_here", error);
-    return { reuse: review_round_reuse.REUSE.AGAIN, cause: UNANSWERED_CAUSE };
-  }
-}
-async function is_reused_here(issue) {
-  const answer = await answer_here(issue);
-  return answer.reuse !== review_round_reuse.REUSE.AGAIN;
-}
-function is_lane_child_of(issue) {
-  if (lane_child_marker.marked_issue() !== String(issue)) return false;
-  return lane_child_marker.is_child_of(PROJECT_ROOT);
-}
-async function is_handed_over(issue) {
-  if (!is_lane_child_of(issue)) return false;
-  return await is_reused_here(issue);
-}
-async function is_round_attested(issue) {
-  const verdict = await review_record.check(issue);
-  if (verdict.status !== "ok") return false;
-  const checkout = await review_checkout.read_checkout();
-  return review_attest.is_attested_on(checkout, checkout.root);
-}
-async function is_reopen_refused(issue) {
-  if (!is_lane_child_of(issue)) return false;
-  return await is_round_attested(issue);
-}
-function refusal(issue) {
-  return `\u26D4 run:review: round 1 of ${session_cite.issue(issue)} is recorded and attested, and this is a dispatched lane child (\`${lane_child_marker.KEY}\`), so no brief is minted. ${SHIP_REVIEWS_LINE}`;
-}
-var review_lane_handover = {
-  NEXT_STEP_LINE,
-  SHIP_REVIEWS_LINE,
-  answer_here,
-  is_handed_over,
-  is_reopen_refused,
-  refusal
-};
-
-// scripts/review/review-final-record.ts
-function stamp(issue, root = PROJECT_ROOT) {
-  return file_map_stamp.create(
-    `josh-ship-final-review-${issue}-`,
-    root,
-    () => review_attest.read_pointer(root)?.nonce ?? ""
-  );
-}
-function is_attested_final(root) {
-  const pointer = review_attest.read_pointer(root);
-  if (pointer === void 0 || review_round.current(root) !== "2") return false;
-  const expected = review_attest.read_expectation(pointer.nonce);
-  return expected !== void 0 && review_attest.is_attested_on(expected, root);
-}
-function record(issue, findings, root) {
-  const completion = stamp(String(issue), root);
-  const tree = review_stamps.briefed_stamp.read();
-  completion.remove();
-  if (tree === void 0 || !is_attested_final(root) || !review_attest.is_briefed_since(tree.taken_at, root) || findings.some((finding) => finding.severity !== "low")) {
-    return;
-  }
-  completion.write(tree.files, void 0, tree.base);
-  completion.complete();
-}
-var review_final_record = { record, stamp };
-
-// scripts/review/review-record-interaction.ts
-var NOT_REQUIRED_LINE = "No interaction review is due: the change touches no run tooling, changes only comments in it, or this checkout keeps no ledger.";
-var DUE_HEAD = "Interaction review now due";
-function due_line(issue) {
-  return `${DUE_HEAD}: this round\u2019s change touches the run tooling and no interaction pass is recorded. Before \`josh ship\`, record it with \`pnpm josh review:record --from-slot --interaction --issue ${String(issue)} [<n>=<disposition> ...]\` \u2014 if no interaction reviewer ran beside this round, first open its brief with \`pnpm josh review:brief --interaction\` and run that \`reviewer\` \u2014 so a finding is fixed in this lane rather than stopping the ship.`;
-}
-async function report_due(issue, root) {
-  try {
-    if (await review_interaction.status(issue, root) === "missing") console.info(due_line(issue));
-  } catch (error) {
-    error_text.trace_swallowed("review_record_interaction.report_due", error);
-  }
-}
-var review_record_interaction = {
-  due_line,
-  NOT_REQUIRED_LINE,
-  report_due
-};
-
-// scripts/review/review-record-code-round.ts
-var HIGH_SEVERITY = "high";
-function unsettled_files(findings) {
-  return findings.filter((finding) => finding.severity === HIGH_SEVERITY).map((finding) => finding.file);
-}
-async function report_handover(issue) {
-  const is_handed_over2 = await review_lane_handover.is_handed_over(issue);
-  if (is_handed_over2) console.info(review_lane_handover.NEXT_STEP_LINE);
-  return is_handed_over2;
-}
-function is_restarted_here(is_handed_over2) {
-  return is_handed_over2 && !run_ship_detach.is_supervised();
-}
-async function follow(issue, root, findings) {
-  await review_reviewed_tree.record(unsettled_files(findings));
-  const is_handed_over2 = await report_handover(issue);
-  await review_record_interaction.report_due(issue, root);
-  if (!is_restarted_here(is_handed_over2)) return;
-  await review_record_pinned.read_skipped_join(root);
-  await review_record_pinned.restart_if_moved(root);
-}
-var review_record_code_round = { follow };
-
-// scripts/review/review-record-comment.ts
-var FAILURE_EXIT_CODE = 1;
-var AFTER_PUSH_LINE = "The branch is pushed and the tree is clean, so this round is recorded on the issue, not in the ledger \u2014 a ledger line would need a push of its own and restart CI.";
-async function post(issue, lines) {
-  try {
-    const url = await git_gh_issue_write.issue_comment(
-      String(issue),
-      review_comment_round.body_of(lines)
-    );
-    console.info(`Recorded ${String(lines.length)} review-finding line(s) in ${url.trim()}.`);
-    return 0;
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    return FAILURE_EXIT_CODE;
-  }
-}
-async function is_after_push() {
-  return await run_ship_probe.is_pushed_clean();
-}
-async function post_after_push(round) {
-  console.info(AFTER_PUSH_LINE);
-  const code = await post(round.issue, round.lines);
-  if (code === 0) await review_record_code_round.follow(round.issue, round.root, round.findings);
-  return code;
-}
-var review_record_comment = { is_after_push, post, post_after_push };
-
-// scripts/review/review-record-cli.ts
-var FAILURE_EXIT_CODE2 = 1;
-var USAGE = "Usage: josh review:record --issue <N> [--comment | --interaction] [[<disposition> ]<category>:<severity>:<file>[ \u2014 <reason>] ...] | josh review:record --check [--interaction] --issue <N>";
-var FILE_HINT = "  <file>: the cited path, optionally with :line";
-var DISPOSITION_HINT = "  <disposition>: optional \u2014 fixed | false-positive | filed:#<M> | deferred:#<M>; josh review:round2 skips only when every High/Medium is fixed or false-positive";
-var REASON_HINT = "  <reason>: optional, one sentence on what was wrong, kept for the lane\u2019s next review and fix \u2014 pass each finding with its reason as one single-quoted argument";
-var CHECK_USAGE = "Usage: josh review:record --check [--interaction] --issue <N>";
-var RECORDED_LINE = "Recorded: the review round for this issue is in the ledger.";
-var REUSED_LINE = "Reused: josh ship takes this round as its round 1 \u2014 the files this round covers hold still since the record. A default branch the ship\u2019s sync merges in moves them only where it changed a file this round covers, and the ship then reviews round 1 again itself.";
-var DELTA_LINE = "Reused, delta to round 2: josh ship takes this round as its round 1 and does not review it again \u2014 every moved path a round executes is one round 2 reads after the commit, or the ship\u2019s own round 1 stopped on it.";
-function review_again_line(cause = "the reuse question gave no reason", is_refused = false) {
-  const next = is_refused ? review_lane_handover.SHIP_REVIEWS_LINE : "Run `pnpm josh run:review` and the round-1 `/code-review` here (chain-rule.md step 0).";
-  return `Not reused: josh ship reviews round 1 again \u2014 ${cause}. ${next}`;
-}
-function reuse_line(answer, is_refused) {
-  if (answer.reuse === "again") return review_again_line(answer.cause, is_refused);
-  const line = answer.reuse === "delta" ? DELTA_LINE : REUSED_LINE;
-  return answer.note === void 0 ? line : `${line} \u2014 ${answer.note}`;
-}
-var NOT_REQUIRED_LINE2 = "No review-finding ledger is kept in this checkout, so there is nothing to check.";
-var OPTIONS = {
-  issue: { type: "string" },
-  check: { type: "boolean" },
-  comment: { type: "boolean" },
-  interaction: { type: "boolean" }
-};
-function to_finding(category, severity, file) {
-  if (!review_finding_ledger.is_category(category) || !review_finding_ledger.is_severity(severity)) {
-    return void 0;
-  }
-  return review_finding_ledger.is_valid_file(file) ? { category, severity, file } : void 0;
-}
-function parse_finding(spec) {
-  const first = spec.indexOf(":");
-  const second = spec.indexOf(":", first + 1);
-  if (first === -1 || second === -1) return void 0;
-  return to_finding(spec.slice(0, first), spec.slice(first + 1, second), spec.slice(second + 1));
-}
-function parse_positional(positional) {
-  const { spec: marked, description } = review_finding_text.split_description(positional);
-  const { disposition, spec } = review_finding_ledger.split_disposition(marked);
-  const finding = parse_finding(spec);
-  if (finding === void 0) return void 0;
-  return { finding: disposition === void 0 ? finding : { ...finding, disposition }, description };
-}
-function parse_findings(positionals) {
-  const findings = [];
-  for (const positional of positionals) {
-    const parsed = parse_positional(positional);
-    if (parsed === void 0) return void 0;
-    findings.push({ ...parsed.finding, description: parsed.description });
-  }
-  return findings;
-}
-function parse_argv(argv) {
-  const parsed = cli_flags.arguments_of(argv, OPTIONS);
-  if (parsed === void 0) return void 0;
-  return {
-    check: parsed.values.check === true,
-    comment: parsed.values.comment === true,
-    interaction: parsed.values.interaction === true,
-    issue: parsed.values.issue,
-    positionals: parsed.positionals
-  };
-}
-function to_request(parsed) {
-  const { issue } = parsed;
-  if (issue === void 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) return void 0;
-  const findings = parse_findings(parsed.positionals);
-  return findings === void 0 ? void 0 : { issue: Number(issue), findings };
-}
-function accepted_values(placeholder, values) {
-  return `  ${placeholder}: ${values.join(" | ")}`;
-}
-function usage_text() {
-  return [
-    USAGE,
-    accepted_values("<category>", review_finding_ledger.CATEGORIES),
-    accepted_values("<severity>", review_finding_ledger.SEVERITIES),
-    FILE_HINT,
-    DISPOSITION_HINT,
-    REASON_HINT
-  ].join("\n");
-}
-function build_lines(request, date, kind = "code") {
-  if (request.findings.length === 0) {
-    return [review_finding_ledger.zero_round_line(date, request.issue, kind)];
-  }
-  return request.findings.map(
-    (finding) => review_finding_ledger.finding_line(finding, date, request.issue, kind)
-  );
-}
-function confirmation(count, ledger_path) {
-  return `Recorded ${String(count)} review-finding line(s) in ${ledger_path}.`;
-}
-async function code_recorded(issue) {
-  const answer = await review_lane_handover.answer_here(issue);
-  const is_refused = await review_lane_handover.is_reopen_refused(issue);
-  return [RECORDED_LINE, reuse_line(answer, is_refused)].join("\n");
-}
-async function interaction_recorded() {
-  return RECORDED_LINE;
-}
-async function code_status(issue, root) {
-  const verdict = await review_record.check(issue, root);
-  return verdict.status;
-}
-var CHECK_MODES = {
-  code: {
-    status: code_status,
-    recorded: code_recorded,
-    refusal: review_record.refusal_message,
-    not_required: NOT_REQUIRED_LINE2
-  },
-  interaction: {
-    status: review_interaction.status,
-    recorded: interaction_recorded,
-    refusal: review_interaction.refusal_message,
-    not_required: review_record_interaction.NOT_REQUIRED_LINE
-  }
-};
-function kind_of(parsed) {
-  return parsed.interaction ? "interaction" : "code";
-}
-async function report_check(issue, mode, root) {
-  const status = await mode.status(issue, root);
-  if (status === "missing") {
-    console.error(mode.refusal(issue));
-    return FAILURE_EXIT_CODE2;
-  }
-  console.info(status === "ok" ? await mode.recorded(issue) : mode.not_required);
-  return 0;
-}
-async function run_check(parsed, root) {
-  const { issue } = parsed;
-  if (issue === void 0 || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue)) {
-    console.error(CHECK_USAGE);
-    return FAILURE_EXIT_CODE2;
-  }
-  return await report_check(Number(issue), CHECK_MODES[kind_of(parsed)], root);
-}
-function ledger_lines({ issue, lines, kind, date }) {
-  if (kind === "interaction") return lines;
-  return [review_finding_ledger.round_line(date, issue), ...lines];
-}
-async function append_round(round) {
-  const { issue, lines, root, kind, findings } = round;
-  const ledger_path = observation_ledger_home.issue_path(issue, root);
-  await observation_ledger_home.append(ledger_path, ledger_lines(round));
-  console.info(confirmation(lines.length, ledger_path));
-  await review_comment_carry.carry_from_record(root);
-  if (kind === "code") await review_record_code_round.follow(issue, root, findings);
-  return 0;
-}
-async function write_round(parsed, request, now, root) {
-  const kind = kind_of(parsed);
-  const date = observation_ledger_home.ledger_date(now);
-  const lines = [
-    ...build_lines(request, date, kind),
-    ...review_fix_round.lines(request.round, root)
-  ];
-  const { issue, findings } = request;
-  if (parsed.comment) return await review_record_comment.post(issue, lines);
-  if (kind === "code" && await review_record_comment.is_after_push()) {
-    return await review_record_comment.post_after_push({ issue, lines, root, findings });
-  }
-  return await append_round({ issue, lines, root, kind, findings, date });
-}
-async function record_prepared(parsed, request, now, root) {
-  request.round = parsed.interaction ? void 0 : review_fix_round.prepare(request.issue, request.findings, root);
-  const code = await write_round(parsed, request, now, root);
-  if (code !== 0) return code;
-  if (!parsed.interaction) review_final_record.record(request.issue, request.findings, root);
-  review_fix_round.record_reasons(request.issue, request.findings);
-  if (request.round !== void 0) review_fix_round.save(request.round, root);
-  return code;
-}
-async function run_record(parsed, now, root) {
-  const request = parsed.comment && parsed.interaction ? void 0 : to_request(parsed);
-  if (request === void 0) {
-    console.error(usage_text());
-    return FAILURE_EXIT_CODE2;
-  }
-  return await record_prepared(parsed, request, now, root);
-}
-async function run(argv, now, root = observation_ledger_home.ledger_root()) {
-  const parsed = parse_argv(argv);
-  if (parsed === void 0) {
-    console.error(usage_text());
-    return FAILURE_EXIT_CODE2;
-  }
-  if (parsed.check) return await run_check(parsed, root);
-  return await run_record(parsed, now, root);
-}
-var review_record_cli = {
-  accepted_values,
-  build_lines,
-  parse_finding,
-  parse_positional,
-  run,
-  usage_text
-};
-
-export {
-  review_final_record,
-  review_lane_handover,
-  review_record_cli
-};

package/dist/commands/chunk-RGGEQM6G.js

@@ -1,140 +0,0 @@
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/progress/run-progress-clock.ts
-import { z } from "zod";
-var PROGRESS_PREFIX = "josh-run-progress-";
-var LIFE_PREFIX = "josh-run-progress-life-";
-var LOG_SUFFIX = ".log";
-var LOG_KEEP = 12;
-var LOG_STALE_MINUTES = 90;
-var LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE;
-var BLOCK_SEPARATOR = "\n\n";
-var report_stamp_schema = z.object({ reported_at: z.string(), line: z.string().optional() });
-function parse_stamp(raw) {
-  const parsed = report_stamp_schema.safeParse(JSON.parse(raw));
-  if (!parsed.success) return void 0;
-  const reported_at = Date.parse(parsed.data.reported_at);
-  return Number.isNaN(reported_at) ? void 0 : reported_at;
-}
-function read_last_line(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  return json_value.parse_with(raw, report_stamp_schema)?.line;
-}
-function read_last_report(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return void 0;
-  try {
-    return parse_stamp(raw);
-  } catch {
-    return void 0;
-  }
-}
-function log_path_of(target) {
-  return `${target}${LOG_SUFFIX}`;
-}
-function is_log_stale(target, now_ms) {
-  const previous_ms = read_last_report(target);
-  return previous_ms === void 0 || now_ms - previous_ms > LOG_STALE_MS;
-}
-function recent_blocks(log_target, is_fresh) {
-  if (is_fresh) return [];
-  const raw = stamp_file.read_stamp_text(log_target);
-  if (raw === void 0) return [];
-  return raw.split(BLOCK_SEPARATOR).map((block) => block.trimEnd()).filter((block) => block.length > 0);
-}
-function append_line(log_target, reported_at, line, is_fresh) {
-  const block = `${reported_at}
-${line}`;
-  const blocks = [...recent_blocks(log_target, is_fresh), block].slice(-LOG_KEEP);
-  stamp_file.write_text_stamp(log_target, `${blocks.join(BLOCK_SEPARATOR)}
-`);
-}
-function mark(target, now_ms, line) {
-  const reported_at = new Date(now_ms).toISOString();
-  const kept = line ?? read_last_line(target);
-  if (line !== void 0) {
-    append_line(log_path_of(target), reported_at, line, is_log_stale(target, now_ms));
-  }
-  stamp_file.write_stamp(target, kept === void 0 ? { reported_at } : { reported_at, line: kept });
-}
-function stamp_target_of(git_directory) {
-  return stamp_file.stamp_path(PROGRESS_PREFIX, git_directory);
-}
-function life_target_of(git_directory) {
-  return stamp_file.stamp_path(LIFE_PREFIX, git_directory);
-}
-var life_schema = z.object({ alive: z.literal(true), pinged_at: z.string().optional() });
-function begin_life(target) {
-  stamp_file.write_stamp(target, { alive: true, pinged_at: (/* @__PURE__ */ new Date()).toISOString() });
-}
-function ping_life(target) {
-  begin_life(target);
-}
-function parse_pinged_at(raw) {
-  const parsed = life_schema.safeParse(JSON.parse(raw));
-  if (!parsed.success || parsed.data.pinged_at === void 0) return void 0;
-  const pinged_ms = Date.parse(parsed.data.pinged_at);
-  return Number.isNaN(pinged_ms) ? void 0 : pinged_ms;
-}
-function is_life_fresh(target, threshold_ms) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return false;
-  try {
-    const pinged_ms = parse_pinged_at(raw);
-    return pinged_ms !== void 0 && Date.now() - pinged_ms < threshold_ms;
-  } catch (error) {
-    error_text.trace_swallowed("run_progress_clock.is_life_fresh", error);
-    return false;
-  }
-}
-function is_life_ended(target) {
-  return stamp_file.read_stamp_text(target) === void 0;
-}
-function end_life(target) {
-  stamp_file.remove_stamp(target);
-}
-function stamp_target_sync() {
-  const directory = git_common_directory.own();
-  return directory === void 0 ? void 0 : stamp_target_of(directory);
-}
-function read_last_report_sync() {
-  const target = stamp_target_sync();
-  return target === void 0 ? void 0 : read_last_report(target);
-}
-var run_progress_clock = {
-  LIFE_PREFIX,
-  LOG_KEEP,
-  LOG_STALE_MS,
-  begin_life,
-  end_life,
-  is_life_ended,
-  is_life_fresh,
-  life_target_of,
-  log_path_of,
-  mark,
-  parse_stamp,
-  ping_life,
-  read_last_line,
-  read_last_report,
-  read_last_report_sync,
-  stamp_target_of
-};
-
-export {
-  run_progress_clock
-};

package/dist/commands/chunk-RH6ZWJOA.js

@@ -1,77 +0,0 @@
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  git_location_environment,
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  COMMAND_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/init/start-exec.ts
-import { execaSync } from "execa";
-var SUCCESS_EXIT_CODE = 0;
-var GIT_DIRECTORY = ".git";
-var IDENTITY_VARIABLES = ["GIT_AUTHOR_IDENT", "GIT_COMMITTER_IDENT"];
-function root_environment() {
-  return git_location_environment.location_free_environment();
-}
-function git_succeeds(args, root) {
-  return git_spawn_sync.run(args, { cwd: root, env: root_environment() }).exit_code === 0;
-}
-function git_read(args, root) {
-  return git_spawn_sync.read(args, { cwd: root, env: root_environment() });
-}
-function is_identity_refused(variable, options) {
-  const { exit_code } = git_spawn_sync.run(["var", variable], options);
-  return exit_code !== void 0 && exit_code !== SUCCESS_EXIT_CODE;
-}
-function lacks_git_identity(root, is_new_repository) {
-  const location = is_new_repository ? { GIT_DIR: GIT_DIRECTORY } : {};
-  const options = { cwd: root, env: { ...root_environment(), ...location } };
-  return IDENTITY_VARIABLES.some((variable) => is_identity_refused(variable, options));
-}
-function git_run(args, root) {
-  const options = { cwd: root, env: root_environment(), timeout: SUITE_TIMEOUT_MS };
-  const { exit_code } = git_spawn_sync.run(args, { ...options, stdio: "inherit" });
-  if (exit_code === SUCCESS_EXIT_CODE) return;
-  const outcome = exit_code === void 0 ? "did not finish" : `exited with ${String(exit_code)}`;
-  throw new Error(`git ${args.join(" ")} ${outcome}`);
-}
-function gh_probe_options(root) {
-  const environment = { ...root_environment(), ...git_gh_exec.direct_environment().env };
-  return { cwd: root, env: environment, timeout: COMMAND_TIMEOUT_MS, reject: false };
-}
-function is_gh_installed(root) {
-  const result = execaSync("gh", ["--version"], gh_probe_options(root));
-  return result.exitCode === SUCCESS_EXIT_CODE;
-}
-function is_gh_signed_in(root) {
-  const result = execaSync("gh", ["auth", "status"], gh_probe_options(root));
-  return result.exitCode === SUCCESS_EXIT_CODE;
-}
-function create_github_repository(name, visibility, root) {
-  const source = ["--source", ".", "--remote", "origin", "--push"];
-  const { env } = gh_probe_options(root);
-  const options = { cwd: root, env, timeout: SUITE_TIMEOUT_MS, stdio: "inherit" };
-  execaSync("gh", ["repo", "create", name, `--${visibility}`, ...source], options);
-}
-function run_local(command, args, root) {
-  execaSync(command, args, { cwd: root, stdio: "inherit" });
-}
-var start_exec = {
-  git_succeeds,
-  git_read,
-  git_run,
-  lacks_git_identity,
-  is_gh_installed,
-  is_gh_signed_in,
-  create_github_repository,
-  run_local
-};
-
-export {
-  start_exec
-};

package/dist/commands/chunk-RHKCWJQX.js

@@ -1,62 +0,0 @@
-import {
-  git_gh_command,
-  git_pr_checks
-} from "./chunk-YGFOGA7C.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-
-// scripts/gh/git-pr-merge-checked.ts
-var MAX_HEAD_MOVES = 3;
-var NO_CHECKED_HEAD_MESSAGE = "The merge gate answered without the head commit it checked, so there is no commit to bind the merge to";
-var HEAD_MOVED_NOTE = "The pull request head moved after its checks passed \u2014 waiting on the new head";
-var HEAD_KEPT_MOVING_MESSAGE = `The pull request head moved after its checks passed ${String(MAX_HEAD_MOVES)} times, so it was not merged`;
-function checked_head(snapshot) {
-  if (snapshot.head_sha === void 0) throw new Error(NO_CHECKED_HEAD_MESSAGE);
-  return snapshot.head_sha;
-}
-async function try_merge(input, snapshot) {
-  const head_sha = checked_head(snapshot);
-  await input.before_merge?.(head_sha);
-  try {
-    await git_gh_command.pr_merge(input.branch_name, head_sha);
-    return true;
-  } catch (error) {
-    if (!git_gh_command.is_head_moved(error)) throw error;
-    return false;
-  }
-}
-async function merge_checked(input) {
-  const progress = { snapshot: input.checked ?? await input.wait_for_green() };
-  const is_merged = await poll.poll_until(
-    async () => {
-      if (await try_merge(input, progress.snapshot)) return true;
-      console.info(HEAD_MOVED_NOTE);
-      Object.assign(progress, { snapshot: await input.wait_for_green() });
-      return false;
-    },
-    {
-      attempts: MAX_HEAD_MOVES,
-      interval_ms: 0,
-      sleeper: async () => {
-        await Promise.resolve();
-      }
-    }
-  );
-  if (is_merged) return;
-  throw new Error(HEAD_KEPT_MOVING_MESSAGE);
-}
-async function merge_when_green(branch_name) {
-  async function wait_for_green() {
-    return await git_pr_checks.wait_for_pr_success(branch_name);
-  }
-  await merge_checked({ branch_name, wait_for_green });
-}
-var git_pr_merge_checked = {
-  merge_checked,
-  merge_when_green
-};
-
-export {
-  git_pr_merge_checked
-};